X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/062dc5fc22801a7c33ea192512de8fe2b5592133..ac10ea91c9bff4a8daae3313063867647c1e1079:/include/wx/string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index aaa1581d9d..43dfbcb175 100644
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -57,6 +57,36 @@
 #include "wx/stringops.h"
 #include "wx/unichar.h"
 
+// by default we cache the mapping of the positions in UTF-8 string to the byte
+// offset as this results in noticeable performance improvements for loops over
+// strings using indices; comment out this line to disable this
+//
+// notice that this optimization is well worth using even in debug builds as it
+// changes asymptotic complexity of algorithms using indices to iterate over
+// wxString back to expected linear from quadratic
+//
+// also notice that wxTLS_TYPE() (__declspec(thread) in this case) is unsafe to
+// use in DLL build under pre-Vista Windows so we disable this code for now, if
+// anybody really needs to use UTF-8 build under Windows with this optimization
+// it would have to be re-tested and probably corrected
+#if wxUSE_UNICODE_UTF8 && !defined(__WXMSW__)
+    #define wxUSE_STRING_POS_CACHE 1
+#else
+    #define wxUSE_STRING_POS_CACHE 0
+#endif
+
+#if wxUSE_STRING_POS_CACHE
+    #include "wx/tls.h"
+
+    // change this 0 to 1 to enable additional (very expensive) asserts
+    // verifying that string caching logic works as expected
+    #if 0
+        #define wxSTRING_CACHE_ASSERT(cond) wxASSERT(cond)
+    #else
+        #define wxSTRING_CACHE_ASSERT(cond)
+    #endif
+#endif // wxUSE_STRING_POS_CACHE
+
 class WXDLLIMPEXP_FWD_BASE wxString;
 
 // unless this symbol is predefined to disable the compatibility functions, do
@@ -508,6 +538,14 @@ private:
   static size_t LenToImpl(size_t len) { return len; }
   static size_t PosFromImpl(size_t pos) { return pos; }
 
+  // we don't want to define these as empty inline functions as it could
+  // result in noticeable (and quite unnecessary in non-UTF-8 build) slowdown
+  // in debug build where the inline functions are not effectively inlined
+  #define wxSTRING_INVALIDATE_CACHE()
+  #define wxSTRING_INVALIDATE_CACHED_LENGTH()
+  #define wxSTRING_UPDATE_CACHED_LENGTH(n)
+  #define wxSTRING_SET_CACHED_LENGTH(n)
+
 #else // wxUSE_UNICODE_UTF8
 
   static wxCharBuffer ImplStr(const char* str,
@@ -522,12 +560,273 @@ private:
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return ConvertStr(str, n, wxMBConvUTF8()); }
 
+#if wxUSE_STRING_POS_CACHE
+  // this is an extremely simple cache used by PosToImpl(): each cache element
+  // contains the string it applies to and the index corresponding to the last
+  // used position in this wxString in its m_impl string
+  //
+  // NB: notice that this struct (and nested Element one) must be a POD or we
+  //     wouldn't be able to use a thread-local variable of this type, in
+  //     particular it should have no ctor -- we rely on statics being
+  //     initialized to 0 instead
+  struct Cache
+  {
+      enum { SIZE = 8 };
+
+      struct Element
+      {
+          const wxString *str;  // the string to which this element applies
+          size_t pos,           // the cached index in this string
+                 impl,          // the corresponding position in its m_impl
+                 len;           // cached length or npos if unknown
+
+          // reset cached index to 0
+          void ResetPos() { pos = impl = 0; }
+
+          // reset position and length
+          void Reset() { ResetPos(); len = npos; }
+      };
+
+      // cache the indices mapping for the last few string used
+      Element cached[SIZE];
+
+      // the last used index
+      unsigned lastUsed;
+  };
+
+#ifndef wxHAS_COMPILER_TLS
+  // we must use an accessor function and not a static variable when the TLS
+  // variables support is implemented in the library (and not by the compiler)
+  // because the global s_cache variable could be not yet initialized when a
+  // ctor of another global object is executed and if that ctor uses any
+  // wxString methods, bad things happen
+  //
+  // however notice that this approach does not work when compiler TLS is used,
+  // at least not with g++ 4.1.2 under amd64 as it apparently compiles code
+  // using this accessor incorrectly when optimizations are enabled (-O2 is
+  // enough) -- luckily we don't need it then neither as static __thread
+  // variables are initialized by 0 anyhow then and so we can use the variable
+  // directly
+  WXEXPORT static Cache& GetCache()
+  {
+      static wxTLS_TYPE(Cache) s_cache;
+
+      return wxTLS_VALUE(s_cache);
+  }
+  
+  // this helper struct is used to ensure that GetCache() is called during
+  // static initialization time, i.e. before any threads creation, as otherwise
+  // the static s_cache construction inside GetCache() wouldn't be MT-safe
+  friend struct wxStrCacheInitializer;
+#else // wxHAS_COMPILER_TLS
+  static wxTLS_TYPE(Cache) ms_cache;
+  static Cache& GetCache() { return wxTLS_VALUE(ms_cache); }
+#endif // !wxHAS_COMPILER_TLS/wxHAS_COMPILER_TLS
+
+  static Cache::Element *GetCacheBegin() { return GetCache().cached; }
+  static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; }
+  static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; }
+
+  // this is used in debug builds only to provide a convenient function,
+  // callable from a debugger, to show the cache contents
+  friend struct wxStrCacheDumper;
+
+  // uncomment this to have access to some profiling statistics on program
+  // termination
+  //#define wxPROFILE_STRING_CACHE
+
+#ifdef wxPROFILE_STRING_CACHE
+  static struct PosToImplCacheStats
+  {
+      unsigned postot,  // total non-trivial calls to PosToImpl
+               poshits, // cache hits from PosToImpl()
+               mishits, // cached position beyond the needed one
+               sumpos,  // sum of all positions, used to compute the
+                        // average position after dividing by postot
+               sumofs,  // sum of all offsets after using the cache, used to
+                        // compute the average after dividing by hits
+               lentot,  // number of total calls to length()
+               lenhits; // number of cache hits in length()
+  } ms_cacheStats;
+
+  friend struct wxStrCacheStatsDumper;
+
+  #define wxCACHE_PROFILE_FIELD_INC(field) ms_cacheStats.field++
+  #define wxCACHE_PROFILE_FIELD_ADD(field, val) ms_cacheStats.field += (val)
+#else // !wxPROFILE_STRING_CACHE
+  #define wxCACHE_PROFILE_FIELD_INC(field)
+  #define wxCACHE_PROFILE_FIELD_ADD(field, val)
+#endif // wxPROFILE_STRING_CACHE/!wxPROFILE_STRING_CACHE
+
+  // note: it could seem that the functions below shouldn't be inline because
+  // they are big, contain loops and so the compiler shouldn't be able to
+  // inline them anyhow, however moving them into string.cpp does decrease the
+  // code performance by ~5%, at least when using g++ 4.1 so do keep them here
+  // unless tests show that it's not advantageous any more
+
+  // return the pointer to the cache element for this string or NULL if not
+  // cached
+  Cache::Element *FindCacheElement() const
+  {
+      // profiling seems to show a small but consistent gain if we use this
+      // simple loop instead of starting from the last used element (there are
+      // a lot of misses in this function...)
+      Cache::Element * const cacheBegin = GetCacheBegin();
+#ifndef wxHAS_COMPILER_TLS
+      // during destruction tls calls may return NULL, in this case return NULL 
+      // immediately without accessing anything else
+      if ( cacheBegin == NULL )
+        return NULL;
+#endif
+      Cache::Element * const cacheEnd = GetCacheEnd();
+      for ( Cache::Element *c = cacheBegin; c != cacheEnd; c++ )
+      {
+          if ( c->str == this )
+              return c;
+      }
+
+      return NULL;
+  }
+
+  // unlike FindCacheElement(), this one always returns a valid pointer to the
+  // cache element for this string, it may have valid last cached position and
+  // its corresponding index in the byte string or not
+  Cache::Element *GetCacheElement() const
+  {
+      Cache::Element * const cacheBegin = GetCacheBegin();
+      Cache::Element * const cacheEnd = GetCacheEnd();
+      Cache::Element * const cacheStart = cacheBegin + LastUsedCacheElement();
+
+      // check the last used first, this does no (measurable) harm for a miss
+      // but does help for simple loops addressing the same string all the time
+      if ( cacheStart->str == this )
+          return cacheStart;
+
+      // notice that we're going to check cacheStart again inside this call but
+      // profiling shows that it's still faster to use a simple loop like
+      // inside FindCacheElement() than manually looping with wrapping starting
+      // from the cache entry after the start one
+      Cache::Element *c = FindCacheElement();
+      if ( !c )
+      {
+          // claim the next cache entry for this string
+          c = cacheStart;
+          if ( ++c == cacheEnd )
+              c = cacheBegin;
+
+          c->str = this;
+          c->Reset();
+
+          // and remember the last used element
+          LastUsedCacheElement() = c - cacheBegin;
+      }
+
+      return c;
+  }
+
+  size_t DoPosToImpl(size_t pos) const
+  {
+      wxCACHE_PROFILE_FIELD_INC(postot);
+
+      // NB: although the case of pos == 1 (and offset from cached position
+      //     equal to 1) are common, nothing is gained by writing special code
+      //     for handling them, the compiler (at least g++ 4.1 used) seems to
+      //     optimize the code well enough on its own
+
+      wxCACHE_PROFILE_FIELD_ADD(sumpos, pos);
+
+      Cache::Element * const cache = GetCacheElement();
+
+      // cached position can't be 0 so if it is, it means that this entry was
+      // used for length caching only so far, i.e. it doesn't count as a hit
+      // from our point of view
+      if ( cache->pos )
+      {
+          wxCACHE_PROFILE_FIELD_INC(poshits);
+      }
+
+      if ( pos == cache->pos )
+          return cache->impl;
+
+      // this seems to happen only rarely so just reset the cache in this case
+      // instead of complicating code even further by seeking backwards in this
+      // case
+      if ( cache->pos > pos )
+      {
+          wxCACHE_PROFILE_FIELD_INC(mishits);
+
+          cache->ResetPos();
+      }
+
+      wxCACHE_PROFILE_FIELD_ADD(sumofs, pos - cache->pos);
+
+
+      wxStringImpl::const_iterator i(m_impl.begin() + cache->impl);
+      for ( size_t n = cache->pos; n < pos; n++ )
+          wxStringOperations::IncIter(i);
+
+      cache->pos = pos;
+      cache->impl = i - m_impl.begin();
+
+      wxSTRING_CACHE_ASSERT(
+          (int)cache->impl == (begin() + pos).impl() - m_impl.begin() );
+
+      return cache->impl;
+  }
+
+  void InvalidateCache()
+  {
+      Cache::Element * const cache = FindCacheElement();
+      if ( cache )
+          cache->Reset();
+  }
+
+  void InvalidateCachedLength()
+  {
+      Cache::Element * const cache = FindCacheElement();
+      if ( cache )
+          cache->len = npos;
+  }
+
+  void SetCachedLength(size_t len)
+  {
+      // we optimistically cache the length here even if the string wasn't
+      // present in the cache before, this seems to do no harm and the
+      // potential for avoiding length recomputation for long strings looks
+      // interesting
+      GetCacheElement()->len = len;
+  }
+
+  void UpdateCachedLength(ptrdiff_t delta)
+  {
+      Cache::Element * const cache = FindCacheElement();
+      if ( cache && cache->len != npos )
+      {
+          wxSTRING_CACHE_ASSERT( (ptrdiff_t)cache->len + delta >= 0 );
+
+          cache->len += delta;
+      }
+  }
+
+  #define wxSTRING_INVALIDATE_CACHE() InvalidateCache()
+  #define wxSTRING_INVALIDATE_CACHED_LENGTH() InvalidateCachedLength()
+  #define wxSTRING_UPDATE_CACHED_LENGTH(n) UpdateCachedLength(n)
+  #define wxSTRING_SET_CACHED_LENGTH(n) SetCachedLength(n)
+#else // !wxUSE_STRING_POS_CACHE
+  size_t DoPosToImpl(size_t pos) const
+  {
+      return (begin() + pos).impl() - m_impl.begin();
+  }
+
+  #define wxSTRING_INVALIDATE_CACHE()
+  #define wxSTRING_INVALIDATE_CACHED_LENGTH()
+  #define wxSTRING_UPDATE_CACHED_LENGTH(n)
+  #define wxSTRING_SET_CACHED_LENGTH(n)
+#endif // wxUSE_STRING_POS_CACHE/!wxUSE_STRING_POS_CACHE
+
   size_t PosToImpl(size_t pos) const
   {
-      if ( pos == 0 || pos == npos )
-          return pos;
-      else
-          return (begin() + pos).impl() - m_impl.begin();
+      return pos == 0 || pos == npos ? pos : DoPosToImpl(pos);
   }
 
   void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const;
@@ -559,22 +858,26 @@ public:
   typedef size_t size_type;
   typedef wxUniChar const_reference;
 
-#if wxUSE_STL
+#if wxUSE_STD_STRING
   #if wxUSE_UNICODE_UTF8
     // random access is not O(1), as required by Random Access Iterator
     #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
   #else
     #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
   #endif
+  #define WX_DEFINE_ITERATOR_CATEGORY(cat) typedef cat iterator_category;
 #else
-  #define WX_STR_ITERATOR_TAG void /* dummy type */
+  // not defining iterator_category at all in this case is better than defining
+  // it as some dummy type -- at least it results in more intelligible error
+  // messages
+  #define WX_DEFINE_ITERATOR_CATEGORY(cat)
 #endif
 
   #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
       private:                                                              \
           typedef wxStringImpl::iterator_name underlying_iterator;          \
       public:                                                               \
-          typedef WX_STR_ITERATOR_TAG iterator_category;                    \
+          WX_DEFINE_ITERATOR_CATEGORY(WX_STR_ITERATOR_TAG)                  \
           typedef wxUniChar value_type;                                     \
           typedef int difference_type;                                      \
           typedef reference_type reference;                                 \
@@ -673,7 +976,7 @@ public:
       }
 
       reference operator*()
-        { return wxUniCharRef::CreateForString(m_node, m_cur); }
+        { return wxUniCharRef::CreateForString(*str(), m_cur); }
 
       iterator operator+(ptrdiff_t n) const
         { return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
@@ -737,6 +1040,10 @@ public:
   size_t IterToImplPos(wxString::iterator i) const
     { return wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); }
 
+  iterator GetIterForNthChar(size_t n)
+    { return iterator(this, m_impl.begin() + PosToImpl(n)); }
+  const_iterator GetIterForNthChar(size_t n) const
+    { return const_iterator(this, m_impl.begin() + PosToImpl(n)); }
 #else // !wxUSE_UNICODE_UTF8
 
   class WXDLLIMPEXP_BASE iterator
@@ -788,6 +1095,9 @@ public:
       const_iterator(const wxString *WXUNUSED(str), underlying_iterator ptr)
           : m_cur(ptr) {}
   };
+
+  iterator GetIterForNthChar(size_t n) { return begin() + n; }
+  const_iterator GetIterForNthChar(size_t n) const { return begin() + n; }
 #endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
 
   #undef WX_STR_ITERATOR_TAG
@@ -802,7 +1112,7 @@ public:
   public:
       typedef T iterator_type;
 
-      typedef typename T::iterator_category iterator_category;
+      WX_DEFINE_ITERATOR_CATEGORY(typename T::iterator_category)
       typedef typename T::value_type value_type;
       typedef typename T::difference_type difference_type;
       typedef typename T::reference reference;
@@ -974,6 +1284,17 @@ public:
   wxString(const wxString& str, size_t nLength)
     { assign(str, nLength); }
 
+
+#if wxUSE_STRING_POS_CACHE
+  ~wxString()
+  {
+      // we need to invalidate our cache entry as another string could be
+      // recreated at the same address (unlikely, but still possible, with the
+      // heap-allocated strings but perfectly common with stack-allocated ones)
+      InvalidateCache();
+  }
+#endif // wxUSE_STRING_POS_CACHE
+
   // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
   // implicit conversions from std::string to wxString and vice verse as this
   // allows to use the same strings in non-GUI and GUI code, however we don't
@@ -1049,7 +1370,32 @@ public:
 
   // std::string methods:
 #if wxUSE_UNICODE_UTF8
-  size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
+  size_t length() const
+  {
+#if wxUSE_STRING_POS_CACHE
+      wxCACHE_PROFILE_FIELD_INC(lentot);
+
+      Cache::Element * const cache = GetCacheElement();
+
+      if ( cache->len == npos )
+      {
+          // it's probably not worth trying to be clever and using cache->pos
+          // here as it's probably 0 anyhow -- you usually call length() before
+          // starting to index the string
+          cache->len = end() - begin();
+      }
+      else
+      {
+          wxCACHE_PROFILE_FIELD_INC(lenhits);
+
+          wxSTRING_CACHE_ASSERT( (int)cache->len == end() - begin() );
+      }
+
+      return cache->len;
+#else // !wxUSE_STRING_POS_CACHE
+      return end() - begin();
+#endif // wxUSE_STRING_POS_CACHE/!wxUSE_STRING_POS_CACHE
+  }
 #else
   size_t length() const { return m_impl.length(); }
 #endif
@@ -1059,8 +1405,9 @@ public:
 
   bool empty() const { return m_impl.empty(); }
 
-  size_type capacity() const { return m_impl.capacity(); } // FIXME-UTF8
-  void reserve(size_t sz) { m_impl.reserve(sz); } // FIXME-UTF8
+  // NB: these methods don't have a well-defined meaning in UTF-8 case
+  size_type capacity() const { return m_impl.capacity(); }
+  void reserve(size_t sz) { m_impl.reserve(sz); }
 
   void resize(size_t nSize, wxUniChar ch = wxT('\0'))
   {
@@ -1071,6 +1418,8 @@ public:
 #if wxUSE_UNICODE_UTF8
     if ( nSize < len )
     {
+        wxSTRING_INVALIDATE_CACHE();
+
         // we can't use wxStringImpl::resize() for truncating the string as it
         // counts in bytes, not characters
         erase(nSize);
@@ -1080,10 +1429,16 @@ public:
     // we also can't use (presumably more efficient) resize() if we have to
     // append characters taking more than one byte
     if ( !ch.IsAscii() )
+    {
         append(nSize - len, ch);
-    else
+    }
+    else // can use (presumably faster) resize() version
 #endif // wxUSE_UNICODE_UTF8
+    {
+        wxSTRING_INVALIDATE_CACHED_LENGTH();
+
         m_impl.resize(nSize, (wxStringCharType)ch);
+    }
   }
 
   wxString substr(size_t nStart = 0, size_t nLen = npos) const
@@ -1103,18 +1458,9 @@ public:
     // truncate the string to given length
   wxString& Truncate(size_t uiLen);
     // empty string contents
-  void Empty()
-  {
-    Truncate(0);
-
-    wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
-  }
+  void Empty() { clear(); }
     // empty the string and free memory
-  void Clear()
-  {
-    wxString tmp(wxEmptyString);
-    swap(tmp);
-  }
+  void Clear() { clear(); }
 
   // contents test
     // Is an ascii value
@@ -1127,16 +1473,16 @@ public:
   // data access (all indexes are 0 based)
     // read access
     wxUniChar at(size_t n) const
-      { return *(begin() + n); } // FIXME-UTF8: optimize?
+      { return wxStringOperations::DecodeChar(m_impl.begin() + PosToImpl(n)); }
     wxUniChar GetChar(size_t n) const
       { return at(n); }
     // read/write access
     wxUniCharRef at(size_t n)
-      { return *(begin() + n); } // FIXME-UTF8: optimize?
+      { return *GetIterForNthChar(n); }
     wxUniCharRef GetWritableChar(size_t n)
       { return at(n); }
     // write access
-    void  SetChar(size_t n, wxUniChar ch)
+    void SetChar(size_t n, wxUniChar ch)
       { at(n) = ch; }
 
     // get last character
@@ -1180,11 +1526,53 @@ public:
       { return at(n); }
 #endif // size_t != unsigned int
 
-    // explicit conversion to C string (use this with printf()!)
+
+    /*
+        Overview of wxString conversions, implicit and explicit:
+
+        - wxString has a std::[w]string-like c_str() method, however it does
+          not return a C-style string directly but instead returns wxCStrData
+          helper object which is convertible to either "char *" narrow string
+          or "wchar_t *" wide string. Usually the correct conversion will be
+          applied by the compiler automatically but if this doesn't happen you
+          need to explicitly choose one using wxCStrData::AsChar() or AsWChar()
+          methods or another wxString conversion function.
+
+        - One of the places where the conversion does *NOT* happen correctly is
+          when c_str() is passed to a vararg function such as printf() so you
+          must *NOT* use c_str() with them. Either use wxPrintf() (all wx
+          functions do handle c_str() correctly, even if they appear to be
+          vararg (but they're not, really)) or add an explicit AsChar() or, if
+          compatibility with previous wxWidgets versions is important, add a
+          cast to "const char *".
+
+        - In non-STL mode only, wxString is also implicitly convertible to
+          wxCStrData. The same warning as above applies.
+
+        - c_str() is polymorphic as it can be converted to either narrow or
+          wide string. If you explicitly need one or the other, choose to use
+          mb_str() (for narrow) or wc_str() (for wide) instead. Notice that
+          these functions can return either the pointer to string directly (if
+          this is what the string uses internally) or a temporary buffer
+          containing the string and convertible to it. Again, conversion will
+          usually be done automatically by the compiler but beware of the
+          vararg functions: you need an explicit cast when using them.
+
+        - There are also non-const versions of mb_str() and wc_str() called
+          char_str() and wchar_str(). They are only meant to be used with
+          non-const-correct functions and they always return buffers.
+
+        - Finally wx_str() returns whatever string representation is used by
+          wxString internally. It may be either a narrow or wide string
+          depending on wxWidgets build mode but it will always be a raw pointer
+          (and not a buffer).
+     */
+
+    // explicit conversion to wxCStrData
     wxCStrData c_str() const { return wxCStrData(this); }
     wxCStrData data() const { return c_str(); }
 
-    // implicit conversion to C string
+    // implicit conversion to wxCStrData
     operator wxCStrData() const { return c_str(); }
 
     // the first two operators conflict with operators for conversion to
@@ -1268,7 +1656,7 @@ public:
 
     // conversion to/from UTF-8:
 #if wxUSE_UNICODE_UTF8
-    static wxString FromUTF8(const char *utf8)
+    static wxString FromUTF8Unchecked(const char *utf8)
     {
       if ( !utf8 )
           return wxEmptyString;
@@ -1276,16 +1664,35 @@ public:
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
       return FromImpl(wxStringImpl(utf8));
     }
-    static wxString FromUTF8(const char *utf8, size_t len)
+    static wxString FromUTF8Unchecked(const char *utf8, size_t len)
     {
       if ( !utf8 )
           return wxEmptyString;
       if ( len == npos )
-          return FromUTF8(utf8);
+          return FromUTF8Unchecked(utf8);
 
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
       return FromImpl(wxStringImpl(utf8, len));
     }
+
+    static wxString FromUTF8(const char *utf8)
+    {
+        if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8) )
+            return "";
+
+        return FromImpl(wxStringImpl(utf8));
+    }
+    static wxString FromUTF8(const char *utf8, size_t len)
+    {
+        if ( len == npos )
+            return FromUTF8(utf8);
+
+        if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8, len) )
+            return "";
+
+        return FromImpl(wxStringImpl(utf8, len));
+    }
+
     const char* utf8_str() const { return wx_str(); }
     const char* ToUTF8() const { return wx_str(); }
 
@@ -1293,10 +1700,15 @@ public:
     // internal UTF-8 representation
     size_t utf8_length() const { return m_impl.length(); }
 #elif wxUSE_UNICODE_WCHAR
-    static wxString FromUTF8(const char *utf8)
-      { return wxString(utf8, wxMBConvUTF8()); }
-    static wxString FromUTF8(const char *utf8, size_t len)
+    static wxString FromUTF8(const char *utf8, size_t len = npos)
       { return wxString(utf8, wxMBConvUTF8(), len); }
+    static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+    {
+        const wxString s(utf8, wxMBConvUTF8(), len);
+        wxASSERT_MSG( !utf8 || !*utf8 || !s.empty(),
+                      "string must be valid UTF-8" );
+        return s;
+    }
     const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
     const wxCharBuffer ToUTF8() const { return utf8_str(); }
 #else // ANSI
@@ -1304,9 +1716,20 @@ public:
       { return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
     static wxString FromUTF8(const char *utf8, size_t len)
     {
-      size_t wlen;
-      wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
-      return wxString(buf.data(), wlen);
+        size_t wlen;
+        wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
+        return wxString(buf.data(), wlen);
+    }
+    static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+    {
+        size_t wlen;
+        wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8,
+                                                len == npos ? wxNO_LEN : len,
+                                                &wlen));
+        wxASSERT_MSG( !utf8 || !*utf8 || wlen,
+                      "string must be valid UTF-8" );
+
+        return wxString(buf.data(), wlen);
     }
     const wxCharBuffer utf8_str() const
       { return wxMBConvUTF8().cWC2MB(wc_str()); }
@@ -1351,7 +1774,7 @@ public:
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 #if wxUSE_UNICODE_WCHAR
-    const wxChar* wc_str() const { return wx_str(); }
+    const wchar_t* wc_str() const { return wx_str(); }
 #elif wxUSE_UNICODE_UTF8
     const wxWCharBuffer wc_str() const;
 #endif
@@ -1369,7 +1792,7 @@ public:
     const wxChar* mb_str() const { return wx_str(); }
 
     // for compatibility with wxUSE_UNICODE version
-    const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
+    const char* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
@@ -1379,23 +1802,45 @@ public:
     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
 #endif // Unicode/ANSI
 
+#if wxUSE_UNICODE_UTF8
+    const wxWCharBuffer t_str() const { return wc_str(); }
+#elif wxUSE_UNICODE_WCHAR
+    const wchar_t* t_str() const { return wx_str(); }
+#else
+    const char* t_str() const { return wx_str(); }
+#endif 
+
+
   // overloaded assignment
     // from another wxString
   wxString& operator=(const wxString& stringSrc)
-    { if (&stringSrc != this) m_impl = stringSrc.m_impl; return *this; }
+  {
+    if ( this != &stringSrc )
+    {
+        wxSTRING_INVALIDATE_CACHE();
+
+        m_impl = stringSrc.m_impl;
+    }
+
+    return *this;
+  }
+
   wxString& operator=(const wxCStrData& cstr)
     { return *this = cstr.AsString(); }
     // from a character
   wxString& operator=(wxUniChar ch)
   {
+    wxSTRING_INVALIDATE_CACHE();
+
 #if wxUSE_UNICODE_UTF8
     if ( !ch.IsAscii() )
         m_impl = wxStringOperations::EncodeChar(ch);
     else
-#endif
+#endif // wxUSE_UNICODE_UTF8
         m_impl = (wxStringCharType)ch;
     return *this;
   }
+
   wxString& operator=(wxUniCharRef ch)
     { return operator=((wxUniChar)ch); }
   wxString& operator=(char ch)
@@ -1408,15 +1853,48 @@ public:
     // so we need to compensate in that case
 #if wxUSE_STL_BASED_WXSTRING
   wxString& operator=(const char *psz)
-    { if (psz) m_impl = ImplStr(psz); else Clear(); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      if ( psz )
+          m_impl = ImplStr(psz);
+      else
+          clear();
+
+      return *this;
+  }
+
   wxString& operator=(const wchar_t *pwz)
-    { if (pwz) m_impl = ImplStr(pwz); else Clear(); return *this; }
-#else
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      if ( pwz )
+          m_impl = ImplStr(pwz);
+      else
+          clear();
+
+      return *this;
+  }
+#else // !wxUSE_STL_BASED_WXSTRING
   wxString& operator=(const char *psz)
-    { m_impl = ImplStr(psz); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl = ImplStr(psz);
+
+      return *this;
+  }
+
   wxString& operator=(const wchar_t *pwz)
-    { m_impl = ImplStr(pwz); return *this; }
-#endif
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl = ImplStr(pwz);
+
+      return *this;
+  }
+#endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
+
   wxString& operator=(const unsigned char *psz)
     { return operator=((const char*)psz); }
 
@@ -1556,7 +2034,7 @@ public:
       const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
       return (*this) << Format(fmt , ull);
     }
-#endif
+#endif // wxLongLong_t && !wxLongLongIsLong
       // insert a float into string
   wxString& operator<<(float f)
     { return (*this) << Format(_T("%f"), f); }
@@ -1639,16 +2117,16 @@ public:
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;
-      // get all characters before the first occurance of ch
+      // get all characters before the first occurrence of ch
       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxUniChar ch) const;
-      // 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 BeforeLast(wxUniChar ch) const;
-      // 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 AfterFirst(wxUniChar ch) const;
-      // 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 AfterLast(wxUniChar ch) const;
 
@@ -1660,12 +2138,17 @@ public:
       // convert to upper case in place, return the string itself
   wxString& MakeUpper();
       // convert to upper case, return the copy of the string
-      // Here's something to remember: BC++ doesn't like returns in inlines.
-  wxString Upper() const ;
+  wxString Upper() const { return wxString(*this).MakeUpper(); }
       // convert to lower case in place, return the string itself
   wxString& MakeLower();
       // convert to lower case, return the copy of the string
-  wxString Lower() const ;
+  wxString Lower() const { return wxString(*this).MakeLower(); }
+      // convert the first character to the upper case and the rest to the
+      // lower one, return the modified string itself
+  wxString& MakeCapitalized();
+      // convert the first character to the upper case and the rest to the
+      // lower one, return the copy of the string
+  wxString Capitalize() const { return wxString(*this).MakeCapitalized(); }
 
   // trimming/padding whitespace (either side) and truncating
       // remove spaces from left or from right (default) side
@@ -1708,7 +2191,7 @@ public:
   int Find(const wxWCharBuffer& sub) const
     { return Find(sub.data()); }
 
-      // replace first (or all of bReplaceAll) occurences of substring with
+      // replace first (or all of bReplaceAll) occurrences of substring with
       // another string, returns the number of replacements made
   size_t Replace(const wxString& strOld,
                  const wxString& strNew,
@@ -1826,7 +2309,7 @@ public:
 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
 
     // use Cmp()
-  inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
+  int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
     { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
 
     // use length()
@@ -1898,30 +2381,54 @@ public:
     // append elements str[pos], ..., str[pos+n]
   wxString& append(const wxString& str, size_t pos, size_t n)
   {
-    size_t from, len;
-    str.PosLenToImpl(pos, n, &from, &len);
-    m_impl.append(str.m_impl, from, len);
-    return *this;
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+      size_t from, len;
+      str.PosLenToImpl(pos, n, &from, &len);
+      m_impl.append(str.m_impl, from, len);
+      return *this;
   }
     // append a string
   wxString& append(const wxString& str)
-    { m_impl.append(str.m_impl); return *this; }
+  {
+      wxSTRING_UPDATE_CACHED_LENGTH(str.length());
+
+      m_impl.append(str.m_impl);
+      return *this;
+  }
+
     // append first n (or all if n == npos) characters of sz
   wxString& append(const char *sz)
-    { m_impl.append(ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl.append(ImplStr(sz));
+      return *this;
+  }
+
   wxString& append(const wchar_t *sz)
-    { m_impl.append(ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl.append(ImplStr(sz));
+      return *this;
+  }
+
   wxString& append(const char *sz, size_t n)
   {
-    SubstrBufFromMB str(ImplStr(sz, n));
-    m_impl.append(str.data, str.len);
-    return *this;
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      SubstrBufFromMB str(ImplStr(sz, n));
+      m_impl.append(str.data, str.len);
+      return *this;
   }
   wxString& append(const wchar_t *sz, size_t n)
   {
-    SubstrBufFromWC str(ImplStr(sz, n));
-    m_impl.append(str.data, str.len);
-    return *this;
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+      SubstrBufFromWC str(ImplStr(sz, n));
+      m_impl.append(str.data, str.len);
+      return *this;
   }
 
   wxString& append(const wxCStrData& str)
@@ -1941,13 +2448,23 @@ public:
   wxString& append(size_t n, wxUniChar ch)
   {
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.append(wxStringOperations::EncodeNChars(n, ch));
-    else
+      if ( !ch.IsAscii() )
+      {
+          wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+          m_impl.append(wxStringOperations::EncodeNChars(n, ch));
+      }
+      else // ASCII
 #endif
-        m_impl.append(n, (wxStringCharType)ch);
-    return *this;
+      {
+          wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+          m_impl.append(n, (wxStringCharType)ch);
+      }
+
+      return *this;
   }
+
   wxString& append(size_t n, wxUniCharRef ch)
     { return append(n, wxUniChar(ch)); }
   wxString& append(size_t n, char ch)
@@ -1959,7 +2476,12 @@ public:
 
     // append from first to last
   wxString& append(const_iterator first, const_iterator last)
-    { m_impl.append(first.impl(), last.impl()); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl.append(first.impl(), last.impl());
+      return *this;
+  }
 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
   wxString& append(const char *first, const char *last)
     { return append(first, last - first); }
@@ -1971,36 +2493,74 @@ public:
 
     // same as `this_string = str'
   wxString& assign(const wxString& str)
-    { m_impl = str.m_impl; return *this; }
+  {
+      wxSTRING_SET_CACHED_LENGTH(str.length());
+
+      m_impl = str.m_impl;
+
+      return *this;
+  }
+
   wxString& assign(const wxString& str, size_t len)
   {
-    m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
-    return *this;
+      wxSTRING_SET_CACHED_LENGTH(len);
+
+      m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
+
+      return *this;
   }
+
     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)
   {
-    size_t from, len;
-    str.PosLenToImpl(pos, n, &from, &len);
-    m_impl.assign(str.m_impl, from, len);
-    return *this;
+      size_t from, len;
+      str.PosLenToImpl(pos, n, &from, &len);
+      m_impl.assign(str.m_impl, from, len);
+
+      // it's important to call this after PosLenToImpl() above in case str is
+      // the same string as this one
+      wxSTRING_SET_CACHED_LENGTH(n);
+
+      return *this;
   }
+
     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const char *sz)
-    { m_impl.assign(ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.assign(ImplStr(sz));
+
+      return *this;
+  }
+
   wxString& assign(const wchar_t *sz)
-    { m_impl.assign(ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.assign(ImplStr(sz));
+
+      return *this;
+  }
+
   wxString& assign(const char *sz, size_t n)
   {
-    SubstrBufFromMB str(ImplStr(sz, n));
-    m_impl.assign(str.data, str.len);
-    return *this;
+      wxSTRING_SET_CACHED_LENGTH(n);
+
+      SubstrBufFromMB str(ImplStr(sz, n));
+      m_impl.assign(str.data, str.len);
+
+      return *this;
   }
+
   wxString& assign(const wchar_t *sz, size_t n)
   {
-    SubstrBufFromWC str(ImplStr(sz, n));
-    m_impl.assign(str.data, str.len);
-    return *this;
+      wxSTRING_SET_CACHED_LENGTH(n);
+
+      SubstrBufFromWC str(ImplStr(sz, n));
+      m_impl.assign(str.data, str.len);
+
+      return *this;
   }
 
   wxString& assign(const wxCStrData& str)
@@ -2019,13 +2579,16 @@ public:
     // same as `= n copies of ch'
   wxString& assign(size_t n, wxUniChar ch)
   {
+      wxSTRING_SET_CACHED_LENGTH(n);
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
-    else
+      if ( !ch.IsAscii() )
+          m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
+      else
 #endif
-        m_impl.assign(n, (wxStringCharType)ch);
-    return *this;
+          m_impl.assign(n, (wxStringCharType)ch);
+
+      return *this;
   }
 
   wxString& assign(size_t n, wxUniCharRef ch)
@@ -2039,7 +2602,13 @@ public:
 
     // assign from first to last
   wxString& assign(const_iterator first, const_iterator last)
-    { m_impl.assign(first.impl(), last.impl()); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.assign(first.impl(), last.impl());
+
+      return *this;
+  }
 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
   wxString& assign(const char *first, const char *last)
     { return assign(first, last - first); }
@@ -2072,58 +2641,93 @@ public:
 
     // insert another string
   wxString& insert(size_t nPos, const wxString& str)
-    { insert(begin() + nPos, str.begin(), str.end()); return *this; }
+    { insert(GetIterForNthChar(nPos), str.begin(), str.end()); return *this; }
     // insert n chars of str starting at nStart (in str)
   wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
   {
-    size_t from, len;
-    str.PosLenToImpl(nStart, n, &from, &len);
-    m_impl.insert(PosToImpl(nPos), str.m_impl, from, len);
-    return *this;
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+      size_t from, len;
+      str.PosLenToImpl(nStart, n, &from, &len);
+      m_impl.insert(PosToImpl(nPos), str.m_impl, from, len);
+
+      return *this;
   }
+
     // insert first n (or all if n == npos) characters of sz
   wxString& insert(size_t nPos, const char *sz)
-    { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.insert(PosToImpl(nPos), ImplStr(sz));
+
+      return *this;
+  }
+
   wxString& insert(size_t nPos, const wchar_t *sz)
-    { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this;
+  }
+
   wxString& insert(size_t nPos, const char *sz, size_t n)
   {
-    SubstrBufFromMB str(ImplStr(sz, n));
-    m_impl.insert(PosToImpl(nPos), str.data, str.len);
-    return *this;
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+      SubstrBufFromMB str(ImplStr(sz, n));
+      m_impl.insert(PosToImpl(nPos), str.data, str.len);
+
+      return *this;
   }
+
   wxString& insert(size_t nPos, const wchar_t *sz, size_t n)
   {
-    SubstrBufFromWC str(ImplStr(sz, n));
-    m_impl.insert(PosToImpl(nPos), str.data, str.len);
-    return *this;
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+      SubstrBufFromWC str(ImplStr(sz, n));
+      m_impl.insert(PosToImpl(nPos), str.data, str.len);
+
+      return *this;
   }
+
     // insert n copies of ch
   wxString& insert(size_t nPos, size_t n, wxUniChar ch)
   {
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
-    else
+      if ( !ch.IsAscii() )
+          m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
+      else
 #endif
-        m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
-    return *this;
+          m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
+      return *this;
   }
+
   iterator insert(iterator it, wxUniChar ch)
   {
+      wxSTRING_UPDATE_CACHED_LENGTH(1);
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-    {
-        size_t pos = IterToImplPos(it);
-        m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
-        return iterator(this, m_impl.begin() + pos);
-    }
-    else
+      if ( !ch.IsAscii() )
+      {
+          size_t pos = IterToImplPos(it);
+          m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
+          return iterator(this, m_impl.begin() + pos);
+      }
+      else
 #endif
-        return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch));
+          return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch));
   }
+
   void insert(iterator it, const_iterator first, const_iterator last)
-    { m_impl.insert(it.impl(), first.impl(), last.impl()); }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.insert(it.impl(), first.impl(), last.impl());
+  }
+
 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
   void insert(iterator it, const char *first, const char *last)
     { insert(it - begin(), first, last - first); }
@@ -2135,150 +2739,238 @@ public:
 
   void insert(iterator it, size_type n, wxUniChar ch)
   {
+      wxSTRING_UPDATE_CACHED_LENGTH(n);
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
-    else
+      if ( !ch.IsAscii() )
+          m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
+      else
 #endif
-        m_impl.insert(it.impl(), n, (wxStringCharType)ch);
+          m_impl.insert(it.impl(), n, (wxStringCharType)ch);
   }
 
     // delete characters from nStart to nStart + nLen
   wxString& erase(size_type pos = 0, size_type n = npos)
   {
-    size_t from, len;
-    PosLenToImpl(pos, n, &from, &len);
-    m_impl.erase(from, len);
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(pos, n, &from, &len);
+      m_impl.erase(from, len);
+
+      return *this;
   }
+
     // delete characters from first up to last
   iterator erase(iterator first, iterator last)
-    { return iterator(this, m_impl.erase(first.impl(), last.impl())); }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      return iterator(this, m_impl.erase(first.impl(), last.impl()));
+  }
+
   iterator erase(iterator first)
-    { return iterator(this, m_impl.erase(first.impl())); }
+  {
+      wxSTRING_UPDATE_CACHED_LENGTH(-1);
+
+      return iterator(this, m_impl.erase(first.impl()));
+  }
 
 #ifdef wxSTRING_BASE_HASNT_CLEAR
   void clear() { erase(); }
 #else
-  void clear() { m_impl.clear(); }
+  void clear()
+  {
+      wxSTRING_SET_CACHED_LENGTH(0);
+
+      m_impl.clear();
+  }
 #endif
 
     // replaces the substring of length nLen starting at nStart
   wxString& replace(size_t nStart, size_t nLen, const char* sz)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
-    m_impl.replace(from, len, ImplStr(sz));
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
+      m_impl.replace(from, len, ImplStr(sz));
+
+      return *this;
   }
+
   wxString& replace(size_t nStart, size_t nLen, const wchar_t* sz)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
-    m_impl.replace(from, len, ImplStr(sz));
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
+      m_impl.replace(from, len, ImplStr(sz));
+
+      return *this;
   }
+
     // replaces the substring of length nLen starting at nStart
   wxString& replace(size_t nStart, size_t nLen, const wxString& str)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
-    m_impl.replace(from, len, str.m_impl);
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
+      m_impl.replace(from, len, str.m_impl);
+
+      return *this;
   }
+
     // replaces the substring with nCount copies of ch
   wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
-    else
+      if ( !ch.IsAscii() )
+          m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
+      else
 #endif
-        m_impl.replace(from, len, nCount, (wxStringCharType)ch);
-    return *this;
+          m_impl.replace(from, len, nCount, (wxStringCharType)ch);
+
+      return *this;
   }
+
     // replaces a substring with another substring
   wxString& replace(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
+      wxSTRING_INVALIDATE_CACHE();
 
-    size_t from2, len2;
-    str.PosLenToImpl(nStart2, nLen2, &from2, &len2);
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
 
-    m_impl.replace(from, len, str.m_impl, from2, len2);
-    return *this;
+      size_t from2, len2;
+      str.PosLenToImpl(nStart2, nLen2, &from2, &len2);
+
+      m_impl.replace(from, len, str.m_impl, from2, len2);
+
+      return *this;
   }
+
      // replaces the substring with first nCount chars of sz
   wxString& replace(size_t nStart, size_t nLen,
                     const char* sz, size_t nCount)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
+      wxSTRING_INVALIDATE_CACHE();
 
-    SubstrBufFromMB str(ImplStr(sz, nCount));
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
 
-    m_impl.replace(from, len, str.data, str.len);
-    return *this;
+      SubstrBufFromMB str(ImplStr(sz, nCount));
+
+      m_impl.replace(from, len, str.data, str.len);
+
+      return *this;
   }
+
   wxString& replace(size_t nStart, size_t nLen,
                     const wchar_t* sz, size_t nCount)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
+      wxSTRING_INVALIDATE_CACHE();
 
-    SubstrBufFromWC str(ImplStr(sz, nCount));
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
 
-    m_impl.replace(from, len, str.data, str.len);
-    return *this;
+      SubstrBufFromWC str(ImplStr(sz, nCount));
+
+      m_impl.replace(from, len, str.data, str.len);
+
+      return *this;
   }
+
   wxString& replace(size_t nStart, size_t nLen,
                     const wxString& s, size_t nCount)
   {
-    size_t from, len;
-    PosLenToImpl(nStart, nLen, &from, &len);
-    m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      size_t from, len;
+      PosLenToImpl(nStart, nLen, &from, &len);
+      m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
+
+      return *this;
   }
 
   wxString& replace(iterator first, iterator last, const char* s)
-    { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.replace(first.impl(), last.impl(), ImplStr(s));
+
+      return *this;
+  }
+
   wxString& replace(iterator first, iterator last, const wchar_t* s)
-    { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.replace(first.impl(), last.impl(), ImplStr(s));
+
+      return *this;
+  }
+
   wxString& replace(iterator first, iterator last, const char* s, size_type n)
   {
-    SubstrBufFromMB str(ImplStr(s, n));
-    m_impl.replace(first.impl(), last.impl(), str.data, str.len);
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      SubstrBufFromMB str(ImplStr(s, n));
+      m_impl.replace(first.impl(), last.impl(), str.data, str.len);
+
+      return *this;
   }
+
   wxString& replace(iterator first, iterator last, const wchar_t* s, size_type n)
   {
-    SubstrBufFromWC str(ImplStr(s, n));
-    m_impl.replace(first.impl(), last.impl(), str.data, str.len);
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      SubstrBufFromWC str(ImplStr(s, n));
+      m_impl.replace(first.impl(), last.impl(), str.data, str.len);
+
+      return *this;
   }
+
   wxString& replace(iterator first, iterator last, const wxString& s)
-    { m_impl.replace(first.impl(), last.impl(), s.m_impl); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.replace(first.impl(), last.impl(), s.m_impl);
+
+      return *this;
+  }
+
   wxString& replace(iterator first, iterator last, size_type n, wxUniChar ch)
   {
+      wxSTRING_INVALIDATE_CACHE();
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl.replace(first.impl(), last.impl(),
-                       wxStringOperations::EncodeNChars(n, ch));
-    else
+      if ( !ch.IsAscii() )
+          m_impl.replace(first.impl(), last.impl(),
+                  wxStringOperations::EncodeNChars(n, ch));
+      else
 #endif
-        m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
-    return *this;
+          m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
+
+      return *this;
   }
+
   wxString& replace(iterator first, iterator last,
                     const_iterator first1, const_iterator last1)
   {
-    m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl());
-    return *this;
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl());
+
+      return *this;
   }
+
   wxString& replace(iterator first, iterator last,
                     const char *first1, const char *last1)
     { replace(first, last, first1, last1 - first1); return *this; }
@@ -2288,7 +2980,17 @@ public:
 
   // swap two strings
   void swap(wxString& str)
-    { m_impl.swap(str.m_impl); }
+  {
+#if wxUSE_STRING_POS_CACHE
+      // we modify not only this string but also the other one directly so we
+      // need to invalidate cache for both of them (we could also try to
+      // exchange their cache entries but it seems unlikely to be worth it)
+      InvalidateCache();
+      str.InvalidateCache();
+#endif // wxUSE_STRING_POS_CACHE
+
+      m_impl.swap(str.m_impl);
+  }
 
     // find a substring
   size_t find(const wxString& str, size_t nStart = 0) const
@@ -2312,7 +3014,7 @@ public:
   size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const
     { return find(s.AsWChar(), nStart, n); }
 
-    // find the first occurence of character ch after nStart
+    // find the first occurrence of character ch after nStart
   size_t find(wxUniChar ch, size_t nStart = 0) const
   {
 #if wxUSE_UNICODE_UTF8
@@ -2378,7 +3080,7 @@ public:
   size_t rfind(wchar_t ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }
 
-  // find first/last occurence of any character (not) in the set:
+  // find first/last occurrence of any character (not) in the set:
 #if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
   // FIXME-UTF8: this is not entirely correct, because it doesn't work if
   //             sizeof(wchar_t)==2 and surrogates are present in the string;
@@ -2469,7 +3171,7 @@ public:
   size_t find_last_of(wxUniChar c, size_t nStart = npos) const
     { return rfind(c, nStart); }
 
-    // find first/last occurence of any character not in the set
+    // find first/last occurrence of any character not in the set
 
     // as strspn() (starting from nStart), returns npos on failure
   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
@@ -2591,14 +3293,34 @@ public:
 
       // string += string
   wxString& operator+=(const wxString& s)
-    { m_impl += s.m_impl; return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl += s.m_impl;
+      return *this;
+  }
       // string += C string
   wxString& operator+=(const char *psz)
-    { m_impl += ImplStr(psz); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl += ImplStr(psz);
+      return *this;
+  }
   wxString& operator+=(const wchar_t *pwz)
-    { m_impl += ImplStr(pwz); return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl += ImplStr(pwz);
+      return *this;
+  }
   wxString& operator+=(const wxCStrData& s)
-    { m_impl += s.AsString().m_impl; return *this; }
+  {
+      wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+      m_impl += s.AsString().m_impl;
+      return *this;
+  }
   wxString& operator+=(const wxCharBuffer& s)
     { return operator+=(s.data()); }
   wxString& operator+=(const wxWCharBuffer& s)
@@ -2606,13 +3328,15 @@ public:
       // string += char
   wxString& operator+=(wxUniChar ch)
   {
+      wxSTRING_UPDATE_CACHED_LENGTH(1);
+
 #if wxUSE_UNICODE_UTF8
-    if ( !ch.IsAscii() )
-        m_impl += wxStringOperations::EncodeChar(ch);
-    else
+      if ( !ch.IsAscii() )
+          m_impl += wxStringOperations::EncodeChar(ch);
+      else
 #endif
-        m_impl += (wxStringCharType)ch;
-    return *this;
+          m_impl += (wxStringCharType)ch;
+      return *this;
   }
   wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(int ch) { return *this += wxUniChar(ch); }
@@ -2624,11 +3348,23 @@ private:
 #if !wxUSE_STL_BASED_WXSTRING
   // helpers for wxStringBuffer and wxStringBufferLength
   wxStringCharType *DoGetWriteBuf(size_t nLen)
-    { return m_impl.DoGetWriteBuf(nLen); }
+  {
+      return m_impl.DoGetWriteBuf(nLen);
+  }
+
   void DoUngetWriteBuf()
-    { m_impl.DoUngetWriteBuf(); }
+  {
+      wxSTRING_INVALIDATE_CACHE();
+
+      m_impl.DoUngetWriteBuf();
+  }
+
   void DoUngetWriteBuf(size_t nLen)
-    { m_impl.DoUngetWriteBuf(nLen); }
+  {
+      wxSTRING_SET_CACHED_LENGTH(nLen);
+
+      m_impl.DoUngetWriteBuf(nLen);
+  }
 #endif // !wxUSE_STL_BASED_WXSTRING
 
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
@@ -2895,7 +3631,7 @@ public:
                 len = lenWanted - 1;
             }
 
-            wxTmemcpy(m_buf.data(), buf, len + 1);
+            memcpy(m_buf.data(), buf, (len + 1)*sizeof(CharType));
         }
         //else: conversion failed, this can happen when trying to get Unicode
         //      string contents into a char string