]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/string.cpp
use guard classes automatically restoring the old state in their dtor instead of...
[wxWidgets.git] / src / common / string.cpp
index daa4901016cbaee06499c06036851c21f672bdac..d7a7c7d9f3612d4fe5034ca246896d346c881b1e 100644 (file)
 #include <string.h>
 #include <stdlib.h>
 
 #include <string.h>
 #include <stdlib.h>
 
-#ifdef __SALFORDC__
-    #include <clib.h>
-#endif
-
 #include "wx/hashmap.h"
 
 // string handling functions used by wxString:
 #include "wx/hashmap.h"
 
 // string handling functions used by wxString:
     #define wxStringStrlen   wxStrlen
 #endif
 
     #define wxStringStrlen   wxStrlen
 #endif
 
+// ----------------------------------------------------------------------------
+// global variables
+// ----------------------------------------------------------------------------
+
+namespace wxPrivate
+{
+
+static UntypedBufferData s_untypedNullData(NULL);
+
+UntypedBufferData * const untypedNullDataPtr = &s_untypedNullData;
+
+} // namespace wxPrivate
 
 // ---------------------------------------------------------------------------
 // static class variables definition
 
 // ---------------------------------------------------------------------------
 // static class variables definition
 //According to STL _must_ be a -1 size_t
 const size_t wxString::npos = (size_t) -1;
 
 //According to STL _must_ be a -1 size_t
 const size_t wxString::npos = (size_t) -1;
 
+#if wxUSE_STRING_POS_CACHE
+
+#ifdef wxHAS_COMPILER_TLS
+
+wxTLS_TYPE(wxString::Cache) wxString::ms_cache;
+
+#else // !wxHAS_COMPILER_TLS
+
+struct wxStrCacheInitializer
+{
+    wxStrCacheInitializer()
+    {
+        // calling this function triggers s_cache initialization in it, and
+        // from now on it becomes safe to call from multiple threads
+        wxString::GetCache();
+    }
+};
+
+/*
+wxString::Cache& wxString::GetCache()
+{
+    static wxTLS_TYPE(Cache) s_cache;
+
+    return wxTLS_VALUE(s_cache);
+}
+*/
+
+static wxStrCacheInitializer gs_stringCacheInit;
+
+#endif // wxHAS_COMPILER_TLS/!wxHAS_COMPILER_TLS
+
+// gdb seems to be unable to display thread-local variables correctly, at least
+// not my 6.4.98 version under amd64, so provide this debugging helper to do it
+#ifdef __WXDEBUG__
+
+struct wxStrCacheDumper
+{
+    static void ShowAll()
+    {
+        puts("*** wxString cache dump:");
+        for ( unsigned n = 0; n < wxString::Cache::SIZE; n++ )
+        {
+            const wxString::Cache::Element&
+                c = wxString::GetCacheBegin()[n];
+
+            printf("\t%u%s\t%p: pos=(%lu, %lu), len=%ld\n",
+                   n,
+                   n == wxString::LastUsedCacheElement() ? " [*]" : "",
+                   c.str,
+                   (unsigned long)c.pos,
+                   (unsigned long)c.impl,
+                   (long)c.len);
+        }
+    }
+};
+
+void wxDumpStrCache() { wxStrCacheDumper::ShowAll(); }
+
+#endif // __WXDEBUG__
+
+#ifdef wxPROFILE_STRING_CACHE
+
+wxString::CacheStats wxString::ms_cacheStats;
+
+struct wxStrCacheStatsDumper
+{
+    ~wxStrCacheStatsDumper()
+    {
+        const wxString::CacheStats& stats = wxString::ms_cacheStats;
+
+        if ( stats.postot )
+        {
+            puts("*** wxString cache statistics:");
+            printf("\tTotal non-trivial calls to PosToImpl(): %u\n",
+                   stats.postot);
+            printf("\tHits %u (of which %u not used) or %.2f%%\n",
+                   stats.poshits,
+                   stats.mishits,
+                   100.*float(stats.poshits - stats.mishits)/stats.postot);
+            printf("\tAverage position requested: %.2f\n",
+                   float(stats.sumpos) / stats.postot);
+            printf("\tAverage offset after cached hint: %.2f\n",
+                   float(stats.sumofs) / stats.postot);
+        }
+
+        if ( stats.lentot )
+        {
+            printf("\tNumber of calls to length(): %u, hits=%.2f%%\n",
+                   stats.lentot, 100.*float(stats.lenhits)/stats.lentot);
+        }
+    }
+};
+
+static wxStrCacheStatsDumper s_showCacheStats;
+
+#endif // wxPROFILE_STRING_CACHE
+
+#endif // wxUSE_STRING_POS_CACHE
+
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
@@ -72,11 +179,16 @@ const size_t wxString::npos = (size_t) -1;
 
 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
 {
 
 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
 {
-// FIXME-UTF8: always, not only if wxUSE_UNICODE
-#if wxUSE_UNICODE && !defined(__BORLANDC__)
-    return os << (const wchar_t*)str.AsWCharBuf();
+#if wxUSE_UNICODE && !wxUSE_UNICODE_UTF8
+    const wxCharBuffer buf(str.AsCharBuf());
+    if ( !buf )
+        os.clear(wxSTD ios_base::failbit);
+    else
+        os << buf.data();
+
+    return os;
 #else
 #else
-    return os << (const char*)str.AsCharBuf();
+    return os << str.AsInternal();
 #endif
 }
 
 #endif
 }
 
@@ -97,6 +209,25 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
 }
 #endif
 
 }
 #endif
 
+#if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
+
+wxSTD wostream& operator<<(wxSTD wostream& wos, const wxString& str)
+{
+    return wos << str.wc_str();
+}
+
+wxSTD wostream& operator<<(wxSTD wostream& wos, const wxCStrData& str)
+{
+    return wos << str.AsWChar();
+}
+
+wxSTD wostream& operator<<(wxSTD wostream& wos, const wxWCharBuffer& str)
+{
+    return wos << str.data();
+}
+
+#endif  // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
+
 #endif // wxUSE_STD_IOSTREAM
 
 // ===========================================================================
 #endif // wxUSE_STD_IOSTREAM
 
 // ===========================================================================
@@ -109,22 +240,30 @@ void wxString::PosLenToImpl(size_t pos, size_t len,
                             size_t *implPos, size_t *implLen) const
 {
     if ( pos == npos )
                             size_t *implPos, size_t *implLen) const
 {
     if ( pos == npos )
+    {
         *implPos = npos;
         *implPos = npos;
-    else
+    }
+    else // have valid start position
     {
     {
-        const_iterator i = begin() + pos;
-        *implPos = wxStringImpl::const_iterator(i.impl()) - m_impl.begin();
+        const const_iterator b = GetIterForNthChar(pos);
+        *implPos = wxStringImpl::const_iterator(b.impl()) - m_impl.begin();
         if ( len == npos )
         if ( len == npos )
+        {
             *implLen = npos;
             *implLen = npos;
-        else
+        }
+        else // have valid length too
         {
         {
-            // too large length is interpreted as "to the end of the string"
-            // FIXME-UTF8: verify this is the case in std::string, assert
-            // otherwise
-            if ( pos + len > length() )
-                len = length() - pos;
-
-            *implLen = (i + len).impl() - i.impl();
+            // we need to handle the case of length specifying a substring
+            // going beyond the end of the string, just as std::string does
+            const const_iterator e(end());
+            const_iterator i(b);
+            while ( len && i <= e )
+            {
+                ++i;
+                --len;
+            }
+
+            *implLen = i.impl() - b.impl();
         }
     }
 }
         }
     }
 }
@@ -233,9 +372,35 @@ const char* wxCStrData::AsChar() const
     wxString *str = wxConstCast(m_str, wxString);
 
     // convert the string:
     wxString *str = wxConstCast(m_str, wxString);
 
     // convert the string:
+    //
+    // FIXME-UTF8: we'd like to do the conversion in the existing buffer (if we
+    //             have it) but it's unfortunately not obvious to implement
+    //             because we don't know how big buffer do we need for the
+    //             given string length (in case of multibyte encodings, e.g.
+    //             ISO-2022-JP or UTF-8 when internal representation is wchar_t)
+    //
+    //             One idea would be to store more than just m_convertedToChar
+    //             in wxString: then we could record the length of the string
+    //             which was converted the last time and try to reuse the same
+    //             buffer if the current length is not greater than it (this
+    //             could still fail because string could have been modified in
+    //             place but it would work most of the time, so we'd do it and
+    //             only allocate the new buffer if in-place conversion returned
+    //             an error). We could also store a bit saying if the string
+    //             was modified since the last conversion (and update it in all
+    //             operation modifying the string, of course) to avoid unneeded
+    //             consequential conversions. But both of these ideas require
+    //             adding more fields to wxString and require profiling results
+    //             to be sure that we really gain enough from them to justify
+    //             doing it.
     wxCharBuffer buf(str->mb_str());
 
     wxCharBuffer buf(str->mb_str());
 
-    // FIXME-UTF8: do the conversion in-place in the existing buffer
+    // if it failed, return empty string and not NULL to avoid crashes in code
+    // written with either wxWidgets 2 wxString or std::string behaviour in
+    // mind: neither of them ever returns NULL and so we shouldn't neither
+    if ( !buf )
+        return "";
+
     if ( str->m_convertedToChar &&
          strlen(buf) == strlen(str->m_convertedToChar) )
     {
     if ( str->m_convertedToChar &&
          strlen(buf) == strlen(str->m_convertedToChar) )
     {
@@ -261,6 +426,10 @@ const wchar_t* wxCStrData::AsWChar() const
     // convert the string:
     wxWCharBuffer buf(str->wc_str());
 
     // convert the string:
     wxWCharBuffer buf(str->wc_str());
 
+    // notice that here, unlike above in AsChar(), conversion can't fail as our
+    // internal UTF-8 is always well-formed -- or the string was corrupted and
+    // all bets are off anyhow
+
     // FIXME-UTF8: do the conversion in-place in the existing buffer
     if ( str->m_convertedToWChar &&
          wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
     // FIXME-UTF8: do the conversion in-place in the existing buffer
     if ( str->m_convertedToWChar &&
          wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
@@ -325,6 +494,9 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
         // UTF-8 sequence and psz may be invalid:
         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
         {
         // UTF-8 sequence and psz may be invalid:
         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
         {
+            // we must pass the real string length to SubstrBufFromMB ctor
+            if ( nLength == npos )
+                nLength = psz ? strlen(psz) : 0;
             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
         }
         // else: do the roundtrip through wchar_t*
             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
         }
         // else: do the roundtrip through wchar_t*
@@ -340,7 +512,7 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
         return SubstrBufFromMB("", 0);
 
     // and then to UTF-8:
         return SubstrBufFromMB("", 0);
 
     // and then to UTF-8:
-    SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxConvUTF8));
+    SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
     // widechar -> UTF-8 conversion isn't supposed to ever fail:
     wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
 
     // widechar -> UTF-8 conversion isn't supposed to ever fail:
     wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
 
@@ -382,9 +554,12 @@ const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 
 const wxWCharBuffer wxString::wc_str() const
 {
 
 const wxWCharBuffer wxString::wc_str() const
 {
-    return wxConvUTF8.cMB2WC(m_impl.c_str(),
-                             m_impl.length() + 1 /* size, not length */,
-                             NULL);
+    return wxMBConvStrictUTF8().cMB2WC
+                                (
+                                    m_impl.c_str(),
+                                    m_impl.length() + 1, // size, not length
+                                    NULL
+                                );
 }
 
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 }
 
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
@@ -395,14 +570,16 @@ const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
     // FIXME-UTF8: use wc_str() here once we have buffers with length
 
     size_t wcLen;
     // FIXME-UTF8: use wc_str() here once we have buffers with length
 
     size_t wcLen;
-    wxWCharBuffer wcBuf(
-            wxConvUTF8.cMB2WC(m_impl.c_str(),
-                              m_impl.length() + 1 /* size, not length */,
-                              &wcLen));
+    wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC
+                                             (
+                                                m_impl.c_str(),
+                                                m_impl.length() + 1, // size
+                                                &wcLen
+                                             ));
     if ( !wcLen )
         return wxCharBuffer("");
 
     if ( !wcLen )
         return wxCharBuffer("");
 
-    return conv.cWC2MB(wcBuf, wcLen, NULL);
+    return conv.cWC2MB(wcBuf, wcLen+1, NULL);
 }
 
 #else // ANSI
 }
 
 #else // ANSI
@@ -565,6 +742,12 @@ wxString operator+(const wchar_t *pwz, const wxString& str)
 // string comparison
 // ---------------------------------------------------------------------------
 
 // string comparison
 // ---------------------------------------------------------------------------
 
+bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const
+{
+    return (length() == 1) && (compareWithCase ? GetChar(0u) == c
+                               : wxToupper(GetChar(0u)) == wxToupper(c));
+}
+
 #ifdef HAVE_STD_STRING_COMPARE
 
 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
 #ifdef HAVE_STD_STRING_COMPARE
 
 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
@@ -934,13 +1117,12 @@ int wxString::CmpNoCase(const wxString& s) const
 {
     // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
 
 {
     // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
 
-    size_t idx = 0;
     const_iterator i1 = begin();
     const_iterator end1 = end();
     const_iterator i2 = s.begin();
     const_iterator end2 = s.end();
 
     const_iterator i1 = begin();
     const_iterator end1 = end();
     const_iterator i2 = s.begin();
     const_iterator end2 = s.end();
 
-    for ( ; i1 != end1 && i2 != end2; ++idx, ++i1, ++i2 )
+    for ( ; i1 != end1 && i2 != end2; ++i1, ++i2 )
     {
         wxUniChar lower1 = (wxChar)wxTolower(*i1);
         wxUniChar lower2 = (wxChar)wxTolower(*i2);
     {
         wxUniChar lower1 = (wxChar)wxTolower(*i1);
         wxUniChar lower2 = (wxChar)wxTolower(*i2);
@@ -967,36 +1149,36 @@ int wxString::CmpNoCase(const wxString& s) const
 #endif
 #endif
 
 #endif
 #endif
 
-wxString wxString::FromAscii(const char *ascii)
+wxString wxString::FromAscii(const char *ascii, size_t len)
 {
 {
-    if (!ascii)
+    if (!ascii || len == 0)
        return wxEmptyString;
 
        return wxEmptyString;
 
-    size_t len = strlen(ascii);
     wxString res;
 
     wxString res;
 
-    if ( len )
     {
     {
-        wxImplStringBuffer buf(res, len);
+        wxStringInternalBuffer buf(res, len);
         wxStringCharType *dest = buf;
 
         wxStringCharType *dest = buf;
 
-        for ( ;; )
+        for ( ; len > 0; --len )
         {
             unsigned char c = (unsigned char)*ascii++;
             wxASSERT_MSG( c < 0x80,
                           _T("Non-ASCII value passed to FromAscii().") );
 
             *dest++ = (wchar_t)c;
         {
             unsigned char c = (unsigned char)*ascii++;
             wxASSERT_MSG( c < 0x80,
                           _T("Non-ASCII value passed to FromAscii().") );
 
             *dest++ = (wchar_t)c;
-
-            if ( c == '\0' )
-                break;
         }
     }
 
     return res;
 }
 
         }
     }
 
     return res;
 }
 
-wxString wxString::FromAscii(const char ascii)
+wxString wxString::FromAscii(const char *ascii)
+{
+    return FromAscii(ascii, wxStrlen(ascii));
+}
+
+wxString wxString::FromAscii(char ascii)
 {
     // What do we do with '\0' ?
 
 {
     // What do we do with '\0' ?
 
@@ -1065,28 +1247,15 @@ wxString wxString::Mid(size_t nFirst, size_t nCount) const
 
 // check that the string starts with prefix and return the rest of the string
 // in the provided pointer if it is not NULL, otherwise return false
 
 // check that the string starts with prefix and return the rest of the string
 // in the provided pointer if it is not NULL, otherwise return false
-bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
+bool wxString::StartsWith(const wxString& prefix, wxString *rest) const
 {
 {
-    wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
-
-    // first check if the beginning of the string matches the prefix: note
-    // that we don't have to check that we don't run out of this string as
-    // when we reach the terminating NUL, either prefix string ends too (and
-    // then it's ok) or we break out of the loop because there is no match
-    const wxChar *p = c_str();
-    while ( *prefix )
-    {
-        if ( *prefix++ != *p++ )
-        {
-            // no match
-            return false;
-        }
-    }
+    if ( compare(0, prefix.length(), prefix) != 0 )
+        return false;
 
     if ( rest )
     {
         // put the rest of the string into provided pointer
 
     if ( rest )
     {
         // put the rest of the string into provided pointer
-        *rest = p;
+        rest->assign(*this, prefix.length(), npos);
     }
 
     return true;
     }
 
     return true;
@@ -1095,11 +1264,9 @@ bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
 
 // check that the string ends with suffix and return the rest of it in the
 // provided pointer if it is not NULL, otherwise return false
 
 // check that the string ends with suffix and return the rest of it in the
 // provided pointer if it is not NULL, otherwise return false
-bool wxString::EndsWith(const wxChar *suffix, wxString *rest) const
+bool wxString::EndsWith(const wxString& suffix, wxString *rest) const
 {
 {
-    wxASSERT_MSG( suffix, _T("invalid parameter in wxString::EndssWith") );
-
-    int start = length() - wxStrlen(suffix);
+    int start = length() - suffix.length();
 
     if ( start < 0 || compare(start, npos, suffix) != 0 )
         return false;
 
     if ( start < 0 || compare(start, npos, suffix) != 0 )
         return false;
@@ -1127,7 +1294,7 @@ wxString wxString::Right(size_t nCount) const
   return dest;
 }
 
   return dest;
 }
 
-// get all characters after the last occurence of ch
+// get all characters after the last occurrence of ch
 // (returns the whole string if ch not found)
 wxString wxString::AfterLast(wxUniChar ch) const
 {
 // (returns the whole string if ch not found)
 wxString wxString::AfterLast(wxUniChar ch) const
 {
@@ -1136,7 +1303,7 @@ wxString wxString::AfterLast(wxUniChar ch) const
   if ( iPos == wxNOT_FOUND )
     str = *this;
   else
   if ( iPos == wxNOT_FOUND )
     str = *this;
   else
-    str = wx_str() + iPos + 1;
+    str.assign(*this, iPos + 1, npos);
 
   return str;
 }
 
   return str;
 }
@@ -1154,16 +1321,17 @@ wxString wxString::Left(size_t nCount) const
   return dest;
 }
 
   return dest;
 }
 
-// get all characters before the first occurence of ch
+// get all characters before the first occurrence of ch
 // (returns the whole string if ch not found)
 wxString wxString::BeforeFirst(wxUniChar ch) const
 {
   int iPos = Find(ch);
 // (returns the whole string if ch not found)
 wxString wxString::BeforeFirst(wxUniChar ch) const
 {
   int iPos = Find(ch);
-  if ( iPos == wxNOT_FOUND ) iPos = length();
+  if ( iPos == wxNOT_FOUND )
+      iPos = length();
   return wxString(*this, 0, iPos);
 }
 
   return wxString(*this, 0, iPos);
 }
 
-/// get all characters before the last occurence of ch
+/// get all characters before the last occurrence of ch
 /// (returns empty string if ch not found)
 wxString wxString::BeforeLast(wxUniChar ch) const
 {
 /// (returns empty string if ch not found)
 wxString wxString::BeforeLast(wxUniChar ch) const
 {
@@ -1175,19 +1343,19 @@ wxString wxString::BeforeLast(wxUniChar ch) const
   return str;
 }
 
   return str;
 }
 
-/// get all characters after the first occurence of ch
+/// get all characters after the first occurrence of ch
 /// (returns empty string if ch not found)
 wxString wxString::AfterFirst(wxUniChar ch) const
 {
   wxString str;
   int iPos = Find(ch);
   if ( iPos != wxNOT_FOUND )
 /// (returns empty string if ch not found)
 wxString wxString::AfterFirst(wxUniChar ch) const
 {
   wxString str;
   int iPos = Find(ch);
   if ( iPos != wxNOT_FOUND )
-    str = wx_str() + iPos + 1;
+      str.assign(*this, iPos + 1, npos);
 
   return str;
 }
 
 
   return str;
 }
 
-// replace first (or all) occurences of some substring with another one
+// replace first (or all) occurrences of some substring with another one
 size_t wxString::Replace(const wxString& strOld,
                          const wxString& strNew, bool bReplaceAll)
 {
 size_t wxString::Replace(const wxString& strOld,
                          const wxString& strNew, bool bReplaceAll)
 {
@@ -1195,35 +1363,59 @@ size_t wxString::Replace(const wxString& strOld,
     wxCHECK_MSG( !strOld.empty(), 0,
                  _T("wxString::Replace(): invalid parameter") );
 
     wxCHECK_MSG( !strOld.empty(), 0,
                  _T("wxString::Replace(): invalid parameter") );
 
+    wxSTRING_INVALIDATE_CACHE();
+
     size_t uiCount = 0;   // count of replacements made
 
     size_t uiCount = 0;   // count of replacements made
 
-    size_t uiOldLen = strOld.length();
-    size_t uiNewLen = strNew.length();
+    // optimize the special common case: replacement of one character by
+    // another one (in UTF-8 case we can only do this for ASCII characters)
+    //
+    // benchmarks show that this special version is around 3 times faster
+    // (depending on the proportion of matching characters and UTF-8/wchar_t
+    // build)
+    if ( strOld.m_impl.length() == 1 && strNew.m_impl.length() == 1 )
+    {
+        const wxStringCharType chOld = strOld.m_impl[0],
+                               chNew = strNew.m_impl[0];
+
+        // this loop is the simplified version of the one below
+        for ( size_t pos = 0; ; )
+        {
+            pos = m_impl.find(chOld, pos);
+            if ( pos == npos )
+                break;
+
+            m_impl[pos++] = chNew;
 
 
-    size_t dwPos = 0;
+            uiCount++;
 
 
-    while ( (*this)[dwPos] != wxT('\0') )
+            if ( !bReplaceAll )
+                break;
+        }
+    }
+    else // general case
     {
     {
-        //DO NOT USE STRSTR HERE
-        //this string can contain embedded null characters,
-        //so strstr will function incorrectly
-        dwPos = find(strOld, dwPos);
-        if ( dwPos == npos )
-            break;                  // exit the loop
-        else
+        const size_t uiOldLen = strOld.m_impl.length();
+        const size_t uiNewLen = strNew.m_impl.length();
+
+        for ( size_t pos = 0; ; )
         {
         {
-            //replace this occurance of the old string with the new one
-            replace(dwPos, uiOldLen, strNew, uiNewLen);
+            pos = m_impl.find(strOld.m_impl, pos);
+            if ( pos == npos )
+                break;
+
+            // replace this occurrence of the old string with the new one
+            m_impl.replace(pos, uiOldLen, strNew.m_impl);
 
 
-            //move up pos past the string that was replaced
-            dwPos += uiNewLen;
+            // move up pos past the string that was replaced
+            pos += uiNewLen;
 
 
-            //increase replace count
-            ++uiCount;
+            // increase replace count
+            uiCount++;
 
 
-            // stop now?
+            // stop after the first one?
             if ( !bReplaceAll )
             if ( !bReplaceAll )
-                break;                  // exit the loop
+                break;
         }
     }
 
         }
     }
 
@@ -1299,14 +1491,28 @@ wxString& wxString::MakeLower()
   return *this;
 }
 
   return *this;
 }
 
+wxString& wxString::MakeCapitalized()
+{
+    const iterator en = end();
+    iterator it = begin();
+    if ( it != en )
+    {
+        *it = (wxChar)wxToupper(*it);
+        for ( ++it; it != en; ++it )
+            *it = (wxChar)wxTolower(*it);
+    }
+
+    return *this;
+}
+
 // ---------------------------------------------------------------------------
 // trimming and padding
 // ---------------------------------------------------------------------------
 
 // some compilers (VC++ 6.0 not to name them) return true for a call to
 // ---------------------------------------------------------------------------
 // trimming and padding
 // ---------------------------------------------------------------------------
 
 // some compilers (VC++ 6.0 not to name them) return true for a call to
-// isspace('ê') in the C locale which seems to be broken to me, but we have to
-// live with this by checking that the character is a 7 bit one - even if this
-// may fail to detect some spaces (I don't know if Unicode doesn't have
+// isspace('\xEA') in the C locale which seems to be broken to me, but we have
+// to live with this by checking that the character is a 7 bit one - even if
+// this may fail to detect some spaces (I don't know if Unicode doesn't have
 // space-like symbols somewhere except in the first 128 chars), it is arguably
 // still better than trimming away accented letters
 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
 // space-like symbols somewhere except in the first 128 chars), it is arguably
 // still better than trimming away accented letters
 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
@@ -1327,7 +1533,7 @@ wxString& wxString::Trim(bool bFromRight)
             // find last non-space character
             reverse_iterator psz = rbegin();
             while ( (psz != rend()) && wxSafeIsspace(*psz) )
             // find last non-space character
             reverse_iterator psz = rbegin();
             while ( (psz != rend()) && wxSafeIsspace(*psz) )
-                psz++;
+                ++psz;
 
             // truncate at trailing space start
             erase(psz.base(), end());
 
             // truncate at trailing space start
             erase(psz.base(), end());
@@ -1337,7 +1543,7 @@ wxString& wxString::Trim(bool bFromRight)
             // find first non-space character
             iterator psz = begin();
             while ( (psz != end()) && wxSafeIsspace(*psz) )
             // find first non-space character
             iterator psz = begin();
             while ( (psz != end()) && wxSafeIsspace(*psz) )
-                psz++;
+                ++psz;
 
             // fix up data and length
             erase(begin(), psz);
 
             // fix up data and length
             erase(begin(), psz);
@@ -1391,73 +1597,72 @@ int wxString::Find(wxUniChar ch, bool bFromEnd) const
 // conversion to numbers
 // ----------------------------------------------------------------------------
 
 // conversion to numbers
 // ----------------------------------------------------------------------------
 
-// the implementation of all the functions below is exactly the same so factor
-// it out
-
-template <typename T, typename F>
-bool wxStringToIntType(const wxChar *start,
-                       T *val,
-                       int base,
-                       F func)
-{
-    wxCHECK_MSG( val, false, _T("NULL output pointer") );
-    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+// The implementation of all the functions below is exactly the same so factor
+// it out. Note that number extraction works correctly on UTF-8 strings, so
+// we can use wxStringCharType and wx_str() for maximum efficiency.
 
 #ifndef __WXWINCE__
 
 #ifndef __WXWINCE__
-    errno = 0;
+    #define DO_IF_NOT_WINCE(x) x
+#else
+    #define DO_IF_NOT_WINCE(x)
 #endif
 
 #endif
 
-    wxChar *end;
-    *val = (*func)(start, &end, base);
-
-    // return true only if scan was stopped by the terminating NUL and if the
-    // string was not empty to start with and no under/overflow occurred
-    return !*end && (end != start)
-#ifndef __WXWINCE__
-        && (errno != ERANGE)
-#endif
-    ;
-}
+#define WX_STRING_TO_INT_TYPE(out, base, func, T)                           \
+    wxCHECK_MSG( out, false, _T("NULL output pointer") );                   \
+    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );  \
+                                                                            \
+    DO_IF_NOT_WINCE( errno = 0; )                                           \
+                                                                            \
+    const wxStringCharType *start = wx_str();                               \
+    wxStringCharType *end;                                                  \
+    T val = func(start, &end, base);                                        \
+                                                                            \
+    /* return true only if scan was stopped by the terminating NUL and */   \
+    /* if the string was not empty to start with and no under/overflow */   \
+    /* occurred: */                                                         \
+    if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) )         \
+        return false;                                                       \
+    *out = val;                                                             \
+    return true
 
 
-bool wxString::ToLong(long *val, int base) const
+bool wxString::ToLong(long *pVal, int base) const
 {
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtol);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtol, long);
 }
 
 }
 
-bool wxString::ToULong(unsigned long *val, int base) const
+bool wxString::ToULong(unsigned long *pVal, int base) const
 {
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoul);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoul, unsigned long);
 }
 
 }
 
-bool wxString::ToLongLong(wxLongLong_t *val, int base) const
+bool wxString::ToLongLong(wxLongLong_t *pVal, int base) const
 {
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoll, wxLongLong_t);
 }
 
 }
 
-bool wxString::ToULongLong(wxULongLong_t *val, int base) const
+bool wxString::ToULongLong(wxULongLong_t *pVal, int base) const
 {
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoull, wxULongLong_t);
 }
 
 }
 
-bool wxString::ToDouble(double *val) const
+bool wxString::ToDouble(double *pVal) const
 {
 {
-    wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") );
+    wxCHECK_MSG( pVal, false, _T("NULL output pointer") );
 
 
-#ifndef __WXWINCE__
-    errno = 0;
-#endif
+    DO_IF_NOT_WINCE( errno = 0; )
 
     const wxChar *start = c_str();
     wxChar *end;
 
     const wxChar *start = c_str();
     wxChar *end;
-    *val = wxStrtod(start, &end);
+    double val = wxStrtod(start, &end);
 
     // return true only if scan was stopped by the terminating NUL and if the
     // string was not empty to start with and no under/overflow occurred
 
     // return true only if scan was stopped by the terminating NUL and if the
     // string was not empty to start with and no under/overflow occurred
-    return !*end && (end != start)
-#ifndef __WXWINCE__
-        && (errno != ERANGE)
-#endif
-    ;
+    if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) )
+        return false;
+
+    *pVal = val;
+
+    return true;
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------
@@ -1467,7 +1672,7 @@ bool wxString::ToDouble(double *val) const
 #if !wxUSE_UTF8_LOCALE_ONLY
 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 #if !wxUSE_UTF8_LOCALE_ONLY
 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
-wxString wxStringPrintfMixinBase::DoFormat(const wxChar *format, ...)
+wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...)
 #else
 wxString wxString::DoFormatWchar(const wxChar *format, ...)
 #endif
 #else
 wxString wxString::DoFormatWchar(const wxChar *format, ...)
 #endif
@@ -1549,6 +1754,60 @@ int wxString::DoPrintfUtf8(const char *format, ...)
 }
 #endif // wxUSE_UNICODE_UTF8
 
 }
 #endif // wxUSE_UNICODE_UTF8
 
+/*
+    Uses wxVsnprintf and places the result into the this string.
+
+    In ANSI build, wxVsnprintf is effectively vsnprintf but in Unicode build
+    it is vswprintf.  Due to a discrepancy between vsnprintf and vswprintf in
+    the ISO C99 (and thus SUSv3) standard the return value for the case of
+    an undersized buffer is inconsistent.  For conforming vsnprintf
+    implementations the function must return the number of characters that
+    would have been printed had the buffer been large enough.  For conforming
+    vswprintf implementations the function must return a negative number
+    and set errno.
+
+    What vswprintf sets errno to is undefined but Darwin seems to set it to
+    EOVERFLOW.  The only expected errno are EILSEQ and EINVAL.  Both of
+    those are defined in the standard and backed up by several conformance
+    statements.  Note that ENOMEM mentioned in the manual page does not
+    apply to swprintf, only wprintf and fwprintf.
+
+    Official manual page:
+    http://www.opengroup.org/onlinepubs/009695399/functions/swprintf.html
+
+    Some conformance statements (AIX, Solaris):
+    http://www.opengroup.org/csq/view.mhtml?RID=ibm%2FSD1%2F3
+    http://www.theopengroup.org/csq/view.mhtml?norationale=1&noreferences=1&RID=Fujitsu%2FSE2%2F10
+
+    Since EILSEQ and EINVAL are rather common but EOVERFLOW is not and since
+    EILSEQ and EINVAL are specifically defined to mean the error is other than
+    an undersized buffer and no other errno are defined we treat those two
+    as meaning hard errors and everything else gets the old behavior which
+    is to keep looping and increasing buffer size until the function succeeds.
+
+    In practice it's impossible to determine before compilation which behavior
+    may be used.  The vswprintf function may have vsnprintf-like behavior or
+    vice-versa.  Behavior detected on one release can theoretically change
+    with an updated release.  Not to mention that configure testing for it
+    would require the test to be run on the host system, not the build system
+    which makes cross compilation difficult. Therefore, we make no assumptions
+    about behavior and try our best to handle every known case, including the
+    case where wxVsnprintf returns a negative number and fails to set errno.
+
+    There is yet one more non-standard implementation and that is our own.
+    Fortunately, that can be detected at compile-time.
+
+    On top of all that, ISO C99 explicitly defines snprintf to write a null
+    character to the last position of the specified buffer.  That would be at
+    at the given buffer size minus 1.  It is supposed to do this even if it
+    turns out that the buffer is sized too small.
+
+    Darwin (tested on 10.5) follows the C99 behavior exactly.
+
+    Glibc 2.6 almost follows the C99 behavior except vswprintf never sets
+    errno even when it fails.  However, it only seems to ever fail due
+    to an undersized buffer.
+*/
 #if wxUSE_UNICODE_UTF8
 template<typename BufferType>
 #else
 #if wxUSE_UNICODE_UTF8
 template<typename BufferType>
 #else
@@ -1574,6 +1833,11 @@ static int DoStringPrintfV(wxString& str,
         if ( !buf )
         {
             // out of memory
         if ( !buf )
         {
             // out of memory
+
+            // in UTF-8 build, leaving uninitialized junk in the buffer
+            // could result in invalid non-empty UTF-8 string, so just
+            // reset the string to empty on failure:
+            buf[0] = '\0';
             return -1;
         }
 
             return -1;
         }
 
@@ -1581,12 +1845,19 @@ static int DoStringPrintfV(wxString& str,
         // only a copy
         va_list argptrcopy;
         wxVaCopy(argptrcopy, argptr);
         // only a copy
         va_list argptrcopy;
         wxVaCopy(argptrcopy, argptr);
+
+#ifndef __WXWINCE__
+        // Set errno to 0 to make it determinate if wxVsnprintf fails to set it.
+        errno = 0;
+#endif
         int len = wxVsnprintf(buf, size, format, argptrcopy);
         va_end(argptrcopy);
 
         // some implementations of vsnprintf() don't NUL terminate
         // the string if there is not enough space for it so
         // always do it manually
         int len = wxVsnprintf(buf, size, format, argptrcopy);
         va_end(argptrcopy);
 
         // some implementations of vsnprintf() don't NUL terminate
         // the string if there is not enough space for it so
         // always do it manually
+        // FIXME: This really seems to be the wrong and would be an off-by-one
+        // bug except the code above allocates an extra character.
         buf[size] = _T('\0');
 
         // vsnprintf() may return either -1 (traditional Unix behaviour) or the
         buf[size] = _T('\0');
 
         // vsnprintf() may return either -1 (traditional Unix behaviour) or the
@@ -1594,27 +1865,47 @@ static int DoStringPrintfV(wxString& str,
         // buffer were large enough (newer standards such as Unix98)
         if ( len < 0 )
         {
         // buffer were large enough (newer standards such as Unix98)
         if ( len < 0 )
         {
+            // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or
+            //     wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF
+            //     is true if *both* of them use our own implementation,
+            //     otherwise we can't be sure
 #if wxUSE_WXVSNPRINTF
             // we know that our own implementation of wxVsnprintf() returns -1
             // only for a format error - thus there's something wrong with
             // the user's format string
 #if wxUSE_WXVSNPRINTF
             // we know that our own implementation of wxVsnprintf() returns -1
             // only for a format error - thus there's something wrong with
             // the user's format string
+            buf[0] = '\0';
             return -1;
             return -1;
-#else // assume that system version only returns error if not enough space
+#else // possibly using system version
+            // assume it only returns error if there is not enough space, but
+            // as we don't know how much we need, double the current size of
+            // the buffer
+#ifndef __WXWINCE__
+            if( (errno == EILSEQ) || (errno == EINVAL) )
+            // If errno was set to one of the two well-known hard errors
+            // then fail immediately to avoid an infinite loop.
+                return -1;
+            else
+#endif // __WXWINCE__
             // still not enough, as we don't know how much we need, double the
             // current size of the buffer
             // still not enough, as we don't know how much we need, double the
             // current size of the buffer
-            size *= 2;
+                size *= 2;
 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
         }
         else if ( len >= size )
         {
 #if wxUSE_WXVSNPRINTF
 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
         }
         else if ( len >= size )
         {
 #if wxUSE_WXVSNPRINTF
-            // we know that our own implementation of wxVsnprintf() returns 
+            // we know that our own implementation of wxVsnprintf() returns
             // size+1 when there's not enough space but that's not the size
             // of the required buffer!
             size *= 2;      // so we just double the current size of the buffer
 #else
             // some vsnprintf() implementations NUL-terminate the buffer and
             // some don't in len == size case, to be safe always add 1
             // size+1 when there's not enough space but that's not the size
             // of the required buffer!
             size *= 2;      // so we just double the current size of the buffer
 #else
             // some vsnprintf() implementations NUL-terminate the buffer and
             // some don't in len == size case, to be safe always add 1
+            // FIXME: I don't quite understand this comment.  The vsnprintf
+            // function is specifically defined to return the number of
+            // characters printed not including the null terminator.
+            // So OF COURSE you need to add 1 to get the right buffer size.
+            // The following line is definitely correct, no question.
             size = len + 1;
 #endif
         }
             size = len + 1;
 #endif
         }
@@ -1632,28 +1923,25 @@ static int DoStringPrintfV(wxString& str,
 
 int wxString::PrintfV(const wxString& format, va_list argptr)
 {
 
 int wxString::PrintfV(const wxString& format, va_list argptr)
 {
-    va_list argcopy;
-    wxVaCopy(argcopy, argptr);
-
 #if wxUSE_UNICODE_UTF8
     #if wxUSE_STL_BASED_WXSTRING
         typedef wxStringTypeBuffer<char> Utf8Buffer;
     #else
 #if wxUSE_UNICODE_UTF8
     #if wxUSE_STL_BASED_WXSTRING
         typedef wxStringTypeBuffer<char> Utf8Buffer;
     #else
-        typedef wxImplStringBuffer Utf8Buffer;
+        typedef wxStringInternalBuffer Utf8Buffer;
     #endif
 #endif
 
 #if wxUSE_UTF8_LOCALE_ONLY
     #endif
 #endif
 
 #if wxUSE_UTF8_LOCALE_ONLY
-    return DoStringPrintfV<Utf8Buffer>(*this, format, argcopy);
+    return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )
 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )
-        return DoStringPrintfV<Utf8Buffer>(*this, format, argcopy);
+        return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
     else
         // wxChar* version
     else
         // wxChar* version
-        return DoStringPrintfV<wxStringBuffer>(*this, format, argcopy);
+        return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);
     #else
     #else
-        return DoStringPrintfV(*this, format, argcopy);
+        return DoStringPrintfV(*this, format, argptr);
     #endif // UTF8/WCHAR
 #endif
 }
     #endif // UTF8/WCHAR
 #endif
 }
@@ -1821,9 +2109,3 @@ int wxString::Freq(wxUniChar ch) const
     return count;
 }
 
     return count;
 }
 
-// convert to upper case, return the copy of the string
-wxString wxString::Upper() const
-{ wxString s(*this); return s.MakeUpper(); }
-
-// convert to lower case, return the copy of the string
-wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }