remove wxTextAttr::CreateFont(); return wxNullFont from GetFont() if we have no font...

[wxWidgets.git] / src / common / wxcrt.cpp

diff --git a/src/common/wxcrt.cpp b/src/common/wxcrt.cpp
index 2f84583445512d41840f6f92f7121d24b0034c98..6f3377d6cd3e7b13ed557280e27d5e9164fbef1b 100644 (file)
--- a/src/common/wxcrt.cpp
+++ b/src/common/wxcrt.cpp
@@ -21,6 +21,7 @@
 #endif
 
 #include "wx/crt.h"
 #endif
 
 #include "wx/crt.h"

+#include "wx/strconv.h" // wxMBConv::cWC2MB()

 
 #define _ISOC9X_SOURCE 1 // to get vsscanf()
 #define _BSD_SOURCE    1 // to still get strdup()
 
 #define _ISOC9X_SOURCE 1 // to get vsscanf()
 #define _BSD_SOURCE    1 // to still get strdup()


@@ -29,12 +30,14 @@
 #include <stdlib.h>
 #include <string.h>
 
 #include <stdlib.h>
 #include <string.h>
 

+#ifndef __WXPALMOS5__

 #ifndef __WXWINCE__
     #include <time.h>
     #include <locale.h>
 #else
     #include "wx/msw/wince/time.h"
 #endif
 #ifndef __WXWINCE__
     #include <time.h>
     #include <locale.h>
 #else
     #include "wx/msw/wince/time.h"
 #endif

+#endif // !__WXPALMOS5__

 
 #ifndef WX_PRECOMP
     #include "wx/string.h"
 
 #ifndef WX_PRECOMP
     #include "wx/string.h"


@@ -43,11 +46,8 @@
     #include "wx/log.h"
 #endif
 
     #include "wx/log.h"
 #endif
 

-#if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
-  #include <windef.h>
-    #include <winbase.h>
-    #include <winnls.h>
-    #include <winnt.h>
+#ifdef HAVE_LANGINFO_H
+    #include <langinfo.h>

 #endif
 
 #ifdef __WXWINCE__
 #endif
 
 #ifdef __WXWINCE__


@@ -64,8 +64,15 @@ namespace std {}
 using namespace std ;
 #endif
 
 using namespace std ;
 #endif
 

+#if defined(__DARWIN__)
+       #include "wx/mac/corefoundation/cfref.h"
+       #include <CoreFoundation/CFLocale.h>
+       #include "wx/mac/corefoundation/cfstring.h"
+    #include <xlocale.h>
+#endif
+

 #if wxUSE_WCHAR_T
 #if wxUSE_WCHAR_T

-size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
+WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n)

 {
   // assume that we have mbsrtowcs() too if we have wcsrtombs()
 #ifdef HAVE_WCSRTOMBS
 {
   // assume that we have mbsrtowcs() too if we have wcsrtombs()
 #ifdef HAVE_WCSRTOMBS


@@ -98,7 +105,7 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 #endif
 }
 
 #endif
 }
 

-size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
+WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *pwz, size_t n)

 {
 #ifdef HAVE_WCSRTOMBS
   mbstate_t mbstate;
 {
 #ifdef HAVE_WCSRTOMBS
   mbstate_t mbstate;


@@ -126,7 +133,7 @@ size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 }
 #endif // wxUSE_WCHAR_T
 
 }
 #endif // wxUSE_WCHAR_T
 

-bool WXDLLEXPORT wxOKlibc()
+WXDLLIMPEXP_BASE bool wxOKlibc()

 {
 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
   // glibc 2.0 uses UTF-8 even when it shouldn't
 {
 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
   // glibc 2.0 uses UTF-8 even when it shouldn't


@@ -149,13 +156,41 @@ bool WXDLLEXPORT wxOKlibc()
 
 char* wxSetlocale(int category, const char *locale)
 {
 
 char* wxSetlocale(int category, const char *locale)
 {

+#ifdef __WXWINCE__
+    // FIXME-CE: there is no setlocale() in CE CRT, use SetThreadLocale()?
+    wxUnusedVar(category);
+    wxUnusedVar(locale);
+
+    return NULL;
+#else // !__WXWINCE__
+#ifdef __WXMAC__
+    char *rv = NULL ;
+    if ( locale != NULL && locale[0] == 0 )
+    {
+        // the attempt to use newlocale(LC_ALL_MASK, "", NULL);
+        // here in order to deduce the language along the environment vars rules
+        // lead to strange crashes later...
+
+        // we have to emulate the behaviour under OS X
+        wxCFRef<CFLocaleRef> userLocaleRef(CFLocaleCopyCurrent());
+        wxCFStringRef str(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleLanguageCode)));
+        wxString langFull = str.AsString()+"_";
+        str.reset(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleCountryCode)));
+        langFull += str.AsString();
+        rv = setlocale(category, langFull.c_str());
+    }
+    else
+        rv = setlocale(category, locale);
+#else

     char *rv = setlocale(category, locale);
     char *rv = setlocale(category, locale);

+#endif

     if ( locale != NULL /* setting locale, not querying */ &&
          rv /* call was successful */ )
     {
         wxUpdateLocaleIsUtf8();
     }
     return rv;
     if ( locale != NULL /* setting locale, not querying */ &&
          rv /* call was successful */ )
     {
         wxUpdateLocaleIsUtf8();
     }
     return rv;

+#endif // __WXWINCE__/!__WXWINCE__

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -246,21 +281,6 @@ static int vwscanf(const wchar_t *format, va_list argptr)
     return -1;
 }
 
     return -1;
 }
 

-static int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
-{
-    // The best we can do without proper Unicode support in glibc is to
-    // convert the strings into MB representation and run ANSI version
-    // of the function. This doesn't work with %c and %s because of difference
-    // in size of char and wchar_t, though.
-
-    wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
-                 _T("incomplete vswscanf implementation doesn't allow %s") );
-    wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
-                 _T("incomplete vswscanf implementation doesn't allow %c") );
-
-    return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argptr);
-}
-

 static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 {
     wxFAIL_MSG( _T("TODO") );
 static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 {
     wxFAIL_MSG( _T("TODO") );


@@ -268,7 +288,7 @@ static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
     return -1;
 }
 
     return -1;
 }
 

-#define vswprintf wxCRT_VsnprintfW_
+#define vswprintf wxCRT_VsnprintfW

 
 static int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
 {
 
 static int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
 {


@@ -292,220 +312,21 @@ static int vwprintf(const wchar_t *format, va_list argptr)
 
 #endif // wxNEED_WPRINTF
 
 
 #endif // wxNEED_WPRINTF
 

-#ifdef wxNEED_PRINTF_CONVERSION
-
-// ----------------------------------------------------------------------------
-// wxFormatConverter: class doing the "%s" -> "%ls" conversion
-// ----------------------------------------------------------------------------
-
-/*
-   Here are the gory details. We want to follow the Windows/MS conventions,
-   that is to have
-
-   In ANSI mode:
-
-   format specifier         results in
-   -----------------------------------
-   %c, %hc, %hC             char
-   %lc, %C, %lC             wchar_t
-
-   In Unicode mode:
-
-   format specifier         results in
-   -----------------------------------
-   %hc, %C, %hC             char
-   %c, %lc, %lC             wchar_t
-
-
-   while on POSIX systems we have %C identical to %lc and %c always means char
-   (in any mode) while %lc always means wchar_t,
-
-   So to use native functions in order to get our semantics we must do the
-   following translations in Unicode mode (nothing to do in ANSI mode):
-
-   wxWidgets specifier      POSIX specifier
-   ----------------------------------------
-
-   %hc, %C, %hC             %c
-   %c                       %lc
-
-
-   And, of course, the same should be done for %s as well.
-*/
-
-class wxFormatConverter
-{
-public:
-    wxFormatConverter(const wchar_t *format);
-
-    // notice that we only translated the string if m_fmtOrig == NULL (as set
-    // by CopyAllBefore()), otherwise we should simply use the original format
-    operator const wchar_t *() const
-        { return m_fmtOrig ? m_fmtOrig : m_fmt.c_str(); }
-
-private:
-    // copy another character to the translated format: this function does the
-    // copy if we are translating but doesn't do anything at all if we don't,
-    // so we don't create the translated format string at all unless we really
-    // need to (i.e. InsertFmtChar() is called)
-    wchar_t CopyFmtChar(wchar_t ch)
-    {
-        if ( !m_fmtOrig )
-        {
-            // we're translating, do copy
-            m_fmt += ch;
-        }
-        else
-        {
-            // simply increase the count which should be copied by
-            // CopyAllBefore() later if needed
-            m_nCopied++;
-        }
-
-        return ch;
-    }
-
-    // insert an extra character
-    void InsertFmtChar(wchar_t ch)
-    {
-        if ( m_fmtOrig )
-        {
-            // so far we haven't translated anything yet
-            CopyAllBefore();
-        }
-
-        m_fmt += ch;
-    }
-
-    void CopyAllBefore()
-    {
-        wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
-
-        m_fmt = wxString(m_fmtOrig, m_nCopied);
-
-        // we won't need it any longer
-        m_fmtOrig = NULL;
-    }
-
-    static bool IsFlagChar(wchar_t ch)
-    {
-        return ch == _T('-') || ch == _T('+') ||
-               ch == _T('0') || ch == _T(' ') || ch == _T('#');
-    }
-
-    void SkipDigits(const wchar_t **ptpc)
-    {
-        while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
-            CopyFmtChar(*(*ptpc)++);
-    }
-
-    // the translated format
-    wxString m_fmt;
-
-    // the original format
-    const wchar_t *m_fmtOrig;
-
-    // the number of characters already copied
-    size_t m_nCopied;
-};
-
-wxFormatConverter::wxFormatConverter(const wchar_t *format)
+#ifdef wxNEED_VSWSCANF
+static int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)

 {
 {

-    m_fmtOrig = format;
-    m_nCopied = 0;
-
-    while ( *format )
-    {
-        if ( CopyFmtChar(*format++) == _T('%') )
-        {
-            // skip any flags
-            while ( IsFlagChar(*format) )
-                CopyFmtChar(*format++);
-
-            // and possible width
-            if ( *format == _T('*') )
-                CopyFmtChar(*format++);
-            else
-                SkipDigits(&format);
-
-            // precision?
-            if ( *format == _T('.') )
-            {
-                CopyFmtChar(*format++);
-                if ( *format == _T('*') )
-                    CopyFmtChar(*format++);
-                else
-                    SkipDigits(&format);
-            }
-
-            // next we can have a size modifier
-            enum
-            {
-                Default,
-                Short,
-                Long
-            } size;
-
-            switch ( *format )
-            {
-                case _T('h'):
-                    size = Short;
-                    format++;
-                    break;
-
-                case _T('l'):
-                    // "ll" has a different meaning!
-                    if ( format[1] != _T('l') )
-                    {
-                        size = Long;
-                        format++;
-                        break;
-                    }
-                    //else: fall through
-
-                default:
-                    size = Default;
-            }
-
-            // and finally we should have the type
-            switch ( *format )
-            {
-                case _T('C'):
-                case _T('S'):
-                    // %C and %hC -> %c and %lC -> %lc
-                    if ( size == Long )
-                        CopyFmtChar(_T('l'));
-
-                    InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
-                    break;
-
-                case _T('c'):
-                case _T('s'):
-                    // %c -> %lc but %hc stays %hc and %lc is still %lc
-                    if ( size == Default)
-                        InsertFmtChar(_T('l'));
-                    // fall through
-
-                default:
-                    // nothing special to do
-                    if ( size != Default )
-                        CopyFmtChar(*(format - 1));
-                    CopyFmtChar(*format++);
-            }
-        }
-    }
-}
+    // The best we can do without proper Unicode support in glibc is to
+    // convert the strings into MB representation and run ANSI version
+    // of the function. This doesn't work with %c and %s because of difference
+    // in size of char and wchar_t, though.

 
 

-#else // !wxNEED_PRINTF_CONVERSION
-    // no conversion necessary
-    #define wxFormatConverter(x) (x)
-#endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
+    wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
+                 _T("incomplete vswscanf implementation doesn't allow %s") );
+    wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
+                 _T("incomplete vswscanf implementation doesn't allow %c") );

 
 

-#ifdef __WXDEBUG__
-// For testing the format converter
-wxString wxConvertFormat(const wchar_t *format)
-{
-    return wxString(wxFormatConverter(format));
+    return vsscanf(wx_static_cast(const char*, wxConvLibc.cWX2MB(ws)),
+        wxConvLibc.cWX2MB(format), argptr);

 }
 #endif
 
 }
 #endif
 


@@ -524,7 +345,7 @@ int wxCRT_PrintfW( const wchar_t *format, ... )
     va_list argptr;
     va_start(argptr, format);
 
     va_list argptr;
     va_start(argptr, format);
 

-    int ret = vwprintf( wxFormatConverter(format), argptr );
+    int ret = vwprintf( format, argptr );

 
     va_end(argptr);
 
 
     va_end(argptr);
 


@@ -538,7 +359,7 @@ int wxCRT_FprintfW( FILE *stream, const wchar_t *format, ... )
     va_list argptr;
     va_start( argptr, format );
 
     va_list argptr;
     va_start( argptr, format );
 

-    int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
+    int ret = vfwprintf( stream, format, argptr );

 
     va_end(argptr);
 
 
     va_end(argptr);
 


@@ -549,48 +370,22 @@ int wxCRT_FprintfW( FILE *stream, const wchar_t *format, ... )
 #ifndef wxCRT_VfprintfW
 int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list argptr )
 {
 #ifndef wxCRT_VfprintfW
 int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list argptr )
 {

-    return vfwprintf( stream, wxFormatConverter(format), argptr );
+    return vfwprintf( stream, format, argptr );

 }
 #endif
 
 #ifndef wxCRT_VprintfW
 int wxCRT_VprintfW( const wchar_t *format, va_list argptr )
 {
 }
 #endif
 
 #ifndef wxCRT_VprintfW
 int wxCRT_VprintfW( const wchar_t *format, va_list argptr )
 {

-    return vwprintf( wxFormatConverter(format), argptr );
+    return vwprintf( format, argptr );

 }
 #endif
 
 }
 #endif
 

-#ifndef wxCRT_VsnprintfW
-int wxCRT_VsnprintfW(wchar_t *str, size_t size, const wchar_t *format, va_list argptr )
-{
-    return vswprintf( str, size, wxFormatConverter(format), argptr );
-}
-#endif // !wxCRT_VsnprintfW
-
-// FIXME-UTF8: we only implement widechar version of vsnprintf() in wxprint.cpp,
-//             so this one has to convert the data for now
-#ifndef wxCRT_VsnprintfA
-int wxCRT_VsnprintfA(char *buf, size_t len, const char *format, va_list argptr)
-{
-    wxWCharBuffer wbuf(len);
-    int rt = wxCRT_VsnprintfW(wbuf.data(), len,
-                              (const wchar_t*)wxConvLibc.cMB2WC(format),
-                              argptr);
-    if ( rt < 0 || rt >= (int)len )
-        return rt;
-
-    if ( wxConvLibc.FromWChar(buf, len, wbuf) == wxCONV_FAILED )
-        return -1;
-
-    return rt;
-}
-#endif // !wxCRT_VsnprintfA
-

 #ifndef wxCRT_VsprintfW
 int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list argptr )
 {
     // same as for wxSprintf()
 #ifndef wxCRT_VsprintfW
 int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list argptr )
 {
     // same as for wxSprintf()

-    return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
+    return vswprintf(str, INT_MAX / 4, format, argptr);

 }
 #endif
 
 }
 #endif
 


@@ -602,14 +397,14 @@ int wxCRT_ScanfW(const wchar_t *format, ...)
 
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )

-   int ret = std::vwscanf(wxFormatConverter(format), argptr);
+   int ret = std::vwscanf(format, argptr);

 #else
 #else

-   int ret = vwscanf(wxFormatConverter(format), argptr);
+   int ret = vwscanf(format, argptr);

 #endif
 #else
 #endif
 #else

-   int ret = vwscanf(wxFormatConverter(format), argptr);
+   int ret = vwscanf(format, argptr);

 #endif
 #endif

-   
+

     va_end(argptr);
 
     return ret;
     va_end(argptr);
 
     return ret;


@@ -624,12 +419,12 @@ int wxCRT_SscanfW(const wchar_t *str, const wchar_t *format, ...)
 
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )

-   int ret = std::vswscanf(str, wxFormatConverter(format), argptr);
+   int ret = std::vswscanf(str, format, argptr);

 #else
 #else

-   int ret = vswscanf(str, wxFormatConverter(format), argptr);
+   int ret = vswscanf(str, format, argptr);

 #endif
 #else
 #endif
 #else

-   int ret = vswscanf(str, wxFormatConverter(format), argptr);
+   int ret = vswscanf(str, format, argptr);

 #endif
 
     va_end(argptr);
 #endif
 
     va_end(argptr);


@@ -645,12 +440,12 @@ int wxCRT_FscanfW(FILE *stream, const wchar_t *format, ...)
     va_start(argptr, format);
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
     va_start(argptr, format);
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )

-   int ret = std::vfwscanf(stream, wxFormatConverter(format), argptr);
+   int ret = std::vfwscanf(stream, format, argptr);

 #else
 #else

-   int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
+   int ret = vfwscanf(stream, format, argptr);

 #endif
 #else
 #endif
 #else

-   int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
+   int ret = vfwscanf(stream, format, argptr);

 #endif
 
     va_end(argptr);
 #endif
 
     va_end(argptr);


@@ -664,12 +459,12 @@ int wxCRT_VsscanfW(const wchar_t *str, const wchar_t *format, va_list argptr)
 {
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 {
 #ifdef __VMS
 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )

-   return std::vswscanf(str, wxFormatConverter(format), argptr);
+   return std::vswscanf(str, format, argptr);

 #else
 #else

-   return vswscanf(str, wxFormatConverter(format), argptr);
+   return vswscanf(str, format, argptr);

 #endif
 #else
 #endif
 #else

-   return vswscanf(str, wxFormatConverter(format), argptr);
+   return vswscanf(str, format, argptr);

 #endif
 }
 #endif
 #endif
 }
 #endif


@@ -798,8 +593,11 @@ int wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...)
 
 #if wxUSE_UNICODE
 
 
 #if wxUSE_UNICODE
 

+namespace
+{
+

 #if !wxUSE_UTF8_LOCALE_ONLY
 #if !wxUSE_UTF8_LOCALE_ONLY

-static int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
+int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)

 {
     const wxWX2WCbuf buf = s.wc_str();
 
 {
     const wxWX2WCbuf buf = s.wc_str();
 


@@ -812,17 +610,25 @@ static int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
 #endif // !wxUSE_UTF8_LOCALE_ONLY
 
 #if wxUSE_UNICODE_UTF8
 #endif // !wxUSE_UTF8_LOCALE_ONLY
 
 #if wxUSE_UNICODE_UTF8

-static int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
+int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)

 {
     const wxWX2WCbuf buf(s.wc_str());
 {
     const wxWX2WCbuf buf(s.wc_str());

-    size_t len = wxWcslen(buf);
+    size_t len = s.length(); // same as buf length for wchar_t*

     if ( outsize > len )
     if ( outsize > len )

+    {

         memcpy(out, buf, (len+1) * sizeof(wchar_t));
         memcpy(out, buf, (len+1) * sizeof(wchar_t));

-    // else: not enough space
+    }
+    else // not enough space
+    {
+        memcpy(out, buf, (outsize-1) * sizeof(wchar_t));
+        out[outsize-1] = 0;
+    }

     return len;
 }
 #endif // wxUSE_UNICODE_UTF8
 
     return len;
 }
 #endif // wxUSE_UNICODE_UTF8
 

+} // anonymous namespace
+

 template<typename T>
 static size_t PrintfViaString(T *out, size_t outsize,
                               const wxString& format, va_list argptr)
 template<typename T>
 static size_t PrintfViaString(T *out, size_t outsize,
                               const wxString& format, va_list argptr)


@@ -837,11 +643,11 @@ static size_t PrintfViaString(T *out, size_t outsize,
 int wxVsprintf(char *str, const wxString& format, va_list argptr)
 {
 #if wxUSE_UTF8_LOCALE_ONLY
 int wxVsprintf(char *str, const wxString& format, va_list argptr)
 {
 #if wxUSE_UTF8_LOCALE_ONLY

-    return vsprintf(str, format.wx_str(), argptr);
+    return wxCRT_VsprintfA(str, format.wx_str(), argptr);

 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )
 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )

-        return vsprintf(str, format.wx_str(), argptr);
+        return wxCRT_VsprintfA(str, format.wx_str(), argptr);

     else
     #endif
     #if wxUSE_UNICODE
     else
     #endif
     #if wxUSE_UNICODE


@@ -856,7 +662,20 @@ int wxVsprintf(char *str, const wxString& format, va_list argptr)
 int wxVsprintf(wchar_t *str, const wxString& format, va_list argptr)
 {
 #if wxUSE_UNICODE_WCHAR
 int wxVsprintf(wchar_t *str, const wxString& format, va_list argptr)
 {
 #if wxUSE_UNICODE_WCHAR

+#ifdef __DMC__
+/*
+This fails with a bug similar to 
+http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=c++.beta&artnum=680
+in DMC 8.49 and 8.50
+I don't see it being used in the wxWidgets sources at present (oct 2007) CE
+*/
+#pragma message ( "warning ::::: wxVsprintf(wchar_t *str, const wxString& format, va_list argptr) not yet implemented" )
+    wxFAIL_MSG( _T("TODO") );
+
+    return -1;
+#else

     return wxCRT_VsprintfW(str, format.wc_str(), argptr);
     return wxCRT_VsprintfW(str, format.wc_str(), argptr);

+#endif //DMC

 #else // wxUSE_UNICODE_UTF8
     #if !wxUSE_UTF8_LOCALE_ONLY
     if ( !wxLocaleIsUtf8 )
 #else // wxUSE_UNICODE_UTF8
     #if !wxUSE_UTF8_LOCALE_ONLY
     if ( !wxLocaleIsUtf8 )


@@ -933,32 +752,9 @@ int wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argpt
 // ctype.h stuff (currently unused)
 // ----------------------------------------------------------------------------
 
 // ctype.h stuff (currently unused)
 // ----------------------------------------------------------------------------
 

-#if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
-static inline WORD wxMSW_ctype(wchar_t ch)
-{
-  WORD ret;
-  GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &ret);
-  return ret;
-}
-
-int wxCRT_IsalnumW(wchar_t ch) { return IsCharAlphaNumeric(ch); }
-int wxCRT_IsalphaW(wchar_t ch) { return IsCharAlpha(ch); }
-int wxCRT_IscntrlW(wchar_t ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
-int wxCRT_IsdigitW(wchar_t ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
-int wxCRT_IsgraphW(wchar_t ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
-int wxCRT_IslowerW(wchar_t ch) { return IsCharLower(ch); }
-int wxCRT_IsprintW(wchar_t ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_SPACE|C1_PUNCT|C1_ALPHA); }
-int wxCRT_IspunctW(wchar_t ch) { return wxMSW_ctype(ch) & C1_PUNCT; }
-int wxCRT_IsspaceW(wchar_t ch) { return wxMSW_ctype(ch) & C1_SPACE; }
-int wxCRT_IsupperW(wchar_t ch) { return IsCharUpper(ch); }
-int wxCRT_IsxdigitW(wchar_t ch) { return wxMSW_ctype(ch) & C1_XDIGIT; }
-int wxCRT_Tolower(wchar_t ch) { return (wchar_t)CharLower((LPTSTR)(ch)); }
-int wxCRT_Toupper(wchar_t ch) { return (wchar_t)CharUpper((LPTSTR)(ch)); }
-#endif
-

 #ifdef wxNEED_WX_MBSTOWCS
 
 #ifdef wxNEED_WX_MBSTOWCS
 

-WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
+WXDLLIMPEXP_BASE size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)

 {
     if (!out)
     {
 {
     if (!out)
     {


@@ -980,7 +776,7 @@ WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
     return in - origin;
 }
 
     return in - origin;
 }
 

-WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
+WXDLLIMPEXP_BASE size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)

 {
     if (!out)
     {
 {
     if (!out)
     {


@@ -1004,48 +800,15 @@ WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
 
 #endif // wxNEED_WX_MBSTOWCS
 
 
 #endif // wxNEED_WX_MBSTOWCS
 

-#if defined(wxNEED_WX_CTYPE_H)
-
-#include <CoreFoundation/CoreFoundation.h>
-
-#define cfalnumset CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric)
-#define cfalphaset CFCharacterSetGetPredefined(kCFCharacterSetLetter)
-#define cfcntrlset CFCharacterSetGetPredefined(kCFCharacterSetControl)
-#define cfdigitset CFCharacterSetGetPredefined(kCFCharacterSetDecimalDigit)
-//CFCharacterSetRef cfgraphset = kCFCharacterSetControl && !' '
-#define cflowerset CFCharacterSetGetPredefined(kCFCharacterSetLowercaseLetter)
-//CFCharacterSetRef cfprintset = !kCFCharacterSetControl
-#define cfpunctset CFCharacterSetGetPredefined(kCFCharacterSetPunctuation)
-#define cfspaceset CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline)
-#define cfupperset CFCharacterSetGetPredefined(kCFCharacterSetUppercaseLetter)
-
-int wxCRT_IsalnumW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfalnumset, ch); }
-int wxCRT_IsalphaW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfalphaset, ch); }
-int wxCRT_IscntrlW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
-int wxCRT_IsdigitW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfdigitset, ch); }
-int wxCRT_IsgraphW(wchar_t ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch) && ch != ' '; }
-int wxCRT_IslowerW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cflowerset, ch); }
-int wxCRT_IsprintW(wchar_t ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
-int wxCRT_IspunctW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfpunctset, ch); }
-int wxCRT_IsspaceW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfspaceset, ch); }
-int wxCRT_IsupperW(wchar_t ch) { return CFCharacterSetIsCharacterMember(cfupperset, ch); }
-int wxCRT_IsxdigitW(wchar_t ch) { return wxCRT_IsdigitW(ch) || (ch>='a' && ch<='f') || (ch>='A' && ch<='F'); }
-
-// FIXME: these are broken!
-extern "C" int wxCRT_TolowerW(wchar_t ch) { return (wchar_t)tolower((char)(ch)); }
-extern "C" int wxCRT_ToupperW(wchar_t ch) { return (wchar_t)toupper((char)(ch)); }
-
-#endif  // wxNEED_WX_CTYPE_H
-

 #ifndef wxCRT_StrdupA
 #ifndef wxCRT_StrdupA

-WXDLLEXPORT char *wxCRT_StrdupA(const char *s)
+WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *s)

 {
     return strcpy((char *)malloc(strlen(s) + 1), s);
 }
 #endif // wxCRT_StrdupA
 
 #ifndef wxCRT_StrdupW
 {
     return strcpy((char *)malloc(strlen(s) + 1), s);
 }
 #endif // wxCRT_StrdupA
 
 #ifndef wxCRT_StrdupW

-WXDLLEXPORT wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
+WXDLLIMPEXP_BASE wchar_t * wxCRT_StrdupW(const wchar_t *pwz)

 {
   size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
   wchar_t *ret = (wchar_t *) malloc(size);
 {
   size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
   wchar_t *ret = (wchar_t *) malloc(size);


@@ -1055,7 +818,7 @@ WXDLLEXPORT wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
 #endif // wxCRT_StrdupW
 
 #ifndef wxCRT_StricmpA
 #endif // wxCRT_StrdupW
 
 #ifndef wxCRT_StricmpA

-int WXDLLEXPORT wxCRT_StricmpA(const char *psz1, const char *psz2)
+WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2)

 {
   register char c1, c2;
   do {
 {
   register char c1, c2;
   do {


@@ -1067,7 +830,7 @@ int WXDLLEXPORT wxCRT_StricmpA(const char *psz1, const char *psz2)
 #endif // !defined(wxCRT_StricmpA)
 
 #ifndef wxCRT_StricmpW
 #endif // !defined(wxCRT_StricmpA)
 
 #ifndef wxCRT_StricmpW

-int WXDLLEXPORT wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
+WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)

 {
   register wchar_t c1, c2;
   do {
 {
   register wchar_t c1, c2;
   do {


@@ -1079,7 +842,7 @@ int WXDLLEXPORT wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
 #endif // !defined(wxCRT_StricmpW)
 
 #ifndef wxCRT_StrnicmpA
 #endif // !defined(wxCRT_StricmpW)
 
 #ifndef wxCRT_StrnicmpA

-int WXDLLEXPORT wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
+WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)

 {
   // initialize the variables just to suppress stupid gcc warning
   register char c1 = 0, c2 = 0;
 {
   // initialize the variables just to suppress stupid gcc warning
   register char c1 = 0, c2 = 0;


@@ -1093,7 +856,7 @@ int WXDLLEXPORT wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
 #endif // !defined(wxCRT_StrnicmpA)
 
 #ifndef wxCRT_StrnicmpW
 #endif // !defined(wxCRT_StrnicmpA)
 
 #ifndef wxCRT_StrnicmpW

-int WXDLLEXPORT wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
+WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)

 {
   // initialize the variables just to suppress stupid gcc warning
   register wchar_t c1 = 0, c2 = 0;
 {
   // initialize the variables just to suppress stupid gcc warning
   register wchar_t c1 = 0, c2 = 0;


@@ -1110,51 +873,10 @@ int WXDLLEXPORT wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
 // string.h functions
 // ----------------------------------------------------------------------------
 
 // string.h functions
 // ----------------------------------------------------------------------------
 

-#ifndef wxCRT_StrcatW
-WXDLLEXPORT wchar_t *wxCRT_StrcatW(wchar_t *dest, const wchar_t *src)
-{
-  wchar_t *ret = dest;
-  while (*dest) dest++;
-  while ((*dest++ = *src++));
-  return ret;
-}
-#endif
-
-#ifndef wxCRT_StrchrW
-WXDLLEXPORT const wchar_t *wxCRT_StrchrW(const wchar_t *s, wchar_t c)
-{
-    // be careful here as the terminating NUL makes part of the string
-    while ( *s != c )
-    {
-        if ( !*s++ )
-            return NULL;
-    }
-
-    return s;
-}
-#endif
-
-#ifndef wxCRT_StrcmpW
-WXDLLEXPORT int wxCRT_StrcmpW(const wchar_t *s1, const wchar_t *s2)
-{
-  while ((*s1 == *s2) && *s1) s1++, s2++;
-  if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
-  if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
-  return 0;
-}
-#endif
-
-#ifndef wxCRT_StrcpyW
-WXDLLEXPORT wchar_t * wxCRT_StrcpyW(wchar_t *dest, const wchar_t *src)
-{
-  wchar_t *ret = dest;
-  while ((*dest++ = *src++));
-  return ret;
-}
-#endif
-
-template<typename T>
-static inline size_t wxCRT_DoStrlen(const T *s)
+// this (and wxCRT_StrncmpW below) are extern "C" because they are needed
+// by regex code, the rest isn't needed, so it's not declared as extern "C"
+#ifndef wxCRT_StrlenW
+extern "C" WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s)

 {
     size_t n = 0;
     while ( *s++ )
 {
     size_t n = 0;
     while ( *s++ )


@@ -1162,178 +884,14 @@ static inline size_t wxCRT_DoStrlen(const T *s)
 
     return n;
 }
 
     return n;
 }

-
-// these two (and wxCRT_StrncmpW below) are extern "C" because they are needed
-// by regex code, the rest isn't needed, so it's not declared as extern "C"
-#ifndef wxCRT_StrlenA
-WXDLLEXPORT size_t wxCRT_StrlenA(const char *s)
-    { return wxCRT_DoStrlen(s); }
-#endif
-#ifndef wxCRT_StrlenW
-extern "C" WXDLLEXPORT size_t wxCRT_StrlenW(const wchar_t *s)
-    { return wxCRT_DoStrlen(s); }
-#endif
-
-#ifndef wxCRT_StrncatW
-WXDLLEXPORT wchar_t * wxCRT_StrncatW(wchar_t *dest, const wchar_t *src, size_t n)
-{
-  wchar_t *ret = dest;
-  while (*dest) dest++;
-  while (n && (*dest++ = *src++)) n--;
-  return ret;
-}

 #endif
 
 #endif
 

-#ifndef wxCRT_StrncmpW
-extern "C"
-WXDLLEXPORT int wxCRT_StrncmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
-{
-  while (n && (*s1 == *s2) && *s1) n--, s1++, s2++;
-  if (n) {
-    if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
-    if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
-  }
-  return 0;
-}
-#endif
-
-#ifndef wxCRT_StrncpyW
-WXDLLEXPORT wchar_t * wxCRT_StrncpyW(wchar_t *dest, const wchar_t *src, size_t n)
-{
-  wchar_t *ret = dest;
-  while (n && (*dest++ = *src++)) n--;
-  while (n) *dest++=0, n--; // the docs specify padding with zeroes
-  return ret;
-}
-#endif
-
-#ifndef wxCRT_StrpbrkW
-WXDLLEXPORT const wchar_t * wxCRT_StrpbrkW(const wchar_t *s, const wchar_t *accept)
-{
-  while (*s && !wxCRT_Strchr(accept, *s))
-      s++;
-
-  return *s ? s : NULL;
-}
-#endif
-
-#ifndef wxCRT_StrrchrW
-WXDLLEXPORT const wchar_t * wxCRT_StrrchrW(const wchar_t *s, wchar_t c)
-{
-    const wchar_t *ret = NULL;
-    do
-    {
-        if ( *s == c )
-            ret = s;
-        s++;
-    }
-    while ( *s );
-
-    return ret;
-}
-#endif
-
-#ifndef wxCRT_StrspnW
-WXDLLEXPORT size_t wxCRT_StrspnW(const wchar_t *s, const wchar_t *accept)
-{
-  size_t len = 0;
-  while (wxCRT_Strchr(accept, *s++)) len++;
-  return len;
-}
-#endif
-
-#ifndef wxCRT_StrstrW
-WXDLLEXPORT const wchar_t *wxCRT_StrstrW(const wchar_t *haystack, const wchar_t *needle)
-{
-    wxASSERT_MSG( needle != NULL, _T("NULL argument in wxCRT_Strstr") );
-
-    // VZ: this is not exactly the most efficient string search algorithm...
-
-    const size_t len = wxStrlen(needle);
-
-    while ( const wchar_t *fnd = wxCRT_Strchr(haystack, *needle) )
-    {
-        if ( !wxCRT_Strncmp(fnd, needle, len) )
-            return fnd;
-
-        haystack = fnd + 1;
-    }
-
-    return NULL;
-}
-#endif
-
-#ifndef wxCRT_StrtodW
-WXDLLEXPORT double wxCRT_StrtodW(const wchar_t *nptr, wchar_t **endptr)
-{
-  const wchar_t *start = nptr;
-
-  // FIXME: only correct for C locale
-  while (wxIsspace(*nptr)) nptr++;
-  if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
-  while (wxIsdigit(*nptr)) nptr++;
-  if (*nptr == wxT('.')) {
-    nptr++;
-    while (wxIsdigit(*nptr)) nptr++;
-  }
-  if (*nptr == wxT('E') || *nptr == wxT('e')) {
-    nptr++;
-    if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
-    while (wxIsdigit(*nptr)) nptr++;
-  }
-
-  wxString data(nptr, nptr-start);
-  wxWX2MBbuf dat = data.mb_str(wxConvLibc);
-  char *rdat = wxMBSTRINGCAST dat;
-  double ret = strtod(dat, &rdat);
-
-  if (endptr) *endptr = (wchar_t *)(start + (rdat - (const char *)dat));
-
-  return ret;
-}
-#endif // !wxCRT_StrtodW
-
-#ifndef wxCRT_StrtolW
-WXDLLEXPORT long int wxCRT_StrtolW(const wchar_t *nptr, wchar_t **endptr, int base)
-{
-  const wchar_t *start = nptr;
-
-  // FIXME: only correct for C locale
-  while (wxIsspace(*nptr)) nptr++;
-  if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
-  if (((base == 0) || (base == 16)) &&
-      (nptr[0] == wxT('0') && nptr[1] == wxT('x'))) {
-    nptr += 2;
-    base = 16;
-  }
-  else if ((base == 0) && (nptr[0] == wxT('0'))) base = 8;
-  else if (base == 0) base = 10;
-
-  while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) ||
-         (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
-
-  wxString data(start, nptr-start);
-  wxWX2MBbuf dat = data.mb_str(wxConvLibc);
-  char *rdat = wxMBSTRINGCAST dat;
-  long int ret = strtol(dat, &rdat, base);
-
-  if (endptr) *endptr = (wchar_t *)(start + (rdat - (const char *)dat));
-
-  return ret;
-}
-#endif // !wxCRT_StrtolW
-
-#ifndef wxCRT_StrtoulW
-WXDLLEXPORT unsigned long int wxCRT_StrtoulW(const wchar_t *nptr, wchar_t **endptr, int base)
-{
-    return (unsigned long int) wxCRT_StrtolW(nptr, endptr, base);
-}
-#endif
-
-
+// ----------------------------------------------------------------------------
+// stdlib.h functions
+// ----------------------------------------------------------------------------

 
 #ifndef wxCRT_GetenvW
 
 #ifndef wxCRT_GetenvW

-wchar_t* WXDLLEXPORT wxCRT_GetenvW(const wchar_t *name)
+WXDLLIMPEXP_BASE wchar_t* wxCRT_GetenvW(const wchar_t *name)

 {
     // NB: buffer returned by getenv() is allowed to be overwritten next
     //     time getenv() is called, so it is OK to use static string
 {
     // NB: buffer returned by getenv() is allowed to be overwritten next
     //     time getenv() is called, so it is OK to use static string


@@ -1345,7 +903,7 @@ wchar_t* WXDLLEXPORT wxCRT_GetenvW(const wchar_t *name)
 #endif // !wxCRT_GetenvW
 
 #ifndef wxCRT_StrftimeW
 #endif // !wxCRT_GetenvW
 
 #ifndef wxCRT_StrftimeW

-WXDLLEXPORT size_t
+WXDLLIMPEXP_BASE size_t

 wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *tm)
 {
     if ( !maxsize )
 wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *tm)
 {
     if ( !maxsize )


@@ -1372,6 +930,7 @@ wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm
 
 #endif // wxUSE_WCHAR_T
 
 
 #endif // wxUSE_WCHAR_T
 

+#ifdef wxLongLong_t

 template<typename T>
 static wxULongLong_t
 wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
 template<typename T>
 static wxULongLong_t
 wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)


@@ -1382,7 +941,7 @@ wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
     wxString::const_iterator end = wxstr.end();
 
     // Skip spaces
     wxString::const_iterator end = wxstr.end();
 
     // Skip spaces

-    while ( i != end && wxIsspace(*i) ) i++;
+    while ( i != end && wxIsspace(*i) ) ++i;

 
     // Starts with sign?
     *sign = wxT(' ');
 
     // Starts with sign?
     *sign = wxT(' ');


@@ -1392,20 +951,20 @@ wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
         if ( c == wxT('+') || c == wxT('-') )
         {
             *sign = c;
         if ( c == wxT('+') || c == wxT('-') )
         {
             *sign = c;

-            i++;
+            ++i;

         }
     }
 
     // Starts with 0x?
     if ( i != end && *i == wxT('0') )
     {
         }
     }
 
     // Starts with 0x?
     if ( i != end && *i == wxT('0') )
     {

-        i++;
+        ++i;

         if ( i != end )
         {
             if ( *i == wxT('x') && (base == 16 || base == 0) )
             {
                 base = 16;
         if ( i != end )
         {
             if ( *i == wxT('x') && (base == 16 || base == 0) )
             {
                 base = 16;

-                i++;
+                ++i;

             }
             else
             {
             }
             else
             {


@@ -1416,20 +975,20 @@ wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
             }
         }
         else
             }
         }
         else

-            i--;
+            --i;

     }
 
     if ( base == 0 )
         base = 10;
 
     }
 
     if ( base == 0 )
         base = 10;
 

-    for ( ; i != end; i++ )
+    for ( ; i != end; ++i )

     {
         unsigned int n;
 
         T c = *i;
     {
         unsigned int n;
 
         T c = *i;

-        if ( c >= wxT('0') )
+        if ( c >= '0' )

         {
         {

-            if ( c <= wxT('9') )
+            if ( c <= '9' )

                 n = c - wxT('0');
             else
                 n = wxTolower(c) - wxT('a') + 10;
                 n = c - wxT('0');
             else
                 n = wxTolower(c) - wxT('a') + 10;


@@ -1463,7 +1022,7 @@ template<typename T>
 static wxULongLong_t wxCRT_DoStrtoull(const T* nptr, T** endptr, int base)
 {
     T sign;
 static wxULongLong_t wxCRT_DoStrtoull(const T* nptr, T** endptr, int base)
 {
     T sign;

-    wxULongLong_t uval = wxCRT_StrtoullBase(nptr, endptr, base, &sign);
+    wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);

 
     if ( sign == wxT('-') )
     {
 
     if ( sign == wxT('-') )
     {


@@ -1478,17 +1037,14 @@ template<typename T>
 static wxLongLong_t wxCRT_DoStrtoll(const T* nptr, T** endptr, int base)
 {
     T sign;
 static wxLongLong_t wxCRT_DoStrtoll(const T* nptr, T** endptr, int base)
 {
     T sign;

-    wxULongLong_t uval = wxCRT_StrtoullBase(nptr, endptr, base, &sign);
+    wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);

     wxLongLong_t val = 0;
 
     if ( sign == wxT('-') )
     {
     wxLongLong_t val = 0;
 
     if ( sign == wxT('-') )
     {

-        if ( uval <= wxULL(wxINT64_MAX+1) )
+        if (uval <= (wxULongLong_t)wxINT64_MAX + 1)

         {
         {

-            if ( uval == wxULL(wxINT64_MAX+1))
-                val = -((wxLongLong_t)wxINT64_MAX) - 1;
-            else
-                val = -((wxLongLong_t)uval);
+            val = -(wxLongLong_t)uval;

         }
         else
         {
         }
         else
         {


@@ -1525,6 +1081,8 @@ wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr, wchar_t** endptr, int base)
     { return wxCRT_DoStrtoull(nptr, endptr, base); }
 #endif
 
     { return wxCRT_DoStrtoull(nptr, endptr, base); }
 #endif
 

+#endif // wxLongLong_t
+

 // ----------------------------------------------------------------------------
 // functions which we may need even if !wxUSE_WCHAR_T
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // functions which we may need even if !wxUSE_WCHAR_T
 // ----------------------------------------------------------------------------


@@ -1596,31 +1154,6 @@ void *calloc( size_t num, size_t size )
 
 #endif // __WXWINCE__ <= 211
 
 
 #endif // __WXWINCE__ <= 211
 

-#ifdef __WXWINCE__
-int wxCRT_RemoveW(const wchar_t *path)
-{
-    return ::DeleteFile(path) == 0;
-}
-#endif
-
-#ifndef wxCRT_TmpnamW
-wchar_t *wxCRT_TmpnamW(wchar_t *s)
-{
-    // tmpnam_r() returns NULL if s=NULL, do the same
-    wxCHECK_MSG( s, NULL, "wxTmpnam must be called with a buffer" );
-
-#ifndef L_tmpnam
-    #define L_tmpnam 1024
-#endif
-    wxCharBuffer buf(L_tmpnam);
-    tmpnam(buf.data());
-
-    wxConvLibc.ToWChar(s, L_tmpnam+1, buf.data());
-    return s;
-}
-#endif // !wxCRT_TmpnamW
-
-

 // ============================================================================
 // wxLocaleIsUtf8
 // ============================================================================
 // ============================================================================
 // wxLocaleIsUtf8
 // ============================================================================


@@ -1653,7 +1186,7 @@ static bool wxIsLocaleUtf8()
             return true;
         }
     }
             return true;
         }
     }

-#endif
+#endif // HAVE_LANGINFO_H

 
     // check if we're running under the "C" locale: it is 7bit subset
     // of UTF-8, so it can be safely used with the UTF-8 build:
 
     // check if we're running under the "C" locale: it is 7bit subset
     // of UTF-8, so it can be safely used with the UTF-8 build:


@@ -1721,6 +1254,8 @@ int wxFputc(const wxUniChar& c, FILE *stream)
 #endif
 }
 
 #endif
 }
 

+#ifdef wxCRT_PerrorA
+

 void wxPerror(const wxString& s)
 {
 #ifdef wxCRT_PerrorW
 void wxPerror(const wxString& s)
 {
 #ifdef wxCRT_PerrorW


@@ -1732,6 +1267,8 @@ void wxPerror(const wxString& s)
 #endif
 }
 
 #endif
 }
 

+#endif // wxCRT_PerrorA
+

 wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
 {
     wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );
 wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
 {
     wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );


@@ -1753,21 +1290,21 @@ wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
 // wxScanf() and friends
 // ----------------------------------------------------------------------------
 
 // wxScanf() and friends
 // ----------------------------------------------------------------------------
 

-#ifndef __VISUALC__
+#ifndef HAVE_NO_VSSCANF // __VISUALC__ and __DMC__ see wx/crt.h

 int wxVsscanf(const char *str, const char *format, va_list ap)
     { return wxCRT_VsscanfA(str, format, ap); }
 int wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxCharBuffer& str, const char *format, va_list ap)
 int wxVsscanf(const char *str, const char *format, va_list ap)
     { return wxCRT_VsscanfA(str, format, ap); }
 int wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxCharBuffer& str, const char *format, va_list ap)

-    { return wxCRT_VsscanfA(str, format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str), format, ap); }

 int wxVsscanf(const wxWCharBuffer& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxString& str, const char *format, va_list ap)
 int wxVsscanf(const wxWCharBuffer& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxString& str, const char *format, va_list ap)

-    { return wxCRT_VsscanfA(str.mb_str(), format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str.mb_str()), format, ap); }

 int wxVsscanf(const wxString& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.wc_str(), format, ap); }
 int wxVsscanf(const wxCStrData& str, const char *format, va_list ap)
 int wxVsscanf(const wxString& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.wc_str(), format, ap); }
 int wxVsscanf(const wxCStrData& str, const char *format, va_list ap)

-    { return wxCRT_VsscanfA(str.AsCharBuf(), format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str.AsCharBuf()), format, ap); }

 int wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.AsWCharBuf(), format, ap); }
 int wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.AsWCharBuf(), format, ap); }

-#endif // !__VISUALC__
+#endif // HAVE_NO_VSSCANF