Apply patch [ 1554746 ] wxXmlNode::InsertChild fix

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

diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp
index 94b56cde9e2248055d475505a5a8df0964f65196..c77dc9cec371ec528ff6eaed25156aa71478180c 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


@@ -82,6 +74,12 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t 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


@@ -91,7 +89,7 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {
 
 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,14 +100,14 @@ 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 wxWcstombs(buf, pwz, n);
 #endif
   }
 
     return wcsrtombs(buf, &pwz, n, &mbstate);
 #else
     return wxWcstombs(buf, pwz, n);
 #endif
   }
 

-#if HAVE_WCSRTOMBS
+#ifdef HAVE_WCSRTOMBS

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


@@ -161,42 +159,568 @@ 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         16
+#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 m_pos;
+
+    // the type of this conversion specifier
+    wxPrintfArgType m_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 m_nMinWidth, m_nMaxWidth;
+
+    // does the argument need to the be aligned to left ?
+    bool m_bAlignLeft;
+
+    // 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 *m_pArgPos;
+
+    // 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 *m_pArgEnd;

 
 

-    for ( size_t n = 0; ; n++ )
+    // a little buffer where formatting flags like #+\.hlqLZ are stored by Parse()
+    // for use in Process()
+    // NB: even if this buffer is used only for numeric conversion specifiers and
+    //     thus could be safely declared as a char[] buffer, we want it to be wxChar
+    //     so that in Unicode builds we can avoid to convert its contents to Unicode
+    //     chars when copying it in user's buffer.
+    wxChar m_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()
+{
+    m_nMinWidth = 0;
+    m_nMaxWidth = 0xFFFF;
+    m_pos = 0;
+    m_bAlignLeft = false;
+    m_pArgPos = m_pArgEnd = NULL;
+    m_type = wxPAT_INVALID;
+
+    // this character will never be removed from m_szFlags array and
+    // is important when calling sprintf() in wxPrintfConvSpec::Process() !
+    m_szFlags[0] = wxT('%');
+}
+
+bool wxPrintfConvSpec::Parse(const wxChar *format)
+{
+    bool done = false;
+
+    // temporary parse data
+    size_t flagofs = 1;
+    bool in_prec, prec_dot;
+    int ilen = 0;
+
+    m_bAlignLeft = in_prec = prec_dot = false;
+    m_pArgPos = m_pArgEnd = format;
+    do

     {
     {

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

 
 

-        if ( chCur == wxT('%') )
+        // what follows '%'?
+        const wxChar ch = *(++m_pArgEnd);
+        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
+                m_szFlags[flagofs++] = ch;
+                break;
+
+            case wxT('-'):
+                CHECK_PREC
+                m_bAlignLeft = true;
+                m_szFlags[flagofs++] = ch;
+                break;
+
+            case wxT('.'):
+                CHECK_PREC
+                in_prec = true;
+                prec_dot = false;
+                m_nMaxWidth = 0;
+                // dot will be auto-added to m_szFlags if non-negative
+                // number follows
+                break;
+
+            case wxT('h'):
+                ilen = -1;
+                CHECK_PREC
+                m_szFlags[flagofs++] = ch;
+                break;
+
+            case wxT('l'):
+                // NB: it's safe to use flagofs-1 as flagofs always start from 1
+                if (m_szFlags[flagofs-1] == 'l')       // 'll' modifier is the same as 'L' or 'q'
+                    ilen = 2;
+                else
+                ilen = 1;
+                CHECK_PREC
+                m_szFlags[flagofs++] = ch;
+                break;
+
+            case wxT('q'):
+            case wxT('L'):
+                ilen = 2;
+                CHECK_PREC
+                m_szFlags[flagofs++] = ch;
+                break;
+
+            case wxT('Z'):
+                ilen = 3;
+                CHECK_PREC
+                m_szFlags[flagofs++] = 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...
+                    m_nMaxWidth = -1;
+                }
+                else
+                {
+                    // tell Process() to use the next argument
+                    // in the stack as minwidth...
+                    m_nMinWidth = -1;
+                }
+
+                // save the * in our formatting buffer...
+                // will be replaced later by Process()
+                m_szFlags[flagofs++] = 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 ( (*m_pArgEnd >= wxT('0')) &&
+                            (*m_pArgEnd <= wxT('9')) )
+                    {
+                        m_szFlags[flagofs++] = (*m_pArgEnd);
+                        len = len*10 + (*m_pArgEnd - wxT('0'));
+                        m_pArgEnd++;
+                    }
+
+                    if (in_prec)
+                        m_nMaxWidth = len;
+                    else
+                        m_nMinWidth = len;
+
+                    m_pArgEnd--; // the main loop pre-increments n again
+                }
+                break;
+
+            case wxT('$'):      // a positional parameter (e.g. %2$s) ?
+                {
+                    if (m_nMinWidth <= 0)
+                        break;      // ignore this formatting flag as no
+                                    // numbers are preceding it
+
+                    // remove from m_szFlags all digits previously added
+                    do {
+                        flagofs--;
+                    } while (m_szFlags[flagofs] >= '1' &&
+                             m_szFlags[flagofs] <= '9');
+
+                    // re-adjust the offset making it point to the
+                    // next free char of m_szFlags
+                    flagofs++;
+
+                    m_pos = m_nMinWidth;
+                    m_nMinWidth = 0;
+                }
+                break;
+
+            case wxT('d'):
+            case wxT('i'):
+            case wxT('o'):
+            case wxT('u'):
+            case wxT('x'):
+            case wxT('X'):
+                CHECK_PREC
+                m_szFlags[flagofs++] = ch;
+                m_szFlags[flagofs] = '\0';
+                if (ilen == 0)
+                    m_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
+                    m_type = wxPAT_INT;
+                else if (ilen == 1)
+                    m_type = wxPAT_LONGINT;
+                else if (ilen == 2)
+#if SIZEOF_LONG_LONG
+                    m_type = wxPAT_LONGLONGINT;
+#else // !long long
+                    m_type = wxPAT_LONGINT;
+#endif // long long/!long long
+                else if (ilen == 3)
+                    m_type = wxPAT_SIZET;
+                done = true;
+                break;
+
+            case wxT('e'):
+            case wxT('E'):
+            case wxT('f'):
+            case wxT('g'):
+            case wxT('G'):
+                CHECK_PREC
+                m_szFlags[flagofs++] = ch;
+                m_szFlags[flagofs] = '\0';
+                if (ilen == 2)
+                    m_type = wxPAT_LONGDOUBLE;
+                else
+                    m_type = wxPAT_DOUBLE;
+                done = true;
+                break;
+
+            case wxT('p'):
+                m_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...
+                    m_type = wxPAT_CHAR;
+                }
+                else if (ilen == 1)
+                {
+                    // in ANSI mode %lc == Unicode character
+                    // and in Unicode mode, %lc == %c == Unicode...
+                    m_type = wxPAT_WCHAR;
+                }
+                else
+                {
+#if wxUSE_UNICODE
+                    // in Unicode mode, %c == Unicode character
+                    m_type = wxPAT_WCHAR;
+#else
+                    // in ANSI mode, %c == ANSI character
+                    m_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)
+                    m_type = wxPAT_PCHAR;
+                }
+                else if (ilen == 1)
+                {
+                    // in Unicode mode, %ls == %s == Unicode string
+                    // in ANSI mode, %ls == Unicode string
+                    m_type = wxPAT_PWCHAR;
+                }
+                else
+                {
+#if wxUSE_UNICODE
+                    m_type = wxPAT_PWCHAR;
+#else
+                    m_type = wxPAT_PCHAR;
+#endif

                 }
                 }

+                done = true;
+                break;
+
+            case wxT('n'):
+                if (ilen == 0)
+                    m_type = wxPAT_NINT;
+                else if (ilen == -1)
+                    m_type = wxPAT_NSHORTINT;
+                else if (ilen >= 1)
+                    m_type = wxPAT_NLONGINT;
+                done = true;
+                break;
+
+            default:
+                // bad format, don't consider this an argument;
+                // leave it unchanged
+                return false;
+        }
+
+        if (flagofs == wxMAX_SVNPRINTF_FLAGBUFFER_LEN)
+        {
+            wxLogDebug(wxT("Too many flags specified for a single conversion specifier!"));
+            return false;
+        }
+    }
+    while (!done);
+
+    return true;        // parsing was successful
+}
+
+
+void wxPrintfConvSpec::ReplaceAsteriskWith(int width)
+{
+    wxChar temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
+
+    // find the first * in our flag buffer
+    wxChar *pwidth = wxStrchr(m_szFlags, wxT('*'));
+    wxASSERT(pwidth);
+
+    // save what follows the * (the +1 is to skip the asterisk itself!)
+    wxStrcpy(temp, pwidth+1);
+    if (width < 0)
+    {
+        pwidth[0] = wxT('-');
+        pwidth++;
+    }
+
+    // replace * with the actual integer given as width
+#if wxUSE_UNICODE
+    int maxlen = (m_szFlags + wxMAX_SVNPRINTF_FLAGBUFFER_LEN - pwidth) / sizeof(wxChar);
+    int offset = ::swprintf(pwidth, maxlen, L"%d", abs(width));
+#else
+    int offset = ::sprintf(pwidth, "%d", abs(width));
+#endif
+
+    // restore after the expanded * what was following it
+    wxStrcpy(pwidth+offset, temp);
+}
+
+bool wxPrintfConvSpec::LoadArg(wxPrintfArg *p, va_list &argptr)
+{
+    // did the '*' width/precision specifier was used ?
+    if (m_nMaxWidth == -1)
+    {
+        // take the maxwidth specifier from the stack
+        m_nMaxWidth = va_arg(argptr, int);
+        if (m_nMaxWidth < 0)
+            m_nMaxWidth = 0;
+        else
+            ReplaceAsteriskWith(m_nMaxWidth);
+    }
+
+    if (m_nMinWidth == -1)
+    {
+        // take the minwidth specifier from the stack
+        m_nMinWidth = va_arg(argptr, int);
+
+        ReplaceAsteriskWith(m_nMinWidth);
+        if (m_nMinWidth < 0)
+        {
+            m_bAlignLeft = !m_bAlignLeft;
+            m_nMinWidth = -m_nMinWidth;
+        }
+    }
+
+    switch (m_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 = 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;
+    // note that this buffer is used only to hold results of number formatting,
+    // %s directly writes user's string in buf, without using szScratch
+#define wxSCRATCH_BUFFER_SIZE       512
+
+    wxChar szScratch[wxSCRATCH_BUFFER_SIZE];
+    size_t lenScratch = 0, lenCur = 0;
+
+#if wxUSE_UNICODE
+#define system_sprintf(buff, flags, data)      ::swprintf(buff, wxSCRATCH_BUFFER_SIZE, flags, data)
+#else
+#define system_sprintf                         ::sprintf
+#endif

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


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

-                // what follows '%'?
-                const wxChar ch = format[++n];
-                switch ( ch )
+    switch ( m_type )
+    {
+        case wxPAT_INT:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_int);
+            break;
+
+        case wxPAT_LONGINT:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_longint);
+            break;
+
+#if SIZEOF_LONG_LONG
+        case wxPAT_LONGLONGINT:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_longlongint);
+            break;
+#endif // SIZEOF_LONG_LONG
+
+        case wxPAT_SIZET:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_sizet);
+            break;
+
+        case wxPAT_LONGDOUBLE:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_longdouble);
+            break;
+
+        case wxPAT_DOUBLE:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_double);
+            break;
+
+        case wxPAT_POINTER:
+            lenScratch = system_sprintf(szScratch, m_szFlags, p->pad_pointer);
+            break;
+
+        case wxPAT_CHAR:
+        case wxPAT_WCHAR:
+            {
+                wxChar val =
+#if wxUSE_UNICODE
+                    p->pad_wchar;
+
+                if (m_type == wxPAT_CHAR)

                 {
                 {

-                    case wxT('\0'):
-                        APPEND_CH(_T('\0'));
+                    // user passed a character explicitely indicated as ANSI...
+                    const char buf[2] = { p->pad_char, 0 };
+                    val = wxString(buf, wxConvLibc)[0u];

 
 

-                        done = true;
-                        break;
+                    //wprintf(L"converting ANSI=>Unicode");   // for debug
+                }
+#else
+                    p->pad_char;

 
 

-                    case wxT('%'):
-                        APPEND_CH(_T('%'));
-                        done = true;
-                        break;
+#if wxUSE_WCHAR_T
+                if (m_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];

 
 

-                    case wxT('#'):
-                    case wxT('0'):
-                    case wxT(' '):
-                    case wxT('+'):
-                    case wxT('\''):
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                    //printf("converting Unicode=>ANSI");   // for debug
+                }
+#endif
+#endif

 
 

-                    case wxT('-'):
-                        CHECK_PREC
-                        adj_left = true;
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                size_t i;

 
 

-                    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;
+                if (!m_bAlignLeft)
+                    for (i = 1; i < (size_t)m_nMinWidth; i++)
+                        APPEND_CH(_T(' '));

 
 

-                    case wxT('h'):
-                        ilen = -1;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                APPEND_CH(val);

 
 

-                    case wxT('l'):
-                        ilen = 1;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                if (m_bAlignLeft)
+                    for (i = 1; i < (size_t)m_nMinWidth; i++)
+                        APPEND_CH(_T(' '));
+            }
+            break;

 
 

-                    case wxT('q'):
-                    case wxT('L'):
-                        ilen = 2;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+        case wxPAT_PCHAR:
+        case wxPAT_PWCHAR:
+            {
+                wxString s;
+                const wxChar *val =
+#if wxUSE_UNICODE
+                    p->pad_pwchar;

 
 

-                    case wxT('Z'):
-                        ilen = 3;
-                        CHECK_PREC
-                        s_szFlags[flagofs++] = ch;
-                        break;
+                if (m_type == wxPAT_PCHAR)
+                {
+                    // user passed a string explicitely indicated as ANSI...
+                    val = s = wxString(p->pad_pchar, wxConvLibc);

 
 

-                    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;
+                    //wprintf(L"converting ANSI=>Unicode");   // for debug
+                }
+#else
+                    p->pad_pchar;

 
 

-                    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 wxUSE_WCHAR_T
+                if (m_type == wxPAT_PWCHAR)
+                {
+                    // user passed a string explicitely indicated as Unicode...
+                    val = s = wxString(p->pad_pwchar, wxConvLibc);

 
 

-                    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;
+                    //printf("converting Unicode=>ANSI");   // for debug
+                }
+#endif
+#endif
+                int len;

 
 

-                    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 (val)
+                {
+#if wxUSE_STRUTILS
+                    // at this point we are sure that m_nMaxWidth is positive or null
+                    // (see top of wxPrintfConvSpec::LoadArg)
+                    len = wxMin((unsigned int)m_nMaxWidth, wxStrlen(val));
+#else
+                    for ( len = 0; val[len] && (len < m_nMaxWidth); len++ )
+                        ;
+#endif
+                }
+                else if (m_nMaxWidth >= 6)
+                {
+                    val = wxT("(null)");
+                    len = 6;
+                }
+                else
+                {
+                    val = wxEmptyString;
+                    len = 0;
+                }

 
 

-                    case wxT('p'):
-                        {
-                            void *val = va_arg(argptr, void *);
-                            CHECK_PREC
-                            s_szFlags[flagofs++] = ch;
-                            s_szFlags[flagofs] = '\0';
-                            ::sprintf(szScratch, s_szFlags, val);
+                int i;

 
 

-                            const wxMB2WXbuf tmp =
-                                wxConvLibc.cMB2WX(szScratch);
-                            APPEND_STR(tmp);
+                if (!m_bAlignLeft)
+                {
+                    for (i = len; i < m_nMinWidth; i++)
+                        APPEND_CH(_T(' '));
+                }

 
 

-                            done = true;
-                        }
-                        break;
+#if wxUSE_STRUTILS
+                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

 
 

-                    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 (m_bAlignLeft)
+                {
+                    for (i = len; i < m_nMinWidth; i++)
+                        APPEND_CH(_T(' '));
+                }
+            }
+            break;
+
+        case wxPAT_NINT:
+            *p->pad_nint = lenCur;
+            break;
+
+        case wxPAT_NSHORTINT:
+            *p->pad_nshortint = (short int)lenCur;
+            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 (m_type)
+    {
+        case wxPAT_INT:
+        case wxPAT_LONGINT:
+#if SIZEOF_LONG_LONG
+        case wxPAT_LONGLONGINT:

 #endif
 #endif

-                            size_t i;
+        case wxPAT_SIZET:
+        case wxPAT_LONGDOUBLE:
+        case wxPAT_DOUBLE:
+        case wxPAT_POINTER:
+#if wxUSE_STRUTILS
+            {
+                wxASSERT(lenScratch >= 0 && lenScratch < wxSCRATCH_BUFFER_SIZE);
+                if (lenMax < lenScratch)
+                {
+                    // fill output buffer and then return -1
+                    wxStrncpy(buf, szScratch, lenMax);
+                    return -1;
+                }
+                wxStrncpy(buf, szScratch, lenScratch);
+                lenCur += lenScratch;
+            }
+#else
+            {
+                APPEND_STR(szScratch);
+            }
+#endif
+            break;

 
 

-                            if (!adj_left)
-                                for (i = 1; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
+        default:
+            break;      // all other cases were completed previously
+    }

 
 

-                            APPEND_CH(val);
+    return lenCur;
+}

 
 

-                            if (adj_left)
-                                for (i = 1; i < min_width; i++)
-                                    APPEND_CH(_T(' '));
+// 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;

 
 

-                            done = true;
-                        }
-                        break;
+    if (n == 0)
+        return 0;

 
 

-                    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
+    size_t i;
+    for ( i = 0; i < n-1; source++, i++)
+    {
+        dest[written++] = *source;
+        if (*(source+1) == wxT('%'))
+        {
+            // skip this additional '%' character
+            source++;
+            i++;
+        }
+    }
+
+    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)
+{
+    // useful for debugging, to understand if we are really using this function
+    // rather than the system implementation
+#if 0
+    wprintf(L"Using wxVsnprintf_\n");

 #endif
 #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 = wxEmptyString;
-                                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 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;
+    // required memory:
+    wxPrintfConvSpec arg[wxMAX_SVNPRINTF_ARGUMENTS];
+    wxPrintfArg argdata[wxMAX_SVNPRINTF_ARGUMENTS];
+    wxPrintfConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS] = { NULL };

 
 

-                    default:
-                        // bad format, leave unchanged
-                        APPEND_CH(_T('%'));
-                        APPEND_CH(ch);
-                        done = true;
-                        break;
+    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('%') )
+        {
+            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->m_pArgEnd;
+
+                if (current->m_pos > 0)
+                {
+                    // the positionals start from number 1... adjust the index
+                    current->m_pos--;
+                    posarg_present = true;

                 }
                 }

+                else
+                {
+                    // not a positional argument...
+                    current->m_pos = nargs;
+                    nonposarg_present = true;
+                }
+
+                // this conversion specifier is tied to the pos-th argument...
+                pspec[current->m_pos] = current;
+                nargs++;
+
+                if (nargs == wxMAX_SVNPRINTF_ARGUMENTS)
+                {
+                    wxLogDebug(wxT("A single call to wxVsnprintf() has more than %d arguments; ")
+                               wxT("ignoring all remaining arguments."), wxMAX_SVNPRINTF_ARGUMENTS);
+                    break;  // cannot handle any additional conv spec
+                }
+            }
+            else
+            {
+                // it's safe to look in the next character of toparse as at worst
+                // we'll hit its \0
+                if (*(toparse+1) == wxT('%'))
+                    toparse++;      // the Parse() returned false because we've found a %%

             }
             }

-            while (!done);

         }
         }

-        else
+    }
+
+    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] means that the user forgot a positional parameter (e.g. %$1s %$3s);
+        // LoadArg == false means that wxPrintfConvSpec::Parse failed to set the
+        // conversion specifier '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].m_pArgPos - toparse );
+        if (lenCur+tocopy >= lenMax)

         {
         {

-            APPEND_CH(chCur);
+            // not enough space in the output buffer !
+            // copy until the end of remaining space and then stop
+            wxCopyStrWithPercents(buf+lenCur, toparse, lenMax - lenCur - 1);
+            buf[lenMax-1] = wxT('\0');
+            return -1;

         }
 
         }
 

-        // terminating NUL?
-        if ( !chCur )
-            break;
+        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].m_pos]);
+        if (n == -1)
+        {
+            buf[lenMax-1] = wxT('\0');  // be sure to always NUL-terminate the string
+            return -1;      // not enough space in the output buffer !
+        }
+        lenCur += n;
+
+        // the +1 is because wxPrintfConvSpec::m_pArgEnd points to the last character
+        // of the format specifier, but we are not interested to it...
+        toparse = arg[i].m_pArgEnd + 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;
+
+    wxASSERT(lenCur == wxStrlen(buf));

     return lenCur;
 }
 
     return lenCur;
 }
 


@@ -978,6 +1536,10 @@ int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... )
 
     int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
 
 
     int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
 

+    // VsnprintfTestCase reveals that glibc's implementation of vswprintf
+    // doesn't nul terminate on truncation.
+    str[size - 1] = 0;
+

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


@@ -1070,7 +1632,7 @@ 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 wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
 {
 
 WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
 {


@@ -1094,7 +1656,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)
+WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)

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


@@ -1116,6 +1678,8 @@ WXDLLEXPORT size_t        wxWcstombs (char * out, const wchar_t * in, size_t outlen)
     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 +1711,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)


@@ -1451,8 +2013,8 @@ 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
     return atof(wxConvLibc.cWX2MB(psz));
 #endif
 #else
     return atof(wxConvLibc.cWX2MB(psz));
 #endif