]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/wxchar.h
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Header Cosmetics
[wxWidgets.git] / include / wx / wxchar.h
diff --git a/include/wx/wxchar.h b/include/wx/wxchar.h
index aa3ebf487573ca6dbe3c3938b216675032758d11..0a8f8ea2040cf19c5107832adadb8290debb663c 100644 (file)
--- a/include/wx/wxchar.h
+++ b/include/wx/wxchar.h
@@ -1,51 +1,32 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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 */
+/*  Created:     1998/06/12 */
+/*  RCS-ID:      $Id$ */
+/*  Copyright:   (c) 1998-2002 wxWindows 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
-// ----------------------------------------------------------------------------
+#include "wx/defs.h"        /*  for wxUSE_UNICODE */
 
 
-// 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
+/*  ---------------------------------------------------------------------------- */
+/*  check whether we have wchar_t and which size it is if we do */
+/*  ---------------------------------------------------------------------------- */
 
 
-// check whether we have wchar_t
 #if !defined(wxUSE_WCHAR_T)
     #if defined(__WIN16__)
 #if !defined(wxUSE_WCHAR_T)
     #if defined(__WIN16__)
-        // no wchar_t under Win16 regadrless of compiler used
+        /*  no wchar_t under Win16 regadrless of compiler used */
         #define wxUSE_WCHAR_T 0
     #elif defined(__UNIX__)
         #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
         #define wxUSE_WCHAR_T 0
     #elif defined(__UNIX__)
         #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
@@ -60,29 +41,37 @@
     #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 */
+/*  */
+/*  NB: don't include any wxWindows headers here because almost of them include */
+/*      this one! */
+/*  ---------------------------------------------------------------------------- */
 
 
-// Required for wxPrintf() etc
+/*  Required for wxPrintf() etc */
 #include <stdarg.h>
 
 #include <stdarg.h>
 
-// non Unix compilers which do have wchar.h (but not tchar.h which is included
-// below and which includes wchar.h anyhow)
-#if defined(__MWERKS__) || defined(__VISAGECPP__)
+/*  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__)
+    /*  use #define, not inline wrapper, as it is tested with #ifndef below */
+    #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__)
     #ifndef HAVE_WCHAR_H
         #define HAVE_WCHAR_H
     #endif
     #ifndef HAVE_WCHAR_H
         #define HAVE_WCHAR_H
     #endif
@@ -90,122 +79,139 @@
 
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCHAR_H
 
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCHAR_H
-        #include <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 */
+        #ifdef __CYGWIN__
+            #include <sys/types.h>
+            extern "C" {
+        #endif /*  Cygwin */
+                #include <wchar.h>
+        #ifdef __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(__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 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: 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. */
         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 wxWindows 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__)
@@ -221,18 +227,18 @@
     #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  wxIsctrl    _istctrl
     #define  wxIsalnum   _istalnum
     #define  wxIsalpha   _istalpha
     #define  wxIsctrl    _istctrl
@@ -247,20 +253,21 @@
     #define  wxTolower   _totlower
     #define  wxToupper   _totupper
 
     #define  wxTolower   _totlower
     #define  wxToupper   _totupper
 
-    // locale.h functons
+    /*  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  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
@@ -273,7 +280,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
@@ -302,40 +309,44 @@
     #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
     #else
     #if wxUSE_UNICODE_MSLU
         #define  wxRemove    wxMSLU__tremove
         #define  wxRename    wxMSLU__trename
     #else
-        #define  wxRemove    _tremove
-        #define  wxRename    _trename
+        #ifdef __WXWINCE__
+            #define  wxRemove    DeleteFile
+        #else
+            #define  wxRemove    _tremove
+            #define  wxRename    _trename
+        #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
+        /*  this is probably glibc-specific */
         #if defined(__WCHAR_TYPE__)
         #if defined(__WCHAR_TYPE__)
-            // ctype.h functions (wctype.h)
+            /*  ctype.h functions (wctype.h) */
             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha
             #define  wxIsctrl    iswcntrl
             #define  wxIsalnum   iswalnum
             #define  wxIsalpha   iswalpha
             #define  wxIsctrl    iswcntrl
@@ -349,24 +360,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
@@ -406,22 +417,109 @@
                 #define wxPutchar(wch) wxPutc(wch, stdout)
             #endif
 
                 #define wxPutchar(wch) wxPutc(wch, 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
+
+            /*  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
+        #elif defined(__MWERKS__) && ( defined(macintosh) || defined(__MACH__) )
+            /*  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
+            #define  wxTolower   towlower
+            #define  wxToupper   towupper
+
+            /*  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_   wxWcslen /*  wxStrlen_() is used in wxStrlen() */
+            #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  wxStrtol    wcstol
+            #define  wxStrtoul   wcstoul
+            #define  wxStrxfrm   wcsxfrm
+
+            #define  wxFgetc     fgetwc
+            #define  wxFgetchar  fgetwchar
+            #define  wxFgets     fgetws
+            #define  wxFputc     fputwc
+            #define  wxFputchar  fputwchar
+            #define  wxGetc      getwc
+            #define  wxGetchar   getwchar
+            #define  wxGets      getws
+            #define  wxUngetc    ungetwc
+
             #define wxNEED_PRINTF_CONVERSION
 
             #define wxNEED_PRINTF_CONVERSION
 
-            // glibc doesn't have wide char equivalents of the other stuff so
-            // use our own versions
+            #define  wxPutc      putwc
+            #define  wxPutchar   putwchar
+            #define  wxFputs     fputws
+            
+            /*  stdio.h functions */
+            
+             #define wxNEED_WX_STDIO_H
+
+            /*  stdlib.h functions */
+            #define  wxAtof      watof
+            #define  wxAtoi      watoi
+            #define  wxAtol      watol
+            #define  wxGetenv(a)    ((wxChar*)NULL)
+            #define  wxSystem(a)    ((int)NULL)
+
+            /*  time.h functions */
+            #define  wxAsctime   wasciitime
+            #define  wxCtime     wctime
+            /*  #define  wxStrftime  wcsftime */
+
+            /*
+            #define wxNEED_FPUTWC
+
+            #include <stdio.h>
+
+            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_STDIO_H
             #define wxNEED_WX_STDLIB_H
+            */
             #define wxNEED_WX_TIME_H
             #define wxNEED_WX_TIME_H
-        #else // !glibc
+        #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  wxIsctrl    isctrl
         #define  wxIsalnum   isalnum
         #define  wxIsalpha   isalpha
         #define  wxIsctrl    isctrl
@@ -436,21 +534,19 @@
         #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  wxStrcoll   strcoll
         #define  wxStrcpy    strcpy
         #define  wxStrcspn   strcspn
         #define  wxStrcat    strcat
         #define  wxStrchr    strchr
         #define  wxStrcmp    strcmp
         #define  wxStrcoll   strcoll
         #define  wxStrcpy    strcpy
         #define  wxStrcspn   strcspn
-        #if !defined(__MWERKS__) || !defined(__WXMAC__)
-            #define  wxStrdup    strdup
-        #endif
-        // 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
@@ -466,18 +562,20 @@
         #define  wxStrtoul   strtoul
         #define  wxStrxfrm   strxfrm
 
         #define  wxStrtoul   strtoul
         #define  wxStrxfrm   strxfrm
 
-        // stdio.h functions
+        /*  stdio.h functions */
         #define  wxFopen     fopen
         #define  wxFreopen   freopen
         #define  wxFopen     fopen
         #define  wxFreopen   freopen
-        #define  wxPerror    perror
         #define  wxRemove    remove
         #define  wxRename    rename
         #define  wxRemove    remove
         #define  wxRename    rename
+
+        #define  wxPerror    perror
         #define  wxTmpnam    tmpnam
 
         #define  wxFgetc     fgetc
         #define  wxFgetchar  fgetchar
         #define  wxFgets     fgets
         #define  wxFputc     fputc
         #define  wxTmpnam    tmpnam
 
         #define  wxFgetc     fgetc
         #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
@@ -497,47 +595,47 @@
         #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
-//
-// note that in Unicode mode we definitely are going to need our own version
+/*  define wxStricmp and wxStrnicmp for various compilers */
+/*  */
+/*  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__) || \
             defined(__EMX__) || defined(__DJGPP__)
         #define wxStricmp stricmp
         #define wxStrnicmp strnicmp
 #if !defined(wxStricmp) && !wxUSE_UNICODE
     #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
             defined(__SALFORDC__) || defined(__VISAGECPP__) || \
             defined(__EMX__) || defined(__DJGPP__)
         #define wxStricmp stricmp
         #define wxStrnicmp strnicmp
-    #elif defined(__SC__) || defined(__VISUALC__) || \
+    #elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
             (defined(__MWERKS__) && defined(__INTEL__))
         #define wxStricmp _stricmp
         #define wxStrnicmp _strnicmp
     #elif defined(__UNIX__) || defined(__GNUWIN32__)
         #define wxStricmp strcasecmp
         #define wxStrnicmp strncasecmp
             (defined(__MWERKS__) && defined(__INTEL__))
         #define wxStricmp _stricmp
         #define wxStrnicmp _strnicmp
     #elif defined(__UNIX__) || defined(__GNUWIN32__)
         #define wxStricmp strcasecmp
         #define wxStrnicmp strncasecmp
-    // #else -- use wxWindows implementation
+    /*  #else -- use wxWindows 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
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCSLEN
         #define wxWcslen wcslen
@@ -551,19 +649,43 @@
             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
+        /*  checks whether the passed in pointer is NULL and if the string is empty */
+#ifdef __cplusplus
 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 */
+#if wxUSE_UNICODE
+    #define wxStrdup wxStrdupW
+#else
+    #define wxStrdup wxStrdupA
+#endif
 
 
-WXDLLEXPORT 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
+   headers, so we need to declare it ourselves to be able to use it.
+ */
+#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 */
 
 /*
    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
@@ -576,28 +698,34 @@ WXDLLEXPORT bool wxOKlibc(); // for internal use
  */
 #ifndef wxVsnprintf_
     #if wxUSE_UNICODE
  */
 #ifndef wxVsnprintf_
     #if wxUSE_UNICODE
+        #if defined(__MWERKS__)
+            #define HAVE_WCSRTOMBS 1
+            #define HAVE_VSWPRINTF 1
+        #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()
+    #else /*  ASCII */
+        /*  all versions of CodeWarrior supported by wxWindows apparently have */
+        /*  vsnprintf() */
         #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
         #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
-            // assume we have snprintf() too if we have vsnprintf()
+            /*  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 wxVsnprintf_
-    // no [v]snprintf(), cook our own
-    WXDLLEXPORT int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
+#ifndef wxSnprintf_
+    /*  no [v]snprintf(), cook our own */
+    WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
                                 ...) ATTRIBUTE_PRINTF_3;
                                 ...) ATTRIBUTE_PRINTF_3;
-    WXDLLEXPORT int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
+#endif
+#ifndef wxVsnprintf_
+    WXDLLIMPEXP_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
                                  va_list argptr);
 #endif
 
                                  va_list argptr);
 #endif
 
@@ -629,11 +757,11 @@ WXDLLEXPORT bool wxOKlibc(); // for internal use
 #endif
 
 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 #endif
 
 #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;
@@ -645,10 +773,10 @@ WXDLLEXPORT 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
+/*  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
     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 );
 #ifdef wxNEED_PRINTF_CONVERSION
     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 );
@@ -657,130 +785,150 @@ WXDLLEXPORT 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
-//
-// VZ: note that this is never defined currently
+/*  ctype.h functions */
+/*  */
+/*  VZ: note that this is never defined currently */
 #ifdef wxNEED_WX_CTYPE_H
 #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 // 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
+    WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
+    WXDLLIMPEXP_BASE int wxIsupper(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 */
+
+/*  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++ */
 
 
 
 
-// string.h functions
-//
-// VZ: this is never defined neither currently
+/*  string.h functions */
+/*  */
+/*  VZ: this is never defined neither currently */
 #ifdef wxNEED_WX_STRING_H
 #ifdef wxNEED_WX_STRING_H
-    WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src);
-    WXDLLEXPORT const wxChar * wxStrchr(const wxChar *s, wxChar c);
-    WXDLLEXPORT wxChar * wxStrchr(wxChar *s, wxChar c)
+    WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
+    WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
+    WXDLLIMPEXP_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
         { return (wxChar *)wxStrchr((const wxChar *)s, c); }
         { return (wxChar *)wxStrchr((const wxChar *)s, 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 const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
-    WXDLLEXPORT wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
+    WXDLLIMPEXP_BASE int      wxStrcmp(const wxChar *s1, const wxChar *s2);
+    WXDLLIMPEXP_BASE int      wxStrcoll(const wxChar *s1, const wxChar *s2);
+    WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
+    WXDLLIMPEXP_BASE size_t   wxStrcspn(const wxChar *s, const wxChar *reject);
+    WXDLLIMPEXP_BASE size_t   wxStrlen(const wxChar *s);
+    WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
+    WXDLLIMPEXP_BASE int      wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
+    WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
+    WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
+    WXDLLIMPEXP_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
         { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
         { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
-    WXDLLEXPORT const wxChar * wxStrrchr(const wxChar *s, wxChar c);
-    WXDLLEXPORT wxChar * wxStrrchr(wxChar *s, wxChar c)
+    WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
+    WXDLLIMPEXP_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
         { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
         { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
-    WXDLLEXPORT size_t   wxStrspn(const wxChar *s, const wxChar *accept);
-    WXDLLEXPORT const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
-    WXDLLEXPORT wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
+    WXDLLIMPEXP_BASE size_t   wxStrspn(const wxChar *s, const wxChar *accept);
+    WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
+    WXDLLIMPEXP_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
         { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
         { return (wxChar *)wxStrstr((const wxChar *)haystack, 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 // wxNEED_WX_STRING_H
-
-#ifndef wxStrdup
-WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz);
+    WXDLLIMPEXP_BASE double   wxStrtod(const wxChar *nptr, wxChar **endptr);
+    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 */
+
+#ifndef wxStrdupA
+WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
+#endif
+
+#ifndef wxStrdupW
+WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
 #endif
 
 #ifndef wxStricmp
 #endif
 
 #ifndef wxStricmp
-WXDLLEXPORT int wxStricmp(const wxChar *psz1, const wxChar *psz2);
+WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
 #endif
 
 #ifndef wxStrnicmp
 #endif
 
 #ifndef wxStrnicmp
-WXDLLEXPORT int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
+WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
 #endif
 
 #ifndef wxStrtok
 #endif
 
 #ifndef wxStrtok
-WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
+WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
 #endif
 
 #ifndef wxSetlocale
 #endif
 
 #ifndef wxSetlocale
-class WXDLLEXPORT wxWCharBuffer;
-WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
+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>
 #ifdef wxNEED_WX_STDIO_H
     #include <stdio.h>
-    WXDLLEXPORT FILE *   wxFopen(const wxChar *path, const wxChar *mode);
-    WXDLLEXPORT FILE *   wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
-    WXDLLEXPORT int      wxRemove(const wxChar *path);
-    WXDLLEXPORT int      wxRename(const wxChar *oldpath, const wxChar *newpath);
+    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);
 
 
-    // *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
 #ifndef wxAtof
-WXDLLEXPORT double   wxAtof(const wxChar *psz);
+WXDLLIMPEXP_BASE double   wxAtof(const wxChar *psz);
 #endif
 
 #ifdef wxNEED_WX_STDLIB_H
 #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);
+WXDLLIMPEXP_BASE int      wxAtoi(const wxChar *psz);
+WXDLLIMPEXP_BASE long     wxAtol(const wxChar *psz);
+WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
+WXDLLIMPEXP_BASE int      wxSystem(const wxChar *psz);
 #endif
 
 
 #endif
 
 
-// time.h functions
+/*  time.h functions */
 #ifdef wxNEED_WX_TIME_H
 #ifdef wxNEED_WX_TIME_H
-    WXDLLEXPORT size_t wxStrftime(wxChar *s, size_t max,
+#if defined(__MWERKS__) && defined(macintosh)
+    #include <time.h> 
+#endif
+    WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
                                   const wxChar *fmt, const struct tm *tm);
                                   const wxChar *fmt, const struct tm *tm);
-#endif // wxNEED_WX_TIME_H
+#endif /*  wxNEED_WX_TIME_H */
+
+/*  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
-    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);
+    /*  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);
 
     #if wxUSE_UNICODE
         #define wxMB2WX wxMB2WC
 
     #if wxUSE_UNICODE
         #define wxMB2WX wxMB2WC
@@ -793,8 +941,8 @@ WXDLLEXPORT 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
@@ -803,5 +951,5 @@ WXDLLEXPORT int      wxSystem(const wxChar *psz);
     #define wxWX2WC wxMB2WC
 #endif
 
     #define wxWX2WC wxMB2WC
 #endif
 
-#endif //_WX_WXCHAR_H_
+#endif /* _WX_WXCHAR_H_ */
 
 
wxWidgets (Impactor)