fixing compilo for 10.5

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

diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp
index 9db633db07767e4f629431e92ce59b253fb2688a..089d645b8272c2d2b13162b0c93ea2243fe32207 100644 (file)
--- a/src/common/wxchar.cpp
+++ b/src/common/wxchar.cpp
@@ -1,18 +1,14 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        wxchar.cpp
+// Name:        src/common/wxchar.cpp

 // Purpose:     wxChar implementation
 // Purpose:     wxChar implementation

-// Author:      Ove Kåven
-// Modified by: Ron Lee
+// Author:      Ove Kaven
+// Modified by: Ron Lee, Francesco Montorsi

 // Created:     09/04/99
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWidgets copyright
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Created:     09/04/99
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWidgets copyright
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-  #pragma implementation "wxchar.h"
-#endif
-

 // ===========================================================================
 // headers, declarations, constants
 // ===========================================================================
 // ===========================================================================
 // headers, declarations, constants
 // ===========================================================================


@@ -21,7 +17,7 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-  #pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #define _ISOC9X_SOURCE 1 // to get vsscanf()
 #endif
 
 #define _ISOC9X_SOURCE 1 // to get vsscanf()


@@ -32,24 +28,24 @@
 #include <string.h>
 
 #ifndef __WXWINCE__
 #include <string.h>
 
 #ifndef __WXWINCE__

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

 #else
 #else

-#include "wx/msw/wince/time.h"
+    #include "wx/msw/wince/time.h"

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-  #include "wx/defs.h"
-  #include "wx/wxchar.h"
-  #include "wx/string.h"
-  #include "wx/hash.h"
+    #include "wx/wxchar.h"
+    #include "wx/string.h"
+    #include "wx/hash.h"

 #endif
 #endif

+  #include "wx/utils.h"     // for wxMin and wxMax

 
 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
   #include <windef.h>
 
 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
   #include <windef.h>

-  #include <winbase.h>
-  #include <winnls.h>
-  #include <winnt.h>
+    #include <winbase.h>
+    #include <winnls.h>
+    #include <winnt.h>

 #endif
 
 #if defined(__MWERKS__) && __MSL__ >= 0x6000
 #endif
 
 #if defined(__MWERKS__) && __MSL__ >= 0x6000


@@ -57,15 +53,11 @@ namespace std {}
 using namespace std ;
 #endif
 
 using namespace std ;
 #endif
 

-#ifdef __WXMAC__
-    #include "wx/mac/private.h"
-#endif
-

 #if wxUSE_WCHAR_T
 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 {
   // assume that we have mbsrtowcs() too if we have wcsrtombs()
 #if wxUSE_WCHAR_T
 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 {
   // assume that we have mbsrtowcs() too if we have wcsrtombs()

-#if HAVE_WCSRTOMBS
+#ifdef HAVE_WCSRTOMBS

   mbstate_t mbstate;
   memset(&mbstate, 0, sizeof(mbstate_t));
 #endif
   mbstate_t mbstate;
   memset(&mbstate, 0, sizeof(mbstate_t));
 #endif


@@ -78,20 +70,26 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 #ifdef HAVE_WCSRTOMBS
     return mbsrtowcs(buf, &psz, n, &mbstate);
 #else
 #ifdef HAVE_WCSRTOMBS
     return mbsrtowcs(buf, &psz, n, &mbstate);
 #else

-    return mbstowcs(buf, psz, n);
+    return wxMbstowcs(buf, psz, n);

 #endif
   }
 
 #endif
   }
 

+  // note that we rely on common (and required by Unix98 but unfortunately not
+  // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
+  // to just get the size of the needed buffer -- this is needed as otherwise
+  // we have no idea about how much space we need and if the CRT doesn't
+  // support it (the only currently known example being Metrowerks, see
+  // wx/wxchar.h) we don't use its mbstowcs() at all

 #ifdef HAVE_WCSRTOMBS
   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
 #else
 #ifdef HAVE_WCSRTOMBS
   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
 #else

-  return mbstowcs((wchar_t *) NULL, psz, 0);
+  return wxMbstowcs((wchar_t *) NULL, psz, 0);

 #endif
 }
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {
 #endif
 }
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {

-#if HAVE_WCSRTOMBS
+#ifdef HAVE_WCSRTOMBS

   mbstate_t mbstate;
   memset(&mbstate, 0, sizeof(mbstate_t));
 #endif
   mbstate_t mbstate;
   memset(&mbstate, 0, sizeof(mbstate_t));
 #endif


@@ -102,17 +100,17 @@ size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
       if (n) *buf = '\0';
       return 0;
     }
       if (n) *buf = '\0';
       return 0;
     }

-#if HAVE_WCSRTOMBS
+#ifdef HAVE_WCSRTOMBS

     return wcsrtombs(buf, &pwz, n, &mbstate);
 #else
     return wcsrtombs(buf, &pwz, n, &mbstate);
 #else

-    return wcstombs(buf, pwz, n);
+    return wxWcstombs(buf, pwz, n);

 #endif
   }
 
 #endif
   }
 

-#if HAVE_WCSRTOMBS
+#ifdef HAVE_WCSRTOMBS

   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
 #else
   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
 #else

-  return wcstombs((char *) NULL, pwz, 0);
+  return wxWcstombs((char *) NULL, pwz, 0);

 #endif
 }
 #endif // wxUSE_WCHAR_T
 #endif
 }
 #endif // wxUSE_WCHAR_T


@@ -161,42 +159,541 @@ bool WXDLLEXPORT wxOKlibc()
 
 // ----------------------------------------------------------------------------
 // implement [v]snprintf() if the system doesn't provide a safe one
 
 // ----------------------------------------------------------------------------
 // implement [v]snprintf() if the system doesn't provide a safe one

+// or if the system's one does not support positional parameters
+// (very useful for i18n purposes)

 // ----------------------------------------------------------------------------
 
 #if !defined(wxVsnprintf_)
 // ----------------------------------------------------------------------------
 
 #if !defined(wxVsnprintf_)

-int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
-                             const wxChar *format, va_list argptr)
+
+// wxUSE_STRUTILS says our wxVsnprintf_ implementation to use or not to
+// use wxStrlen and wxStrncpy functions over one-char processing loops.
+//
+// Some benchmarking revealed that wxUSE_STRUTILS == 1 has the following
+// effects:
+// -> on Windows:
+//     when in ANSI mode, this setting does not change almost anything
+//     when in Unicode mode, it gives ~ 50% of slowdown !
+// -> on Linux:
+//     both in ANSI and Unicode mode it gives ~ 60% of speedup !
+//
+#if defined(WIN32) && wxUSE_UNICODE
+#define wxUSE_STRUTILS      0
+#else
+#define wxUSE_STRUTILS      1
+#endif
+
+// some limits of our implementation
+#define wxMAX_SVNPRINTF_ARGUMENTS         64
+#define wxMAX_SVNPRINTF_FLAGBUFFER_LEN    32
+
+// the conversion specifiers accepted by wxVsnprintf_
+enum wxPrintfArgType {
+    wxPAT_INVALID = -1,
+
+    wxPAT_INT,          // %d, %i, %o, %u, %x, %X
+    wxPAT_LONGINT,      // %ld, etc
+#if SIZEOF_LONG_LONG
+    wxPAT_LONGLONGINT,  // %Ld, etc
+#endif
+    wxPAT_SIZET,        // %Zd, etc
+
+    wxPAT_DOUBLE,       // %e, %E, %f, %g, %G
+    wxPAT_LONGDOUBLE,   // %le, etc
+
+    wxPAT_POINTER,      // %p
+
+    wxPAT_CHAR,         // %hc  (in ANSI mode: %c, too)
+    wxPAT_WCHAR,        // %lc  (in Unicode mode: %c, too)
+
+    wxPAT_PCHAR,        // %s   (related to a char *)
+    wxPAT_PWCHAR,       // %s   (related to a wchar_t *)
+
+    wxPAT_NINT,         // %n
+    wxPAT_NSHORTINT,    // %hn
+    wxPAT_NLONGINT      // %ln
+};
+
+// an argument passed to wxVsnprintf_
+typedef union {
+    int pad_int;                        //  %d, %i, %o, %u, %x, %X
+    long int pad_longint;               // %ld, etc
+#if SIZEOF_LONG_LONG
+    long long int pad_longlongint;      // %Ld, etc
+#endif
+    size_t pad_sizet;                   // %Zd, etc
+
+    double pad_double;                  // %e, %E, %f, %g, %G
+    long double pad_longdouble;         // %le, etc
+
+    void *pad_pointer;                  // %p
+
+    char pad_char;                      // %hc  (in ANSI mode: %c, too)
+    wchar_t pad_wchar;                  // %lc  (in Unicode mode: %c, too)
+
+    char *pad_pchar;                    // %s   (related to a char *)
+    wchar_t *pad_pwchar;                // %s   (related to a wchar_t *)
+
+    int *pad_nint;                      // %n
+    short int *pad_nshortint;           // %hn
+    long int *pad_nlongint;             // %ln
+} wxPrintfArg;
+
+
+// Contains parsed data relative to a conversion specifier given to
+// wxVsnprintf_ and parsed from the format string
+// NOTE: in C++ there is almost no difference between struct & classes thus
+//       there is no performance gain by using a struct here...
+class wxPrintfConvSpec

 {
 {

-    // buffer to avoid dynamic memory allocation each time for small strings
-    char szScratch[1024];
+public:

 
 

-    // number of characters in the buffer so far, must be less than lenMax
-    size_t lenCur = 0;
+    // the position of the argument relative to this conversion specifier
+    size_t pos;
+
+    // the type of this conversion specifier
+    wxPrintfArgType type;
+
+    // the minimum and maximum width
+    // when one of this var is set to -1 it means: use the following argument
+    // in the stack as minimum/maximum width for this conversion specifier
+    int min_width, max_width;
+
+    // does the argument need to the be aligned to left ?
+    bool adj_left;

 
 

-    for ( size_t n = 0; ; n++ )
+    // pointer to the '%' of this conversion specifier in the format string
+    // NOTE: this points somewhere in the string given to the Parse() function -
+    //       it's task of the caller ensure that memory is still valid !
+    const wxChar *argpos;
+
+    // pointer to the last character of this conversion specifier in the
+    // format string
+    // NOTE: this points somewhere in the string given to the Parse() function -
+    //       it's task of the caller ensure that memory is still valid !
+    const wxChar *argend;
+
+    // a little buffer where formatting flags like #+\.hlqLZ are stored by Parse()
+    // for use in Process()
+    // NB: this buffer can be safely a char buffer instead of a wchar_t buffer
+    //     since it's used only for numeric conversion specifier and always
+    //     with sprintf().
+    char szFlags[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
+
+
+public:
+
+    // we don't declare this as a constructor otherwise it would be called
+    // automatically and we don't want this: to be optimized, wxVsnprintf_
+    // calls this function only on really-used instances of this class.
+    void Init();
+
+    // Parses the first conversion specifier in the given string, which must
+    // begin with a '%'. Returns false if the first '%' does not introduce a
+    // (valid) conversion specifier and thus should be ignored.
+    bool Parse(const wxChar *format);
+
+    // Process this conversion specifier and puts the result in the given
+    // buffer. Returns the number of characters written in 'buf' or -1 if
+    // there's not enough space.
+    int Process(wxChar *buf, size_t lenMax, wxPrintfArg *p);
+
+    // Loads the argument of this conversion specifier from given va_list.
+    bool LoadArg(wxPrintfArg *p, va_list &argptr);
+
+private:
+    // An helper function of LoadArg() which is used to handle the '*' flag
+    void ReplaceAsteriskWith(int w);
+};
+
+void wxPrintfConvSpec::Init()
+{
+    min_width = 0;
+    max_width = 0xFFFF;
+    pos = 0;
+    adj_left = false;
+    argpos = argend = NULL;
+    type = wxPAT_INVALID;
+
+    // this character will never be removed from szFlags array and
+    // is important when calling sprintf() in wxPrintfConvSpec::Process() !
+    szFlags[0] = '%';
+}
+
+bool wxPrintfConvSpec::Parse(const wxChar *format)
+{
+    bool done = false;
+
+    // temporary parse data
+    size_t flagofs = 1;
+    bool in_prec, prec_dot;
+    int ilen = 0;
+
+    adj_left = in_prec = prec_dot = false;
+    argpos = argend = format;
+    do

     {
     {

-        const wxChar chCur = format[n];
+#define CHECK_PREC \
+        if (in_prec && !prec_dot) \
+        { \
+            szFlags[flagofs++] = (char)'.'; \
+            prec_dot = true; \
+        }

 
 

-        if ( chCur == wxT('%') )
+        // what follows '%'?
+        const wxChar ch = *(++argend);
+        switch ( ch )

         {
         {

-            static char s_szFlags[256] = "%";
-            size_t flagofs = 1;
-            bool adj_left = false,
-                 in_prec = false,
-                 prec_dot = false,
-                 done = false;
-            int ilen = 0;
-            size_t min_width = 0,
-                   max_width = wxSTRING_MAXLEN;
-            do
-            {
+            case wxT('\0'):
+                return false;       // not really an argument
+
+            case wxT('%'):
+                return false;       // not really an argument
+
+            case wxT('#'):
+            case wxT('0'):
+            case wxT(' '):
+            case wxT('+'):
+            case wxT('\''):
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('-'):
+                CHECK_PREC
+                adj_left = true;
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('.'):
+                CHECK_PREC
+                in_prec = true;
+                prec_dot = false;
+                max_width = 0;
+                // dot will be auto-added to szFlags if non-negative
+                // number follows
+                break;
+
+            case wxT('h'):
+                ilen = -1;
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('l'):
+                ilen = 1;
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('q'):
+            case wxT('L'):
+                ilen = 2;
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('Z'):
+                ilen = 3;
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('*'):
+                if (in_prec)
+                {
+                    CHECK_PREC

 
 

-#define CHECK_PREC \
-                if (in_prec && !prec_dot) \
-                { \
-                    s_szFlags[flagofs++] = '.'; \
-                    prec_dot = true; \
+                    // tell Process() to use the next argument
+                    // in the stack as maxwidth...
+                    max_width = -1;
+                }
+                else
+                {
+                    // tell Process() to use the next argument
+                    // in the stack as minwidth...
+                    min_width = -1;
+                }
+
+                // save the * in our formatting buffer...
+                // will be replaced later by Process()
+                szFlags[flagofs++] = (char)ch;
+                break;
+
+            case wxT('1'): case wxT('2'): case wxT('3'):
+            case wxT('4'): case wxT('5'): case wxT('6'):
+            case wxT('7'): case wxT('8'): case wxT('9'):
+                {
+                    int len = 0;
+                    CHECK_PREC
+                    while ( (*argend >= wxT('0')) &&
+                            (*argend <= wxT('9')) )
+                    {
+                        szFlags[flagofs++] = (char)(*argend);
+                        len = len*10 + (*argend - wxT('0'));
+                        argend++;
+                    }
+
+                    if (in_prec)
+                        max_width = len;
+                    else
+                        min_width = len;
+
+                    argend--; // the main loop pre-increments n again
+                }
+                break;
+
+            case wxT('$'):      // a positional parameter (e.g. %2$s) ?
+                {
+                    if (min_width <= 0)
+                        break;      // ignore this formatting flag as no
+                                    // numbers are preceding it
+
+                    // remove from szFlags all digits previously added
+                    do {
+                        flagofs--;
+                    } while (szFlags[flagofs] >= '1' &&
+                             szFlags[flagofs] <= '9');
+
+                    // re-adjust the offset making it point to the
+                    // next free char of szFlags
+                    flagofs++;
+
+                    pos = min_width;
+                    min_width = 0;
+                }
+                break;
+
+            case wxT('d'):
+            case wxT('i'):
+            case wxT('o'):
+            case wxT('u'):
+            case wxT('x'):
+            case wxT('X'):
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                szFlags[flagofs] = (char)'\0';
+                if (ilen == 0)
+                    type = wxPAT_INT;
+                else if (ilen == -1)
+                    // NB: 'short int' value passed through '...'
+                    //      is promoted to 'int', so we have to get
+                    //      an int from stack even if we need a short
+                    type = wxPAT_INT;
+                else if (ilen == 1)
+                    type = wxPAT_LONGINT;
+                else if (ilen == 2)
+#if SIZEOF_LONG_LONG
+                    type = wxPAT_LONGLONGINT;
+#else // !long long
+                    type = wxPAT_LONGINT;
+#endif // long long/!long long
+                else if (ilen == 3)
+                    type = wxPAT_SIZET;
+                done = true;
+                break;
+
+            case wxT('e'):
+            case wxT('E'):
+            case wxT('f'):
+            case wxT('g'):
+            case wxT('G'):
+                CHECK_PREC
+                szFlags[flagofs++] = (char)ch;
+                szFlags[flagofs] = (char)'\0';
+                if (ilen == 2)
+                    type = wxPAT_LONGDOUBLE;
+                else
+                    type = wxPAT_DOUBLE;
+                done = true;
+                break;
+
+            case wxT('p'):
+                type = wxPAT_POINTER;
+                done = true;
+                break;
+
+            case wxT('c'):
+                if (ilen == -1)
+                {
+                    // in Unicode mode %hc == ANSI character
+                    // and in ANSI mode, %hc == %c == ANSI...
+                    type = wxPAT_CHAR;
+                }
+                else if (ilen == 1)
+                {
+                    // in ANSI mode %lc == Unicode character
+                    // and in Unicode mode, %lc == %c == Unicode...
+                    type = wxPAT_WCHAR;

                 }
                 }

+                else
+                {
+#if wxUSE_UNICODE
+                    // in Unicode mode, %c == Unicode character
+                    type = wxPAT_WCHAR;
+#else
+                    // in ANSI mode, %c == ANSI character
+                    type = wxPAT_CHAR;
+#endif
+                }
+                done = true;
+                break;
+
+            case wxT('s'):
+                if (ilen == -1)
+                {
+                    // Unicode mode wx extension: we'll let %hs mean non-Unicode
+                    // strings (when in ANSI mode, %s == %hs == ANSI string)
+                    type = wxPAT_PCHAR;
+                }
+                else if (ilen == 1)
+                {
+                    // in Unicode mode, %ls == %s == Unicode string
+                    // in ANSI mode, %ls == Unicode string
+                    type = wxPAT_PWCHAR;
+                }
+                else
+                {
+#if wxUSE_UNICODE
+                    type = wxPAT_PWCHAR;
+#else
+                    type = wxPAT_PCHAR;
+#endif
+                }
+                done = true;
+                break;
+
+            case wxT('n'):
+                if (ilen == 0)
+                        type = wxPAT_NINT;
+                else if (ilen == -1)
+                        type = wxPAT_NSHORTINT;
+                else if (ilen >= 1)
+                        type = wxPAT_NLONGINT;
+                done = true;
+                break;
+
+            default:
+                // bad format, don't consider this an argument;
+                // leave it unchanged
+                return false;
+        }
+    }
+    while (!done);
+
+    return true;        // parsing was successful
+}
+
+
+void wxPrintfConvSpec::ReplaceAsteriskWith(int w)
+{
+    char temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
+
+    // find the first * in our flag buffer
+    char *pwidth = strchr(szFlags, '*');
+    wxASSERT(pwidth);
+
+    // save what follows the * (the +1 is to skip it!)
+    strcpy(temp, pwidth+1);
+    if (w < 0) {
+        pwidth[0] = '-';
+        pwidth++;
+    }
+
+    // replace * with the actual integer given as width
+    int offset = ::sprintf(pwidth,"%d",abs(w));
+
+    // restore after the expanded * what was following it
+    strcpy(pwidth+offset, temp);
+}
+
+bool wxPrintfConvSpec::LoadArg(wxPrintfArg *p, va_list &argptr)
+{
+    // did the '*' width/precision specifier was used ?
+    if (max_width == -1)
+    {
+        // take the maxwidth specifier from the stack
+        max_width = va_arg(argptr, int);
+        if (max_width < 0)
+            max_width = 0;
+        else
+            ReplaceAsteriskWith(max_width);
+    }
+
+    if (min_width == -1)
+    {
+        // take the minwidth specifier from the stack
+        min_width = va_arg(argptr, int);
+
+        ReplaceAsteriskWith(min_width);
+        if (min_width < 0)
+        {
+            adj_left = !adj_left;
+            min_width = -min_width;
+        }
+    }
+
+    switch (type) {
+        case wxPAT_INT:
+            p->pad_int = va_arg(argptr, int);
+            break;
+        case wxPAT_LONGINT:
+            p->pad_longint = va_arg(argptr, long int);
+            break;
+#if SIZEOF_LONG_LONG
+        case wxPAT_LONGLONGINT:
+            p->pad_longlongint = va_arg(argptr, long long int);
+            break;
+#endif
+        case wxPAT_SIZET:
+            p->pad_sizet = va_arg(argptr, size_t);
+            break;
+        case wxPAT_DOUBLE:
+            p->pad_double = va_arg(argptr, double);
+            break;
+        case wxPAT_LONGDOUBLE:
+            p->pad_longdouble = va_arg(argptr, long double);
+            break;
+        case wxPAT_POINTER:
+            p->pad_pointer = va_arg(argptr, void *);
+            break;
+
+        case wxPAT_CHAR:
+            p->pad_char = (char)va_arg(argptr, int);  // char is promoted to int when passed through '...'
+            break;
+        case wxPAT_WCHAR:
+            p->pad_wchar = (wchar_t)va_arg(argptr, int);  // char is promoted to int when passed through '...'
+            break;
+
+        case wxPAT_PCHAR:
+            p->pad_pchar = va_arg(argptr, char *);
+            break;
+        case wxPAT_PWCHAR:
+            p->pad_pwchar = va_arg(argptr, wchar_t *);
+            break;
+
+        case wxPAT_NINT:
+            p->pad_nint = va_arg(argptr, int *);
+            break;
+        case wxPAT_NSHORTINT:
+            p->pad_nshortint = va_arg(argptr, short int *);
+            break;
+        case wxPAT_NLONGINT:
+            p->pad_nlongint = va_arg(argptr, long int *);
+            break;
+
+        case wxPAT_INVALID:
+        default:
+            return false;
+    }
+
+    return true;    // loading was successful
+}
+
+int wxPrintfConvSpec::Process(wxChar *buf, size_t lenMax, wxPrintfArg *p)
+{
+    // buffer to avoid dynamic memory allocation each time for small strings
+    static char szScratch[1024];
+    size_t lenCur = 0;

 
 #define APPEND_CH(ch) \
                 { \
 
 #define APPEND_CH(ch) \
                 { \


@@ -214,353 +711,348 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                     } \
                 }
 
                     } \
                 }
 

-                // what follows '%'?
-                const wxChar ch = format[++n];
-                switch ( ch )
-                {
-                    case wxT('\0'):
-                        APPEND_CH(_T('\0'));
+    switch ( type )
+    {
+        case wxPAT_INT:
+            ::sprintf(szScratch, szFlags, p->pad_int);
+            break;

 
 

-                        done = true;
-                        break;
+        case wxPAT_LONGINT:
+            ::sprintf(szScratch, szFlags, p->pad_longint);
+            break;

 
 

-                    case wxT('%'):
-                        APPEND_CH(_T('%'));
-                        done = true;
-                        break;
+#if SIZEOF_LONG_LONG
+        case wxPAT_LONGLONGINT:
+            ::sprintf(szScratch, szFlags, p->pad_longlongint);
+            break;
+#endif // SIZEOF_LONG_LONG

 
 

-                    case wxT('#'):
-                    case wxT('0'):
-                    case wxT(' '):
-                    case wxT('+'):
-                    case wxT('\''):
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+        case wxPAT_SIZET:
+            ::sprintf(szScratch, szFlags, p->pad_sizet);
+            break;

 
 

-                    case wxT('-'):
-                        CHECK_PREC
-                        adj_left = true;
-                        s_szFlags[flagofs++] = ch;
-                        break;
+        case wxPAT_LONGDOUBLE:
+            ::sprintf(szScratch, szFlags, p->pad_longdouble);
+            break;

 
 

-                    case wxT('.'):
-                        CHECK_PREC
-                        in_prec = true;
-                        prec_dot = false;
-                        max_width = 0;
-                        // dot will be auto-added to s_szFlags if non-negative
-                        // number follows
-                        break;
+        case wxPAT_DOUBLE:
+            ::sprintf(szScratch, szFlags, p->pad_double);
+            break;

 
 

-                    case wxT('h'):
-                        ilen = -1;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+        case wxPAT_POINTER:
+            ::sprintf(szScratch, szFlags, p->pad_pointer);
+            break;

 
 

-                    case wxT('l'):
-                        ilen = 1;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+        case wxPAT_CHAR:
+        case wxPAT_WCHAR:
+            {
+                wxChar val =
+#if wxUSE_UNICODE
+                    p->pad_wchar;

 
 

-                    case wxT('q'):
-                    case wxT('L'):
-                        ilen = 2;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                if (type == wxPAT_CHAR) {
+                    // user passed a character explicitely indicated as ANSI...
+                    const char buf[2] = { p->pad_char, 0 };
+                    val = wxString(buf, wxConvLibc)[0u];
+                }
+#else
+                    p->pad_char;

 
 

-                    case wxT('Z'):
-                        ilen = 3;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+#if wxUSE_WCHAR_T
+                if (type == wxPAT_WCHAR) {
+                    // user passed a character explicitely indicated as Unicode...
+                    const wchar_t buf[2] = { p->pad_wchar, 0 };
+                    val = wxString(buf, wxConvLibc)[0u];
+                }
+#endif
+#endif

 
 

-                    case wxT('*'):
-                        {
-                            int len = va_arg(argptr, int);
-                            if (in_prec)
-                            {
-                                if (len<0) break;
-                                CHECK_PREC
-                                    max_width = len;
-                            }
-                            else
-                            {
-                                if (len<0)
-                                {
-                                    adj_left = !adj_left;
-                                    s_szFlags[flagofs++] = '-';
-                                    len = -len;
-                                }
-                                min_width = len;
-                            }
-                            flagofs += ::sprintf(s_szFlags+flagofs,"%d",len);
-                        }
-                        break;
+                size_t i;

 
 

-                    case wxT('1'): case wxT('2'): case wxT('3'):
-                    case wxT('4'): case wxT('5'): case wxT('6'):
-                    case wxT('7'): case wxT('8'): case wxT('9'):
-                        {
-                            int len = 0;
-                            CHECK_PREC
-                            while ( (format[n] >= wxT('0')) &&
-                                    (format[n] <= wxT('9')) )
-                            {
-                                s_szFlags[flagofs++] = format[n];
-                                len = len*10 + (format[n] - wxT('0'));
-                                n++;
-                            }
-
-                            if (in_prec)
-                                max_width = len;
-                            else
-                                min_width = len;
-
-                            n--; // the main loop pre-increments n again
-                        }
-                        break;
+                if (!adj_left)
+                    for (i = 1; i < (size_t)min_width; i++)
+                        APPEND_CH(_T(' '));

 
 

-                    case wxT('d'):
-                    case wxT('i'):
-                    case wxT('o'):
-                    case wxT('u'):
-                    case wxT('x'):
-                    case wxT('X'):
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        s_szFlags[flagofs] = '\0';
-                        if (ilen == 0 )
-                        {
-                            int val = va_arg(argptr, int);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-                        else if (ilen == -1)
-                        {
-                            // NB: 'short int' value passed through '...'
-                            //      is promoted to 'int', so we have to get
-                            //      an int from stack even if we need a short
-                            short int val = (short int) va_arg(argptr, int);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-                        else if (ilen == 1)
-                        {
-                            long int val = va_arg(argptr, long int);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-                        else if (ilen == 2)
-                        {
-#if SIZEOF_LONG_LONG
-                            long long int val = va_arg(argptr, long long int);
-                            ::sprintf(szScratch, s_szFlags, val);
-#else // !long long
-                            long int val = va_arg(argptr, long int);
-                            ::sprintf(szScratch, s_szFlags, val);
-#endif // long long/!long long
-                        }
-                        else if (ilen == 3)
-                        {
-                            size_t val = va_arg(argptr, size_t);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-
-                        {
-                            const wxMB2WXbuf tmp =
-                                wxConvLibc.cMB2WX(szScratch);
-                            APPEND_STR(tmp);
-                        }
-
-                        done = true;
-                        break;
+                APPEND_CH(val);

 
 

-                    case wxT('e'):
-                    case wxT('E'):
-                    case wxT('f'):
-                    case wxT('g'):
-                    case wxT('G'):
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        s_szFlags[flagofs] = '\0';
-                        if (ilen == 2)
-                        {
-                            long double val = va_arg(argptr, long double);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-                        else
-                        {
-                            double val = va_arg(argptr, double);
-                            ::sprintf(szScratch, s_szFlags, val);
-                        }
-
-                        {
-                            const wxMB2WXbuf tmp =
-                                wxConvLibc.cMB2WX(szScratch);
-                            APPEND_STR(tmp);
-                        }
-
-                        done = true;
-                        break;
+                if (adj_left)
+                    for (i = 1; i < (size_t)min_width; i++)
+                        APPEND_CH(_T(' '));
+            }
+            break;

 
 

-                    case wxT('p'):
-                        {
-                            void *val = va_arg(argptr, void *);
-                            CHECK_PREC
-                            s_szFlags[flagofs++] = ch;
-                            s_szFlags[flagofs] = '\0';
-                            ::sprintf(szScratch, s_szFlags, val);
+        case wxPAT_PCHAR:
+        case wxPAT_PWCHAR:
+            {
+                wxString s;
+                const wxChar *val =
+#if wxUSE_UNICODE
+                    p->pad_pwchar;

 
 

-                            const wxMB2WXbuf tmp =
-                                wxConvLibc.cMB2WX(szScratch);
-                            APPEND_STR(tmp);
+                if (type == wxPAT_PCHAR) {
+                    // user passed a string explicitely indicated as ANSI...
+                    val = s = wxString(p->pad_pchar, wxConvLibc);
+                }
+#else
+                    p->pad_pchar;

 
 

-                            done = true;
-                        }
-                        break;
+#if wxUSE_WCHAR_T
+                if (type == wxPAT_PWCHAR) {
+                    // user passed a string explicitely indicated as Unicode...
+                    val = s = wxString(p->pad_pwchar, wxConvLibc);
+                }
+#endif
+#endif
+                int len;

 
 

-                    case wxT('c'):
-                        {
-                            int val = va_arg(argptr, int);
-#if wxUSE_UNICODE
-                            if (ilen == -1)
-                            {
-                                const char buf[2] = { val, 0 };
-                                val = wxString(buf, wxConvLibc)[0u];
-                            }
-#elif wxUSE_WCHAR_T
-                            if (ilen == 1)
-                            {
-                                const wchar_t buf[2] = { val, 0 };
-                                val = wxString(buf, wxConvLibc)[0u];
-                            }
+                if (val)
+                {
+#if wxUSE_STRUTILS
+                    // at this point we are sure that max_width is positive or null
+                    // (see top of wxPrintfConvSpec::LoadArg)
+                    len = wxMin((unsigned int)max_width, wxStrlen(val));
+#else
+                    for ( len = 0; val[len] && (len < max_width); len++ )
+                        ;

 #endif
 #endif

-                            size_t i;
+                }
+                else if (max_width >= 6)
+                {
+                    val = wxT("(null)");
+                    len = 6;
+                }
+                else
+                {
+                    val = wxEmptyString;
+                    len = 0;
+                }

 
 

-                            if (!adj_left)
-                                for (i = 1; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
+                int i;

 
 

-                            APPEND_CH(val);
+                if (!adj_left)
+                {
+                    for (i = len; i < min_width; i++)
+                        APPEND_CH(_T(' '));
+                }

 
 

-                            if (adj_left)
-                                for (i = 1; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
+#if wxUSE_STRUTILS
+                // at this point we are sure that max_width is positive or null
+                // (see top of wxPrintfConvSpec::LoadArg)
+                len = wxMin((unsigned int)len, lenMax-lenCur);
+                wxStrncpy(buf+lenCur, val, len);
+                lenCur += len;
+#else
+                for (i = 0; i < len; i++)
+                    APPEND_CH(val[i]);
+#endif

 
 

-                            done = true;
-                        }
-                        break;
+                if (adj_left)
+                {
+                    for (i = len; i < min_width; i++)
+                        APPEND_CH(_T(' '));
+                }
+            }
+            break;

 
 

-                    case wxT('s'):
-                        {
-                            const wxChar *val = NULL;
-#if wxUSE_UNICODE
-                            wxString s;
-
-                            if (ilen == -1)
-                            {
-                                // wx extension: we'll let %hs mean non-Unicode
-                                // strings
-                                char *v = va_arg(argptr, char *);
-
-                                if (v)
-                                    val = s = wxString(v, wxConvLibc);
-                            }
-                            else
-#elif wxUSE_WCHAR_T
-                            wxString s;
-
-                            if (ilen == 1)
-                            {
-                                // %ls means Unicode strings
-                                wchar_t *v = va_arg(argptr, wchar_t *);
-
-                                if (v)
-                                    val = s = wxString(v, wxConvLibc);
-                            }
-                            else
-#endif
-                            {
-                                val = va_arg(argptr, wxChar *);
-                            }
-
-                            size_t len = 0;
-
-                            if (val)
-                            {
-                                for ( len = 0;
-                                      val[len] && (len < max_width);
-                                      len++ )
-                                    ;
-                            }
-                            else if (max_width >= 6)
-                            {
-                                val = wxT("(null)");
-                                len = 6;
-                            }
-                            else
-                            {
-                                val = wxT("");
-                                len = 0;
-                            }
-
-                            size_t i;
-
-                            if (!adj_left)
-                                for (i = len; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
-
-                            for (i = 0; i < len; i++)
-                                APPEND_CH(val[i]);
-
-                            if (adj_left)
-                                for (i = len; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
-
-                            done = true;
-                        }
-                        break;
+        case wxPAT_NINT:
+            *p->pad_nint = lenCur;
+            break;

 
 

-                    case wxT('n'):
-                        if (ilen == 0)
-                        {
-                            int *val = va_arg(argptr, int *);
-                            *val = lenCur;
-                        }
-                        else if (ilen == -1)
-                        {
-                            short int *val = va_arg(argptr, short int *);
-                            *val = lenCur;
-                        }
-                        else if (ilen >= 1)
-                        {
-                            long int *val = va_arg(argptr, long int *);
-                            *val = lenCur;
-                        }
-                        done = true;
-                        break;
+        case wxPAT_NSHORTINT:
+            *p->pad_nshortint = (short int)lenCur;
+            break;

 
 

-                    default:
-                        // bad format, leave unchanged
-                        APPEND_CH(_T('%'));
-                        APPEND_CH(ch);
-                        done = true;
-                        break;
-                }
+        case wxPAT_NLONGINT:
+            *p->pad_nlongint = lenCur;
+            break;
+
+        case wxPAT_INVALID:
+        default:
+            return -1;
+    }
+
+    // if we used system's sprintf() then we now need to append the s_szScratch
+    // buffer to the given one...
+    switch (type)
+    {
+        case wxPAT_INT:
+        case wxPAT_LONGINT:
+#if SIZEOF_LONG_LONG
+        case wxPAT_LONGLONGINT:
+#endif
+        case wxPAT_SIZET:
+        case wxPAT_LONGDOUBLE:
+        case wxPAT_DOUBLE:
+        case wxPAT_POINTER:
+#if wxUSE_STRUTILS
+            {
+               const wxMB2WXbuf tmp = wxConvLibc.cMB2WX(szScratch);
+               size_t len = wxMin(lenMax, wxStrlen(tmp));
+               wxStrncpy(buf, tmp, len);
+               lenCur += len;
+            }
+#else
+            {
+                const wxMB2WXbuf tmp =
+                    wxConvLibc.cMB2WX(szScratch);
+                APPEND_STR(tmp);

             }
             }

-            while (!done);
+#endif
+            break;
+
+        default:
+            break;      // all other cases were completed previously
+    }
+
+    return lenCur;
+}
+
+// differences from standard strncpy:
+// 1) copies everything from 'source' except for '%%' sequence which is copied as '%'
+// 2) returns the number of written characters in 'dest' as it could differ from given 'n'
+// 3) much less optimized, unfortunately...
+static int wxCopyStrWithPercents(wxChar *dest, const wxChar *source, size_t n)
+{
+    size_t written = 0;
+
+    if (n == 0)
+        return 0;
+
+    size_t i;
+    for ( i = 0; i < n-1; source++, i++)
+    {
+        dest[written++] = *source;
+        if (*(source+1) == wxT('%'))
+        {
+            // skip this additional '%' character
+            source++;
+            i++;

         }
         }

-        else
+    }
+
+    if (i < n)
+        // copy last character inconditionally
+        dest[written++] = *source;
+
+    return written;
+}
+
+int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
+                             const wxChar *format, va_list argptr)
+{
+    // cached data
+    static wxPrintfConvSpec arg[wxMAX_SVNPRINTF_ARGUMENTS];
+    static wxPrintfArg argdata[wxMAX_SVNPRINTF_ARGUMENTS];
+    static wxPrintfConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS] = { NULL };
+
+    size_t i;
+
+    // number of characters in the buffer so far, must be less than lenMax
+    size_t lenCur = 0;
+
+    size_t nargs = 0;
+    const wxChar *toparse = format;
+
+    // parse the format string
+    bool posarg_present = false, nonposarg_present = false;
+    for (; *toparse != wxT('\0'); toparse++)
+    {
+        if (*toparse == wxT('%') )

         {
         {

-            APPEND_CH(chCur);
+            arg[nargs].Init();
+
+            // let's see if this is a (valid) conversion specifier...
+            if (arg[nargs].Parse(toparse))
+            {
+                // ...yes it is
+                wxPrintfConvSpec *current = &arg[nargs];
+
+                // make toparse point to the end of this specifier
+                toparse = current->argend;
+
+                if (current->pos > 0) {
+                    // the positionals start from number 1... adjust the index
+                    current->pos--;
+                    posarg_present = true;
+                } else {
+                    // not a positional argument...
+                    current->pos = nargs;
+                    nonposarg_present = true;
+                }
+
+                // this conversion specifier is tied to the pos-th argument...
+                pspec[current->pos] = current;
+                nargs++;
+
+                if (nargs == wxMAX_SVNPRINTF_ARGUMENTS)
+                    break;  // cannot handle any additional conv spec
+            }

         }
         }

+    }

 
 

-        // terminating NUL?
-        if ( !chCur )
-            break;
+    if (posarg_present && nonposarg_present)
+        return -1;      // format strings with both positional and
+                        // non-positional conversion specifier are unsupported !!
+
+    // on platforms where va_list is an array type, it is necessary to make a
+    // copy to be able to pass it to LoadArg as a reference.
+    bool ok = true;
+    va_list ap;
+    wxVaCopy(ap, argptr);
+
+    // now load arguments from stack
+    for (i=0; i < nargs && ok; i++) {
+        // !pspec[i] if user forgot a positional parameter (e.g. %$1s %$3s) ?
+        // or LoadArg false if wxPrintfConvSpec::Parse failed to set its 'type'
+        // to a valid value...
+        ok = pspec[i] && pspec[i]->LoadArg(&argdata[i], ap);

     }
 
     }
 

+    va_end(ap);
+
+    // something failed while loading arguments from the variable list...
+    if (!ok)
+        return -1;
+
+    // finally, process each conversion specifier with its own argument
+    toparse = format;
+    for (i=0; i < nargs; i++)
+    {
+        // copy in the output buffer the portion of the format string between
+        // last specifier and the current one
+        size_t tocopy = ( arg[i].argpos - toparse );
+        if (lenCur+tocopy >= lenMax)
+            return -1;      // not enough space in the output buffer !
+
+        lenCur += wxCopyStrWithPercents(buf+lenCur, toparse, tocopy);
+
+        // process this specifier directly in the output buffer
+        int n = arg[i].Process(buf+lenCur, lenMax - lenCur, &argdata[arg[i].pos]);
+        if (n == -1)
+            return -1;      // not enough space in the output buffer !
+        lenCur += n;
+
+        // the +1 is because wxPrintfConvSpec::argend points to the last character
+        // of the format specifier, but we are not interested to it...
+        toparse = arg[i].argend + 1;
+    }
+
+    // copy portion of the format string after last specifier
+    // NOTE: toparse is pointing to the character just after the last processed
+    //       conversion specifier
+    // NOTE2: the +1 is because we want to copy also the '\0'
+    size_t tocopy = wxStrlen(format) + 1  - ( toparse - format ) ;
+    if (lenCur+tocopy >= lenMax)
+        return -1;      // not enough space in the output buffer !
+
+    // the -1 is because of the '\0'
+    lenCur += wxCopyStrWithPercents(buf+lenCur, toparse, tocopy) - 1;
+
+    // clean the static array portion used...
+    // NOTE: other arrays do not need cleanup!
+    memset(pspec, 0, sizeof(wxPrintfConvSpec*)*nargs);
+
+    wxASSERT(lenCur == wxStrlen(buf));

     return lenCur;
 }
 
     return lenCur;
 }
 


@@ -658,12 +1150,12 @@ int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr)
     // 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.
     // 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") );
     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") );

-    
+

     va_list argcopy;
     wxVaCopy(argcopy, argptr);
     return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy);
     va_list argcopy;
     wxVaCopy(argcopy, argptr);
     return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy);


@@ -1070,9 +1562,9 @@ WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
 #endif
 
 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
 #endif
 

-#if defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 ) 
+#ifdef wxNEED_WX_MBSTOWCS

 
 

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

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


@@ -1081,20 +1573,20 @@ WXDLLEXPORT size_t wxInternalMbstowcs (wchar_t * out, const char * in, size_t ou
             outsize++;
         return outsize;
     }
             outsize++;
         return outsize;
     }

-    
+

     const char* origin = in;
     const char* origin = in;

-    
+

     while (outlen-- && *in)
     {
         *out++ = (wchar_t) *in++;
     }
     while (outlen-- && *in)
     {
         *out++ = (wchar_t) *in++;
     }

-    
+

     *out = '\0';
     *out = '\0';

-    
+

     return in - origin;
 }
 
     return in - origin;
 }
 

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

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


@@ -1103,19 +1595,21 @@ WXDLLEXPORT size_t      wxInternalWcstombs (char * out, const wchar_t * in, size_t ou
             outsize++;
         return outsize;
     }
             outsize++;
         return outsize;
     }

-    
+

     const wchar_t* origin = in;
     const wchar_t* origin = in;

-    
+

     while (outlen-- && *in)
     {
         *out++ = (char) *in++;
     }
     while (outlen-- && *in)
     {
         *out++ = (char) *in++;
     }

-    
+

     *out = '\0';
     *out = '\0';

-    
+

     return in - origin;
 }
     return in - origin;
 }

-        
+
+#endif // wxNEED_WX_MBSTOWCS
+

 #if defined(wxNEED_WX_CTYPE_H)
 
 #include <CoreFoundation/CoreFoundation.h>
 #if defined(wxNEED_WX_CTYPE_H)
 
 #include <CoreFoundation/CoreFoundation.h>


@@ -1147,8 +1641,6 @@ WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); }
 
 #endif  // wxNEED_WX_CTYPE_H
 
 
 #endif  // wxNEED_WX_CTYPE_H
 

-#endif  // defined(__DARWIN__) and OSX <= 10.2
-

 #ifndef wxStrdupA
 
 WXDLLEXPORT char *wxStrdupA(const char *s)
 #ifndef wxStrdupA
 
 WXDLLEXPORT char *wxStrdupA(const char *s)


@@ -1199,9 +1691,9 @@ int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 #ifndef wxSetlocale
 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 {
 #ifndef wxSetlocale
 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 {

-    char *localeOld = setlocale(category, wxConvLocal.cWX2MB(locale));
+    char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale));

 
 

-    return wxWCharBuffer(wxConvLocal.cMB2WC(localeOld));
+    return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld));

 }
 #endif
 
 }
 #endif
 


@@ -1267,7 +1759,7 @@ WXDLLEXPORT size_t wxStrlen_(const wxChar *s)
     size_t n = 0;
     while ( *s++ )
         n++;
     size_t n = 0;
     while ( *s++ )
         n++;

-            
+

     return n;
 }
 
     return n;
 }
 


@@ -1369,7 +1861,7 @@ WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr)
   }
 
   wxString data(nptr, nptr-start);
   }
 
   wxString data(nptr, nptr-start);

-  wxWX2MBbuf dat = data.mb_str(wxConvLocal);
+  wxWX2MBbuf dat = data.mb_str(wxConvLibc);

   char *rdat = wxMBSTRINGCAST dat;
   double ret = strtod(dat, &rdat);
 
   char *rdat = wxMBSTRINGCAST dat;
   double ret = strtod(dat, &rdat);
 


@@ -1397,7 +1889,7 @@ WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
          (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
 
   wxString data(start, nptr-start);
          (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
 
   wxString data(start, nptr-start);

-  wxWX2MBbuf dat = data.mb_str(wxConvLocal);
+  wxWX2MBbuf dat = data.mb_str(wxConvLibc);

   char *rdat = wxMBSTRINGCAST dat;
   long int ret = strtol(dat, &rdat, base);
 
   char *rdat = wxMBSTRINGCAST dat;
   long int ret = strtol(dat, &rdat, base);
 


@@ -1451,10 +1943,10 @@ double   WXDLLEXPORT wxAtof(const wxChar *psz)
     wxString str(psz);
     if (str.ToDouble(& d))
         return d;
     wxString str(psz);
     if (str.ToDouble(& d))
         return d;

-    else
-        return 0.0;
+
+    return 0.0;

 #else
 #else

-    return atof(wxConvLocal.cWX2MB(psz));
+    return atof(wxConvLibc.cWX2MB(psz));

 #endif
 }
 #endif
 #endif
 }
 #endif


@@ -1462,12 +1954,12 @@ double   WXDLLEXPORT wxAtof(const wxChar *psz)
 #ifdef wxNEED_WX_STDLIB_H
 int      WXDLLEXPORT wxAtoi(const wxChar *psz)
 {
 #ifdef wxNEED_WX_STDLIB_H
 int      WXDLLEXPORT wxAtoi(const wxChar *psz)
 {

-  return atoi(wxConvLocal.cWX2MB(psz));
+  return atoi(wxConvLibc.cWX2MB(psz));

 }
 
 long     WXDLLEXPORT wxAtol(const wxChar *psz)
 {
 }
 
 long     WXDLLEXPORT wxAtol(const wxChar *psz)
 {

-  return atol(wxConvLocal.cWX2MB(psz));
+  return atol(wxConvLibc.cWX2MB(psz));

 }
 
 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
 }
 
 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)


@@ -1477,7 +1969,7 @@ wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
     //     time getenv() is called, so it is OK to use static string
     //     buffer to hold the data.
     static wxWCharBuffer value((wxChar*)NULL);
     //     time getenv() is called, so it is OK to use static string
     //     buffer to hold the data.
     static wxWCharBuffer value((wxChar*)NULL);

-    value = wxConvLocal.cMB2WX(getenv(wxConvLocal.cWX2MB(name)));
+    value = wxConvLibc.cMB2WX(getenv(wxConvLibc.cWX2MB(name)));

     return value.data();
 #else
     return getenv(name);
     return value.data();
 #else
     return getenv(name);


@@ -1486,40 +1978,48 @@ wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
 
 int WXDLLEXPORT wxSystem(const wxChar *psz)
 {
 
 int WXDLLEXPORT wxSystem(const wxChar *psz)
 {

-    return system(wxConvLocal.cWX2MB(psz));
+    return system(wxConvLibc.cWX2MB(psz));

 }
 
 #endif // wxNEED_WX_STDLIB_H
 
 #ifdef wxNEED_WX_TIME_H
 }
 
 #endif // wxNEED_WX_STDLIB_H
 
 #ifdef wxNEED_WX_TIME_H

-WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm)
+WXDLLEXPORT size_t
+wxStrftime(wxChar *s, size_t maxsize, const wxChar *fmt, const struct tm *tm)

 {
 {

-    if (!max) return 0;
+    if ( !maxsize )
+        return 0;

 
 

-    char *buf = (char *)malloc(max);
-    size_t ret = strftime(buf, max, wxConvLocal.cWX2MB(fmt), tm);
-    if (ret)
-    {
-        wxStrcpy(s, wxConvLocal.cMB2WX(buf));
-        free(buf);
-        return wxStrlen(s);
-    }
-    else
-    {
-        free(buf);
-        *s = 0;
+    wxCharBuffer buf(maxsize);
+
+    wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
+    if ( !bufFmt )

         return 0;
         return 0;

-  }
+
+    size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
+    if  ( !ret )
+        return 0;
+
+    wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
+    if ( !wbuf )
+        return 0;
+
+    wxStrncpy(s, wbuf, maxsize);
+    return wxStrlen(s);

 }
 #endif // wxNEED_WX_TIME_H
 
 #ifndef wxCtime
 WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
 {
 }
 #endif // wxNEED_WX_TIME_H
 
 #ifndef wxCtime
 WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
 {

-    static wxChar   buf[128];
+    // normally the string is 26 chars but give one more in case some broken
+    // DOS compiler decides to use "\r\n" instead of "\n" at the end
+    static wxChar buf[27];

 
 

-    wxStrncpy( buf, wxConvertMB2WX( ctime( timep ) ), sizeof( buf ) );
-    buf[ sizeof( buf ) - 1 ] = _T('\0');
+    // ctime() is guaranteed to return a string containing only ASCII
+    // characters, as its format is always the same for any locale
+    wxStrncpy(buf, wxString::FromAscii(ctime(timep)), WXSIZEOF(buf));
+    buf[WXSIZEOF(buf) - 1] = _T('\0');

 
     return buf;
 }
 
     return buf;
 }


@@ -1570,7 +2070,7 @@ WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_pt
 // missing C RTL functions
 // ----------------------------------------------------------------------------
 
 // missing C RTL functions
 // ----------------------------------------------------------------------------
 

-#if wxNEED_STRDUP
+#ifdef wxNEED_STRDUP

 
 char *strdup(const char *s)
 {
 
 char *strdup(const char *s)
 {


@@ -1592,3 +2092,11 @@ void *calloc( size_t num, size_t size )
 
 #endif // __WXWINCE__ <= 211
 
 
 #endif // __WXWINCE__ <= 211
 

+#ifdef __WXWINCE__
+
+int wxRemove(const wxChar *path)
+{
+    return ::DeleteFile(path) == 0;
+}
+
+#endif