no changes, just remove #if'd out code

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

diff --git a/include/wx/string.h b/include/wx/string.h
index d8aebef9acfe025b306cb7bae211038a07bb244f..65e29e10ec36b561562ce74a2e96e1133cf05f48 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -69,7 +69,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(__WXMSW__) && !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


@@ -207,7 +209,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


@@ -243,8 +245,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 +270,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


@@ -285,8 +297,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 +368,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 +390,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)
 


@@ -424,7 +444,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 +494,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 +530,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 +543,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 +568,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 +614,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 +669,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 +691,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 +761,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;


@@ -965,7 +1007,7 @@ public:
       iterator(wxString *str, underlying_iterator ptr)
           : m_cur(ptr), m_node(str, &m_cur) {}
 
       iterator(wxString *str, underlying_iterator ptr)
           : m_cur(ptr), m_node(str, &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;
 


@@ -1241,10 +1283,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


@@ -1306,8 +1348,10 @@ public:
   #else
     // wxStringImpl is either not std::string or needs conversion
     operator wxStdWideString() const
   #else
     // wxStringImpl is either not std::string or needs conversion
     operator wxStdWideString() const

-        // FIXME-UTF8: broken for embedded NULs
-        { return wxStdWideString(wc_str()); }
+    {
+        wxScopedWCharBuffer buf(wc_str());
+        return wxStdWideString(buf.data(), buf.length());
+    }

   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING


@@ -1316,8 +1360,10 @@ public:
   #else
     // wxStringImpl is either not std::string or needs conversion
     operator std::string() const
   #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()); }
+    {
+        wxScopedCharBuffer buf(mb_str());
+        return std::string(buf.data(), buf.length());
+    }

   #endif
 #endif // wxUSE_STL
 
   #endif
 #endif // wxUSE_STL
 


@@ -1436,12 +1482,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(); }
 


@@ -1509,11 +1550,53 @@ 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


@@ -1565,7 +1648,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 +1662,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 +1717,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 +1733,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,7 +1773,8 @@ 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); }
 #else // ANSI
     static wxString From8BitData(const char *data, size_t len)
       { return wxString(data, len); }


@@ -1703,53 +1793,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 +1943,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


@@ -1879,10 +1983,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 +2004,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 +2014,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)


@@ -1993,9 +2097,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 +2122,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 +2162,16 @@ 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
+      // get all characters before the first occurrence of ch

       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxUniChar ch) const;
       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxUniChar ch) const;

-      // get all characters before the last occurence of ch
+      // get all characters before the last occurrence of ch

       // (returns empty string if ch not found)
   wxString BeforeLast(wxUniChar ch) const;
       // (returns empty string if ch not found)
   wxString BeforeLast(wxUniChar ch) const;

-      // get all characters after the first occurence of ch
+      // get all characters after the first occurrence of ch

       // (returns empty string if ch not found)
   wxString AfterFirst(wxUniChar ch) const;
       // (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 +2231,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,25 +2245,34 @@ 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;
+
+#if wxUSE_XLOCALE
+  // 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;
+#endif
+  

 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output
     // as sprintf(), returns the number of characters written or < 0 on error
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output
     // as sprintf(), returns the number of characters written or < 0 on error


@@ -2184,7 +2297,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 +2346,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__


@@ -2374,15 +2487,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


@@ -2506,15 +2619,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 +2678,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 +3061,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 +3107,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 +3134,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 +3225,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 +3295,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 +3375,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)
   {


@@ -3328,36 +3441,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); }
+
+      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;

 
 

-      operator T*() const { return m_buf; }
+          m_str = static_cast<T *>(str);
+          m_len = len;

 
 

-      ConvertedBuffer& operator=(T *str)
+          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 +3561,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;


@@ -3437,9 +3631,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 +3643,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 +3657,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 +3706,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 +3736,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 +3782,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 +3816,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 +3832,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 +3847,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 +3865,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 +3886,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?" );
+
+        wxStringInternalBuffer wbuf(m_str, wlen);
+        conv.ToWChar(wbuf, wlen, m_buf);
+    }

 
 

-    DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
+    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 +3975,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


@@ -3831,16 +4058,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 +4092,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


@@ -3988,7 +4223,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 +4240,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 +4257,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_