reorganized, improved and hopefully simplified wxchar.h and printf() functions handling; also added wxWcslen() to fix wcslen() problems

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@16767 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/common/string.cpp

@@ -46,13 +46,6 @@
   #include <clib.h>
 #endif
 
-#if wxUSE_UNICODE
-    #undef wxUSE_EXPERIMENTAL_PRINTF
-    #ifndef wvsnprintf
-        #define wxUSE_EXPERIMENTAL_PRINTF 1
-    #endif
-#endif
-
 // allocating extra space for each string consumes more memory but speeds up
 // the concatenation operations (nLen is the current string's length)
 // NB: EXTRA_ALLOC must be >= 0!
@@ -88,54 +81,6 @@ static const struct
 // empty C style string: points to 'string data' byte of g_strEmpty
 extern const wxChar WXDLLEXPORT *wxEmptyString = &g_strEmpty.dummy;
 
-// ----------------------------------------------------------------------------
-// conditional compilation
-// ----------------------------------------------------------------------------
-
-#if !defined(__WXSW__) && wxUSE_UNICODE
-  #ifdef wxUSE_EXPERIMENTAL_PRINTF
-    #undef wxUSE_EXPERIMENTAL_PRINTF
-  #endif
-  #define wxUSE_EXPERIMENTAL_PRINTF 1
-#endif
-
-// we want to find out if the current platform supports vsnprintf()-like
-// function: for Unix this is done with configure, for Windows we test the
-// compiler explicitly.
-//
-// FIXME currently, this is only for ANSI (!Unicode) strings, so we call this
-//       function wxVsnprintfA (A for ANSI), should also find one for Unicode
-//       strings in Unicode build
-#ifdef __WXMSW__
-    #if defined(__VISUALC__) || (defined(__MINGW32__) && wxUSE_NORLANDER_HEADERS)
-        #define wxVsnprintfA     _vsnprintf
-    #endif
-#elif defined(__WXMAC__)
-    #define wxVsnprintfA       vsnprintf
-#else   // !Windows
-    #ifdef HAVE_VSNPRINTF
-        #define wxVsnprintfA       vsnprintf
-    #endif
-#endif  // Windows/!Windows
-
-#ifndef wxVsnprintfA
-    // in this case we'll use vsprintf() (which is ANSI and thus should be
-    // always available), but it's unsafe because it doesn't check for buffer
-    // size - so give a warning
-    #define wxVsnprintfA(buf, len, format, arg) vsprintf(buf, format, arg)
-
-    #if defined(__VISUALC__)
-        #pragma message("Using sprintf() because no snprintf()-like function defined")
-    #elif defined(__GNUG__)
-        #warning "Using sprintf() because no snprintf()-like function defined"
-    #endif //compiler
-#endif // no vsnprintf
-
-#if defined(_AIX)
-  // AIX has vsnprintf, but there's no prototype in the system headers.
-  extern "C" int vsnprintf(char* str, size_t n, const char* format, va_list ap);
-#endif
-
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
@@ -196,15 +141,15 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
   class Averager
   {
   public:
-    Averager(const char *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
+    Averager(const wxChar *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
    ~Averager()
-   { printf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
+   { wxPrintf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
 
     void Add(size_t n) { m_nTotal += n; m_nCount++; }
 
   private:
     size_t m_nCount, m_nTotal;
-    const char *m_sz;
+    const wxChar *m_sz;
   } g_averageLength("allocation size"),
     g_averageSummandLength("summand length"),
     g_averageConcatHit("hit probability in concat"),
@@ -235,8 +180,9 @@ wxString::wxString(wxChar ch, size_t nLength)
     }
 
 #if wxUSE_UNICODE
-    // memset only works on char
+    // memset only works on chars
-    for (size_t n=0; n<nLength; n++) m_pchData[n] = ch;
+    for ( size_t n = 0; n < nLength; n++ )
+        m_pchData[n] = ch;
 #else
     memset(m_pchData, ch, nLength);
 #endif
@@ -1273,265 +1219,26 @@ int wxString::Printf(const wxChar *pszFormat, ...)
 
 int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
 {
-#if wxUSE_EXPERIMENTAL_PRINTF
+    int size = 1024;
-  // the new implementation
+    for ( ;; )
-
-  // buffer to avoid dynamic memory allocation each time for small strings
-  char szScratch[1024];
-
-  Reinit();
-  for (size_t n = 0; pszFormat[n]; n++)
-    if (pszFormat[n] == wxT('%')) {
-      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 {
-#define CHECK_PREC if (in_prec && !prec_dot) { s_szFlags[flagofs++] = '.'; prec_dot = TRUE; }
-        switch (pszFormat[++n]) {
-        case wxT('\0'):
-          done = TRUE;
-          break;
-        case wxT('%'):
-          *this += wxT('%');
-          done = TRUE;
-          break;
-        case wxT('#'):
-        case wxT('0'):
-        case wxT(' '):
-        case wxT('+'):
-        case wxT('\''):
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          break;
-        case wxT('-'):
-          CHECK_PREC
-          adj_left = TRUE;
-          s_szFlags[flagofs++] = pszFormat[n];
-          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 wxT('h'):
-          ilen = -1;
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          break;
-        case wxT('l'):
-          ilen = 1;
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          break;
-        case wxT('q'):
-        case wxT('L'):
-          ilen = 2;
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          break;
-        case wxT('Z'):
-          ilen = 3;
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          break;
-        case wxT('*'):
     {
-            int len = va_arg(argptr, int);
+        wxChar *buf = GetWriteBuf(size + 1);
-            if (in_prec) {
+        if ( !buf )
-              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;
-        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;
+            // out of memory
-            CHECK_PREC
+            return -1;
-            while ((pszFormat[n]>=wxT('0')) && (pszFormat[n]<=wxT('9'))) {
-              s_szFlags[flagofs++] = pszFormat[n];
-              len = len*10 + (pszFormat[n] - wxT('0'));
-              n++;
         }
-            if (in_prec) max_width = len;
-            else min_width = len;
-            n--; // the main loop pre-increments n again
-          }
-          break;
-        case wxT('d'):
-        case wxT('i'):
-        case wxT('o'):
-        case wxT('u'):
-        case wxT('x'):
-        case wxT('X'):
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          s_szFlags[flagofs] = '\0';
-          if (ilen == 0 ) {
-            int val = va_arg(argptr, int);
-            ::sprintf(szScratch, s_szFlags, val);
-          }
-          else if (ilen == -1) {
-            short int val = va_arg(argptr, short 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 int val = va_arg(argptr, long int);
-            ::sprintf(szScratch, s_szFlags, val);
-#endif
-          }
-          else if (ilen == 3) {
-            size_t val = va_arg(argptr, size_t);
-            ::sprintf(szScratch, s_szFlags, val);
-          }
-          *this += wxString(szScratch);
-          done = TRUE;
-          break;
-        case wxT('e'):
-        case wxT('E'):
-        case wxT('f'):
-        case wxT('g'):
-        case wxT('G'):
-          CHECK_PREC
-          s_szFlags[flagofs++] = pszFormat[n];
-          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);
-          }
-          *this += wxString(szScratch);
-          done = TRUE;
-          break;
-        case wxT('p'):
-          {
-            void *val = va_arg(argptr, void *);
-            CHECK_PREC
-            s_szFlags[flagofs++] = pszFormat[n];
-            s_szFlags[flagofs] = '\0';
-            ::sprintf(szScratch, s_szFlags, val);
-            *this += wxString(szScratch);
-            done = TRUE;
-          }
-          break;
-        case wxT('c'):
-          {
-            wxChar val = va_arg(argptr, int);
-            // we don't need to honor padding here, do we?
-            *this += val;
-            done = TRUE;
-          }
-          break;
-        case wxT('s'):
-          if (ilen == -1) {
-            // wx extension: we'll let %hs mean non-Unicode strings
-            char *val = va_arg(argptr, char *);
-#if wxUSE_UNICODE
-            // ASCII->Unicode constructor handles max_width right
-            wxString s(val, wxConvLibc, max_width);
-#else
-            size_t len = wxSTRING_MAXLEN;
-            if (val) {
-              for (len = 0; val[len] && (len<max_width); len++);
-            } else val = wxT("(null)");
-            wxString s(val, len);
-#endif
-            if (s.Len() < min_width)
-              s.Pad(min_width - s.Len(), wxT(' '), adj_left);
-            *this += s;
-          } else {
-            wxChar *val = va_arg(argptr, wxChar *);
-            size_t len = wxSTRING_MAXLEN;
-            if (val) {
-              for (len = 0; val[len] && (len<max_width); len++);
-            } else val = wxT("(null)");
-            wxString s(val, len);
-            if (s.Len() < min_width)
-              s.Pad(min_width - s.Len(), wxT(' '), adj_left);
-            *this += s;
-          }
-          done = TRUE;
-          break;
-        case wxT('n'):
-          if (ilen == 0) {
-            int *val = va_arg(argptr, int *);
-            *val = Len();
-          }
-          else if (ilen == -1) {
-            short int *val = va_arg(argptr, short int *);
-            *val = Len();
-          }
-          else if (ilen >= 1) {
-            long int *val = va_arg(argptr, long int *);
-            *val = Len();
-          }
-          done = TRUE;
-          break;
-        default:
-          if (wxIsalpha(pszFormat[n]))
-            // probably some flag not taken care of here yet
-            s_szFlags[flagofs++] = pszFormat[n];
-          else {
-            // bad format
-            *this += wxT('%'); // just to pass the glibc tst-printf.c
-            n--;
-            done = TRUE;
-          }
-          break;
-        }
-#undef CHECK_PREC
-      } while (!done);
-    } else *this += pszFormat[n];
 
-#else
+        int len = wxVsnprintf(buf, size, pszFormat, argptr);
-  // buffer to avoid dynamic memory allocation each time for small strings
-  char szScratch[1024];
 
-  // NB: wxVsnprintf() may return either less than the buffer size or -1 if
+        // some implementations of vsnprintf() don't NUL terminate the string
-  //     there is not enough place depending on implementation
+        // if there is not enough space for it so always do it manually
-  int iLen = wxVsnprintfA(szScratch, WXSIZEOF(szScratch), (char *)pszFormat, argptr);
+        buf[size] = _T('\0');
-  if ( iLen != -1 ) {
-    // the whole string is in szScratch
-    *this = szScratch;
-  }
-  else {
-      bool outOfMemory = FALSE;
-      int size = 2*WXSIZEOF(szScratch);
-      while ( !outOfMemory ) {
-          char *buf = GetWriteBuf(size);
-          if ( buf )
-            iLen = wxVsnprintfA(buf, size, pszFormat, argptr);
-          else
-            outOfMemory = TRUE;
 
         UngetWriteBuf();
 
-          if ( iLen != -1 ) {
+        if ( len >= 0 )
+        {
             // ok, there was enough space
             break;
         }
@@ -1540,12 +1247,8 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
         size *= 2;
     }
 
-      if ( outOfMemory ) {
+    // we could have overshot
-          // out of memory
+    Shrink();
-          return -1;
-      }
-  }
-#endif // wxUSE_EXPERIMENTAL_PRINTF/!wxUSE_EXPERIMENTAL_PRINTF
 
     return Len();
 }

src/common/wxchar.cpp

@@ -117,62 +117,632 @@ size_t   WXDLLEXPORT wcslen(const wchar_t *s)
 }
 #endif
 
-#ifdef wxNEED_PRINTF_CONVERSION
+// ============================================================================
+// printf() functions business
+// ============================================================================
 
-#define CONVERT_FORMAT_1  \
+// ----------------------------------------------------------------------------
-    wxChar *new_format = (wxChar*) format; \
+// implement [v]snprintf() if the system doesn't provide a safe one
-    size_t old_len = wxStrlen( format ); \
+// ----------------------------------------------------------------------------
-    int n = 0; \
+
-    size_t i; \
+#if !defined(wxVsnprintf_)
-    for (i = 0; i < old_len; i++) \
+int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
+                             const wxChar *format, va_list argptr)
+{
+    // buffer to avoid dynamic memory allocation each time for small strings
+    char szScratch[1024];
+
+    // number of characters in the buffer so far, must be less than lenMax
+    size_t lenCur = 0;
+
+    for (size_t n = 0; format[n]; n++)
+    {
+        if (format[n] == wxT('%')) {
+            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 {
+
+#define CHECK_PREC \
+                if (in_prec && !prec_dot) \
                 { \
-        if ( (format[i] == L'%') && \
+                    s_szFlags[flagofs++] = '.'; \
-             ((i < old_len) && ((format[i+1] == L's') || (format[i+1] == L'c'))) && \
+                    prec_dot = TRUE; \
-             ((i == 0) || (format[i-1] != L'%')) ) \
-        { \
-            n++; \
-        } \
-    } \
- \
-    if (n > 0) \
-    { \
-        new_format = new wxChar[old_len+n+1]; \
-        wxChar *s = new_format; \
- \
-        for (i = 0; i < old_len+1; i++) \
-        { \
-            if ( (format[i] == L'%') && \
-                 ((i < old_len) && ((format[i+1] == L's') || (format[i+1] == L'c'))) && \
-                 ((i == 0) || (format[i-1] != L'%')) ) \
-            { \
-                *s = L'%'; \
-                s++; \
-                *s = L'l'; \
-                s++; \
-            } \
-            else \
-            { \
-                *s = format[i]; \
-                s++; \
-            } \
-        } \
                 }
 
-#define CONVERT_FORMAT_2 \
+#define APPEND_CH(ch) \
-    if (n > 0) \
+                if ( lenCur == lenMax ) \
-        delete [] new_format;
+                    return -1; \
+                \
+                buf[lenCur++] = ch
 
+#define APPEND_STR(s) \
+                for ( const char *p = s; *p; p++ ) \
+                { \
+                    APPEND_CH((wchar_t)(*p)); \
+                }
 
-int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
+#define APPEND_WSTR(s) \
+                for ( const wchar_t *p = s; *p; p++ ) \
+                { \
+                    APPEND_CH(*p); \
+                }
+
+                switch (format[++n]) {
+                    case wxT('\0'):
+                        APPEND_CH(_T('\0'));
+
+                        done = TRUE;
+                        break;
+
+                    case wxT('%'):
+                        APPEND_CH(_T('%'));
+                        done = TRUE;
+                        break;
+
+                    case wxT('#'):
+                    case wxT('0'):
+                    case wxT(' '):
+                    case wxT('+'):
+                    case wxT('\''):
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        break;
+
+                    case wxT('-'):
+                        CHECK_PREC
+                        adj_left = TRUE;
+                        s_szFlags[flagofs++] = format[n];
+                        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 wxT('h'):
+                        ilen = -1;
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        break;
+
+                    case wxT('l'):
+                        ilen = 1;
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        break;
+
+                    case wxT('q'):
+                    case wxT('L'):
+                        ilen = 2;
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        break;
+
+                    case wxT('Z'):
+                        ilen = 3;
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        break;
+
+                    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;
+
+                    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;
+
+                    case wxT('d'):
+                    case wxT('i'):
+                    case wxT('o'):
+                    case wxT('u'):
+                    case wxT('x'):
+                    case wxT('X'):
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs] = '\0';
+                        if (ilen == 0 ) {
+                            int val = va_arg(argptr, int);
+                            ::sprintf(szScratch, s_szFlags, val);
+                        }
+                        else if (ilen == -1) {
+                            short int val = va_arg(argptr, short 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 int val = va_arg(argptr, long int);
+                            ::sprintf(szScratch, s_szFlags, val);
+#endif
+                        }
+                        else if (ilen == 3) {
+                            size_t val = va_arg(argptr, size_t);
+                            ::sprintf(szScratch, s_szFlags, val);
+                        }
+
+                        APPEND_STR(szScratch);
+
+                        done = TRUE;
+                        break;
+
+                    case wxT('e'):
+                    case wxT('E'):
+                    case wxT('f'):
+                    case wxT('g'):
+                    case wxT('G'):
+                        CHECK_PREC
+                        s_szFlags[flagofs++] = format[n];
+                        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);
+                        }
+
+                        APPEND_STR(szScratch);
+
+                        done = TRUE;
+                        break;
+
+                    case wxT('p'):
+                        {
+                            void *val = va_arg(argptr, void *);
+                            CHECK_PREC
+                                s_szFlags[flagofs++] = format[n];
+                            s_szFlags[flagofs] = '\0';
+                            ::sprintf(szScratch, s_szFlags, val);
+
+                            APPEND_STR(szScratch);
+
+                            done = TRUE;
+                        }
+                        break;
+
+                    case wxT('c'):
+                        {
+                            wxChar val = va_arg(argptr, int);
+                            // we don't need to honor padding here, do we?
+                            APPEND_CH(val);
+
+                            done = TRUE;
+                        }
+                        break;
+
+                    case wxT('s'):
+                        if (ilen == -1) {
+                            // wx extension: we'll let %hs mean non-Unicode strings
+                            char *val = va_arg(argptr, char *);
+#if wxUSE_UNICODE
+                            // ASCII->Unicode constructor handles max_width right
+                            wxString s(val, wxConvLibc, max_width);
+#else
+                            size_t len = wxSTRING_MAXLEN;
+                            if (val) {
+                                for (len = 0; val[len] && (len<max_width); len++);
+                            } else val = wxT("(null)");
+                            wxString s(val, len);
+#endif
+                            if (s.Len() < min_width)
+                                s.Pad(min_width - s.Len(), wxT(' '), adj_left);
+
+                            APPEND_WSTR(s);
+                        } else {
+                            wxChar *val = va_arg(argptr, wxChar *);
+                            size_t len = wxSTRING_MAXLEN;
+                            if (val) {
+                                for (len = 0; val[len] && (len<max_width); len++);
+                            } else val = wxT("(null)");
+                            wxString s(val, len);
+                            if (s.Len() < min_width)
+                                s.Pad(min_width - s.Len(), wxT(' '), adj_left);
+
+                            APPEND_WSTR(s);
+                        }
+                        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;
+
+                    default:
+                        if (wxIsalpha(format[n]))
+                            // probably some flag not taken care of here yet
+                            s_szFlags[flagofs++] = format[n];
+                        else {
+                            // bad format
+                            APPEND_CH(_T('%')); // just to pass the glibc tst-printf.c
+                            n--;
+                            done = TRUE;
+                        }
+                        break;
+                }
+            } while (!done);
+        }
+        else
+        {
+            APPEND_CH(format[n]);
+        }
+    }
+
+    return lenCur;
+}
+
+#undef APPEND_CH
+#undef APPEND_STR
+#undef CHECK_PREC
+
+#endif // !wxVsnprintfA
+
+#if !defined(wxSnprintf_)
+int WXDLLEXPORT wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...)
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    int ret = vwscanf( new_format, argptr );
+    int iLen = wxVsnprintf_(buf, len, format, argptr);
 
-    CONVERT_FORMAT_2
+    va_end(argptr);
+
+    return iLen;
+}
+#endif // wxSnprintf_
+
+// ----------------------------------------------------------------------------
+// implement the standard IO functions for wide char if libc doesn't have them
+// ----------------------------------------------------------------------------
+
+#ifndef HAVE_FPUTWC
+
+int wxFputs(const wchar_t *ws, FILE *stream)
+{
+    // counting the number of wide characters written isn't worth the trouble,
+    // simply distinguish between ok and error
+    return fputs(wxConvLibc.cWC2MB(ws), stream) == -1 ? -1 : 0;
+}
+
+int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
+{
+    wchar_t ws[2] = { wc, L'\0' };
+
+    return wxFputs(ws, stream);
+}
+
+#endif // HAVE_FPUTWC
+
+// NB: we only implement va_list functions here, the ones taking ... are
+//     defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
+//     the definitions there to avoid duplicating them here
+#ifdef wxNEED_WPRINTF
+
+// TODO: implement the scanf() functions
+int vwscanf(const wchar_t *format, va_list argptr)
+{
+    wxFAIL_MSG( _T("TODO") );
+
+    return -1;
+}
+
+int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
+{
+    wxFAIL_MSG( _T("TODO") );
+
+    return -1;
+}
+
+int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
+{
+    wxFAIL_MSG( _T("TODO") );
+
+    return -1;
+}
+
+#define vswprintf wxVsnprintf_
+
+int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
+{
+    wxString s;
+    int rc = s.PrintfV(format, argptr);
+
+    if ( rc != -1 )
+    {
+        // we can't do much better without Unicode support in libc...
+        if ( fprintf(stream, s.mb_str()) == -1 )
+            return -1;
+    }
+
+    return rc;
+}
+
+int vwprintf(const wchar_t *format, va_list argptr)
+{
+    return wxVfprintf(stdout, format, argptr);
+}
+
+#endif // wxNEED_WPRINTF
+
+#ifdef wxNEED_PRINTF_CONVERSION
+
+// ----------------------------------------------------------------------------
+// wxFormatConverter: class doing the "%s" -> "%ls" conversion
+// ----------------------------------------------------------------------------
+
+/*
+   Here are the gory details. We want to follow the Windows/MS conventions,
+   that is to have
+
+   In ANSI mode:
+
+   format specifier         results in
+   -----------------------------------
+   %c, %hc, %hC             char
+   %lc, %C, %lC             wchar_t
+
+   In Unicode mode:
+
+   format specifier         results in
+   -----------------------------------
+   %hc, %C, %hC             char
+   %c, %lc, %lC             wchar_t
+
+
+   while on POSIX systems we have %C identical to %lc and %c always means char
+   (in any mode) while %lc always means wchar_t,
+
+   So to use native functions in order to get our semantics we must do the
+   following translations in Unicode mode (nothing to do in ANSI mode):
+
+   wxWindows specifier      POSIX specifier
+   ----------------------------------------
+
+   %hc, %C, %hC             %c
+   %c                       %lc
+
+
+   And, of course, the same should be done for %s as well.
+*/
+
+class wxFormatConverter
+{
+public:
+    wxFormatConverter(const wxChar *format);
+
+    operator const wxChar *() const { return m_fmt.c_str(); }
+
+private:
+    // copy another character to the translated format: this function does the
+    // copy if we are translating but doesn't do anything at all if we don't,
+    // so we don't create the translated format string at all unless we really
+    // need to (i.e. InsertFmtChar() is called)
+    wxChar CopyFmtChar(wxChar ch)
+    {
+        if ( !m_fmtOrig )
+        {
+            // we're translating, d copy
+            m_fmt += ch;
+        }
+        else
+        {
+            // simply increase the count which should be copied by
+            // CopyAllBefore() later if needed
+            m_nCopied++;
+        }
+
+        return ch;
+    }
+
+    // insert an extra character
+    void InsertFmtChar(wxChar ch)
+    {
+        if ( m_fmtOrig )
+        {
+            // so far we haven't translated anything yet
+            CopyAllBefore();
+        }
+
+        m_fmt += ch;
+    }
+
+    void CopyAllBefore()
+    {
+        wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
+
+        m_fmt = wxString(m_fmtOrig, m_nCopied);
+
+        // we won't need it any longer
+        m_fmtOrig = NULL;
+    }
+
+    static bool IsFlagChar(wxChar ch)
+    {
+        return ch == _T('-') || ch == _T('+') ||
+               ch == _T('0') || ch == _T(' ') || ch == _T('#');
+    }
+
+    void SkipDigits(const wxChar **ppc)
+    {
+        while ( **ppc >= _T('0') && **ppc <= _T('9') )
+            CopyFmtChar(*(*ppc)++);
+    }
+
+    // the translated format
+    wxString m_fmt;
+
+    // the original format
+    const wxChar *m_fmtOrig;
+
+    // the number of characters already copied
+    size_t m_nCopied;
+};
+
+wxFormatConverter::wxFormatConverter(const wxChar *format)
+{
+    m_fmtOrig = format;
+    m_nCopied = 0;
+
+    while ( *format )
+    {
+        if ( CopyFmtChar(*format++) == _T('%') )
+        {
+            // skip any flags
+            while ( IsFlagChar(*format) )
+                CopyFmtChar(*format++);
+
+            // and possible width
+            if ( *format == _T('*') )
+                CopyFmtChar(*format++);
+            else
+                SkipDigits(&format);
+
+            // precision?
+            if ( *format == _T('.') )
+            {
+                SkipDigits(&format);
+            }
+
+            // next we can have a size modifier
+            enum
+            {
+                Default,
+                Short,
+                Long
+            } size;
+
+            switch ( *format )
+            {
+                case _T('h'):
+                    size = Short;
+                    format++;
+                    break;
+
+                case _T('l'):
+                    // "ll" has a different meaning!
+                    if ( format[1] != _T('l') )
+                    {
+                        size = Long;
+                        format++;
+                        break;
+                    }
+                    //else: fall through
+
+                default:
+                    size = Default;
+            }
+
+            // and finally we should have the type
+            switch ( *format )
+            {
+                case _T('C'):
+                case _T('S'):
+                    // %C and %hC -> %c and %lC -> %lc
+                    if ( size == Long )
+                        CopyFmtChar(_T('l'));
+
+                    InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
+                    break;
+
+                case _T('c'):
+                case _T('s'):
+                    // %c -> %lc but %hc stays %hc and %lc is still %lc
+                    switch ( size )
+                    {
+                        case Default:
+                            InsertFmtChar(_T('l'));
+                            break;
+
+                        case Short:
+                            CopyFmtChar(_T('h'));
+                            break;
+
+                        case Long:
+                            ;
+                    }
+                    // fall through
+
+                default:
+                    // nothing special to do
+                    CopyFmtChar(*format++);
+            }
+        }
+    }
+}
+
+#else // !wxNEED_PRINTF_CONVERSION
+    // no conversion necessary
+    #define wxFormatConverter(x) (x)
+#endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
+
+// ----------------------------------------------------------------------------
+// wxPrintf(), wxScanf() and relatives
+// ----------------------------------------------------------------------------
+
+#if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
+
+int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
+{
+    va_list argptr;
+    va_start(argptr, format);
+
+    int ret = vwscanf(wxFormatConverter(format), argptr );
 
     va_end(argptr);
 
@@ -181,14 +751,10 @@ int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
 
 int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    int ret = vswscanf( str, new_format, argptr );
+    int ret = vswscanf( str, wxFormatConverter(format), argptr );
-
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
@@ -197,74 +763,49 @@ int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 
 int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    int ret = vfwscanf(stream, new_format, argptr);
+    int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
-
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
     return ret;
 }
 
-int wxVsscanf( const wxChar *str, const wxChar *format, va_list ap )
-{
-    CONVERT_FORMAT_1
-
-    int ret = vswscanf( str, new_format, ap );
-    
-    CONVERT_FORMAT_2
-
-    return ret;
-}
-
 int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    int ret = vwprintf( new_format, argptr );
+    int ret = vwprintf( wxFormatConverter(format), argptr );
-    
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
     return ret;
 }
 
+#ifndef wxSnprintf
 int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_4
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    int ret = vswprintf( str, size, new_format, argptr );
+    int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
-
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
     return ret;
 }
+#endif // wxSnprintf
 
 int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start(argptr, format);
 
-    // Ugly
+    // callers of wxSprintf() deserve what they get
-    int ret = vswprintf( str, 10000, new_format, argptr );
+    int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr );
-
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
@@ -273,145 +814,49 @@ int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 
 int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
 {
-    CONVERT_FORMAT_1
-
     va_list argptr;
     va_start( argptr, format );
 
-    int ret = vfwprintf( stream, new_format, argptr );
+    int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
-
-    CONVERT_FORMAT_2
 
     va_end(argptr);
 
     return ret;
 }
 
-int wxVfprint( FILE *stream, const wxChar *format, va_list ap )
+int wxVsscanf( const wxChar *str, const wxChar *format, va_list argptr )
 {
-    CONVERT_FORMAT_1
+    return vswscanf( str, wxFormatConverter(format), argptr );
-
-    int ret = vfwprintf( stream, new_format, ap );
-
-    CONVERT_FORMAT_2
-
-    return ret;
 }
 
-int wxVprintf( const wxChar *format, va_list ap )
+int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr )
 {
-    CONVERT_FORMAT_1
+    return vfwprintf( stream, wxFormatConverter(format), argptr );
-
-    int ret = vwprintf( new_format, ap );
-
-    CONVERT_FORMAT_2
-
-    return ret;
 }
 
-int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap )
+int wxVprintf( const wxChar *format, va_list argptr )
 {
-    CONVERT_FORMAT_1
+    return vwprintf( wxFormatConverter(format), argptr );
-
-    int ret = vswprintf( str, size, new_format, ap );
-
-    CONVERT_FORMAT_2
-
-    return ret;
 }
 
-int wxVsprintf( wxChar *str, const wxChar *format, va_list ap )
+#ifndef wxVsnprintf
+int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr )
 {
-    CONVERT_FORMAT_1
+    return vswprintf( str, size, wxFormatConverter(format), argptr );
-
-    // This is so ugly
-    int ret = vswprintf(str, 10000, new_format, ap);
-
-    CONVERT_FORMAT_2
-
-    return ret;
 }
-#endif
+#endif // wxVsnprintf
 
-// we want to find out if the current platform supports vsnprintf()-like
+int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
-// function: for Unix this is done with configure, for Windows we test the
-// compiler explicitly.
-//
-// FIXME currently, this is only for ANSI (!Unicode) strings, so we call this
-//       function wxVsnprintfA (A for ANSI), should also find one for Unicode
-//       strings in Unicode build
-#ifdef __WXMSW__
-    #if defined(__VISUALC__) || (defined(__MINGW32__) && wxUSE_NORLANDER_HEADERS)
-        #define wxVsnprintfA     _vsnprintf
-    #endif
-#elif defined(__WXMAC__)
-    #define wxVsnprintfA       vsnprintf
-#else   // !Windows
-    #ifdef HAVE_VSNPRINTF
-        #define wxVsnprintfA       vsnprintf
-    #endif
-#endif  // Windows/!Windows
-
-#ifndef wxVsnprintfA
-    // in this case we'll use vsprintf() (which is ANSI and thus should be
-    // always available), but it's unsafe because it doesn't check for buffer
-    // size - so give a warning
-    #define wxVsnprintfA(buf, len, format, arg) vsprintf(buf, format, arg)
-
-    #if defined(__VISUALC__)
-        #pragma message("Using sprintf() because no snprintf()-like function defined")
-    #elif defined(__GNUG__)
-        #warning "Using sprintf() because no snprintf()-like function defined"
-    #endif //compiler
-#endif // no vsnprintf
-
-#if defined(_AIX)
-  // AIX has vsnprintf, but there's no prototype in the system headers.
-  extern "C" int vsnprintf(char* str, size_t n, const char* format, va_list ap);
-#endif
-
-#if !defined(wxVsnprintf) && !defined(wxHAS_VSNPRINTF)
-int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
-                            const wxChar *format, va_list argptr)
 {
-#if wxUSE_UNICODE
+    // same as for wxSprintf()
-    wxString s;
+    return vswprintf(str, UINT_MAX, wxFormatConverter(format), argptr);
-    int iLen = s.PrintfV(format, argptr);
-    if ( iLen != -1 )
-    {
-        wxStrncpy(buf, s.c_str(), len);
-        buf[len-1] = wxT('\0');
-    }
-
-    return iLen;
-#else // ANSI
-    // vsnprintf() will not terminate the string with '\0' if there is not
-    // enough place, but we want the string to always be NUL terminated
-    int rc = wxVsnprintfA(buf, len - 1, format, argptr);
-    if ( rc == -1 )
-    {
-        buf[len] = 0;
-    }
-
-    return rc;
-#endif // Unicode/ANSI
 }
-#endif
 
-#if !defined(wxSnprintf) && !defined(wxHAS_SNPRINTF)
+#endif // wxNEED_PRINTF_CONVERSION
-int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
-                           const wxChar *format, ...)
-{
-    va_list argptr;
-    va_start(argptr, format);
 
-    int iLen = wxVsnprintf(buf, len, format, argptr);
+// ----------------------------------------------------------------------------
-
+// ctype.h stuff (currently unused)
-    va_end(argptr);
+// ----------------------------------------------------------------------------
-
-    return iLen;
-}
-#endif
 
 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
 inline WORD wxMSW_ctype(wxChar ch)
@@ -500,6 +945,10 @@ WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 }
 #endif
 
+// ----------------------------------------------------------------------------
+// string.h functions
+// ----------------------------------------------------------------------------
+
 #ifdef wxNEED_WX_STRING_H
 WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src)
 {
@@ -665,7 +1114,7 @@ WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
 
   return ret;
 }
-#endif
+#endif // wxNEED_WX_STRING_H
 
 #ifdef wxNEED_WX_STDIO_H
 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)