Document that wxDC::FloodFill() is not implemented under wxOSX.

[wxWidgets.git] / include / wx / string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index d8aebef9acfe025b306cb7bae211038a07bb244f..53ae8907d8b0185320b00251412fc71c9ecb392e 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -24,7 +24,6 @@
 
 #include "wx/defs.h"        // everybody should include this
 
 
 #include "wx/defs.h"        // everybody should include this
 

-#ifndef __WXPALMOS5__

 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif
 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif


@@ -47,7 +46,6 @@
 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // HAVE_STRCASECMP_IN_STRINGS_H
 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // HAVE_STRCASECMP_IN_STRINGS_H

-#endif // ! __WXPALMOS5__

 
 #include "wx/wxcrtbase.h"   // for wxChar, wxStrlen() etc.
 #include "wx/strvararg.h"
 
 #include "wx/wxcrtbase.h"   // for wxChar, wxStrlen() etc.
 #include "wx/strvararg.h"


@@ -69,7 +67,9 @@
 // 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
 // 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__)
+// CS: under OSX release builds the string destructor/cache cleanup sometimes
+// crashes, disable until we find the true reason or a better workaround
+#if wxUSE_UNICODE_UTF8 && !defined(__WINDOWS__) && !defined(__WXOSX__)

     #define wxUSE_STRING_POS_CACHE 1
 #else
     #define wxUSE_STRING_POS_CACHE 0
     #define wxUSE_STRING_POS_CACHE 1
 #else
     #define wxUSE_STRING_POS_CACHE 0


@@ -154,7 +154,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
   } while ( c1 && (c1 == c2) );
 
   return c1 - c2;
   } while ( c1 && (c1 == c2) );
 
   return c1 - c2;

-#elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
+#elif defined(__VISUALC__)

   return _stricmp(psz1, psz2);
 #elif defined(__SC__)
   return _stricmp(psz1, psz2);
   return _stricmp(psz1, psz2);
 #elif defined(__SC__)
   return _stricmp(psz1, psz2);


@@ -168,19 +168,10 @@ inline int Stricmp(const char *psz1, const char *psz2)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
   return stricmp(psz1, psz2);

-#elif defined(__WXPALMOS__) || \
-      defined(HAVE_STRCASECMP_IN_STRING_H) || \
+#elif defined(HAVE_STRCASECMP_IN_STRING_H) || \

       defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
       defined(__GNUWIN32__)
   return strcasecmp(psz1, psz2);
       defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
       defined(__GNUWIN32__)
   return strcasecmp(psz1, psz2);

-#elif defined(__MWERKS__) && !defined(__INTEL__)
-  register char c1, c2;
-  do {
-    c1 = tolower(*psz1++);
-    c2 = tolower(*psz2++);
-  } while ( c1 && (c1 == c2) );
-
-  return c1 - c2;

 #else
   // almost all compilers/libraries provide this function (unfortunately under
   // different names), that's why we don't implement our own which will surely
 #else
   // almost all compilers/libraries provide this function (unfortunately under
   // different names), that's why we don't implement our own which will surely


@@ -207,7 +198,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.

-class WXDLLIMPEXP_BASE wxCStrData
+class wxCStrData

 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only
 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only


@@ -223,19 +214,19 @@ public:
 
     inline ~wxCStrData();
 
 
     inline ~wxCStrData();
 

-    // methods defined inline below must be declared inline or mingw32 3.4.5
-    // warns about "<symbol> defined locally after being referenced with
-    // dllimport linkage"
-#if wxUSE_UNICODE_WCHAR
-    inline
-#endif
-    const wchar_t* AsWChar() const;
+    // AsWChar() and AsChar() can't be defined here as they use wxString and so
+    // must come after it and because of this won't be inlined when called from
+    // wxString methods (without a lot of work to extract these wxString methods
+    // from inside the class itself). But we still define them being inline
+    // below to let compiler inline them from elsewhere. And because of this we
+    // must declare them as inline here because otherwise some compilers give
+    // warnings about them, e.g. mingw32 3.4.5 warns about "<symbol> defined
+    // locally after being referenced with dllimport linkage" while IRIX
+    // mipsPro 7.4 warns about "function declared inline after being called".
+    inline const wchar_t* AsWChar() const;

     operator const wchar_t*() const { return AsWChar(); }
 
     operator const wchar_t*() const { return AsWChar(); }
 

-#if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
-    inline
-#endif
-    const char* AsChar() const;
+    inline const char* AsChar() const;

     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     operator const char*() const { return AsChar(); }
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     operator const char*() const { return AsChar(); }


@@ -243,8 +234,16 @@ public:
 
     operator const void*() const { return AsChar(); }
 
 
     operator const void*() const { return AsChar(); }
 

-    inline const wxCharBuffer AsCharBuf() const;
-    inline const wxWCharBuffer AsWCharBuf() const;
+    // returns buffers that are valid as long as the associated wxString exists
+    const wxScopedCharBuffer AsCharBuf() const
+    {
+        return wxScopedCharBuffer::CreateNonOwned(AsChar());
+    }
+
+    const wxScopedWCharBuffer AsWCharBuf() const
+    {
+        return wxScopedWCharBuffer::CreateNonOwned(AsWChar());
+    }

 
     inline wxString AsString() const;
 
 
     inline wxString AsString() const;
 


@@ -260,9 +259,11 @@ public:
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
 #endif // size_t != unsigned int
 
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
 #endif // size_t != unsigned int
 

-    // these operators are needed to emulate the pointer semantics of c_str():
+    // These operators are needed to emulate the pointer semantics of c_str():

     // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
     // expressions like "wxChar *p = str.c_str() + 1;" should continue to work

-    // (we need both versions to resolve ambiguities):
+    // (we need both versions to resolve ambiguities). Note that this means
+    // the 'n' value is interpreted as addition to char*/wchar_t* pointer, it
+    // is *not* number of Unicode characters in wxString.

     wxCStrData operator+(int n) const
         { return wxCStrData(m_str, m_offset + n, m_owned); }
     wxCStrData operator+(long n) const
     wxCStrData operator+(int n) const
         { return wxCStrData(m_str, m_offset + n, m_owned); }
     wxCStrData operator+(long n) const


@@ -276,7 +277,7 @@ public:
     wxCStrData operator-(ptrdiff_t n) const
     {
         wxASSERT_MSG( n <= (ptrdiff_t)m_offset,
     wxCStrData operator-(ptrdiff_t n) const
     {
         wxASSERT_MSG( n <= (ptrdiff_t)m_offset,

-                      _T("attempt to construct address before the beginning of the string") );
+                      wxT("attempt to construct address before the beginning of the string") );

         return wxCStrData(m_str, m_offset - n, m_owned);
     }
 
         return wxCStrData(m_str, m_offset - n, m_owned);
     }
 


@@ -285,8 +286,16 @@ public:
     inline wxUniChar operator*() const;
 
 private:
     inline wxUniChar operator*() const;
 
 private:

+    // the wxString this object was returned for

     const wxString *m_str;
     const wxString *m_str;

+    // Offset into c_str() return value. Note that this is *not* offset in
+    // m_str in Unicode characters. Instead, it is index into the
+    // char*/wchar_t* buffer returned by c_str(). It's interpretation depends
+    // on how is the wxCStrData instance used: if it is eventually cast to
+    // const char*, m_offset will be in bytes form string's start; if it is
+    // cast to const wchar_t*, it will be in wchar_t values.

     size_t m_offset;
     size_t m_offset;

+    // should m_str be deleted, i.e. is it owned by us?

     bool m_owned;
 
     friend class WXDLLIMPEXP_FWD_BASE wxString;
     bool m_owned;
 
     friend class WXDLLIMPEXP_FWD_BASE wxString;


@@ -348,7 +357,7 @@ public:
     // these are duplicated wxString methods, they're also declared below
     // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
 
     // these are duplicated wxString methods, they're also declared below
     // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
 

-    // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1;
+    // static wxString Format(const wString& format, ...) WX_ATTRIBUTE_PRINTF_1;

     WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType<T1>::type,
                                   Format, 1, (const wxFormatString&),
                                   DoFormatWchar, DoFormatUtf8)
     WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType<T1>::type,
                                   Format, 1, (const wxFormatString&),
                                   DoFormatWchar, DoFormatUtf8)


@@ -370,7 +379,7 @@ public:
     // int Printf(const wxString& format, ...);
     WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&),
                           DoPrintfWchar, DoPrintfUtf8)
     // int Printf(const wxString& format, ...);
     WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&),
                           DoPrintfWchar, DoPrintfUtf8)

-    // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
+    // int sprintf(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_2;

     WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
                           DoPrintfWchar, DoPrintfUtf8)
 
     WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
                           DoPrintfWchar, DoPrintfUtf8)
 


@@ -388,6 +397,7 @@ protected:
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // "non dll-interface class 'wxStringPrintfMixin' used as base interface
     // for dll-interface class 'wxString'" -- this is OK in our case
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // "non dll-interface class 'wxStringPrintfMixin' used as base interface
     // for dll-interface class 'wxString'" -- this is OK in our case

+    #pragma warning (push)

     #pragma warning (disable:4275)
 #endif
 
     #pragma warning (disable:4275)
 #endif
 


@@ -424,7 +434,7 @@ private:
 
     // the node belongs to a particular iterator instance, it's not copied
     // when a copy of the iterator is made
 
     // the node belongs to a particular iterator instance, it's not copied
     // when a copy of the iterator is made

-    DECLARE_NO_COPY_CLASS(wxStringIteratorNode)
+    wxDECLARE_NO_COPY_CLASS(wxStringIteratorNode);

 };
 #endif // wxUSE_UNICODE_UTF8
 
 };
 #endif // wxUSE_UNICODE_UTF8
 


@@ -474,14 +484,14 @@ private:
 
 #if wxUSE_UNICODE_UTF8
   // even char* -> char* needs conversion, from locale charset to UTF-8
 
 #if wxUSE_UNICODE_UTF8
   // even char* -> char* needs conversion, from locale charset to UTF-8

-  typedef SubstrBufFromType<wxCharBuffer>    SubstrBufFromWC;
-  typedef SubstrBufFromType<wxCharBuffer>    SubstrBufFromMB;
+  typedef SubstrBufFromType<wxScopedCharBuffer>    SubstrBufFromWC;
+  typedef SubstrBufFromType<wxScopedCharBuffer>    SubstrBufFromMB;

 #elif wxUSE_UNICODE_WCHAR
 #elif wxUSE_UNICODE_WCHAR

-  typedef SubstrBufFromType<const wchar_t*>  SubstrBufFromWC;
-  typedef SubstrBufFromType<wxWCharBuffer>   SubstrBufFromMB;
+  typedef SubstrBufFromType<const wchar_t*>        SubstrBufFromWC;
+  typedef SubstrBufFromType<wxScopedWCharBuffer>   SubstrBufFromMB;

 #else
 #else

-  typedef SubstrBufFromType<const char*>     SubstrBufFromMB;
-  typedef SubstrBufFromType<wxCharBuffer>    SubstrBufFromWC;
+  typedef SubstrBufFromType<const char*>           SubstrBufFromMB;
+  typedef SubstrBufFromType<wxScopedCharBuffer>    SubstrBufFromWC;

 #endif
 
 
 #endif
 
 


@@ -510,8 +520,8 @@ private:
     { return str ? str : wxT(""); }
   static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); }
     { return str ? str : wxT(""); }
   static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); }

-  static wxWCharBuffer ImplStr(const char* str,
-                               const wxMBConv& conv = wxConvLibc)
+  static wxScopedWCharBuffer ImplStr(const char* str,
+                                     const wxMBConv& conv = wxConvLibc)

     { return ConvertStr(str, npos, conv).data; }
   static SubstrBufFromMB ImplStr(const char* str, size_t n,
                                  const wxMBConv& conv = wxConvLibc)
     { return ConvertStr(str, npos, conv).data; }
   static SubstrBufFromMB ImplStr(const char* str, size_t n,
                                  const wxMBConv& conv = wxConvLibc)


@@ -523,7 +533,7 @@ private:
   static const SubstrBufFromMB ImplStr(const char* str, size_t n,
                                        const wxMBConv& WXUNUSED(conv) = wxConvLibc)
     { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); }
   static const SubstrBufFromMB ImplStr(const char* str, size_t n,
                                        const wxMBConv& WXUNUSED(conv) = wxConvLibc)
     { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); }

-  static wxCharBuffer ImplStr(const wchar_t* str)
+  static wxScopedCharBuffer ImplStr(const wchar_t* str)

     { return ConvertStr(str, npos, wxConvLibc).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return ConvertStr(str, n, wxConvLibc); }
     { return ConvertStr(str, npos, wxConvLibc).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return ConvertStr(str, n, wxConvLibc); }


@@ -548,14 +558,14 @@ private:
 
 #else // wxUSE_UNICODE_UTF8
 
 
 #else // wxUSE_UNICODE_UTF8
 

-  static wxCharBuffer ImplStr(const char* str,
-                              const wxMBConv& conv = wxConvLibc)
+  static wxScopedCharBuffer ImplStr(const char* str,
+                                    const wxMBConv& conv = wxConvLibc)

     { return ConvertStr(str, npos, conv).data; }
   static SubstrBufFromMB ImplStr(const char* str, size_t n,
                                  const wxMBConv& conv = wxConvLibc)
     { return ConvertStr(str, n, conv); }
 
     { return ConvertStr(str, npos, conv).data; }
   static SubstrBufFromMB ImplStr(const char* str, size_t n,
                                  const wxMBConv& conv = wxConvLibc)
     { return ConvertStr(str, n, conv); }
 

-  static wxCharBuffer ImplStr(const wchar_t* str)
+  static wxScopedCharBuffer ImplStr(const wchar_t* str)

     { return ConvertStr(str, npos, wxMBConvUTF8()).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return ConvertStr(str, n, wxMBConvUTF8()); }
     { return ConvertStr(str, npos, wxMBConvUTF8()).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
     { return ConvertStr(str, n, wxMBConvUTF8()); }


@@ -594,26 +604,38 @@ private:
       unsigned lastUsed;
   };
 
       unsigned lastUsed;
   };
 

-  // notice that we must use an accessor function and not a static variable
-  // because when the TLS variables support is implemented in the library (and
-  // not by the compiler), 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
-  static Cache& GetCache()
+#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);
   }
 
   {
       static wxTLS_TYPE(Cache) s_cache;
 
       return wxTLS_VALUE(s_cache);
   }
 

-  static Cache::Element *GetCacheBegin() { return GetCache().cached; }
-  static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; }
-  static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; }
-

   // 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;
   // 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
 
   // this is used in debug builds only to provide a convenient function,
   // callable from a debugger, to show the cache contents


@@ -637,7 +659,7 @@ private:
                lenhits; // number of cache hits in length()
   } ms_cacheStats;
 
                lenhits; // number of cache hits in length()
   } ms_cacheStats;
 

-  friend struct ShowCacheStats;
+  friend struct wxStrCacheStatsDumper;

 
   #define wxCACHE_PROFILE_FIELD_INC(field) ms_cacheStats.field++
   #define wxCACHE_PROFILE_FIELD_ADD(field, val) ms_cacheStats.field += (val)
 
   #define wxCACHE_PROFILE_FIELD_INC(field) ms_cacheStats.field++
   #define wxCACHE_PROFILE_FIELD_ADD(field, val) ms_cacheStats.field += (val)


@@ -659,7 +681,15 @@ private:
       // 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...)
       // 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...)

-      for ( Cache::Element *c = GetCacheBegin(); c != GetCacheEnd(); c++ )
+      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;
       {
           if ( c->str == this )
               return c;


@@ -721,7 +751,9 @@ private:
       // used for length caching only so far, i.e. it doesn't count as a hit
       // from our point of view
       if ( cache->pos )
       // 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);
           wxCACHE_PROFILE_FIELD_INC(poshits);

+      }

 
       if ( pos == cache->pos )
           return cache->impl;
 
       if ( pos == cache->pos )
           return cache->impl;


@@ -961,11 +993,21 @@ public:
       iterator operator-(ptrdiff_t n) const
         { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 
       iterator operator-(ptrdiff_t n) const
         { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // Normal iterators need to be comparable with the const_iterators so
+      // declare the comparison operators and implement them below after the
+      // full const_iterator declaration.
+      bool operator==(const const_iterator& i) const;
+      bool operator!=(const const_iterator& i) const;
+      bool operator<(const const_iterator& i) const;
+      bool operator>(const const_iterator& i) const;
+      bool operator<=(const const_iterator& i) const;
+      bool operator>=(const const_iterator& i) const;
+

   private:
   private:

-      iterator(wxString *str, underlying_iterator ptr)
-          : m_cur(ptr), m_node(str, &m_cur) {}
+      iterator(wxString *wxstr, underlying_iterator ptr)
+          : m_cur(ptr), m_node(wxstr, &m_cur) {}

 
 

-      wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); }
+      wxString* str() const { return const_cast<wxString*>(m_node.m_str); }

 
       wxStringIteratorNode m_node;
 
 
       wxStringIteratorNode m_node;
 


@@ -1005,10 +1047,15 @@ public:
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // Notice that comparison operators taking non-const iterator are not
+      // needed here because of the implicit conversion from non-const iterator
+      // to const ones ensure that the versions for const_iterator declared
+      // inside WX_STR_ITERATOR_IMPL can be used.
+

   private:
       // for internal wxString use only:
   private:
       // for internal wxString use only:

-      const_iterator(const wxString *str, underlying_iterator ptr)
-          : m_cur(ptr), m_node(str, &m_cur) {}
+      const_iterator(const wxString *wxstr, underlying_iterator ptr)
+          : m_cur(ptr), m_node(wxstr, &m_cur) {}

 
       const wxString* str() const { return m_node.m_str; }
 
 
       const wxString* str() const { return m_node.m_str; }
 


@@ -1040,6 +1087,15 @@ public:
       iterator operator-(ptrdiff_t n) const
         { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 
       iterator operator-(ptrdiff_t n) const
         { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // As in UTF-8 case above, define comparison operators taking
+      // const_iterator too.
+      bool operator==(const const_iterator& i) const;
+      bool operator!=(const const_iterator& i) const;
+      bool operator<(const const_iterator& i) const;
+      bool operator>(const const_iterator& i) const;
+      bool operator<=(const const_iterator& i) const;
+      bool operator>=(const const_iterator& i) const;
+

   private:
       // for internal wxString use only:
       iterator(underlying_iterator ptr) : m_cur(ptr) {}
   private:
       // for internal wxString use only:
       iterator(underlying_iterator ptr) : m_cur(ptr) {}


@@ -1067,6 +1123,11 @@ public:
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // As in UTF-8 case above, we don't need comparison operators taking
+      // iterator because we have an implicit conversion from iterator to
+      // const_iterator so the operators declared by WX_STR_ITERATOR_IMPL will
+      // be used.
+

   private:
       // for internal wxString use only:
       const_iterator(underlying_iterator ptr) : m_cur(ptr) {}
   private:
       // for internal wxString use only:
       const_iterator(underlying_iterator ptr) : m_cur(ptr) {}


@@ -1081,6 +1142,25 @@ public:
   #undef WX_STR_ITERATOR_TAG
   #undef WX_STR_ITERATOR_IMPL
 
   #undef WX_STR_ITERATOR_TAG
   #undef WX_STR_ITERATOR_IMPL
 

+  // This method is mostly used by wxWidgets itself and return the offset of
+  // the given iterator in bytes relative to the start of the buffer
+  // representing the current string contents in the current locale encoding.
+  //
+  // It is inefficient as it involves converting part of the string to this
+  // encoding (and also unsafe as it simply returns 0 if the conversion fails)
+  // and so should be avoided if possible, wx itself only uses it to implement
+  // backwards-compatible API.
+  ptrdiff_t IterOffsetInMBStr(const const_iterator& i) const
+  {
+      const wxString str(begin(), i);
+
+      // This is logically equivalent to strlen(str.mb_str()) but avoids
+      // actually converting the string to multibyte and just computes the
+      // length that it would have after conversion.
+      size_t ofs = wxConvLibc.FromWChar(NULL, 0, str.wc_str(), str.length());
+      return ofs == wxCONV_FAILED ? 0 : static_cast<ptrdiff_t>(ofs);
+  }
+

   friend class iterator;
   friend class const_iterator;
 
   friend class iterator;
   friend class const_iterator;
 


@@ -1241,10 +1321,10 @@ public:
   wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength)
     { assign(pwz, nLength); }
 
   wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength)
     { assign(pwz, nLength); }
 

-  wxString(const wxCharBuffer& buf)
-    { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
-  wxString(const wxWCharBuffer& buf)
-    { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
+  wxString(const wxScopedCharBuffer& buf)
+    { assign(buf.data(), buf.length()); }
+  wxString(const wxScopedWCharBuffer& buf)
+    { assign(buf.data(), buf.length()); }

 
     // NB: this version uses m_impl.c_str() to force making a copy of the
     //     string, so that "wxString(str.c_str())" idiom for passing strings
 
     // NB: this version uses m_impl.c_str() to force making a copy of the
     //     string, so that "wxString(str.c_str())" idiom for passing strings


@@ -1273,12 +1353,13 @@ public:
   }
 #endif // wxUSE_STRING_POS_CACHE
 
   }
 #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
-  // want to unconditionally add this ctor as it would make wx lib dependent on
-  // libstdc++ on some Linux versions which is bad, so instead we ask the
-  // client code to define this wxUSE_STD_STRING symbol if they need it
+  // even if we're not built with wxUSE_STD_STRING_CONV_IN_WXSTRING == 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 want to unconditionally add this ctor as it would
+  // make wx lib dependent on libstdc++ on some Linux versions which is bad, so
+  // instead we ask the client code to define this wxUSE_STD_STRING symbol if
+  // they need it

 #if wxUSE_STD_STRING
   #if wxUSE_UNICODE_WCHAR
     wxString(const wxStdWideString& str) : m_impl(str) {}
 #if wxUSE_STD_STRING
   #if wxUSE_UNICODE_WCHAR
     wxString(const wxStdWideString& str) : m_impl(str) {}


@@ -1296,30 +1377,57 @@ public:
   #endif
 #endif // wxUSE_STD_STRING
 
   #endif
 #endif // wxUSE_STD_STRING
 

-  // Unlike ctor from std::string, we provide conversion to std::string only
-  // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default),
-  // because it conflicts with operator const char/wchar_t*:
-#if wxUSE_STL
+  // Also always provide explicit conversions to std::[w]string in any case,
+  // see below for the implicit ones.
+#if wxUSE_STD_STRING
+  // We can avoid a copy if we already use this string type internally,
+  // otherwise we create a copy on the fly:

   #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
   #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING

-    // wxStringImpl is std::string in the encoding we want
-    operator const wxStdWideString&() const { return m_impl; }
+    #define wxStringToStdWstringRetType const wxStdWideString&
+    const wxStdWideString& ToStdWstring() const { return m_impl; }

   #else
     // wxStringImpl is either not std::string or needs conversion
   #else
     // wxStringImpl is either not std::string or needs conversion

-    operator wxStdWideString() const
-        // FIXME-UTF8: broken for embedded NULs
-        { return wxStdWideString(wc_str()); }
+    #define wxStringToStdWstringRetType wxStdWideString
+    wxStdWideString ToStdWstring() const
+    {
+#if wxUSE_UNICODE_WCHAR
+        wxScopedWCharBuffer buf =
+            wxScopedWCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length());
+#else // !wxUSE_UNICODE_WCHAR
+        wxScopedWCharBuffer buf(wc_str());
+#endif
+
+        return wxStdWideString(buf.data(), buf.length());
+    }

   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
     // wxStringImpl is std::string in the encoding we want
   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
     // wxStringImpl is std::string in the encoding we want

-    operator const std::string&() const { return m_impl; }
+    #define wxStringToStdStringRetType const std::string&
+    const std::string& ToStdString() const { return m_impl; }

   #else
     // wxStringImpl is either not std::string or needs conversion
   #else
     // wxStringImpl is either not std::string or needs conversion

-    operator std::string() const
-        // FIXME-UTF8: broken for embedded NULs
-        { return std::string(mb_str()); }
+    #define wxStringToStdStringRetType std::string
+    std::string ToStdString() const
+    {
+        wxScopedCharBuffer buf(mb_str());
+        return std::string(buf.data(), buf.length());
+    }

   #endif
   #endif

-#endif // wxUSE_STL
+
+#if wxUSE_STD_STRING_CONV_IN_WXSTRING
+    // Implicit conversions to std::[w]string are not provided by default as
+    // they conflict with the implicit conversions to "const char/wchar_t *"
+    // which we use for backwards compatibility but do provide them if
+    // explicitly requested.
+  operator wxStringToStdStringRetType() const { return ToStdString(); }
+  operator wxStringToStdWstringRetType() const { return ToStdWstring(); }
+#endif // wxUSE_STD_STRING_CONV_IN_WXSTRING
+
+#undef wxStringToStdStringRetType
+#undef wxStringToStdWstringRetType
+
+#endif // wxUSE_STD_STRING

 
   wxString Clone() const
   {
 
   wxString Clone() const
   {


@@ -1436,12 +1544,7 @@ public:
     // truncate the string to given length
   wxString& Truncate(size_t uiLen);
     // empty string contents
     // 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() { clear(); }
 
     // empty the string and free memory
   void Clear() { clear(); }
 


@@ -1471,14 +1574,14 @@ public:
     // get last character
     wxUniChar Last() const
     {
     // get last character
     wxUniChar Last() const
     {

-      wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+      wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") );

       return *rbegin();
     }
 
     // get writable last character
     wxUniCharRef Last()
     {
       return *rbegin();
     }
 
     // get writable last character
     wxUniCharRef Last()
     {

-      wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+      wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") );

       return *rbegin();
     }
 
       return *rbegin();
     }
 


@@ -1509,19 +1612,62 @@ public:
       { return at(n); }
 #endif // size_t != unsigned int
 
       { 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(); }
 
     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
     operator wxCStrData() const { return c_str(); }
 
     // the first two operators conflict with operators for conversion to

-    // std::string and they must be disabled in STL build; the next one only
-    // makes sense if conversions to char* are also defined and not defining it
-    // in STL build also helps us to get more clear error messages for the code
-    // which relies on implicit conversion to char* in STL build
-#if !wxUSE_STL
+    // std::string and they must be disabled if those conversions are enabled;
+    // the next one only makes sense if conversions to char* are also defined
+    // and not defining it in STL build also helps us to get more clear error
+    // messages for the code which relies on implicit conversion to char* in
+    // STL build
+#if !wxUSE_STD_STRING_CONV_IN_WXSTRING

     operator const char*() const { return c_str(); }
     operator const wchar_t*() const { return c_str(); }
 
     operator const char*() const { return c_str(); }
     operator const wchar_t*() const { return c_str(); }
 


@@ -1529,7 +1675,7 @@ public:
     // wxWidgets versions: this is the same as conversion to const char * so it
     // may fail!
     operator const void*() const { return c_str(); }
     // wxWidgets versions: this is the same as conversion to const char * so it
     // may fail!
     operator const void*() const { return c_str(); }

-#endif // wxUSE_STL
+#endif // !wxUSE_STD_STRING_CONV_IN_WXSTRING

 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }
 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }


@@ -1565,7 +1711,7 @@ public:
         if ( len )
             *len = length();
 
         if ( len )
             *len = length();
 

-        return wxCharTypeBuffer<T>::CreateNonOwned(wx_str());
+        return wxCharTypeBuffer<T>::CreateNonOwned(wx_str(), length());

 #endif // Unicode build kind
     }
 
 #endif // Unicode build kind
     }
 


@@ -1579,7 +1725,7 @@ public:
     static wxString FromAscii(const char *ascii, size_t len);
     static wxString FromAscii(const char *ascii);
     static wxString FromAscii(char ascii);
     static wxString FromAscii(const char *ascii, size_t len);
     static wxString FromAscii(const char *ascii);
     static wxString FromAscii(char ascii);

-    const wxCharBuffer ToAscii() const;
+    const wxScopedCharBuffer ToAscii() const;

 #else // ANSI
     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
     static wxString FromAscii(const char *ascii, size_t len)
 #else // ANSI
     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
     static wxString FromAscii(const char *ascii, size_t len)


@@ -1634,8 +1780,8 @@ public:
         return FromImpl(wxStringImpl(utf8, len));
     }
 
         return FromImpl(wxStringImpl(utf8, len));
     }
 

-    const char* utf8_str() const { return wx_str(); }
-    const char* ToUTF8() const { return wx_str(); }
+    const wxScopedCharBuffer utf8_str() const
+        { return wxCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length()); }

 
     // this function exists in UTF-8 build only and returns the length of the
     // internal UTF-8 representation
 
     // this function exists in UTF-8 build only and returns the length of the
     // internal UTF-8 representation


@@ -1650,33 +1796,39 @@ public:
                       "string must be valid UTF-8" );
         return s;
     }
                       "string must be valid UTF-8" );
         return s;
     }

-    const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
-    const wxCharBuffer ToUTF8() const { return utf8_str(); }
+    const wxScopedCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }

 #else // ANSI
     static wxString FromUTF8(const char *utf8)
       { return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
     static wxString FromUTF8(const char *utf8, size_t len)
     {
         size_t wlen;
 #else // ANSI
     static wxString FromUTF8(const char *utf8)
       { 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));
+        wxScopedWCharBuffer 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;
         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));
+        wxScopedWCharBuffer 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);
     }
         wxASSERT_MSG( !utf8 || !*utf8 || wlen,
                       "string must be valid UTF-8" );
 
         return wxString(buf.data(), wlen);
     }

-    const wxCharBuffer utf8_str() const
+    const wxScopedCharBuffer utf8_str() const

       { return wxMBConvUTF8().cWC2MB(wc_str()); }
       { return wxMBConvUTF8().cWC2MB(wc_str()); }

-    const wxCharBuffer ToUTF8() const { return utf8_str(); }

 #endif
 
 #endif
 

+    const wxScopedCharBuffer ToUTF8() const { return utf8_str(); }
+

     // functions for storing binary data in wxString:
 #if wxUSE_UNICODE
     static wxString From8BitData(const char *data, size_t len)
     // functions for storing binary data in wxString:
 #if wxUSE_UNICODE
     static wxString From8BitData(const char *data, size_t len)


@@ -1684,14 +1836,16 @@ public:
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data, wxConvISO8859_1); }
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data, wxConvISO8859_1); }

-    const wxCharBuffer To8BitData() const { return mb_str(wxConvISO8859_1); }
+    const wxScopedCharBuffer To8BitData() const
+        { return mb_str(wxConvISO8859_1); }

 #else // ANSI
     static wxString From8BitData(const char *data, size_t len)
       { return wxString(data, len); }
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data); }
 #else // ANSI
     static wxString From8BitData(const char *data, size_t len)
       { return wxString(data, len); }
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data); }

-    const char *To8BitData() const { return c_str(); }
+    const wxScopedCharBuffer To8BitData() const
+        { return wxScopedCharBuffer::CreateNonOwned(wx_str(), length()); }

 #endif // Unicode/ANSI
 
     // conversions with (possible) format conversions: have to return a
 #endif // Unicode/ANSI
 
     // conversions with (possible) format conversions: have to return a


@@ -1703,53 +1857,67 @@ public:
     // accepting the file names. The return value is always the same, but the
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.
     // accepting the file names. The return value is always the same, but the
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.

+

 #if wxUSE_UNICODE
 
 #if wxUSE_UNICODE
 

+    // this is an optimization: even though using mb_str(wxConvLibc) does the
+    // same thing (i.e. returns pointer to internal representation as locale is
+    // always an UTF-8 one) in wxUSE_UTF8_LOCALE_ONLY case, we can avoid the
+    // extra checks and the temporary buffer construction by providing a
+    // separate mb_str() overload

 #if wxUSE_UTF8_LOCALE_ONLY
     const char* mb_str() const { return wx_str(); }
 #if wxUSE_UTF8_LOCALE_ONLY
     const char* mb_str() const { return wx_str(); }

-    const wxCharBuffer mb_str(const wxMBConv& conv) const;
-#else
-    const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;
-#endif
+    const wxScopedCharBuffer mb_str(const wxMBConv& conv) const
+    {
+        return AsCharBuf(conv);
+    }
+#else // !wxUSE_UTF8_LOCALE_ONLY
+    const wxScopedCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const
+    {
+        return AsCharBuf(conv);
+    }
+#endif // wxUSE_UTF8_LOCALE_ONLY/!wxUSE_UTF8_LOCALE_ONLY

 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 #if wxUSE_UNICODE_WCHAR
     const wchar_t* wc_str() const { return wx_str(); }
 #elif wxUSE_UNICODE_UTF8
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 #if wxUSE_UNICODE_WCHAR
     const wchar_t* wc_str() const { return wx_str(); }
 #elif wxUSE_UNICODE_UTF8

-    const wxWCharBuffer wc_str() const;
+    const wxScopedWCharBuffer wc_str() const
+        { return AsWCharBuf(wxMBConvStrictUTF8()); }

 #endif
     // for compatibility with !wxUSE_UNICODE version
     const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const
       { return wc_str(); }
 
 #if wxMBFILES
 #endif
     // for compatibility with !wxUSE_UNICODE version
     const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const
       { return wc_str(); }
 
 #if wxMBFILES

-    const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
+    const wxScopedCharBuffer fn_str() const { return mb_str(wxConvFile); }

 #else // !wxMBFILES
     const wxWX2WCbuf fn_str() const { return wc_str(); }
 #endif // wxMBFILES/!wxMBFILES
 
 #else // ANSI
 #else // !wxMBFILES
     const wxWX2WCbuf fn_str() const { return wc_str(); }
 #endif // wxMBFILES/!wxMBFILES
 
 #else // ANSI

-    const wxChar* mb_str() const { return wx_str(); }
+    const char* mb_str() const { return wx_str(); }

 
     // for compatibility with wxUSE_UNICODE version
     const char* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 
     // for compatibility with wxUSE_UNICODE version
     const char* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 

-#if wxUSE_WCHAR_T
-    const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const;
-#endif // wxUSE_WCHAR_T
-    const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
+    const wxScopedWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const
+        { return AsWCharBuf(conv); }
+
+    const wxScopedCharBuffer fn_str() const
+        { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }

 #endif // Unicode/ANSI
 
 #if wxUSE_UNICODE_UTF8
 #endif // Unicode/ANSI
 
 #if wxUSE_UNICODE_UTF8

-    const wxWCharBuffer t_str() const { return wc_str(); }
+    const wxScopedWCharBuffer 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(); }
 #elif wxUSE_UNICODE_WCHAR
     const wchar_t* t_str() const { return wx_str(); }
 #else
     const char* t_str() const { return wx_str(); }

-#endif 
+#endif

 
 
   // overloaded assignment
 
 
   // overloaded assignment


@@ -1839,12 +2007,12 @@ public:
   wxString& operator=(const unsigned char *psz)
     { return operator=((const char*)psz); }
 
   wxString& operator=(const unsigned char *psz)
     { return operator=((const char*)psz); }
 

-    // from wxWCharBuffer
-  wxString& operator=(const wxWCharBuffer& s)
-    { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
-    // from wxCharBuffer
-  wxString& operator=(const wxCharBuffer& s)
-    { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
+    // from wxScopedWCharBuffer
+  wxString& operator=(const wxScopedWCharBuffer& s)
+    { return assign(s); }
+    // from wxScopedCharBuffer
+  wxString& operator=(const wxScopedCharBuffer& s)
+    { return assign(s); }

 
   // string concatenation
     // in place concatenation
 
   // string concatenation
     // in place concatenation


@@ -1858,7 +2026,7 @@ public:
   {
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
     wxASSERT_MSG( s.IsValid(),
   {
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
     wxASSERT_MSG( s.IsValid(),

-                  _T("did you forget to call UngetWriteBuf()?") );
+                  wxT("did you forget to call UngetWriteBuf()?") );

 #endif
 
     append(s);
 #endif
 
     append(s);


@@ -1879,10 +2047,10 @@ public:
   wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
 
       // string += buffer (i.e. from wxGetString)
   wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
 
       // string += buffer (i.e. from wxGetString)

-  wxString& operator<<(const wxWCharBuffer& s)
-    { return operator<<((const wchar_t *)s); }
-  wxString& operator<<(const wxCharBuffer& s)
-    { return operator<<((const char *)s); }
+  wxString& operator<<(const wxScopedWCharBuffer& s)
+    { return append(s); }
+  wxString& operator<<(const wxScopedCharBuffer& s)
+    { return append(s); }

 
     // string += C string
   wxString& Append(const wxString& s)
 
     // string += C string
   wxString& Append(const wxString& s)


@@ -1900,9 +2068,9 @@ public:
     { append(pwz); return *this; }
   wxString& Append(const wxCStrData& psz)
     { append(psz); return *this; }
     { append(pwz); return *this; }
   wxString& Append(const wxCStrData& psz)
     { append(psz); return *this; }

-  wxString& Append(const wxCharBuffer& psz)
+  wxString& Append(const wxScopedCharBuffer& psz)

     { append(psz); return *this; }
     { append(psz); return *this; }

-  wxString& Append(const wxWCharBuffer& psz)
+  wxString& Append(const wxScopedWCharBuffer& psz)

     { append(psz); return *this; }
   wxString& Append(const char* psz, size_t nLen)
     { append(psz, nLen); return *this; }
     { append(psz); return *this; }
   wxString& Append(const char* psz, size_t nLen)
     { append(psz, nLen); return *this; }


@@ -1910,9 +2078,9 @@ public:
     { append(pwz, nLen); return *this; }
   wxString& Append(const wxCStrData& psz, size_t nLen)
     { append(psz, nLen); return *this; }
     { append(pwz, nLen); return *this; }
   wxString& Append(const wxCStrData& psz, size_t nLen)
     { append(psz, nLen); return *this; }

-  wxString& Append(const wxCharBuffer& psz, size_t nLen)
+  wxString& Append(const wxScopedCharBuffer& psz, size_t nLen)

     { append(psz, nLen); return *this; }
     { append(psz, nLen); return *this; }

-  wxString& Append(const wxWCharBuffer& psz, size_t nLen)
+  wxString& Append(const wxScopedWCharBuffer& psz, size_t nLen)

     { append(psz, nLen); return *this; }
     // append count copies of given character
   wxString& Append(wxUniChar ch, size_t count = 1u)
     { append(psz, nLen); return *this; }
     // append count copies of given character
   wxString& Append(wxUniChar ch, size_t count = 1u)


@@ -1952,36 +2120,34 @@ public:
   // stream-like functions
       // insert an int into string
   wxString& operator<<(int i)
   // stream-like functions
       // insert an int into string
   wxString& operator<<(int i)

-    { return (*this) << Format(_T("%d"), i); }
+    { return (*this) << Format(wxT("%d"), i); }

       // insert an unsigned int into string
   wxString& operator<<(unsigned int ui)
       // insert an unsigned int into string
   wxString& operator<<(unsigned int ui)

-    { return (*this) << Format(_T("%u"), ui); }
+    { return (*this) << Format(wxT("%u"), ui); }

       // insert a long into string
   wxString& operator<<(long l)
       // insert a long into string
   wxString& operator<<(long l)

-    { return (*this) << Format(_T("%ld"), l); }
+    { return (*this) << Format(wxT("%ld"), l); }

       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)

-    { return (*this) << Format(_T("%lu"), ul); }
-#if defined wxLongLong_t && !defined wxLongLongIsLong
+    { return (*this) << Format(wxT("%lu"), ul); }
+#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG

       // insert a long long if they exist and aren't longs
   wxString& operator<<(wxLongLong_t ll)
     {
       // insert a long long if they exist and aren't longs
   wxString& operator<<(wxLongLong_t ll)
     {

-      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
-      return (*this) << Format(fmt, ll);
+      return (*this) << Format("%" wxLongLongFmtSpec "d", ll);

     }
       // insert an unsigned long long
   wxString& operator<<(wxULongLong_t ull)
     {
     }
       // insert an unsigned long long
   wxString& operator<<(wxULongLong_t ull)
     {

-      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
-      return (*this) << Format(fmt , ull);
+      return (*this) << Format("%" wxLongLongFmtSpec "u" , ull);

     }
     }

-#endif // wxLongLong_t && !wxLongLongIsLong
+#endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG

       // insert a float into string
   wxString& operator<<(float f)
       // insert a float into string
   wxString& operator<<(float f)

-    { return (*this) << Format(_T("%f"), f); }
+    { return (*this) << Format(wxT("%f"), f); }

       // insert a double into string
   wxString& operator<<(double d)
       // insert a double into string
   wxString& operator<<(double d)

-    { return (*this) << Format(_T("%g"), d); }
+    { return (*this) << Format(wxT("%g"), d); }

 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)


@@ -1993,9 +2159,9 @@ public:
     { return compare(s); }
   int Cmp(const wxCStrData& s) const
     { return compare(s); }
     { return compare(s); }
   int Cmp(const wxCStrData& s) const
     { return compare(s); }

-  int Cmp(const wxCharBuffer& s) const
+  int Cmp(const wxScopedCharBuffer& s) const

     { return compare(s); }
     { return compare(s); }

-  int Cmp(const wxWCharBuffer& s) const
+  int Cmp(const wxScopedWCharBuffer& s) const

     { return compare(s); }
     // same as Cmp() but not case-sensitive
   int CmpNoCase(const wxString& s) const;
     { return compare(s); }
     // same as Cmp() but not case-sensitive
   int CmpNoCase(const wxString& s) const;


@@ -2018,9 +2184,9 @@ public:
 
   bool IsSameAs(const wxCStrData& str, bool compareWithCase = true) const
     { return IsSameAs(str.AsString(), compareWithCase); }
 
   bool IsSameAs(const wxCStrData& str, bool compareWithCase = true) const
     { return IsSameAs(str.AsString(), compareWithCase); }

-  bool IsSameAs(const wxCharBuffer& str, bool compareWithCase = true) const
+  bool IsSameAs(const wxScopedCharBuffer& str, bool compareWithCase = true) const

     { return IsSameAs(str.data(), compareWithCase); }
     { return IsSameAs(str.data(), compareWithCase); }

-  bool IsSameAs(const wxWCharBuffer& str, bool compareWithCase = true) const
+  bool IsSameAs(const wxScopedWCharBuffer& str, bool compareWithCase = true) const

     { return IsSameAs(str.data(), compareWithCase); }
     // comparison with a single character: returns true if equal
   bool IsSameAs(wxUniChar c, bool compareWithCase = true) const;
     { return IsSameAs(str.data(), compareWithCase); }
     // comparison with a single character: returns true if equal
   bool IsSameAs(wxUniChar c, bool compareWithCase = true) const;


@@ -2058,16 +2224,18 @@ public:
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;
   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
-      // (returns the whole string if ch not found)
-  wxString BeforeFirst(wxUniChar ch) const;
-      // get all characters before the last occurence 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 before the first occurrence of ch
+      // (returns the whole string if ch not found) and also put everything
+      // following the first occurrence of ch into rest if it's non-NULL
+  wxString BeforeFirst(wxUniChar ch, wxString *rest = NULL) const;
+      // get all characters before the last occurrence of ch
+      // (returns empty string if ch not found) and also put everything
+      // following the last occurrence of ch into rest if it's non-NULL
+  wxString BeforeLast(wxUniChar ch, wxString *rest = NULL) const;
+      // get all characters after the first occurrence of ch

       // (returns empty string if ch not found)
   wxString AfterFirst(wxUniChar ch) const;
       // (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;
 
       // (returns the whole string if ch not found)
   wxString AfterLast(wxUniChar ch) const;
 


@@ -2127,12 +2295,12 @@ public:
 
   int Find(const wxCStrData& sub) const
     { return Find(sub.AsString()); }
 
   int Find(const wxCStrData& sub) const
     { return Find(sub.AsString()); }

-  int Find(const wxCharBuffer& sub) const
+  int Find(const wxScopedCharBuffer& sub) const

     { return Find(sub.data()); }
     { return Find(sub.data()); }

-  int Find(const wxWCharBuffer& sub) const
+  int Find(const wxScopedWCharBuffer& sub) const

     { return Find(sub.data()); }
 
     { 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,
       // another string, returns the number of replacements made
   size_t Replace(const wxString& strOld,
                  const wxString& strNew,


@@ -2141,24 +2309,38 @@ public:
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxString& mask) const;
 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxString& mask) const;
 

-    // conversion to numbers: all functions return true only if the whole
-    // string is a number and put the value of this number into the pointer
-    // provided, the base is the numeric base in which the conversion should be
-    // done and must be comprised between 2 and 36 or be 0 in which case the
-    // standard C rules apply (leading '0' => octal, "0x" => hex)
-        // convert to a signed integer
-    bool ToLong(long *val, int base = 10) const;
-        // convert to an unsigned integer
-    bool ToULong(unsigned long *val, int base = 10) const;
-        // convert to wxLongLong
+  // conversion to numbers: all functions return true only if the whole
+  // string is a number and put the value of this number into the pointer
+  // provided, the base is the numeric base in which the conversion should be
+  // done and must be comprised between 2 and 36 or be 0 in which case the
+  // standard C rules apply (leading '0' => octal, "0x" => hex)
+      // convert to a signed integer
+  bool ToLong(long *val, int base = 10) const;
+      // convert to an unsigned integer
+  bool ToULong(unsigned long *val, int base = 10) const;
+      // convert to wxLongLong

 #if defined(wxLongLong_t)
 #if defined(wxLongLong_t)

-    bool ToLongLong(wxLongLong_t *val, int base = 10) const;
-        // convert to wxULongLong
-    bool ToULongLong(wxULongLong_t *val, int base = 10) const;
+  bool ToLongLong(wxLongLong_t *val, int base = 10) const;
+      // convert to wxULongLong
+  bool ToULongLong(wxULongLong_t *val, int base = 10) const;

 #endif // wxLongLong_t
 #endif // wxLongLong_t

-        // convert to a double
-    bool ToDouble(double *val) const;
-
+      // convert to a double
+  bool ToDouble(double *val) const;
+
+  // conversions to numbers using C locale
+      // convert to a signed integer
+  bool ToCLong(long *val, int base = 10) const;
+      // convert to an unsigned integer
+  bool ToCULong(unsigned long *val, int base = 10) const;
+      // convert to a double
+  bool ToCDouble(double *val) const;
+
+  // create a string representing the given floating point number with the
+  // default (like %g) or fixed (if precision >=0) precision
+    // in the current locale
+  static wxString FromDouble(double val, int precision = -1);
+    // in C locale
+  static wxString FromCDouble(double val, int precision = -1);

 
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output
 
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output


@@ -2184,7 +2366,7 @@ public:
 
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // returns the string containing the result of Printf() to it
 
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // returns the string containing the result of Printf() to it

-  // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1;
+  // static wxString Format(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_1;

   WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxFormatString&),
                         DoFormatWchar, DoFormatUtf8)
 #ifdef __WATCOMC__
   WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxFormatString&),
                         DoFormatWchar, DoFormatUtf8)
 #ifdef __WATCOMC__


@@ -2233,7 +2415,7 @@ public:
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // use Printf()
   // (take 'this' into account in attribute parameter count)
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // use Printf()
   // (take 'this' into account in attribute parameter count)

-  // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
+  // int sprintf(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_2;

   WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
                         DoPrintfWchar, DoPrintfUtf8)
 #ifdef __WATCOMC__
   WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
                         DoPrintfWchar, DoPrintfUtf8)
 #ifdef __WATCOMC__


@@ -2314,7 +2496,7 @@ public:
                CreateConstIterator(last).impl())
   {
       wxASSERT_MSG( first.m_str == last.m_str,
                CreateConstIterator(last).impl())
   {
       wxASSERT_MSG( first.m_str == last.m_str,

-                    _T("pointers must be into the same string") );
+                    wxT("pointers must be into the same string") );

   }
 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
 
   }
 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
 


@@ -2374,15 +2556,15 @@ public:
 
   wxString& append(const wxCStrData& str)
     { return append(str.AsString()); }
 
   wxString& append(const wxCStrData& str)
     { return append(str.AsString()); }

-  wxString& append(const wxCharBuffer& str)
-    { return append(str.data()); }
-  wxString& append(const wxWCharBuffer& str)
-    { return append(str.data()); }
+  wxString& append(const wxScopedCharBuffer& str)
+    { return append(str.data(), str.length()); }
+  wxString& append(const wxScopedWCharBuffer& str)
+    { return append(str.data(), str.length()); }

   wxString& append(const wxCStrData& str, size_t n)
     { return append(str.AsString(), 0, n); }
   wxString& append(const wxCStrData& str, size_t n)
     { return append(str.AsString(), 0, n); }

-  wxString& append(const wxCharBuffer& str, size_t n)
+  wxString& append(const wxScopedCharBuffer& str, size_t n)

     { return append(str.data(), n); }
     { return append(str.data(), n); }

-  wxString& append(const wxWCharBuffer& str, size_t n)
+  wxString& append(const wxScopedWCharBuffer& str, size_t n)

     { return append(str.data(), n); }
 
     // append n copies of ch
     { return append(str.data(), n); }
 
     // append n copies of ch


@@ -2442,9 +2624,21 @@ public:
       return *this;
   }
 
       return *this;
   }
 

+    // This is a non-standard-compliant overload taking the first "len"
+    // characters of the source string.

   wxString& assign(const wxString& str, size_t len)
   {
   wxString& assign(const wxString& str, size_t len)
   {

+#if wxUSE_STRING_POS_CACHE
+      // It is legal to pass len > str.length() to wxStringImpl::assign() but
+      // by restricting it here we save some work for that function so it's not
+      // really less efficient and, at the same time, ensure that we don't
+      // cache invalid length.
+      const size_t lenSrc = str.length();
+      if ( len > lenSrc )
+          len = lenSrc;
+

       wxSTRING_SET_CACHED_LENGTH(len);
       wxSTRING_SET_CACHED_LENGTH(len);

+#endif // wxUSE_STRING_POS_CACHE

 
       m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
 
 
       m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
 


@@ -2486,7 +2680,7 @@ public:
 
   wxString& assign(const char *sz, size_t n)
   {
 
   wxString& assign(const char *sz, size_t n)
   {

-      wxSTRING_SET_CACHED_LENGTH(n);
+      wxSTRING_INVALIDATE_CACHE();

 
       SubstrBufFromMB str(ImplStr(sz, n));
       m_impl.assign(str.data, str.len);
 
       SubstrBufFromMB str(ImplStr(sz, n));
       m_impl.assign(str.data, str.len);


@@ -2506,15 +2700,15 @@ public:
 
   wxString& assign(const wxCStrData& str)
     { return assign(str.AsString()); }
 
   wxString& assign(const wxCStrData& str)
     { return assign(str.AsString()); }

-  wxString& assign(const wxCharBuffer& str)
-    { return assign(str.data()); }
-  wxString& assign(const wxWCharBuffer& str)
-    { return assign(str.data()); }
+  wxString& assign(const wxScopedCharBuffer& str)
+    { return assign(str.data(), str.length()); }
+  wxString& assign(const wxScopedWCharBuffer& str)
+    { return assign(str.data(), str.length()); }

   wxString& assign(const wxCStrData& str, size_t len)
     { return assign(str.AsString(), len); }
   wxString& assign(const wxCStrData& str, size_t len)
     { return assign(str.AsString(), len); }

-  wxString& assign(const wxCharBuffer& str, size_t len)
+  wxString& assign(const wxScopedCharBuffer& str, size_t len)

     { return assign(str.data(), len); }
     { return assign(str.data(), len); }

-  wxString& assign(const wxWCharBuffer& str, size_t len)
+  wxString& assign(const wxScopedWCharBuffer& str, size_t len)

     { return assign(str.data(), len); }
 
     // same as `= n copies of ch'
     { return assign(str.data(), len); }
 
     // same as `= n copies of ch'


@@ -2565,9 +2759,9 @@ public:
   int compare(const wchar_t* sz) const;
   int compare(const wxCStrData& str) const
     { return compare(str.AsString()); }
   int compare(const wchar_t* sz) const;
   int compare(const wxCStrData& str) const
     { return compare(str.AsString()); }

-  int compare(const wxCharBuffer& str) const
+  int compare(const wxScopedCharBuffer& str) const

     { return compare(str.data()); }
     { return compare(str.data()); }

-  int compare(const wxWCharBuffer& str) const
+  int compare(const wxScopedWCharBuffer& str) const

     { return compare(str.data()); }
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxString& str) const;
     { return compare(str.data()); }
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxString& str) const;


@@ -2948,14 +3142,14 @@ public:
       SubstrBufFromWC str(ImplStr(sz, n));
       return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len));
   }
       SubstrBufFromWC str(ImplStr(sz, n));
       return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len));
   }

-  size_t find(const wxCharBuffer& s, size_t nStart = 0, size_t n = npos) const
+  size_t find(const wxScopedCharBuffer& s, size_t nStart = 0, size_t n = npos) const

     { return find(s.data(), nStart, n); }
     { return find(s.data(), nStart, n); }

-  size_t find(const wxWCharBuffer& s, size_t nStart = 0, size_t n = npos) const
+  size_t find(const wxScopedWCharBuffer& s, size_t nStart = 0, size_t n = npos) const

     { return find(s.data(), nStart, n); }
   size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const
     { return find(s.AsWChar(), nStart, n); }
 
     { return find(s.data(), nStart, n); }
   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
   size_t find(wxUniChar ch, size_t nStart = 0) const
   {
 #if wxUSE_UNICODE_UTF8


@@ -2994,9 +3188,9 @@ public:
       SubstrBufFromWC str(ImplStr(sz, n));
       return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len));
   }
       SubstrBufFromWC str(ImplStr(sz, n));
       return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len));
   }

-  size_t rfind(const wxCharBuffer& s, size_t nStart = npos, size_t n = npos) const
+  size_t rfind(const wxScopedCharBuffer& s, size_t nStart = npos, size_t n = npos) const

     { return rfind(s.data(), nStart, n); }
     { return rfind(s.data(), nStart, n); }

-  size_t rfind(const wxWCharBuffer& s, size_t nStart = npos, size_t n = npos) const
+  size_t rfind(const wxScopedWCharBuffer& s, size_t nStart = npos, size_t n = npos) const

     { return rfind(s.data(), nStart, n); }
   size_t rfind(const wxCStrData& s, size_t nStart = npos, size_t n = npos) const
     { return rfind(s.AsWChar(), nStart, n); }
     { return rfind(s.data(), nStart, n); }
   size_t rfind(const wxCStrData& s, size_t nStart = npos, size_t n = npos) const
     { return rfind(s.AsWChar(), nStart, n); }


@@ -3021,7 +3215,7 @@ public:
   size_t rfind(wchar_t ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }
 
   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;
 #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;


@@ -3112,7 +3306,7 @@ public:
   size_t find_last_of(wxUniChar c, size_t nStart = npos) const
     { return rfind(c, nStart); }
 
   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
 
     // as strspn() (starting from nStart), returns npos on failure
   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const


@@ -3182,54 +3376,54 @@ public:
   // and additional overloads for the versions taking strings:
   size_t find_first_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_first_of(sz.AsString(), nStart); }
   // and additional overloads for the versions taking strings:
   size_t find_first_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_first_of(sz.AsString(), nStart); }

-  size_t find_first_of(const wxCharBuffer& sz, size_t nStart = 0) const
+  size_t find_first_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const

     { return find_first_of(sz.data(), nStart); }
     { return find_first_of(sz.data(), nStart); }

-  size_t find_first_of(const wxWCharBuffer& sz, size_t nStart = 0) const
+  size_t find_first_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const

     { return find_first_of(sz.data(), nStart); }
   size_t find_first_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_first_of(sz.AsWChar(), nStart, n); }
     { return find_first_of(sz.data(), nStart); }
   size_t find_first_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_first_of(sz.AsWChar(), nStart, n); }

-  size_t find_first_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_first_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const

     { return find_first_of(sz.data(), nStart, n); }
     { return find_first_of(sz.data(), nStart, n); }

-  size_t find_first_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_first_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const

     { return find_first_of(sz.data(), nStart, n); }
 
   size_t find_last_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_last_of(sz.AsString(), nStart); }
     { return find_first_of(sz.data(), nStart, n); }
 
   size_t find_last_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_last_of(sz.AsString(), nStart); }

-  size_t find_last_of(const wxCharBuffer& sz, size_t nStart = 0) const
+  size_t find_last_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const

     { return find_last_of(sz.data(), nStart); }
     { return find_last_of(sz.data(), nStart); }

-  size_t find_last_of(const wxWCharBuffer& sz, size_t nStart = 0) const
+  size_t find_last_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const

     { return find_last_of(sz.data(), nStart); }
   size_t find_last_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_last_of(sz.AsWChar(), nStart, n); }
     { return find_last_of(sz.data(), nStart); }
   size_t find_last_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_last_of(sz.AsWChar(), nStart, n); }

-  size_t find_last_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_last_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const

     { return find_last_of(sz.data(), nStart, n); }
     { return find_last_of(sz.data(), nStart, n); }

-  size_t find_last_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_last_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const

     { return find_last_of(sz.data(), nStart, n); }
 
   size_t find_first_not_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_first_not_of(sz.AsString(), nStart); }
     { return find_last_of(sz.data(), nStart, n); }
 
   size_t find_first_not_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_first_not_of(sz.AsString(), nStart); }

-  size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart = 0) const
+  size_t find_first_not_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const

     { return find_first_not_of(sz.data(), nStart); }
     { return find_first_not_of(sz.data(), nStart); }

-  size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const
+  size_t find_first_not_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const

     { return find_first_not_of(sz.data(), nStart); }
   size_t find_first_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_first_not_of(sz.AsWChar(), nStart, n); }
     { return find_first_not_of(sz.data(), nStart); }
   size_t find_first_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_first_not_of(sz.AsWChar(), nStart, n); }

-  size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_first_not_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const

     { return find_first_not_of(sz.data(), nStart, n); }
     { return find_first_not_of(sz.data(), nStart, n); }

-  size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_first_not_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const

     { return find_first_not_of(sz.data(), nStart, n); }
 
   size_t find_last_not_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_last_not_of(sz.AsString(), nStart); }
     { return find_first_not_of(sz.data(), nStart, n); }
 
   size_t find_last_not_of(const wxCStrData& sz, size_t nStart = 0) const
     { return find_last_not_of(sz.AsString(), nStart); }

-  size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart = 0) const
+  size_t find_last_not_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const

     { return find_last_not_of(sz.data(), nStart); }
     { return find_last_not_of(sz.data(), nStart); }

-  size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const
+  size_t find_last_not_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const

     { return find_last_not_of(sz.data(), nStart); }
   size_t find_last_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_last_not_of(sz.AsWChar(), nStart, n); }
     { return find_last_not_of(sz.data(), nStart); }
   size_t find_last_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
     { return find_last_not_of(sz.AsWChar(), nStart, n); }

-  size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_last_not_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const

     { return find_last_not_of(sz.data(), nStart, n); }
     { return find_last_not_of(sz.data(), nStart, n); }

-  size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
+  size_t find_last_not_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const

     { return find_last_not_of(sz.data(), nStart, n); }
 
       // string += string
     { return find_last_not_of(sz.data(), nStart, n); }
 
       // string += string


@@ -3262,10 +3456,10 @@ public:
       m_impl += s.AsString().m_impl;
       return *this;
   }
       m_impl += s.AsString().m_impl;
       return *this;
   }

-  wxString& operator+=(const wxCharBuffer& s)
-    { return operator+=(s.data()); }
-  wxString& operator+=(const wxWCharBuffer& s)
-    { return operator+=(s.data()); }
+  wxString& operator+=(const wxScopedCharBuffer& s)
+    { return append(s); }
+  wxString& operator+=(const wxScopedWCharBuffer& s)
+    { return append(s); }

       // string += char
   wxString& operator+=(wxUniChar ch)
   {
       // string += char
   wxString& operator+=(wxUniChar ch)
   {


@@ -3302,7 +3496,7 @@ private:
 
   void DoUngetWriteBuf(size_t nLen)
   {
 
   void DoUngetWriteBuf(size_t nLen)
   {

-      wxSTRING_SET_CACHED_LENGTH(nLen);
+      wxSTRING_INVALIDATE_CACHE();

 
       m_impl.DoUngetWriteBuf(nLen);
   }
 
       m_impl.DoUngetWriteBuf(nLen);
   }


@@ -3328,36 +3522,117 @@ private:
   wxStringImpl m_impl;
 
   // buffers for compatibility conversion from (char*)c_str() and
   wxStringImpl m_impl;
 
   // buffers for compatibility conversion from (char*)c_str() and

-  // (wchar_t*)c_str():
-  // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
+  // (wchar_t*)c_str(): the pointers returned by these functions should remain
+  // valid until the string itself is modified for compatibility with the
+  // existing code and consistency with std::string::c_str() so returning a
+  // temporary buffer won't do and we need to cache the conversion results
+
+  // TODO-UTF8: benchmark various approaches to keeping compatibility buffers

   template<typename T>
   struct ConvertedBuffer
   {
   template<typename T>
   struct ConvertedBuffer
   {

-      ConvertedBuffer() : m_buf(NULL) {}
+      // notice that there is no need to initialize m_len here as it's unused
+      // as long as m_str is NULL
+      ConvertedBuffer() : m_str(NULL) {}

       ~ConvertedBuffer()
       ~ConvertedBuffer()

-          { free(m_buf); }
+          { free(m_str); }

 
 

-      operator T*() const { return m_buf; }
+      bool Extend(size_t len)
+      {
+          // add extra 1 for the trailing NUL
+          void * const str = realloc(m_str, sizeof(T)*(len + 1));
+          if ( !str )
+              return false;

 
 

-      ConvertedBuffer& operator=(T *str)
+          m_str = static_cast<T *>(str);
+          m_len = len;
+
+          return true;
+      }
+
+      const wxScopedCharTypeBuffer<T> AsScopedBuffer() const

       {
       {

-          free(m_buf);
-          m_buf = str;
-          return *this;
+          return wxScopedCharTypeBuffer<T>::CreateNonOwned(m_str, m_len);

       }
 
       }
 

-      T *m_buf;
+      T *m_str;     // pointer to the string data
+      size_t m_len; // length, not size, i.e. in chars and without last NUL

   };
   };

-#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
+
+
+#if wxUSE_UNICODE
+  // common mb_str() and wxCStrData::AsChar() helper: performs the conversion
+  // and returns either m_convertedToChar.m_str (in which case its m_len is
+  // also updated) or NULL if it failed
+  //
+  // there is an important exception: in wxUSE_UNICODE_UTF8 build if conv is a
+  // UTF-8 one, we return m_impl.c_str() directly, without doing any conversion
+  // as optimization and so the caller needs to check for this before using
+  // m_convertedToChar
+  //
+  // NB: AsChar() returns char* in any build, unlike mb_str()
+  const char *AsChar(const wxMBConv& conv) const;
+
+  // mb_str() implementation helper
+  wxScopedCharBuffer AsCharBuf(const wxMBConv& conv) const
+  {
+#if wxUSE_UNICODE_UTF8
+      // avoid conversion if we can
+      if ( conv.IsUTF8() )
+      {
+          return wxScopedCharBuffer::CreateNonOwned(m_impl.c_str(),
+                  m_impl.length());
+      }
+#endif // wxUSE_UNICODE_UTF8
+
+      // call this solely in order to fill in m_convertedToChar as AsChar()
+      // updates it as a side effect: this is a bit ugly but it's a completely
+      // internal function so the users of this class shouldn't care or know
+      // about it and doing it like this, i.e. having a separate AsChar(),
+      // allows us to avoid the creation and destruction of a temporary buffer
+      // when using wxCStrData without duplicating any code
+      if ( !AsChar(conv) )
+      {
+          // although it would be probably more correct to return NULL buffer
+          // from here if the conversion fails, a lot of existing code doesn't
+          // expect mb_str() (or wc_str()) to ever return NULL so return an
+          // empty string otherwise to avoid crashes in it
+          //
+          // also, some existing code does check for the conversion success and
+          // so asserting here would be bad too -- even if it does mean that
+          // silently losing data is possible for badly written code
+          return wxScopedCharBuffer::CreateNonOwned("", 0);
+      }
+
+      return m_convertedToChar.AsScopedBuffer();
+  }
+

   ConvertedBuffer<char> m_convertedToChar;
   ConvertedBuffer<char> m_convertedToChar;

-#endif
+#endif // !wxUSE_UNICODE
+

 #if !wxUSE_UNICODE_WCHAR
 #if !wxUSE_UNICODE_WCHAR

+  // common wc_str() and wxCStrData::AsWChar() helper for both UTF-8 and ANSI
+  // builds: converts the string contents into m_convertedToWChar and returns
+  // NULL if the conversion failed (this can only happen in ANSI build)
+  //
+  // NB: AsWChar() returns wchar_t* in any build, unlike wc_str()
+  const wchar_t *AsWChar(const wxMBConv& conv) const;
+
+  // wc_str() implementation helper
+  wxScopedWCharBuffer AsWCharBuf(const wxMBConv& conv) const
+  {
+      if ( !AsWChar(conv) )
+          return wxScopedWCharBuffer::CreateNonOwned(L"", 0);
+
+      return m_convertedToWChar.AsScopedBuffer();
+  }
+

   ConvertedBuffer<wchar_t> m_convertedToWChar;
   ConvertedBuffer<wchar_t> m_convertedToWChar;

-#endif
+#endif // !wxUSE_UNICODE_WCHAR

 
 #if wxUSE_UNICODE_UTF8
   // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently
 
 #if wxUSE_UNICODE_UTF8
   // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently

-  //             assigning to character pointer to by wxString::interator may
+  //             assigning to character pointer to by wxString::iterator may

   //             change the underlying wxStringImpl iterator, so we have to
   //             keep track of all iterators and update them as necessary:
   struct wxStringIteratorNodeHead
   //             change the underlying wxStringImpl iterator, so we have to
   //             keep track of all iterators and update them as necessary:
   struct wxStringIteratorNodeHead


@@ -3367,7 +3642,7 @@ private:
 
       // copying is disallowed as it would result in more than one pointer into
       // the same linked list
 
       // copying is disallowed as it would result in more than one pointer into
       // the same linked list

-      DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead)
+      wxDECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead);

   };
 
   wxStringIteratorNodeHead m_iterators;
   };
 
   wxStringIteratorNodeHead m_iterators;


@@ -3382,7 +3657,7 @@ private:
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN

-    #pragma warning (default:4275)
+    #pragma warning (pop)

 #endif
 
 // string iterator operators that satisfy STL Random Access Iterator
 #endif
 
 // string iterator operators that satisfy STL Random Access Iterator


@@ -3437,9 +3712,9 @@ namespace wxPrivate
 template <>
 struct wxStringAsBufHelper<char>
 {
 template <>
 struct wxStringAsBufHelper<char>
 {

-    static wxCharBuffer Get(const wxString& s, size_t *len)
+    static wxScopedCharBuffer Get(const wxString& s, size_t *len)

     {
     {

-        wxCharBuffer buf(s.mb_str());
+        wxScopedCharBuffer buf(s.mb_str());

         if ( len )
             *len = buf ? strlen(buf) : 0;
         return buf;
         if ( len )
             *len = buf ? strlen(buf) : 0;
         return buf;


@@ -3449,11 +3724,12 @@ struct wxStringAsBufHelper<char>
 template <>
 struct wxStringAsBufHelper<wchar_t>
 {
 template <>
 struct wxStringAsBufHelper<wchar_t>
 {

-    static wxWCharBuffer Get(const wxString& s, size_t *len)
+    static wxScopedWCharBuffer Get(const wxString& s, size_t *len)

     {
     {

+        const size_t length = s.length();

         if ( len )
         if ( len )

-            *len = s.length();
-        return wxWCharBuffer::CreateNonOwned(s.wx_str());
+            *len = length;
+        return wxScopedWCharBuffer::CreateNonOwned(s.wx_str(), length);

     }
 };
 
     }
 };
 


@@ -3462,20 +3738,21 @@ struct wxStringAsBufHelper<wchar_t>
 template <>
 struct wxStringAsBufHelper<char>
 {
 template <>
 struct wxStringAsBufHelper<char>
 {

-    static wxCharBuffer Get(const wxString& s, size_t *len)
+    static wxScopedCharBuffer Get(const wxString& s, size_t *len)

     {
     {

+        const size_t length = s.utf8_length();

         if ( len )
         if ( len )

-            *len = s.utf8_length();
-        return wxCharBuffer::CreateNonOwned(s.wx_str());
+            *len = length;
+        return wxScopedCharBuffer::CreateNonOwned(s.wx_str(), length);

     }
 };
 
 template <>
 struct wxStringAsBufHelper<wchar_t>
 {
     }
 };
 
 template <>
 struct wxStringAsBufHelper<wchar_t>
 {

-    static wxWCharBuffer Get(const wxString& s, size_t *len)
+    static wxScopedWCharBuffer Get(const wxString& s, size_t *len)

     {
     {

-        wxWCharBuffer wbuf(s.wc_str());
+        wxScopedWCharBuffer wbuf(s.wc_str());

         if ( len )
             *len = wxWcslen(wbuf);
         return wbuf;
         if ( len )
             *len = wxWcslen(wbuf);
         return wbuf;


@@ -3510,7 +3787,7 @@ private:
     wxString&         m_str;
     wxStringCharType *m_buf;
 
     wxString&         m_str;
     wxStringCharType *m_buf;
 

-    DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+    wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);

 };
 
 class wxStringInternalBufferLength
 };
 
 class wxStringInternalBufferLength


@@ -3540,13 +3817,13 @@ private:
     size_t            m_len;
     bool              m_lenSet;
 
     size_t            m_len;
     bool              m_lenSet;
 

-    DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+    wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);

 };
 
 #endif // !wxUSE_STL_BASED_WXSTRING
 
 template<typename T>
 };
 
 #endif // !wxUSE_STL_BASED_WXSTRING
 
 template<typename T>

-class WXDLLIMPEXP_BASE wxStringTypeBufferBase
+class wxStringTypeBufferBase

 {
 public:
     typedef T CharType;
 {
 public:
     typedef T CharType;


@@ -3586,8 +3863,7 @@ protected:
 };
 
 template<typename T>
 };
 
 template<typename T>

-class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
-    : public wxStringTypeBufferBase<T>
+class wxStringTypeBufferLengthBase : public wxStringTypeBufferBase<T>

 {
 public:
     wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)
 {
 public:
     wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)


@@ -3621,7 +3897,7 @@ public:
         this->m_str.assign(this->m_buf.data());
     }
 
         this->m_str.assign(this->m_buf.data());
     }
 

-    DECLARE_NO_COPY_CLASS(wxStringTypeBuffer)
+    wxDECLARE_NO_COPY_CLASS(wxStringTypeBuffer);

 };
 
 template<typename T>
 };
 
 template<typename T>


@@ -3637,7 +3913,7 @@ public:
         this->m_str.assign(this->m_buf.data(), this->m_len);
     }
 
         this->m_str.assign(this->m_buf.data(), this->m_len);
     }
 

-    DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength)
+    wxDECLARE_NO_COPY_CLASS(wxStringTypeBufferLength);

 };
 
 #if wxUSE_STL_BASED_WXSTRING
 };
 
 #if wxUSE_STL_BASED_WXSTRING


@@ -3652,7 +3928,7 @@ public:
     ~wxStringInternalBuffer()
         { m_str.m_impl.assign(m_buf.data()); }
 
     ~wxStringInternalBuffer()
         { m_str.m_impl.assign(m_buf.data()); }
 

-    DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+    wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);

 };
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
 };
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(


@@ -3670,7 +3946,7 @@ public:
         m_str.m_impl.assign(m_buf.data(), m_len);
     }
 
         m_str.m_impl.assign(m_buf.data(), m_len);
     }
 

-    DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+    wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);

 };
 
 #endif // wxUSE_STL_BASED_WXSTRING
 };
 
 #endif // wxUSE_STL_BASED_WXSTRING


@@ -3691,27 +3967,59 @@ typedef wxStringInternalBufferLength          wxUTF8StringBufferLength;
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<char> )
 
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<char> )
 

-class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase<char>
+// Note about inlined dtors in the classes below: this is done not for
+// performance reasons but just to avoid linking errors in the MSVC DLL build
+// under Windows: if a class has non-inline methods it must be declared as
+// being DLL-exported but, due to an extremely interesting feature of MSVC 7
+// and later, any template class which is used as a base of a DLL-exported
+// class is implicitly made DLL-exported too, as explained at the bottom of
+// http://msdn.microsoft.com/en-us/library/twa2aw10.aspx (just to confirm: yes,
+// _inheriting_ from a class can change whether it is being exported from DLL)
+//
+// But this results in link errors because the base template class is not DLL-
+// exported, whether it is declared with WXDLLIMPEXP_BASE or not, because it
+// does have only inline functions. So the simplest fix is to just make all the
+// functions of these classes inline too.
+
+class wxUTF8StringBuffer : public wxStringTypeBufferBase<char>

 {
 public:
     wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024)
         : wxStringTypeBufferBase<char>(str, lenWanted) {}
 {
 public:
     wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024)
         : wxStringTypeBufferBase<char>(str, lenWanted) {}

-    ~wxUTF8StringBuffer();
+    ~wxUTF8StringBuffer()
+    {
+        wxMBConvStrictUTF8 conv;
+        size_t wlen = conv.ToWChar(NULL, 0, m_buf);
+        wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );

 
 

-    DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
+        wxStringInternalBuffer wbuf(m_str, wlen);
+        conv.ToWChar(wbuf, wlen, m_buf);
+    }
+
+    wxDECLARE_NO_COPY_CLASS(wxUTF8StringBuffer);

 };
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
 
 };
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
 

-class WXDLLIMPEXP_BASE wxUTF8StringBufferLength
-    : public wxStringTypeBufferLengthBase<char>
+class wxUTF8StringBufferLength : public wxStringTypeBufferLengthBase<char>

 {
 public:
     wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024)
         : wxStringTypeBufferLengthBase<char>(str, lenWanted) {}
 {
 public:
     wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024)
         : wxStringTypeBufferLengthBase<char>(str, lenWanted) {}

-    ~wxUTF8StringBufferLength();
+    ~wxUTF8StringBufferLength()
+    {
+        wxCHECK_RET(m_lenSet, "length not set");

 
 

-    DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
+        wxMBConvStrictUTF8 conv;
+        size_t wlen = conv.ToWChar(NULL, 0, m_buf, m_len);
+        wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );
+
+        wxStringInternalBufferLength wbuf(m_str, wlen);
+        conv.ToWChar(wbuf, wlen, m_buf, m_len);
+        wbuf.SetLength(wlen);
+    }
+
+    wxDECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength);

 };
 #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
 
 };
 #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
 


@@ -3748,32 +4056,32 @@ inline bool operator!=(const wxString& s1, const wxCStrData& s2)
 inline bool operator!=(const wxCStrData& s1, const wxString& s2)
     { return s1.AsString() != s2; }
 
 inline bool operator!=(const wxCStrData& s1, const wxString& s2)
     { return s1.AsString() != s2; }
 

-inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
+inline bool operator==(const wxString& s1, const wxScopedWCharBuffer& s2)

     { return (s1.Cmp((const wchar_t *)s2) == 0); }
     { return (s1.Cmp((const wchar_t *)s2) == 0); }

-inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
+inline bool operator==(const wxScopedWCharBuffer& s1, const wxString& s2)

     { return (s2.Cmp((const wchar_t *)s1) == 0); }
     { return (s2.Cmp((const wchar_t *)s1) == 0); }

-inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
+inline bool operator!=(const wxString& s1, const wxScopedWCharBuffer& s2)

     { return (s1.Cmp((const wchar_t *)s2) != 0); }
     { return (s1.Cmp((const wchar_t *)s2) != 0); }

-inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
+inline bool operator!=(const wxScopedWCharBuffer& s1, const wxString& s2)

     { return (s2.Cmp((const wchar_t *)s1) != 0); }
 
     { return (s2.Cmp((const wchar_t *)s1) != 0); }
 

-inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
+inline bool operator==(const wxString& s1, const wxScopedCharBuffer& s2)

     { return (s1.Cmp((const char *)s2) == 0); }
     { return (s1.Cmp((const char *)s2) == 0); }

-inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
+inline bool operator==(const wxScopedCharBuffer& s1, const wxString& s2)

     { return (s2.Cmp((const char *)s1) == 0); }
     { return (s2.Cmp((const char *)s1) == 0); }

-inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
+inline bool operator!=(const wxString& s1, const wxScopedCharBuffer& s2)

     { return (s1.Cmp((const char *)s2) != 0); }
     { return (s1.Cmp((const char *)s2) != 0); }

-inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
+inline bool operator!=(const wxScopedCharBuffer& s1, const wxString& s2)

     { return (s2.Cmp((const char *)s1) != 0); }
 
     { return (s2.Cmp((const char *)s1) != 0); }
 

-inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
+inline wxString operator+(const wxString& string, const wxScopedWCharBuffer& buf)

     { return string + (const wchar_t *)buf; }
     { return string + (const wchar_t *)buf; }

-inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
+inline wxString operator+(const wxScopedWCharBuffer& buf, const wxString& string)

     { return (const wchar_t *)buf + string; }
 
     { return (const wchar_t *)buf + string; }
 

-inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
+inline wxString operator+(const wxString& string, const wxScopedCharBuffer& buf)

     { return string + (const char *)buf; }
     { return string + (const char *)buf; }

-inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
+inline wxString operator+(const wxScopedCharBuffer& buf, const wxString& string)

     { return (const char *)buf + string; }
 
 // comparison with char
     { return (const char *)buf + string; }
 
 // comparison with char


@@ -3796,6 +4104,21 @@ inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsS
 inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
 
 inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
 

+
+// wxString iterators comparisons
+inline bool wxString::iterator::operator==(const const_iterator& i) const
+    { return i == *this; }
+inline bool wxString::iterator::operator!=(const const_iterator& i) const
+    { return i != *this; }
+inline bool wxString::iterator::operator<(const const_iterator& i) const
+    { return i > *this; }
+inline bool wxString::iterator::operator>(const const_iterator& i) const
+    { return i < *this; }
+inline bool wxString::iterator::operator<=(const const_iterator& i) const
+    { return i >= *this; }
+inline bool wxString::iterator::operator>=(const const_iterator& i) const
+    { return i <= *this; }
+

 // comparison with C string in Unicode build
 #if wxUSE_UNICODE
 
 // comparison with C string in Unicode build
 #if wxUSE_UNICODE
 


@@ -3831,16 +4154,16 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA)
 
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);
 
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);

-WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&);
+WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxScopedCharBuffer&);

 #ifndef __BORLANDC__
 #ifndef __BORLANDC__

-WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&);
+WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxScopedWCharBuffer&);

 #endif
 
 #if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 
 WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&);
 #endif
 
 #if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 
 WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&);

-WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxWCharBuffer&);
+WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxScopedWCharBuffer&);

 
 #endif  // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 
 
 #endif  // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 


@@ -3865,48 +4188,56 @@ inline wxCStrData::wxCStrData(const wxCStrData& data)
 inline wxCStrData::~wxCStrData()
 {
     if ( m_owned )
 inline wxCStrData::~wxCStrData()
 {
     if ( m_owned )

-        delete wx_const_cast(wxString*, m_str); // cast to silence warnings
+        delete const_cast<wxString*>(m_str); // cast to silence warnings

 }
 
 }
 

-// simple cases for AsChar() and AsWChar(), the complicated ones are
-// in string.cpp
-#if wxUSE_UNICODE_WCHAR
+// AsChar() and AsWChar() implementations simply forward to wxString methods
+

 inline const wchar_t* wxCStrData::AsWChar() const
 {
 inline const wchar_t* wxCStrData::AsWChar() const
 {

-    return m_str->wx_str() + m_offset;
-}
-#endif // wxUSE_UNICODE_WCHAR
+    const wchar_t * const p =
+#if wxUSE_UNICODE_WCHAR
+        m_str->wc_str();
+#elif wxUSE_UNICODE_UTF8
+        m_str->AsWChar(wxMBConvStrictUTF8());
+#else
+        m_str->AsWChar(wxConvLibc);
+#endif

 
 

+    // in Unicode build the string always has a valid Unicode representation
+    // and even if a conversion is needed (as in UTF8 case) it can't fail
+    //
+    // but in ANSI build the string contents might be not convertible to
+    // Unicode using the current locale encoding so we do need to check for
+    // errors

 #if !wxUSE_UNICODE
 #if !wxUSE_UNICODE

-inline const char* wxCStrData::AsChar() const
-{
-    return m_str->wx_str() + m_offset;
-}
+    if ( !p )
+    {
+        // if conversion fails, 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
+        // from its c_str() and so we shouldn't neither
+        //
+        // notice that the same is done in AsChar() below and
+        // wxString::wc_str() and mb_str() for the same reasons
+        return L"";
+    }

 #endif // !wxUSE_UNICODE
 
 #endif // !wxUSE_UNICODE
 

-#if wxUSE_UTF8_LOCALE_ONLY
-inline const char* wxCStrData::AsChar() const
-{
-    return wxStringOperations::AddToIter(m_str->wx_str(), m_offset);
-}
-#endif // wxUSE_UTF8_LOCALE_ONLY
-
-inline const wxCharBuffer wxCStrData::AsCharBuf() const
-{
-#if !wxUSE_UNICODE
-    return wxCharBuffer::CreateNonOwned(AsChar());
-#else
-    return AsString().mb_str();
-#endif
+    return p + m_offset;

 }
 
 }
 

-inline const wxWCharBuffer wxCStrData::AsWCharBuf() const
+inline const char* wxCStrData::AsChar() const

 {
 {

-#if wxUSE_UNICODE_WCHAR
-    return wxWCharBuffer::CreateNonOwned(AsWChar());
-#else
-    return AsString().wc_str();
-#endif
+#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
+    const char * const p = m_str->AsChar(wxConvLibc);
+    if ( !p )
+        return "";
+#else // !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
+    const char * const p = m_str->mb_str();
+#endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
+
+    return p + m_offset;

 }
 
 inline wxString wxCStrData::AsString() const
 }
 
 inline wxString wxCStrData::AsString() const


@@ -3929,7 +4260,7 @@ inline const wxStringCharType *wxCStrData::AsInternal() const
 inline wxUniChar wxCStrData::operator*() const
 {
     if ( m_str->empty() )
 inline wxUniChar wxCStrData::operator*() const
 {
     if ( m_str->empty() )

-        return wxUniChar(_T('\0'));
+        return wxUniChar(wxT('\0'));

     else
         return (*m_str)[m_offset];
 }
     else
         return (*m_str)[m_offset];
 }


@@ -3988,7 +4319,7 @@ void wxStringIteratorNode::DoSet(const wxString *str,
     if ( str )
     {
         m_next = str->m_iterators.ptr;
     if ( str )
     {
         m_next = str->m_iterators.ptr;

-        wx_const_cast(wxString*, m_str)->m_iterators.ptr = this;
+        const_cast<wxString*>(m_str)->m_iterators.ptr = this;

         if ( m_next )
             m_next->m_prev = this;
     }
         if ( m_next )
             m_next->m_prev = this;
     }


@@ -4005,7 +4336,7 @@ void wxStringIteratorNode::clear()
     if ( m_prev )
         m_prev->m_next = m_next;
     else if ( m_str ) // first in the list
     if ( m_prev )
         m_prev->m_next = m_next;
     else if ( m_str ) // first in the list

-        wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next;
+        const_cast<wxString*>(m_str)->m_iterators.ptr = m_next;

 
     m_next = m_prev = NULL;
     m_citer = NULL;
 
     m_next = m_prev = NULL;
     m_citer = NULL;


@@ -4022,4 +4353,19 @@ void wxStringIteratorNode::clear()
     #include "wx/crt.h"
 #endif
 
     #include "wx/crt.h"
 #endif
 

+// ----------------------------------------------------------------------------
+// Checks on wxString characters
+// ----------------------------------------------------------------------------
+
+template<bool (T)(const wxUniChar& c)>
+    inline bool wxStringCheck(const wxString& val)
+    {
+        for ( wxString::const_iterator i = val.begin();
+              i != val.end();
+              ++i )
+            if (T(*i) == 0)
+                return false;
+        return true;
+    }
+

 #endif  // _WX_WXSTRING_H_
 #endif  // _WX_WXSTRING_H_