X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/af49c4b8a2d3553e733e71c7dd3911881f4c1a2a..682214d5c6ec3e56dbdfd0c97d70d87e614b38c2:/include/wx/wxchar.h

diff --git a/include/wx/wxchar.h b/include/wx/wxchar.h
index d120ab33d8..dd6e3851c2 100644
--- a/include/wx/wxchar.h
+++ b/include/wx/wxchar.h
@@ -1,220 +1,226 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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_
 
-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #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(__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
             #define wxUSE_WCHAR_T 0
         #endif
-    #elif defined(__GNUWIN32__) && !defined(__MINGW32__) // Cygwin (not Mingw32) doesn't have wcslen.h, needed in buffer.h
+    #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
         #define wxUSE_WCHAR_T 0
     #elif defined(__WATCOMC__)
         #define wxUSE_WCHAR_T 0
     #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
-#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"
-#endif // Unicode
+#endif /* Unicode */
+
+/*
+    Standard headers we need here.
 
-// ----------------------------------------------------------------------------
-// standard headers we need here
-//
-// NB: don't include any wxWindows headers here because almost of them include
-//     this one!
-// ----------------------------------------------------------------------------
+    NB: don't include any wxWidgets headers here because almost of them include
+        this one!
+ */
 
-// Required for wxPrintf() etc
+/* Required for wxPrintf() etc */
 #include <stdarg.h>
 
-#if defined(__CYGWIN__)
-    #ifndef HAVE_WCSLEN
-        #define HAVE_WCSLEN
-    #endif // !HAVE_WCSLEN
-    #include <stddef.h>
+/* 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)
-#if defined(__MWERKS__) || defined(__VISAGECPP__)
+/*
+   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
+#if defined(__MWERKS__) && !defined(__MACH__)
+    #ifndef HAVE_WCSLEN
+        #define HAVE_WCSLEN
+    #endif
+#endif
 
 #if wxUSE_WCHAR_T
     #ifdef HAVE_WCHAR_H
-        // include wchar.h to get wcslen() declaration used by wx/buffer.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>
+            #ifdef __cplusplus
+                extern "C" {
+            #endif
+        #endif /* Cygwin */
+
         #include <wchar.h>
+
+        #if defined(__CYGWIN__) && defined(__cplusplus)
+            }
+        #endif /* Cygwin and C++ */
+
     #elif defined(HAVE_WCSTR_H)
-        // old compilers have wcslen() here
+        /* old compilers have relevant declarations here */
         #include <wcstr.h>
     #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
-        // include stdlib.h for wchar_t, wcslen is provided in wxchar.cpp
+        /* include stdlib.h for wchar_t */
         #include <stdlib.h>
-        size_t WXDLLEXPORT wcslen(const wchar_t *s);
-    #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>
-#elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
+#elif defined(__WATCOMC__)
+    #define wxHAVE_TCHAR_SUPPORT
+#elif defined(__DMC__)
+    #define wxHAVE_TCHAR_SUPPORT
+#elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 ) && !defined(__WXPALMOS__)
     #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
-#endif // compilers with (good) TCHAR support
+#endif /* compilers with (good) 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>
 
-    // 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
-    #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
-#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;
-#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))
-        // standard case
+        /* standard case */
         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;
-    #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
 
-// 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
-    #else // Unicode
+    #else /* Unicode */
         #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)
 
-// 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__)
@@ -230,44 +236,58 @@
     #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
-    // ctype.h functions
-    #define  wxIsalnum   _istalnum
-    #define  wxIsalpha   _istalpha
-    #define  wxIsctrl    _istctrl
-    #define  wxIsdigit   _istdigit
-    #define  wxIsgraph   _istgraph
-    #define  wxIslower   _istlower
-    #define  wxIsprint   _istprint
-    #define  wxIspunct   _istpunct
-    #define  wxIsspace   _istspace
-    #define  wxIsupper   _istupper
-    #define  wxIsxdigit  _istxdigit
-    #define  wxTolower   _totlower
-    #define  wxToupper   _totupper
-
-    // locale.h functons
+    #include <ctype.h>
+
+    #if defined(__WATCOMC__) && defined(UNICODE)
+      #define WXWCHAR_T_CAST(c) (wint_t)(c)
+    #else
+      #define WXWCHAR_T_CAST(c) c
+    #endif
+
+    /* ctype.h functions */
+    #define  wxIsalnum(c)   _istalnum(WXWCHAR_T_CAST(c))
+    #define  wxIsalpha(c)   _istalpha(WXWCHAR_T_CAST(c))
+    #define  wxIscntrl(c)   _istcntrl(WXWCHAR_T_CAST(c))
+    #define  wxIsdigit(c)   _istdigit(WXWCHAR_T_CAST(c))
+    #define  wxIsgraph(c)   _istgraph(WXWCHAR_T_CAST(c))
+    #define  wxIslower(c)   _istlower(WXWCHAR_T_CAST(c))
+    #define  wxIsprint(c)   _istprint(WXWCHAR_T_CAST(c))
+    #define  wxIspunct(c)   _istpunct(WXWCHAR_T_CAST(c))
+    #define  wxIsspace(c)   _istspace(WXWCHAR_T_CAST(c))
+    #define  wxIsupper(c)   _istupper(WXWCHAR_T_CAST(c))
+    #define  wxIsxdigit(c)  _istxdigit(WXWCHAR_T_CAST(c))
+
+    /*
+       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
 
-    // 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  wxStrdupW   _wcsdup        /* notice the 'W'! */
     #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
@@ -280,11 +300,15 @@
     #define  wxStrtoul   _tcstoul
     #define  wxStrxfrm   _tcsxfrm
 
-    // stdio.h functions
+    /* stdio.h functions */
     #define  wxFgetc     _fgettc
     #define  wxFgetchar  _fgettchar
     #define  wxFgets     _fgetts
-    #define  wxFopen     _tfopen
+    #if wxUSE_UNICODE_MSLU
+        #define  wxFopen    wxMSLU__tfopen
+    #else
+        #define  wxFopen     _tfopen
+    #endif
     #define  wxFputc     _fputtc
     #define  wxFputchar  _fputtchar
     #define  wxFprintf   _ftprintf
@@ -296,11 +320,22 @@
     #define  wxGets      _getts
     #define  wxPerror    _tperror
     #define  wxPrintf    _tprintf
-    #define  wxPutc      _puttc
+    #define  wxPutc(c,f) _puttc(WXWCHAR_T_CAST(c),f)
     #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
@@ -309,36 +344,107 @@
     #define  wxVsscanf   _vstscanf
     #define  wxVsprintf  _vstprintf
 
-    // special case: these functions are missing under Win9x with Unicows so we
-    // have to implement them ourselves
+    /* special case: not all TCHAR-aware compilers have those */
+    #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 */
     #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
 
-    // stdlib.h functions
+    /* stdlib.h functions */
     #define  wxAtoi      _ttoi
     #define  wxAtol      _ttol
-    // #define  wxAtof   _tttof -- notice that there is no such thing (why?)
-    #define  wxGetenv    _tgetenv
+    /* #define  wxAtof   _tttof -- notice that there is no such thing (why?) */
+    /* there are no env vars at all under CE, so no _tgetenv neither */
+    #ifdef __WXWINCE__
+        /* can't define as inline function as this is a C file... */
+        #define wxGetenv(name)  ((wxChar *)NULL)
+    #else
+        #define  wxGetenv    _tgetenv
+    #endif
     #define  wxSystem    _tsystem
 
-    // time.h functions
+    /* time.h functions */
     #define  wxAsctime   _tasctime
     #define  wxCtime     _tctime
-#else // !TCHAR-aware compilers
-    #if wxUSE_UNICODE
+#else /* !TCHAR-aware compilers */
+
+    #if !defined(__MWERKS__) && defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 )
+        /* even though they are defined and "implemented", they are bad and just
+           stubs so we need our own - we need these even in ANSI builds!! */
+        #define mbstowcs wxInternalMbstowcs
+        #define wcstombs wxInternalWcstombs
+
+        WXDLLIMPEXP_BASE size_t wxInternalMbstowcs (wchar_t *, const char *, size_t);
+        WXDLLIMPEXP_BASE size_t wxInternalWcstombs (char *, const wchar_t *, size_t);
+    #endif
+
+    /* No UNICODE in the c library except wchar_t typedef on mac OSX 10.2 and less - roll our own */
+    #if !defined(__MWERKS__) && wxUSE_UNICODE && defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 )
+
+        /* we need everything! */
+        #define wxNEED_WX_STRING_H
+        #define wxNEED_WX_CTYPE_H
+
+        #define  wxFgetchar(c)  wxFgetc(c, stdin)
+        #define  wxFputc     wxPutc
+        #define  wxFputchar(c)  wxPutc(c, stdout)
+        #define  wxGetc      wxFgetc
+        #define  wxGetchar(c)   wxFgetc(c, stdin)
+
+        #include <stdio.h>
+
+        #define wxNEED_FGETC
+        #define wxNEED_FGETS
+        #define wxNEED_GETS
+        #define wxNEED_UNGETC
+
+        #define wxNEED_FPUTS
+        #define wxNEED_PUTS
+        #define wxNEED_PUTC
+
+        int wxFputs(const wxChar *ch, FILE *stream);
+        int wxPuts(const wxChar *ws);
+        int wxPutc(wxChar ch, FILE *stream);
+
+        #ifdef __cplusplus
+        extern "C" {
+        #endif
+            WXDLLIMPEXP_BASE size_t   wxStrlen_(const wxChar *s);
+        #ifdef __cplusplus
+        }
+        #endif
+
+        #define wxPutchar(wch) wxPutc(wch, stdout)
+
+        #define wxNEED_PRINTF_CONVERSION
+        #define wxNEED_WX_STDIO_H
+        #define wxNEED_WX_STDLIB_H
+        #define wxNEED_WX_TIME_H
+
+    #elif 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  wxIsctrl    iswcntrl
+            #define  wxIscntrl   iswcntrl
             #define  wxIsdigit   iswdigit
             #define  wxIsgraph   iswgraph
             #define  wxIslower   iswlower
@@ -349,24 +455,24 @@
             #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)
-            #else // !glibc 2.0
+            #else /* !glibc 2.0 */
                 #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  wxStrlen_   wcslen // used in wxStrlen inline function
+            #define  wxStrlen_   wxWcslen /* wxStrlen_() is used in wxStrlen() */
             #define  wxStrncat   wcsncat
             #define  wxStrncmp   wcsncmp
             #define  wxStrncpy   wcsncpy
@@ -375,7 +481,6 @@
             #define  wxStrspn    wcsspn
             #define  wxStrstr    wcsstr
             #define  wxStrtod    wcstod
-            #define  wxStrtok    wcstok
             #define  wxStrtol    wcstol
             #define  wxStrtoul   wcstoul
             #define  wxStrxfrm   wcsxfrm
@@ -390,42 +495,126 @@
             #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
-                #define wxNEED_FPUTWC
-
+                #define wxNEED_FPUTS
                 #include <stdio.h>
-
                 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);
+            #endif
 
-                #define wxPuts(ws) wxFputs(ws, stdout)
+            #ifdef HAVE_WPUTCHAR
+                #define wxPutchar   wputchar
+            #else
                 #define wxPutchar(wch) wxPutc(wch, stdout)
             #endif
 
-            // we need %s to %ls conversion for printf and scanf etc
+            #ifdef HAVE_PUTWS
+                #define wxPuts      putws
+            #else
+                #define wxNEED_PUTS
+                int wxPuts(const wxChar *ws);
+            #endif
+
+            /* 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
+            /* 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
-        #else // !glibc
+        #elif defined(__MWERKS__) && ( defined(__MSL__) || defined(__MACH__) )
+            /* ctype.h functions (wctype.h) */
+            #define  wxIsalnum   iswalnum
+            #define  wxIsalpha   iswalpha
+            #define  wxIscntrl   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  wxPutc      putwc
+            #define  wxPutchar   putwchar
+            #define  wxFputs     fputws
+
+            /* 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)
+            #endif
+            /* time.h functions */
+            #define  wxAsctime   wasciitime
+            #define  wxCtime     wctime
+            /* #define  wxStrftime  wcsftime */
+
+            #define wxNEED_WX_TIME_H
+        #else /* !metrowerks for apple */
             #error  "Please define wide character functions for your environment"
         #endif
-    #else // ASCII
+    #else /* ASCII */
         #include <ctype.h>
         #include <string.h>
 
-        // ctype.h functions
+        /* ctype.h functions */
         #define  wxIsalnum   isalnum
         #define  wxIsalpha   isalpha
-        #define  wxIsctrl    isctrl
+        #define  wxIscntrl   iscntrl
         #define  wxIsdigit   isdigit
         #define  wxIsgraph   isgraph
         #define  wxIslower   islower
@@ -437,21 +626,19 @@
         #define  wxTolower   tolower
         #define  wxToupper   toupper
 
-         // locale.h functons
+         /* locale.h functons */
         #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
-        #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
@@ -462,25 +649,25 @@
         #define  wxStrtod    strtod
         #ifdef HAVE_STRTOK_R
             #define  wxStrtok(str, sep, last)    strtok_r(str, sep, last)
-        #else
-            #define  wxStrtok(str, sep, last)    strtok(str, sep)
         #endif
         #define  wxStrtol    strtol
         #define  wxStrtoul   strtoul
         #define  wxStrxfrm   strxfrm
 
-        // stdio.h functions
+        /* stdio.h functions */
         #define  wxFopen     fopen
         #define  wxFreopen   freopen
-        #define  wxPerror    perror
         #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  wxFputs     fputs
         #define  wxFputchar  fputchar
         #define  wxFprintf   fprintf
         #define  wxFscanf    fscanf
@@ -500,72 +687,100 @@
         #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
 
-        // time.h functions
+        /* time.h functions */
         #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__) || \
             defined(__EMX__) || defined(__DJGPP__)
         #define wxStricmp stricmp
         #define wxStrnicmp strnicmp
-    #elif defined(__SC__) || defined(__VISUALC__) || \
+    #elif defined(__WXPALMOS__)
+        /* FIXME: There is no equivalent to strnicmp in the Palm OS API.  This
+         * quick hack should do until one can be written.
+         */
+        #define wxStricmp StrCaselessCompare
+        #define wxStrnicmp strnicmp
+    #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
-    // #else -- use wxWindows implementation
+    /* #else -- use wxWidgets implementation */
     #endif
-#endif // !defined(wxStricmp)
-
-// checks whether the passed in pointer is NULL and if the string is empty
-inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
+#endif /* !defined(wxStricmp) */
 
-// safe version of strlen() (returns 0 if passed NULL pointer)
-inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
-
-// define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
-// it's used in wx/buffer.h)
+/* 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
-        inline size_t wxWcslen(const wchar_t *s)
-        {
-            size_t n = 0;
-            while ( *s++ )
-                n++;
-
-            return n;
-        }
+        WXDLLIMPEXP_BASE size_t wxWcslen(const wchar_t *s);
     #endif
-#endif // wxUSE_WCHAR_T
+#endif /* wxUSE_WCHAR_T */
+
+#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; }
 
-WXDLLEXPORT bool wxOKlibc(); // for internal use
+/* safe version of strlen() (returns 0 if passed NULL pointer) */
+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
 
-// ----------------------------------------------------------------------------
-// printf() family saga
-// ----------------------------------------------------------------------------
+#ifdef __cplusplus
+WXDLLIMPEXP_BASE bool wxOKlibc(); /* for internal use */
+#endif
+
+/* 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)
+#ifdef __cplusplus
+    extern "C"
+#else
+    extern
+#endif
+    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
@@ -576,30 +791,40 @@ WXDLLEXPORT bool wxOKlibc(); // for internal use
    We define function with a trailing underscore here because the real one is a
    wrapper around it as explained below
  */
-#ifdef wxHAVE_TCHAR_SUPPORT
-    #define wxVsnprintf_    _vsntprintf
-    #define wxSnprintf_     _sntprintf
-#else // !TCHAR
+#ifndef wxVsnprintf_
     #if wxUSE_UNICODE
-        #if defined(HAVE_VSWPRINTF)
+        #if defined(__MWERKS__)
+            #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
-    #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
-#endif // TCHAR/!TCHAR
+#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;
-    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
 
@@ -623,166 +848,248 @@ WXDLLEXPORT 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().
 
-   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)
-    // 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_2;
-    int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
-    int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
+    int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
+    int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
+    int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
     int wxVsscanf( const wxChar *str, const wxChar *format, va_list ap );
-    int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
-    int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
-    int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
+    int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
+    int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
+    int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
     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
-    int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_4;
+/* 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
     #define wxSnprintf wxSnprintf_
     #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 */
+
+/* RN: Used only under OSX <= 10.2 currently */
 #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 wxIscntrl(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))
-#endif // VC++
+#endif /* VC++ */
+
+/*
+   a few compilers don't have the (non standard but common) isascii function,
+   define it ourselves for them
+ */
+#ifndef isascii
+    #if defined(__MWERKS__)
+        #define wxNEED_ISASCII
+    #elif defined(_WIN32_WCE)
+        #if _WIN32_WCE <= 211
+            #define wxNEED_ISASCII
+        #endif
+    #endif
+#endif /* isascii */
+
+#ifdef wxNEED_ISASCII
+    inline int isascii(int c) { return (unsigned)c < 0x80; }
+#endif
+
+#ifdef _WIN32_WCE
+    #if _WIN32_WCE <= 211
+        #define isspace(c) ((c) == _T(' ') || (c) == _T('\t'))
+    #endif
+#endif /* _WIN32_WCE */
+
+/*
+   we had goofed and defined wxIsctrl() 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 */
+#ifndef strdup
+    #if defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)
+        #define wxNEED_STRDUP
+    #elif defined(__WXWINCE__)
+        #if _WIN32_WCE <= 211
+            #define wxNEED_STRDUP
+        #endif
+    #endif
+#endif /* strdup */
 
+#ifdef wxNEED_STRDUP
+    WXDLLIMPEXP_BASE char *strdup(const char* s);
+#endif
 
-// string.h functions
-//
-// VZ: this is never defined neither currently
+/* RN: Used only under OSX <= 10.2 currently
+   The __cplusplus ifdefs are messy, but they are required to build
+   the regex library, since c does not support function overloading
+*/
 #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)
-        { 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)
-        { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
-    WXDLLEXPORT const wxChar * wxStrrchr(const wxChar *s, wxChar c);
-    WXDLLEXPORT wxChar * wxStrrchr(wxChar *s, wxChar 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)
-        { 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);
+# ifdef __cplusplus
+    extern "C" {
+# endif
+        WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
+        WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
+        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 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 const wxChar * wxStrrchr(const wxChar *s, wxChar c);
+        WXDLLIMPEXP_BASE size_t   wxStrspn(const wxChar *s, const wxChar *accept);
+        WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
+# ifdef __cplusplus
+    }
+# endif
+
+    /* These functions use C++, so we can't c extern them */
+    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);
+
+    /* inlined versions */
+    #ifdef __cplusplus
+        inline wxChar * wxStrchr(wxChar *s, wxChar c)
+            { return (wxChar *)wxStrchr((const wxChar *)s, c); }
+        inline wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
+            { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
+        inline wxChar * wxStrrchr(wxChar *s, wxChar c)
+            { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
+        inline wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
+            { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
+    #endif
+
+#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
-WXDLLEXPORT int wxStricmp(const wxChar *psz1, const wxChar *psz2);
+WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
 #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
-WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
+WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
 #endif
 
+#ifdef __cplusplus
 #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>
-    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
-WXDLLEXPORT double   wxAtof(const wxChar *psz);
+WXDLLIMPEXP_BASE double   wxAtof(const wxChar *psz);
 #endif
 
 #ifdef wxNEED_WX_STDLIB_H
-WXDLLEXPORT int      wxAtoi(const wxChar *psz);
-WXDLLEXPORT long     wxAtol(const wxChar *psz);
-WXDLLEXPORT wxChar * wxGetenv(const wxChar *name);
-WXDLLEXPORT int      wxSystem(const wxChar *psz);
+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
 
 
-// time.h functions
+/* time.h functions */
 #ifdef wxNEED_WX_TIME_H
-    WXDLLEXPORT size_t wxStrftime(wxChar *s, size_t max,
+#if defined(__MWERKS__) && defined(macintosh)
+    #include <time.h>
+#endif
+    /*silent gabby compilers*/
+    struct tm;
+    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
+#endif /* _WIN32_WCE */
 
-// ----------------------------------------------------------------------------
-// multibyte to wide char conversion functions and macros
-// ----------------------------------------------------------------------------
+/* multibyte to wide char conversion functions and macros */
 
 #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
@@ -795,8 +1102,10 @@ WXDLLEXPORT int      wxSystem(const wxChar *psz);
         #define wxWC2WX wxWC2MB
         #define wxWX2WC wxMB2WC
     #endif
-#else // !wxUSE_UNICODE
-    // No wxUSE_WCHAR_T: we have to do something (JACS)
+#else /* !wxUSE_UNICODE */
+/* Why is this here?
+#error ha */
+    /* No wxUSE_WCHAR_T: we have to do something (JACS) */
     #define wxMB2WC wxStrncpy
     #define wxWC2MB wxStrncpy
     #define wxMB2WX wxStrncpy
@@ -805,5 +1114,75 @@ WXDLLEXPORT int      wxSystem(const wxChar *psz);
     #define wxWX2WC wxMB2WC
 #endif
 
-#endif //_WX_WXCHAR_H_
+/*
+    RN:  The following are not normal versions of memcpy et al., rather
+    these are either char or widechar versions depending on
+    if unicode is used or not.
+*/
+
+#ifdef __cplusplus
+
+    //
+    //  RN: We could do the usual tricky compiler detection here,
+    //  and use their variant (such as wmemchr, etc.).  The problem
+    //  is that these functions are quite rare, even though they are
+    //  part of the current POSIX standard.  In addition, most compilers
+    //  (including even MSC) inline them just like we do right in their
+    //  headers.
+    //
+    #if wxUSE_UNICODE
+        #include <string.h> //for mem funcs
+
+        //implement our own wmem variants
+        inline wxChar* wxTmemchr(const wxChar* s, wxChar c, size_t l)
+        {
+            for(;l && *s != c;--l, ++s) {}
+
+            if(l)
+                return (wxChar*)s;
+            return NULL;
+        }
+
+        inline int wxTmemcmp(const wxChar* sz1, const wxChar* sz2, size_t len)
+        {
+            for(; *sz1 == *sz2 && len; --len, ++sz1, ++sz2) {}
+
+            if(len)
+                return *sz1 < *sz2 ? -1 : *sz1 > *sz2;
+            else
+                return 0;
+        }
+
+        inline wxChar* wxTmemcpy(wxChar* szOut, const wxChar* szIn, size_t len)
+        {
+            return (wxChar*) memcpy(szOut, szIn, len * sizeof(wxChar));
+        }
+
+        inline wxChar* wxTmemmove(wxChar* szOut, const wxChar* szIn, size_t len)
+        {
+            return (wxChar*) memmove(szOut, szIn, len * sizeof(wxChar));
+        }
+
+        inline wxChar* wxTmemset(wxChar* szOut, const wxChar cIn, size_t len)
+        {
+            wxChar* szRet = szOut;
+
+            while (len--)
+                *szOut++ = cIn;
+
+            return szRet;
+        }
+
+    #else //!wxUSE_UNICODE
+    #   define wxTmemchr memchr
+    #   define wxTmemcmp memcmp
+    #   define wxTmemcpy memcpy
+    #   define wxTmemmove memmove
+    #   define wxTmemset memset
+    #endif
+
+#endif /*__cplusplus*/
+
+
+#endif /* _WX_WXCHAR_H_ */