BC++ 5.5 and later supports wxUSE_ON_FATAL_EXCEPTION

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

diff --git a/include/wx/wxchar.h b/include/wx/wxchar.h
index 5cac45dfc9b96b79aa374d0399fd99dc7efe59dc..dd6ca93a71f45789fb7fd4756a2589f40e0b1a8f 100644 (file)
--- a/include/wx/wxchar.h
+++ b/include/wx/wxchar.h
@@ -1,53 +1,28 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        wx/wxchar.h
-// Purpose:     Declarations common to wx char/wchar_t usage (wide chars)
-// Author:      Joel Farley, Ove Kåven
-// Modified by: Vadim Zeitlin, Robert Roebling
-// Created:     1998/06/12
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998-2002 wxWindows dev team
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
+/*
+ * Name:        wx/wxchar.h
+ * Purpose:     Declarations common to wx char/wchar_t usage (wide chars)
+ * Author:      Joel Farley, Ove Kåven
+ * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
+ * Created:     1998/06/12
+ * RCS-ID:      $Id$
+ * Copyright:   (c) 1998-2002 wxWidgets dev team
+ * Licence:     wxWindows licence
+ */
+
+/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

 
 #ifndef _WX_WXCHAR_H_
 #define _WX_WXCHAR_H_
 
 
 #ifndef _WX_WXCHAR_H_
 #define _WX_WXCHAR_H_
 

-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma interface "wxchar.h"
 #endif
 
     #pragma interface "wxchar.h"
 #endif
 

-// ----------------------------------------------------------------------------
-// first deal with Unicode setting: wxUSE_UNICODE should be defined as 0 or 1
-// and is used by wxWindows, _UNICODE and/or UNICODE may be defined or used by
-// the system headers so bring these settings in sync
-// ----------------------------------------------------------------------------
-
-// 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 // Unicode
-
-// 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 // Unicode
+#include "wx/defs.h"        /* for wxUSE_UNICODE */

 
 

-// check whether we have wchar_t
+/* check whether we have wchar_t and which size it is if we do */

 #if !defined(wxUSE_WCHAR_T)
 #if !defined(wxUSE_WCHAR_T)

-    #if defined(__WIN16__)
-        // no wchar_t under Win16 regadrless of compiler used
-        #define wxUSE_WCHAR_T 0
-    #elif defined(__UNIX__)
+    #if defined(__UNIX__)

         #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
             #define wxUSE_WCHAR_T 1
         #else
         #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
             #define wxUSE_WCHAR_T 1
         #else


@@ -60,175 +35,187 @@
     #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
         #define wxUSE_WCHAR_T 0
     #else
     #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
         #define wxUSE_WCHAR_T 0
     #else

-        // add additional compiler checks if this fails
+        /* add additional compiler checks if this fails */

         #define wxUSE_WCHAR_T 1
     #endif
         #define wxUSE_WCHAR_T 1
     #endif

-#endif // !defined(wxUSE_WCHAR_T)
+#endif /* !defined(wxUSE_WCHAR_T) */

 
 

-// Unicode support requires wchar_t
+/* Unicode support requires wchar_t */

 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
     #error "wchar_t must be available in Unicode build"
 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
     #error "wchar_t must be available in Unicode build"

-#endif // Unicode
+#endif /* Unicode */

 
 

-// ----------------------------------------------------------------------------
-// standard headers we need here
-//
-// NB: don't include any wxWindows headers here because almost of them include
-//     this one!
-// ----------------------------------------------------------------------------
+/*
+    Standard headers we need here.

 
 

-// Required for wxPrintf() etc
+    NB: don't include any wxWidgets headers here because almost of them include
+        this one!
+ */
+
+/* Required for wxPrintf() etc */

 #include <stdarg.h>
 
 #include <stdarg.h>
 

-// Almost all compiler have strdup(), but not quite all: CodeWarrior under Mac
-// and VC++ for Windows CE don't provide it
+/* Almost all compiler have strdup(), but not quite all: CodeWarrior under Mac */
+/* and VC++ for Windows CE don't provide it */

 #if !(defined(__MWERKS__) && defined(__WXMAC__)) && !defined(__WXWINCE__)
 #if !(defined(__MWERKS__) && defined(__WXMAC__)) && !defined(__WXWINCE__)

-    // use #define, not inline wrapper, as it is tested with #ifndef below
+    /* use #define, not inline wrapper, as it is tested with #ifndef below */

     #define wxStrdupA strdup
 #endif
 
     #define wxStrdupA strdup
 #endif
 

-// non Unix compilers which do have wchar.h (but not tchar.h which is included
-// below and which includes wchar.h anyhow).
-// Actually MinGW has tchar.h, but it does not include wchar.h
-#if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__)
+/*
+   non Unix compilers which do have wchar.h (but not tchar.h which is included
+   below and which includes wchar.h anyhow).
+
+   Actually MinGW has tchar.h, but it does not include wchar.h
+ */
+#if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__) || defined(__WATCOMC__)

     #ifndef HAVE_WCHAR_H
         #define HAVE_WCHAR_H
     #endif
 #endif
     #ifndef HAVE_WCHAR_H
         #define HAVE_WCHAR_H
     #endif
 #endif

+#if defined(__MWERKS__) && !defined(__MACH__)
+       #ifndef HAVE_WCSLEN
+               #define HAVE_WCSLEN
+       #endif
+#endif

 
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCHAR_H
 
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCHAR_H

-        // the current (as of Nov 2002) version of cygwin has a bug in its
-        // wchar.h -- there is no extern "C" around the declarations in it and
-        // this results in linking errors later; also, at least on some
-        // Cygwin versions, wchar.h requires sys/types.h
+        /* the current (as of Nov 2002) version of cygwin has a bug in its */
+        /* wchar.h -- there is no extern "C" around the declarations in it and */
+        /* this results in linking errors later; also, at least on some */
+        /* Cygwin versions, wchar.h requires sys/types.h */

         #ifdef __CYGWIN__
             #include <sys/types.h>
             extern "C" {
         #ifdef __CYGWIN__
             #include <sys/types.h>
             extern "C" {

-        #endif // Cygwin
+        #endif /* Cygwin */

                 #include <wchar.h>
         #ifdef __CYGWIN__
             }
                 #include <wchar.h>
         #ifdef __CYGWIN__
             }

-        #endif // Cygwin
+        #endif /* Cygwin */

     #elif defined(HAVE_WCSTR_H)
     #elif defined(HAVE_WCSTR_H)

-        // old compilers have relevant declarations here
+        /* old compilers have relevant declarations here */

         #include <wcstr.h>
     #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
         #include <wcstr.h>
     #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)

-        // include stdlib.h for wchar_t
+        /* include stdlib.h for wchar_t */

         #include <stdlib.h>
         #include <stdlib.h>

-    #endif // HAVE_WCHAR_H
-#endif // wxUSE_WCHAR_T
+    #endif /* HAVE_WCHAR_H */
+#endif /* wxUSE_WCHAR_T */

 
 

-// ----------------------------------------------------------------------------
-// define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type
-// mapped to either char or wchar_t depending on the ASCII/Unicode mode and have
-// the function mapping _tfoo() -> foo() or wfoo()
-// ----------------------------------------------------------------------------
+/* ---------------------------------------------------------------------------- */
+/* define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type */
+/* mapped to either char or wchar_t depending on the ASCII/Unicode mode and have */
+/* the function mapping _tfoo() -> foo() or wfoo() */
+/* ---------------------------------------------------------------------------- */

 
 

-// VC++ and BC++ starting with 5.2 have TCHAR support
+/* VC++ and BC++ starting with 5.2 have TCHAR support */

 #ifdef __VISUALC__
     #define wxHAVE_TCHAR_SUPPORT
 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
     #define wxHAVE_TCHAR_SUPPORT
     #include <ctype.h>
 #ifdef __VISUALC__
     #define wxHAVE_TCHAR_SUPPORT
 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
     #define wxHAVE_TCHAR_SUPPORT
     #include <ctype.h>

+#elif defined(__WATCOMC__)
+    #define wxHAVE_TCHAR_SUPPORT
+#elif defined(__DMC__)
+    #define wxHAVE_TCHAR_SUPPORT

 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
     #define wxHAVE_TCHAR_SUPPORT
     #include <stddef.h>
     #include <string.h>
     #include <ctype.h>
 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
     #define wxHAVE_TCHAR_SUPPORT
     #include <stddef.h>
     #include <string.h>
     #include <ctype.h>
 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)

-    // VZ: the old VisualAge definitions were completely wrong and had no
-    //     chance at all to work in Unicode build anyhow so let's pretend that
-    //     VisualAge does _not_ support TCHAR for the moment (as indicated by
-    //     "0 &&" above) until someone really has time to delve into Unicode
-    //     issues under OS/2
+    /* VZ: the old VisualAge definitions were completely wrong and had no */
+    /*     chance at all to work in Unicode build anyhow so let's pretend that */
+    /*     VisualAge does _not_ support TCHAR for the moment (as indicated by */
+    /*     "0 &&" above) until someone really has time to delve into Unicode */
+    /*     issues under OS/2 */

 
 

-    // VisualAge 4.0+ supports TCHAR
+    /* VisualAge 4.0+ supports TCHAR */

     #define wxHAVE_TCHAR_SUPPORT
     #define wxHAVE_TCHAR_SUPPORT

-#endif // compilers with (good) TCHAR support
+#endif /* compilers with (good) TCHAR support */

 
 #ifdef __MWERKS__
     #define HAVE_WPRINTF
 #endif
 
 #ifdef wxHAVE_TCHAR_SUPPORT
 
 #ifdef __MWERKS__
     #define HAVE_WPRINTF
 #endif
 
 #ifdef wxHAVE_TCHAR_SUPPORT

-    // get TCHAR definition if we've got it
+    /* get TCHAR definition if we've got it */

     #include <tchar.h>
 
     #include <tchar.h>
 

-    // we surely do have wchar_t if we have TCHAR
+    /* we surely do have wchar_t if we have TCHAR */

     #ifndef wxUSE_WCHAR_T
         #define wxUSE_WCHAR_T 1
     #ifndef wxUSE_WCHAR_T
         #define wxUSE_WCHAR_T 1

-    #endif // !defined(wxUSE_WCHAR_T)
+    #endif /* !defined(wxUSE_WCHAR_T) */

 
 

-    // and we also do have wcslen()
+    /* and we also do have wcslen() */

     #ifndef HAVE_WCSLEN
         #define HAVE_WCSLEN
     #endif
     #ifndef HAVE_WCSLEN
         #define HAVE_WCSLEN
     #endif

-#endif // wxHAVE_TCHAR_SUPPORT
+#endif /* wxHAVE_TCHAR_SUPPORT */

 
 

-// ----------------------------------------------------------------------------
-// define wxChar type
-// ----------------------------------------------------------------------------
+/* ---------------------------------------------------------------------------- */
+/* define wxChar type */
+/* ---------------------------------------------------------------------------- */

 
 

-// TODO: define wxCharInt to be equal to either int or wint_t?
+/* TODO: define wxCharInt to be equal to either int or wint_t? */

 
 #if !wxUSE_UNICODE
     typedef char wxChar;
     typedef signed char wxSChar;
     typedef unsigned char wxUChar;
 
 #if !wxUSE_UNICODE
     typedef char wxChar;
     typedef signed char wxSChar;
     typedef unsigned char wxUChar;

-#else // Unicode
-    // VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as
-    //     signed/unsigned version of it which (a) makes sense to me (unlike
-    //     char wchar_t is always unsigned) and (b) was how the previous
-    //     definitions worked so keep it like this
-
-    // GNU libc has __WCHAR_TYPE__ which requires special treatment, see
-    // comment below
+#else /* Unicode */
+    /* VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as */
+    /*     signed/unsigned version of it which (a) makes sense to me (unlike */
+    /*     char wchar_t is always unsigned) and (b) was how the previous */
+    /*     definitions worked so keep it like this */
+
+    /* GNU libc has __WCHAR_TYPE__ which requires special treatment, see */
+    /* comment below */

     #if !defined(__WCHAR_TYPE__) || \
         (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
     #if !defined(__WCHAR_TYPE__) || \
         (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))

-        // standard case
+        /* standard case */

         typedef wchar_t wxChar;
         typedef wchar_t wxSChar;
         typedef wchar_t wxUChar;
         typedef wchar_t wxChar;
         typedef wchar_t wxSChar;
         typedef wchar_t wxUChar;

-    #else // __WCHAR_TYPE__ and gcc < 2.96
-        // VS: wxWindows used to define wxChar as __WCHAR_TYPE__ here. However,
-        //     this doesn't work with new GCC 3.x compilers because wchar_t is
-        //     C++'s builtin type in the new standard. OTOH, old compilers (GCC
-        //     2.x) won't accept new definition of wx{S,U}Char, therefore we
-        //     have to define wxChar conditionally depending on detected
-        //     compiler & compiler version.
-        //     with old definition of wxChar.
+    #else /* __WCHAR_TYPE__ and gcc < 2.96 */
+        /* VS: wxWidgets used to define wxChar as __WCHAR_TYPE__ here. However, */
+        /*     this doesn't work with new GCC 3.x compilers because wchar_t is */
+        /*     C++'s builtin type in the new standard. OTOH, old compilers (GCC */
+        /*     2.x) won't accept new definition of wx{S,U}Char, therefore we */
+        /*     have to define wxChar conditionally depending on detected */
+        /*     compiler & compiler version. */
+        /*     with old definition of wxChar. */

         typedef __WCHAR_TYPE__ wxChar;
         typedef __WCHAR_TYPE__ wxSChar;
         typedef __WCHAR_TYPE__ wxUChar;
         typedef __WCHAR_TYPE__ wxChar;
         typedef __WCHAR_TYPE__ wxSChar;
         typedef __WCHAR_TYPE__ wxUChar;

-    #endif // __WCHAR_TYPE__
-#endif // ASCII/Unicode
+    #endif /* __WCHAR_TYPE__ */
+#endif /* ASCII/Unicode */

 
 

-// ----------------------------------------------------------------------------
-// define _T() and related macros
-// ----------------------------------------------------------------------------
+/* ---------------------------------------------------------------------------- */
+/* define _T() and related macros */
+/* ---------------------------------------------------------------------------- */

 
 

-// BSD systems define _T() to be something different in ctype.h, override it
+/* BSD systems define _T() to be something different in ctype.h, override it */

 #if defined(__FreeBSD__) || defined(__DARWIN__)
     #include <ctype.h>
     #undef _T
 #endif
 
 #if defined(__FreeBSD__) || defined(__DARWIN__)
     #include <ctype.h>
     #undef _T
 #endif
 

-// could already be defined by tchar.h (it's quasi standard)
+/* could already be defined by tchar.h (it's quasi standard) */

 #ifndef _T
     #if !wxUSE_UNICODE
         #define _T(x) x
 #ifndef _T
     #if !wxUSE_UNICODE
         #define _T(x) x

-    #else // Unicode
+    #else /* Unicode */

         #define _T(x) L ## x
         #define _T(x) L ## x

-    #endif // ASCII/Unicode
-#endif // !defined(_T)
+    #endif /* ASCII/Unicode */
+#endif /* !defined(_T) */

 
 

-// although global macros with such names are normally bad, we want to have
-// another name for _T() which should be used to avoid confusion between _T()
-// and _() in wxWindows sources
+/* although global macros with such names are normally bad, we want to have */
+/* another name for _T() which should be used to avoid confusion between _T() */
+/* and _() in wxWidgets sources */

 #define wxT(x)       _T(x)
 
 #define wxT(x)       _T(x)
 

-// Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
+/* Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs */

 #ifndef __TFILE__
     #define __XFILE__(x) wxT(x)
     #define __TFILE__ __XFILE__(__FILE__)
 #ifndef __TFILE__
     #define __XFILE__(x) wxT(x)
     #define __TFILE__ __XFILE__(__FILE__)


@@ -244,21 +231,21 @@
     #define __TTIME__ __XTIME__(__TIME__)
 #endif
 
     #define __TTIME__ __XTIME__(__TIME__)
 #endif
 

-// ----------------------------------------------------------------------------
-// define wxFoo() function for each standard foo() function whose signature
-// (exceptionally including the return type) includes any mention of char:
-// wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
-// the same signature but with char replaced by wxChar which allows us to use
-// it in Unicode build as well
-// ----------------------------------------------------------------------------
+/*
+    define wxFoo() function for each standard foo() function whose signature
+    (exceptionally including the return type) includes any mention of char:
+    wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
+    the same signature but with char replaced by wxChar which allows us to use
+    it in Unicode build as well
+ */

 
 #ifdef wxHAVE_TCHAR_SUPPORT
     #include <ctype.h>
 
 
 #ifdef wxHAVE_TCHAR_SUPPORT
     #include <ctype.h>
 

-    // ctype.h functions
+    /* ctype.h functions */

     #define  wxIsalnum   _istalnum
     #define  wxIsalpha   _istalpha
     #define  wxIsalnum   _istalnum
     #define  wxIsalpha   _istalpha

-    #define  wxIsctrl    _istctrl
+    #define  wxIscntrl   _istcntrl

     #define  wxIsdigit   _istdigit
     #define  wxIsgraph   _istgraph
     #define  wxIslower   _istlower
     #define  wxIsdigit   _istdigit
     #define  wxIsgraph   _istgraph
     #define  wxIslower   _istlower


@@ -267,24 +254,29 @@
     #define  wxIsspace   _istspace
     #define  wxIsupper   _istupper
     #define  wxIsxdigit  _istxdigit
     #define  wxIsspace   _istspace
     #define  wxIsupper   _istupper
     #define  wxIsxdigit  _istxdigit

-    #define  wxTolower   _totlower
-    #define  wxToupper   _totupper

 
 

-    // locale.h functons
+    /*
+       There is a bug in VC6 C RTL: toxxx() functions dosn't do anything with
+       signed chars < 0, so "fix" it here.
+     */
+    #define  wxTolower(c) _totlower((wxUChar)(c))
+    #define  wxToupper(c) _totupper((wxUChar)(c))
+
+    /* locale.h functons */

     #define  wxSetlocale _tsetlocale
 
     #define  wxSetlocale _tsetlocale
 

-    // string.h functions
+    /* string.h functions */

     #define  wxStrcat    _tcscat
     #define  wxStrchr    _tcschr
     #define  wxStrcmp    _tcscmp
     #define  wxStrcoll   _tcscoll
     #define  wxStrcpy    _tcscpy
     #define  wxStrcspn   _tcscspn
     #define  wxStrcat    _tcscat
     #define  wxStrchr    _tcschr
     #define  wxStrcmp    _tcscmp
     #define  wxStrcoll   _tcscoll
     #define  wxStrcpy    _tcscpy
     #define  wxStrcspn   _tcscspn

-    #define  wxStrdupW   _wcsdup        // notice the 'W'!
+    #define  wxStrdupW   _wcsdup        /* notice the 'W'! */

     #define  wxStrftime  _tcsftime
     #define  wxStricmp   _tcsicmp
     #define  wxStrnicmp  _tcsnicmp
     #define  wxStrftime  _tcsftime
     #define  wxStricmp   _tcsicmp
     #define  wxStrnicmp  _tcsnicmp

-    #define  wxStrlen_   _tcslen        // used in wxStrlen inline function
+    #define  wxStrlen_   _tcslen        /* used in wxStrlen inline function */

     #define  wxStrncat   _tcsncat
     #define  wxStrncmp   _tcsncmp
     #define  wxStrncpy   _tcsncpy
     #define  wxStrncat   _tcsncat
     #define  wxStrncmp   _tcsncmp
     #define  wxStrncpy   _tcsncpy


@@ -297,7 +289,7 @@
     #define  wxStrtoul   _tcstoul
     #define  wxStrxfrm   _tcsxfrm
 
     #define  wxStrtoul   _tcstoul
     #define  wxStrxfrm   _tcsxfrm
 

-    // stdio.h functions
+    /* stdio.h functions */

     #define  wxFgetc     _fgettc
     #define  wxFgetchar  _fgettchar
     #define  wxFgets     _fgetts
     #define  wxFgetc     _fgettc
     #define  wxFgetchar  _fgettchar
     #define  wxFgets     _fgetts


@@ -317,7 +309,18 @@
     #define  wxPutchar   _puttchar
     #define  wxPuts      _putts
     #define  wxScanf     _tscanf
     #define  wxPutchar   _puttchar
     #define  wxPuts      _putts
     #define  wxScanf     _tscanf

-    #define  wxSprintf   _stprintf
+    #if defined(__DMC__)
+        #if wxUSE_UNICODE
+            /* Digital Mars adds count to _stprintf (C99) so prototype conversion see wxchar.cpp */
+            int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... ) ;
+        #else
+            /* and there is a bug in D Mars tchar.h prior to 8.39.4n, so define as sprintf */
+            #define wxSprintf sprintf
+        #endif
+    #else
+        #define  wxSprintf   _stprintf
+    #endif
+

     #define  wxSscanf    _stscanf
     #define  wxTmpnam    _ttmpnam
     #define  wxUngetc    _tungetc
     #define  wxSscanf    _stscanf
     #define  wxTmpnam    _ttmpnam
     #define  wxUngetc    _tungetc


@@ -326,15 +329,15 @@
     #define  wxVsscanf   _vstscanf
     #define  wxVsprintf  _vstprintf
 
     #define  wxVsscanf   _vstscanf
     #define  wxVsprintf  _vstprintf
 

-    // special case: not all TCHAR-aware compilers have those
+    /* special case: not all TCHAR-aware compilers have those */

     #if defined(__VISUALC__) || \
             (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
         #define wxVsnprintf_    _vsntprintf
         #define wxSnprintf_     _sntprintf
     #endif
 
     #if defined(__VISUALC__) || \
             (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
         #define wxVsnprintf_    _vsntprintf
         #define wxSnprintf_     _sntprintf
     #endif
 

-    // special case: these functions are missing under Win9x with Unicows so we
-    // have to implement them ourselves
+    /* special case: these functions are missing under Win9x with Unicows so we */
+    /* have to implement them ourselves */

     #if wxUSE_UNICODE_MSLU
         #define  wxRemove    wxMSLU__tremove
         #define  wxRename    wxMSLU__trename
     #if wxUSE_UNICODE_MSLU
         #define  wxRemove    wxMSLU__tremove
         #define  wxRename    wxMSLU__trename


@@ -347,26 +350,26 @@
         #endif
     #endif
 
         #endif
     #endif
 

-    // stdlib.h functions
+    /* stdlib.h functions */

     #define  wxAtoi      _ttoi
     #define  wxAtol      _ttol
     #define  wxAtoi      _ttoi
     #define  wxAtol      _ttol

-    // #define  wxAtof   _tttof -- notice that there is no such thing (why?)
+    /* #define  wxAtof   _tttof -- notice that there is no such thing (why?) */

     #define  wxGetenv    _tgetenv
     #define  wxSystem    _tsystem
 
     #define  wxGetenv    _tgetenv
     #define  wxSystem    _tsystem
 

-    // time.h functions
+    /* time.h functions */

     #define  wxAsctime   _tasctime
     #define  wxCtime     _tctime
     #define  wxAsctime   _tasctime
     #define  wxCtime     _tctime

-#else // !TCHAR-aware compilers
+#else /* !TCHAR-aware compilers */

     #if wxUSE_UNICODE
         #include <wctype.h>
 
     #if wxUSE_UNICODE
         #include <wctype.h>
 

-        // this is probably glibc-specific
-        #if defined(__WCHAR_TYPE__)
-            // ctype.h functions (wctype.h)
+        /* this is probably glibc-specific */
+        #if defined(__WCHAR_TYPE__) && !defined(__MWERKS__)
+            /* ctype.h functions (wctype.h) */

             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha
             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha

-            #define  wxIsctrl    iswcntrl
+            #define  wxIscntrl   iswcntrl

             #define  wxIsdigit   iswdigit
             #define  wxIsgraph   iswgraph
             #define  wxIslower   iswlower
             #define  wxIsdigit   iswdigit
             #define  wxIsgraph   iswgraph
             #define  wxIslower   iswlower


@@ -377,24 +380,24 @@
             #define  wxIsxdigit  iswxdigit
 
             #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
             #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
+                /* /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)
                 #define  wxTolower(wc)   towctrans((wc), (wctrans_t)__ctype_tolower)
                 #define  wxToupper(wc)   towctrans((wc), (wctrans_t)__ctype_toupper)

-            #else // !glibc 2.0
+            #else /* !glibc 2.0 */

                 #define  wxTolower   towlower
                 #define  wxToupper   towupper
                 #define  wxTolower   towlower
                 #define  wxToupper   towupper

-            #endif // gcc/!gcc
+            #endif /* gcc/!gcc */

 
 

-            // string.h functions (wchar.h)
+            /* string.h functions (wchar.h) */

             #define  wxStrcat    wcscat
             #define  wxStrchr    wcschr
             #define  wxStrcmp    wcscmp
             #define  wxStrcoll   wcscoll
             #define  wxStrcpy    wcscpy
             #define  wxStrcspn   wcscspn
             #define  wxStrcat    wcscat
             #define  wxStrchr    wcschr
             #define  wxStrcmp    wcscmp
             #define  wxStrcoll   wcscoll
             #define  wxStrcpy    wcscpy
             #define  wxStrcspn   wcscspn

-            #define  wxStrlen_   wxWcslen // wxStrlen_() is used in wxStrlen()
+            #define  wxStrlen_   wxWcslen /* wxStrlen_() is used in wxStrlen() */

             #define  wxStrncat   wcsncat
             #define  wxStrncmp   wcsncmp
             #define  wxStrncpy   wcsncpy
             #define  wxStrncat   wcsncat
             #define  wxStrncmp   wcsncmp
             #define  wxStrncpy   wcsncpy


@@ -417,36 +420,47 @@
             #define  wxGets      getws
             #define  wxUngetc    ungetwc
 
             #define  wxGets      getws
             #define  wxUngetc    ungetwc
 

-            #ifdef HAVE_FPUTWC
-                #define  wxPutc      wputc
-                #define  wxPutchar   wputchar
-                #define  wxPuts      putws
-                #define  wxFputs     fputws
+            #ifdef HAVE_FPUTWS
+                #define wxFputs     fputws

             #else
             #else

-                #define wxNEED_FPUTWC
-
+                #define wxNEED_FPUTS

                 #include <stdio.h>
                 #include <stdio.h>

-

                 int wxFputs(const wxChar *ch, FILE *stream);
                 int wxFputs(const wxChar *ch, FILE *stream);

+            #endif
+
+            #ifdef HAVE_WPUTC
+                #define wxPutc      wputc
+            #else
+                #define wxNEED_PUTC
+                #include <stdio.h>

                 int wxPutc(wxChar ch, FILE *stream);
                 int wxPutc(wxChar ch, FILE *stream);

+            #endif

 
 

-                #define wxPuts(ws) wxFputs(ws, stdout)
+            #ifdef HAVE_WPUTCHAR
+                #define wxPutchar   wputchar
+            #else

                 #define wxPutchar(wch) wxPutc(wch, stdout)
             #endif
                 #define wxPutchar(wch) wxPutc(wch, stdout)
             #endif

+            
+            #ifdef HAVE_PUTWS
+                #define wxPuts      putws
+            #else
+                #define wxPuts(ws) wxFputs(ws, stdout)
+            #endif

 
 

-            // we need %s to %ls conversion for printf and scanf etc
+            /* we need %s to %ls conversion for printf and scanf etc */

             #define wxNEED_PRINTF_CONVERSION
 
             #define wxNEED_PRINTF_CONVERSION
 

-            // glibc doesn't have wide char equivalents of the other stuff so
-            // use our own versions
+            /* glibc doesn't have wide char equivalents of the other stuff so */
+            /* use our own versions */

             #define wxNEED_WX_STDIO_H
             #define wxNEED_WX_STDLIB_H
             #define wxNEED_WX_TIME_H
             #define wxNEED_WX_STDIO_H
             #define wxNEED_WX_STDLIB_H
             #define wxNEED_WX_TIME_H

-        #elif defined(__MWERKS__) && ( defined(macintosh) || defined(__MACH__) )
-            // ctype.h functions (wctype.h)
+        #elif defined(__MWERKS__) && ( defined(__MSL__) || defined(__MACH__) )
+            /* ctype.h functions (wctype.h) */

             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha
             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha

-            #define  wxIsctrl    iswcntrl
+            #define  wxIscntrl   iswcntrl

             #define  wxIsdigit   iswdigit
             #define  wxIsgraph   iswgraph
             #define  wxIslower   iswlower
             #define  wxIsdigit   iswdigit
             #define  wxIsgraph   iswgraph
             #define  wxIslower   iswlower


@@ -458,14 +472,14 @@
             #define  wxTolower   towlower
             #define  wxToupper   towupper
 
             #define  wxTolower   towlower
             #define  wxToupper   towupper
 

-            // string.h functions (wchar.h)
+            /* string.h functions (wchar.h) */

             #define  wxStrcat    wcscat
             #define  wxStrchr    wcschr
             #define  wxStrcmp    wcscmp
             #define  wxStrcoll   wcscoll
             #define  wxStrcpy    wcscpy
             #define  wxStrcspn   wcscspn
             #define  wxStrcat    wcscat
             #define  wxStrchr    wcschr
             #define  wxStrcmp    wcscmp
             #define  wxStrcoll   wcscoll
             #define  wxStrcpy    wcscpy
             #define  wxStrcspn   wcscspn

-            #define  wxStrlen_   wxWcslen // wxStrlen_() is used in wxStrlen()
+            #define  wxStrlen_   wxWcslen /* wxStrlen_() is used in wxStrlen() */

             #define  wxStrncat   wcsncat
             #define  wxStrncmp   wcsncmp
             #define  wxStrncpy   wcsncpy
             #define  wxStrncat   wcsncat
             #define  wxStrncmp   wcsncmp
             #define  wxStrncpy   wcsncpy


@@ -493,53 +507,38 @@
             #define  wxPutc      putwc
             #define  wxPutchar   putwchar
             #define  wxFputs     fputws
             #define  wxPutc      putwc
             #define  wxPutchar   putwchar
             #define  wxFputs     fputws

-            
-            // stdio.h functions
-            
-             #define wxNEED_WX_STDIO_H

 
 

-            // stdlib.h functions
+            /* stdio.h functions */
+
+            #define wxNEED_WX_STDIO_H
+
+            /* stdlib.h functions */
+            #ifdef __MACH__
+            #define wxNEED_WX_STDLIB_H
+            #else

             #define  wxAtof      watof
             #define  wxAtoi      watoi
             #define  wxAtol      watol
             #define  wxGetenv(a)    ((wxChar*)NULL)
             #define  wxSystem(a)    ((int)NULL)
             #define  wxAtof      watof
             #define  wxAtoi      watoi
             #define  wxAtol      watol
             #define  wxGetenv(a)    ((wxChar*)NULL)
             #define  wxSystem(a)    ((int)NULL)

-
-            // time.h functions
+            #endif
+            /* time.h functions */

             #define  wxAsctime   wasciitime
             #define  wxCtime     wctime
             #define  wxAsctime   wasciitime
             #define  wxCtime     wctime

-            #define  wxStrftime  wcsftime
-
-            /*
-            #define wxNEED_FPUTWC
-
-            #include <stdio.h>
+            /* #define  wxStrftime  wcsftime */

 
 

-            int wxFputs(const wxChar *ch, FILE *stream);
-            int wxPutc(wxChar ch, FILE *stream);
-
-            #define wxPuts(ws) wxFputs(ws, stdout)
-            #define wxPutchar(wch) wxPutc(wch, stdout)
-
-            // we need %s to %ls conversion for printf and scanf etc
-            #define wxNEED_PRINTF_CONVERSION
-            // glibc doesn't have wide char equivalents of the other stuff so
-            // use our own versions
-            #define wxNEED_WX_STDIO_H
-            #define wxNEED_WX_STDLIB_H

             #define wxNEED_WX_TIME_H
             #define wxNEED_WX_TIME_H

-            */
-        #else // !metrowerks for apple
+        #else /* !metrowerks for apple */

             #error  "Please define wide character functions for your environment"
         #endif
             #error  "Please define wide character functions for your environment"
         #endif

-    #else // ASCII
+    #else /* ASCII */

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

-        // ctype.h functions
+        /* ctype.h functions */

         #define  wxIsalnum   isalnum
         #define  wxIsalpha   isalpha
         #define  wxIsalnum   isalnum
         #define  wxIsalpha   isalpha

-        #define  wxIsctrl    isctrl
+        #define  wxIscntrl   iscntrl

         #define  wxIsdigit   isdigit
         #define  wxIsgraph   isgraph
         #define  wxIslower   islower
         #define  wxIsdigit   isdigit
         #define  wxIsgraph   isgraph
         #define  wxIslower   islower


@@ -551,10 +550,10 @@
         #define  wxTolower   tolower
         #define  wxToupper   toupper
 
         #define  wxTolower   tolower
         #define  wxToupper   toupper
 

-         // locale.h functons
+         /* locale.h functons */

         #define  wxSetlocale setlocale
 
         #define  wxSetlocale setlocale
 

-         // string.h functions
+         /* string.h functions */

         #define  wxStrcat    strcat
         #define  wxStrchr    strchr
         #define  wxStrcmp    strcmp
         #define  wxStrcat    strcat
         #define  wxStrchr    strchr
         #define  wxStrcmp    strcmp


@@ -562,8 +561,8 @@
         #define  wxStrcpy    strcpy
         #define  wxStrcspn   strcspn
 
         #define  wxStrcpy    strcpy
         #define  wxStrcspn   strcspn
 

-        // wxStricmp and wxStrnicmp are defined below
-        #define  wxStrlen_   strlen // used in wxStrlen inline function
+        /* wxStricmp and wxStrnicmp are defined below */
+        #define  wxStrlen_   strlen /* used in wxStrlen inline function */

         #define  wxStrncat   strncat
         #define  wxStrncmp   strncmp
         #define  wxStrncpy   strncpy
         #define  wxStrncat   strncat
         #define  wxStrncmp   strncmp
         #define  wxStrncpy   strncpy


@@ -579,19 +578,12 @@
         #define  wxStrtoul   strtoul
         #define  wxStrxfrm   strxfrm
 
         #define  wxStrtoul   strtoul
         #define  wxStrxfrm   strxfrm
 

-        // stdio.h functions
-        #if defined(__WXMAC__) && !defined(__DARWIN__)
-        #include <stdio.h>
-        WXDLLIMPEXP_BASE FILE *   wxFopen(const wxChar *path, const wxChar *mode);
-        WXDLLIMPEXP_BASE FILE *   wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
-        WXDLLIMPEXP_BASE int      wxRemove(const wxChar *path);
-        WXDLLIMPEXP_BASE int      wxRename(const wxChar *oldpath, const wxChar *newpath);
-        #else
+        /* stdio.h functions */

         #define  wxFopen     fopen
         #define  wxFreopen   freopen
         #define  wxRemove    remove
         #define  wxRename    rename
         #define  wxFopen     fopen
         #define  wxFreopen   freopen
         #define  wxRemove    remove
         #define  wxRename    rename

-        #endif
+

         #define  wxPerror    perror
         #define  wxTmpnam    tmpnam
 
         #define  wxPerror    perror
         #define  wxTmpnam    tmpnam
 


@@ -599,6 +591,7 @@
         #define  wxFgetchar  fgetchar
         #define  wxFgets     fgets
         #define  wxFputc     fputc
         #define  wxFgetchar  fgetchar
         #define  wxFgets     fgets
         #define  wxFputc     fputc

+        #define  wxFputs     fputs

         #define  wxFputchar  fputchar
         #define  wxFprintf   fprintf
         #define  wxFscanf    fscanf
         #define  wxFputchar  fputchar
         #define  wxFprintf   fprintf
         #define  wxFscanf    fscanf


@@ -618,27 +611,27 @@
         #define  wxVsscanf   vsscanf
         #define  wxVsprintf  vsprintf
 
         #define  wxVsscanf   vsscanf
         #define  wxVsprintf  vsprintf
 

-        // stdlib.h functions
+        /* stdlib.h functions */

         #define  wxAtof      atof
         #define  wxAtoi      atoi
         #define  wxAtol      atol
         #define  wxGetenv    getenv
         #define  wxSystem    system
 
         #define  wxAtof      atof
         #define  wxAtoi      atoi
         #define  wxAtol      atol
         #define  wxGetenv    getenv
         #define  wxSystem    system
 

-        // time.h functions
+        /* time.h functions */

         #define  wxAsctime   asctime
         #define  wxCtime     ctime
         #define  wxStrftime  strftime
         #define  wxAsctime   asctime
         #define  wxCtime     ctime
         #define  wxStrftime  strftime

-    #endif // Unicode/ASCII
-#endif // TCHAR-aware compilers/the others
+    #endif /* Unicode/ASCII */
+#endif /* TCHAR-aware compilers/the others */
+
+/*
+    various special cases
+ */

 
 

-// ----------------------------------------------------------------------------
-// various special cases
-// ----------------------------------------------------------------------------
+/* define wxStricmp and wxStrnicmp for various compilers */

 
 

-// define wxStricmp and wxStrnicmp for various compilers
-//
-// note that in Unicode mode we definitely are going to need our own version
+/* note that in Unicode mode we definitely are going to need our own version */

 #if !defined(wxStricmp) && !wxUSE_UNICODE
     #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
             defined(__SALFORDC__) || defined(__VISAGECPP__) || \
 #if !defined(wxStricmp) && !wxUSE_UNICODE
     #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
             defined(__SALFORDC__) || defined(__VISAGECPP__) || \


@@ -652,17 +645,21 @@
     #elif defined(__UNIX__) || defined(__GNUWIN32__)
         #define wxStricmp strcasecmp
         #define wxStrnicmp strncasecmp
     #elif defined(__UNIX__) || defined(__GNUWIN32__)
         #define wxStricmp strcasecmp
         #define wxStrnicmp strncasecmp

-    // #else -- use wxWindows implementation
+    /* #else -- use wxWidgets implementation */

     #endif
     #endif

-#endif // !defined(wxStricmp)
+#endif /* !defined(wxStricmp) */

 
 

-// define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
-// it's used in wx/buffer.h -- and also might be used just below by wxStrlen()
-// when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen)
+/* define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as */
+/* it's used in wx/buffer.h -- and also might be used just below by wxStrlen() */
+/* when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen) */

 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCSLEN
         #define wxWcslen wcslen
     #else
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCSLEN
         #define wxWcslen wcslen
     #else

+       #if defined( __WXMAC_XCODE__ ) && !defined( __cplusplus )
+       /* xcode native targets are giving multiply defined symbols on regex */
+               static
+       #endif

         inline size_t wxWcslen(const wchar_t *s)
         {
             size_t n = 0;
         inline size_t wxWcslen(const wchar_t *s)
         {
             size_t n = 0;


@@ -672,30 +669,34 @@
             return n;
         }
     #endif
             return n;
         }
     #endif

-#endif // wxUSE_WCHAR_T
+#endif /* wxUSE_WCHAR_T */

 
 

-// checks whether the passed in pointer is NULL and if the string is empty
+#ifdef __cplusplus
+/* checks whether the passed in pointer is NULL and if the string is empty */

 inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
 
 inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
 

-// safe version of strlen() (returns 0 if passed NULL pointer)
+/* safe version of strlen() (returns 0 if passed NULL pointer) */

 inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
 inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }

+#endif

 
 

-// each of strdup() and wcsdup() may or may not be available but we need both
-// of them anyhow for wx/buffer.h so we define the missing one(s) in
-// wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
-// defined -- if this is somehow not the case in some situations, please
-// correct that and not the lines here
+/*
+    each of strdup() and wcsdup() may or may not be available but we need both
+    of them anyhow for wx/buffer.h so we define the missing one(s) in
+    wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
+    defined -- if this is somehow not the case in some situations, please
+    correct that and not the lines here
+ */

 #if wxUSE_UNICODE
     #define wxStrdup wxStrdupW
 #else
     #define wxStrdup wxStrdupA
 #endif
 
 #if wxUSE_UNICODE
     #define wxStrdup wxStrdupW
 #else
     #define wxStrdup wxStrdupA
 #endif
 

-WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
+#ifdef __cplusplus
+WXDLLIMPEXP_BASE bool wxOKlibc(); /* for internal use */
+#endif

 
 

-// ----------------------------------------------------------------------------
-// printf() family saga
-// ----------------------------------------------------------------------------
+/* printf() family saga */

 
 /*
    For some systems vsnprintf() exists in the system libraries but not in the
 
 /*
    For some systems vsnprintf() exists in the system libraries but not in the


@@ -704,7 +705,7 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
     extern "C"
     int vsnprintf(char *str, size_t size, const char *format, va_list ap);
 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
     extern "C"
     int vsnprintf(char *str, size_t size, const char *format, va_list ap);

-#endif // !HAVE_VSNPRINTF_DECL
+#endif /* !HAVE_VSNPRINTF_DECL */

 
 /*
    First of all, we always want to define safe snprintf() function to be used
 
 /*
    First of all, we always want to define safe snprintf() function to be used


@@ -721,25 +722,29 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
             #define HAVE_WCSRTOMBS 1
             #define HAVE_VSWPRINTF 1
         #endif
             #define HAVE_WCSRTOMBS 1
             #define HAVE_VSWPRINTF 1
         #endif

+        #if defined(__WATCOMC__)
+            #define wxVsnprintf_    _vsnwprintf
+            #define wxSnprintf_     _snwprintf
+        #endif

         #if defined(HAVE__VSNWPRINTF)
             #define wxVsnprintf_    _vsnwprintf
         /* MinGW?MSVCRT has the wrong vswprintf */
         #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
             #define wxVsnprintf_    vswprintf
         #endif
         #if defined(HAVE__VSNWPRINTF)
             #define wxVsnprintf_    _vsnwprintf
         /* MinGW?MSVCRT has the wrong vswprintf */
         #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
             #define wxVsnprintf_    vswprintf
         #endif

-    #else // ASCII
-        // all versions of CodeWarrior supported by wxWindows apparently have
-        // vsnprintf()
-        #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
-            // assume we have snprintf() too if we have vsnprintf()
+    #else /* ASCII */
+        /* all versions of CodeWarrior supported by wxWidgets apparently have */
+        /* vsnprintf() */
+        #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__) || defined(__WATCOMC__)
+            /* assume we have snprintf() too if we have vsnprintf() */

             #define wxVsnprintf_    vsnprintf
             #define wxSnprintf_     snprintf
         #endif
     #endif
             #define wxVsnprintf_    vsnprintf
             #define wxSnprintf_     snprintf
         #endif
     #endif

-#endif // wxVsnprintf_ not defined yet
+#endif /* wxVsnprintf_ not defined yet */

 
 #ifndef wxSnprintf_
 
 #ifndef wxSnprintf_

-    // no [v]snprintf(), cook our own
+    /* no [v]snprintf(), cook our own */

     WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
                                 ...) ATTRIBUTE_PRINTF_3;
 #endif
     WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
                                 ...) ATTRIBUTE_PRINTF_3;
 #endif


@@ -768,19 +773,16 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
    We choose to always emulate Windows behaviour as more useful for us so even
    if we have wprintf() we still must wrap it in a non trivial wxPrintf().
 
    We choose to always emulate Windows behaviour as more useful for us so even
    if we have wprintf() we still must wrap it in a non trivial wxPrintf().
 

-   However, if we don't have any vswprintf() at all we don't need to redefine
-   anything as our own wxVsnprintf_() already behaves as needed.

 */
 */

-#ifndef wxVsnprintf_
-    #undef wxNEED_PRINTF_CONVERSION
-#endif

 
 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 
 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)

-    // we need to implement all wide character printf and scanf functions
-    // either because we don't have them at all or because they don't have the
-    // semantics we need
+    /*
+        we need to implement all wide character printf and scanf functions
+        either because we don't have them at all or because they don't have the
+        semantics we need
+     */

 
 

-    #include <stdio.h>  // for FILE
+    #include <stdio.h>  /* for FILE */

 
     int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
     int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 
     int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
     int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;


@@ -792,11 +794,15 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
     int wxVfprintf( FILE *stream, const wxChar *format, va_list ap );
     int wxVprintf( const wxChar *format, va_list ap );
     int wxVsprintf( wxChar *str, const wxChar *format, va_list ap );
     int wxVfprintf( FILE *stream, const wxChar *format, va_list ap );
     int wxVprintf( const wxChar *format, va_list ap );
     int wxVsprintf( wxChar *str, const wxChar *format, va_list ap );

-#endif // wxNEED_PRINTF_CONVERSION
+#endif /* wxNEED_PRINTF_CONVERSION */

 
 

-// these 2 can be simply mapped to the versions with underscore at the end
-// if we don't have to do the conversion
-#ifdef wxNEED_PRINTF_CONVERSION
+/* these 2 can be simply mapped to the versions with underscore at the end */
+/* if we don't have to do the conversion */
+/*
+   However, if we don't have any vswprintf() at all we don't need to redefine
+   anything as our own wxVsnprintf_() already behaves as needed.
+*/
+#if defined(wxNEED_PRINTF_CONVERSION) && defined(wxVsnprintf_)

     int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
     int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
 #else
     int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
     int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
 #else


@@ -804,18 +810,18 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
     #define wxVsnprintf wxVsnprintf_
 #endif
 
     #define wxVsnprintf wxVsnprintf_
 #endif
 

-// ----------------------------------------------------------------------------
-// various functions which might not be available in libc and for which we
-// provide our own replacements in wxchar.cpp
-// ----------------------------------------------------------------------------
+/*
+    various functions which might not be available in libc and for which we
+    provide our own replacements in wxchar.cpp
+ */
+
+/* ctype.h functions */

 
 

-// ctype.h functions
-//
-// VZ: note that this is never defined currently
+/* VZ: note that this is never defined currently */

 #ifdef wxNEED_WX_CTYPE_H
     WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
 #ifdef wxNEED_WX_CTYPE_H
     WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);

-    WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIscntrl(wxChar ch);

     WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
     WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
     WXDLLIMPEXP_BASE int wxIslower(wxChar ch);


@@ -826,19 +832,26 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
     WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
     WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
     WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
     WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
     WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
     WXDLLIMPEXP_BASE int wxToupper(wxChar ch);

-#endif // wxNEED_WX_CTYPE_H
+#endif /* wxNEED_WX_CTYPE_H */

 
 

-// under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
-// the file parsing -- this may be true for 5.0 as well, update #ifdef then
+/* under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks */
+/* the file parsing -- this may be true for 5.0 as well, update #ifdef then */

 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
     #undef wxIsspace
     #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
     #undef wxIsspace
     #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))

-#endif // VC++
+#endif /* VC++ */

 
 

+/*
+   we had goofed and defined wxIctrl() instead of (correct) wxIscntrl() in the
+   initial versions of this header -- now it is too late to remove it so
+   although we fixed the function/macro name above, still provide the
+   backwards-compatible synonym.
+ */
+#define wxIsctrl wxIscntrl
+
+/* string.h functions */

 
 

-// string.h functions
-//
-// VZ: this is never defined neither currently
+/* VZ: this is never defined neither currently */

 #ifdef wxNEED_WX_STRING_H
     WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
     WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
 #ifdef wxNEED_WX_STRING_H
     WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
     WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);


@@ -866,7 +879,7 @@ WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
     WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
     WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
     WXDLLIMPEXP_BASE size_t   wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
     WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
     WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
     WXDLLIMPEXP_BASE size_t   wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);

-#endif // wxNEED_WX_STRING_H
+#endif /* wxNEED_WX_STRING_H */

 
 #ifndef wxStrdupA
 WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
 
 #ifndef wxStrdupA
 WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);


@@ -888,12 +901,14 @@ WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t l
 WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
 #endif
 
 WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
 #endif
 

+#ifdef __cplusplus

 #ifndef wxSetlocale
 class WXDLLIMPEXP_BASE wxWCharBuffer;
 WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
 #endif
 #ifndef wxSetlocale
 class WXDLLIMPEXP_BASE wxWCharBuffer;
 WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
 #endif

+#endif

 
 

-// stdio.h functions
+/* stdio.h functions */

 #ifdef wxNEED_WX_STDIO_H
     #include <stdio.h>
     WXDLLIMPEXP_BASE FILE *   wxFopen(const wxChar *path, const wxChar *mode);
 #ifdef wxNEED_WX_STDIO_H
     #include <stdio.h>
     WXDLLIMPEXP_BASE FILE *   wxFopen(const wxChar *path, const wxChar *mode);


@@ -901,11 +916,11 @@ WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
     WXDLLIMPEXP_BASE int      wxRemove(const wxChar *path);
     WXDLLIMPEXP_BASE int      wxRename(const wxChar *oldpath, const wxChar *newpath);
 
     WXDLLIMPEXP_BASE int      wxRemove(const wxChar *path);
     WXDLLIMPEXP_BASE int      wxRename(const wxChar *oldpath, const wxChar *newpath);
 

-    // *printf() family is handled separately
-#endif // wxNEED_WX_STDIO_H
+    /* *printf() family is handled separately */
+#endif /* wxNEED_WX_STDIO_H */

 
 
 
 

-// stdlib.h functions
+/* stdlib.h functions */

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


@@ -918,21 +933,38 @@ WXDLLIMPEXP_BASE int      wxSystem(const wxChar *psz);
 #endif
 
 
 #endif
 
 

-// time.h functions
+/* time.h functions */

 #ifdef wxNEED_WX_TIME_H
 #if defined(__MWERKS__) && defined(macintosh)
 #ifdef wxNEED_WX_TIME_H
 #if defined(__MWERKS__) && defined(macintosh)

-    #include <time.h> 
+    #include <time.h>

 #endif
     WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
                                   const wxChar *fmt, const struct tm *tm);
 #endif
     WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
                                   const wxChar *fmt, const struct tm *tm);

-#endif // wxNEED_WX_TIME_H
+#endif /* wxNEED_WX_TIME_H */
+
+#ifndef wxCtime
+#include <time.h>
+WXDLLIMPEXP_BASE wxChar *wxCtime(const time_t *timep);
+#endif
+
+
+/* missing functions in some WinCE versions */
+#ifdef _WIN32_WCE
+#if (_WIN32_WCE < 300)
+WXDLLIMPEXP_BASE void *calloc( size_t num, size_t size );
+#endif
+WXDLLIMPEXP_BASE char* strdup(const char* s);
+
+#if _WIN32_WCE <= 211
+WXDLLIMPEXP_BASE int isspace(int c);
+WXDLLIMPEXP_BASE int isascii( int c );
+#endif
+#endif

 
 

-// ----------------------------------------------------------------------------
-// multibyte to wide char conversion functions and macros
-// ----------------------------------------------------------------------------
+/* multibyte to wide char conversion functions and macros */

 
 #if wxUSE_WCHAR_T
 
 #if wxUSE_WCHAR_T

-    // multibyte<->widechar conversion
+    /* multibyte<->widechar conversion */

     WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
     WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
 
     WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
     WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
 


@@ -947,8 +979,8 @@ WXDLLIMPEXP_BASE int      wxSystem(const wxChar *psz);
         #define wxWC2WX wxWC2MB
         #define wxWX2WC wxMB2WC
     #endif
         #define wxWC2WX wxWC2MB
         #define wxWX2WC wxMB2WC
     #endif

-#else // !wxUSE_UNICODE
-    // No wxUSE_WCHAR_T: we have to do something (JACS)
+#else /* !wxUSE_UNICODE */
+    /* No wxUSE_WCHAR_T: we have to do something (JACS) */

     #define wxMB2WC wxStrncpy
     #define wxWC2MB wxStrncpy
     #define wxMB2WX wxStrncpy
     #define wxMB2WC wxStrncpy
     #define wxWC2MB wxStrncpy
     #define wxMB2WX wxStrncpy


@@ -957,5 +989,5 @@ WXDLLIMPEXP_BASE int      wxSystem(const wxChar *psz);
     #define wxWX2WC wxMB2WC
 #endif
 
     #define wxWX2WC wxMB2WC
 #endif
 

-#endif //_WX_WXCHAR_H_
+#endif /* _WX_WXCHAR_H_ */