split wxCharTypeBuffer<T> into wxScopedCharTypeBuffer<T> and wxCharTypeBuffer<T>...

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 3f9214b00b3cc5abf7722772a1e7e92b43370f79..ebd2f0f774e71561ccf5be68c27edc82c9538aa0 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


@@ -243,8 +245,9 @@ 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
+    inline const wxScopedCharBuffer AsCharBuf() const;
+    inline const wxScopedWCharBuffer AsWCharBuf() const;

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


@@ -260,9 +263,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 +290,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 +361,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 +383,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 +437,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 +487,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 +523,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 +536,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 +561,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,27 +607,41 @@ 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
+#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

   //
   //

-  // also note that for the same reason this function _is_ MT-safe: we know
-  // it's going to be called during the program startup (currently during
-  // globals initialization but even if they ever stop using wxString, it would
-  // still be called by wxInitialize()), i.e. before any threads are created
-  static Cache& GetCache()
+  // 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);
   }
 

+  // 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; }
 
   static Cache::Element *GetCacheBegin() { return GetCache().cached; }
   static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; }
   static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; }
 

+  // this is used in debug builds only to provide a convenient function,
+  // callable from a debugger, to show the cache contents

   friend struct wxStrCacheDumper;
 
   // uncomment this to have access to some profiling statistics on program
   friend struct wxStrCacheDumper;
 
   // uncomment this to have access to some profiling statistics on program


@@ -635,7 +662,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)


@@ -657,7 +684,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;


@@ -719,7 +754,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;


@@ -841,19 +878,19 @@ public:
   #else
     #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
   #endif
   #else
     #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
   #endif

-  #define WX_STR_ITERATOR_CATEGORY typedef WX_STR_ITERATOR_TAG iterator_category;
+  #define WX_DEFINE_ITERATOR_CATEGORY(cat) typedef cat iterator_category;

 #else
   // not defining iterator_category at all in this case is better than defining
   // it as some dummy type -- at least it results in more intelligible error
   // messages
 #else
   // not defining iterator_category at all in this case is better than defining
   // it as some dummy type -- at least it results in more intelligible error
   // messages

-  #define WX_STR_ITERATOR_CATEGORY
+  #define WX_DEFINE_ITERATOR_CATEGORY(cat)

 #endif
 
   #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
       private:                                                              \
           typedef wxStringImpl::iterator_name underlying_iterator;          \
       public:                                                               \
 #endif
 
   #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
       private:                                                              \
           typedef wxStringImpl::iterator_name underlying_iterator;          \
       public:                                                               \

-          WX_STR_ITERATOR_CATEGORY                                          \
+          WX_DEFINE_ITERATOR_CATEGORY(WX_STR_ITERATOR_TAG)                  \

           typedef wxUniChar value_type;                                     \
           typedef int difference_type;                                      \
           typedef reference_type reference;                                 \
           typedef wxUniChar value_type;                                     \
           typedef int difference_type;                                      \
           typedef reference_type reference;                                 \


@@ -963,7 +1000,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;
 


@@ -1088,7 +1125,7 @@ public:
   public:
       typedef T iterator_type;
 
   public:
       typedef T iterator_type;
 

-      typedef typename T::iterator_category iterator_category;
+      WX_DEFINE_ITERATOR_CATEGORY(typename T::iterator_category)

       typedef typename T::value_type value_type;
       typedef typename T::difference_type difference_type;
       typedef typename T::reference reference;
       typedef typename T::value_type value_type;
       typedef typename T::difference_type difference_type;
       typedef typename T::reference reference;


@@ -1239,9 +1276,9 @@ 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)
+  wxString(const wxScopedCharBuffer& buf)

     { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
     { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length

-  wxString(const wxWCharBuffer& buf)
+  wxString(const wxScopedWCharBuffer& buf)

     { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
 
     // NB: this version uses m_impl.c_str() to force making a copy of the
     { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
 
     // NB: this version uses m_impl.c_str() to force making a copy of the


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


@@ -1507,11 +1539,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


@@ -1577,7 +1651,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)


@@ -1648,31 +1722,37 @@ 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()); }
+    const wxScopedCharBuffer ToUTF8() const { return utf8_str(); }

 #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(); }
+    const wxScopedCharBuffer ToUTF8() const { return utf8_str(); }

 #endif
 
     // functions for storing binary data in wxString:
 #endif
 
     // functions for storing binary data in wxString:


@@ -1682,7 +1762,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); }


@@ -1705,9 +1786,9 @@ public:
 
 #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;
+    const wxScopedCharBuffer mb_str(const wxMBConv& conv) const;

 #else
 #else

-    const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;
+    const wxScopedCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;

 #endif
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 #endif
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }


@@ -1715,14 +1796,14 @@ public:
 #if wxUSE_UNICODE_WCHAR
     const wchar_t* wc_str() const { return wx_str(); }
 #elif wxUSE_UNICODE_UTF8
 #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;

 #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 // !wxMBFILES
     const wxWX2WCbuf fn_str() const { return wc_str(); }
 #endif // wxMBFILES/!wxMBFILES


@@ -1736,18 +1817,19 @@ public:
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 #if wxUSE_WCHAR_T
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 #if wxUSE_WCHAR_T

-    const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const;
+    const wxScopedWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const;

 #endif // wxUSE_WCHAR_T
 #endif // wxUSE_WCHAR_T

-    const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
+    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


@@ -1837,11 +1919,11 @@ 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)
+    // from wxScopedWCharBuffer
+  wxString& operator=(const wxScopedWCharBuffer& s)

     { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
     { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs

-    // from wxCharBuffer
-  wxString& operator=(const wxCharBuffer& s)
+    // from wxScopedCharBuffer
+  wxString& operator=(const wxScopedCharBuffer& s)

     { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
 
   // string concatenation
     { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
 
   // string concatenation


@@ -1877,9 +1959,9 @@ 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)
+  wxString& operator<<(const wxScopedWCharBuffer& s)

     { return operator<<((const wchar_t *)s); }
     { return operator<<((const wchar_t *)s); }

-  wxString& operator<<(const wxCharBuffer& s)
+  wxString& operator<<(const wxScopedCharBuffer& s)

     { return operator<<((const char *)s); }
 
     // string += C string
     { return operator<<((const char *)s); }
 
     // string += C string


@@ -1898,9 +1980,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; }


@@ -1908,9 +1990,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)


@@ -1991,9 +2073,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;


@@ -2016,9 +2098,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;


@@ -2056,16 +2138,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;
 


@@ -2125,12 +2207,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,


@@ -2139,25 +2221,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


@@ -2182,7 +2273,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__


@@ -2231,7 +2322,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__


@@ -2372,15 +2463,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)
+  wxString& append(const wxScopedCharBuffer& str)

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

-  wxString& append(const wxWCharBuffer& str)
+  wxString& append(const wxScopedWCharBuffer& str)

     { return append(str.data()); }
   wxString& append(const wxCStrData& str, size_t n)
     { return append(str.AsString(), 0, n); }
     { return append(str.data()); }
   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


@@ -2504,15 +2595,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)
+  wxString& assign(const wxScopedCharBuffer& str)

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

-  wxString& assign(const wxWCharBuffer& str)
+  wxString& assign(const wxScopedWCharBuffer& str)

     { return assign(str.data()); }
   wxString& assign(const wxCStrData& str, size_t len)
     { return assign(str.AsString(), len); }
     { return assign(str.data()); }
   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'


@@ -2563,9 +2654,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;


@@ -2946,14 +3037,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


@@ -2992,9 +3083,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); }


@@ -3019,7 +3110,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;


@@ -3110,7 +3201,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


@@ -3180,54 +3271,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


@@ -3260,9 +3351,9 @@ public:
       m_impl += s.AsString().m_impl;
       return *this;
   }
       m_impl += s.AsString().m_impl;
       return *this;
   }

-  wxString& operator+=(const wxCharBuffer& s)
+  wxString& operator+=(const wxScopedCharBuffer& s)

     { return operator+=(s.data()); }
     { return operator+=(s.data()); }

-  wxString& operator+=(const wxWCharBuffer& s)
+  wxString& operator+=(const wxScopedWCharBuffer& s)

     { return operator+=(s.data()); }
       // string += char
   wxString& operator+=(wxUniChar ch)
     { return operator+=(s.data()); }
       // string += char
   wxString& operator+=(wxUniChar ch)


@@ -3365,7 +3456,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;


@@ -3435,9 +3526,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;


@@ -3447,11 +3538,11 @@ 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)

     {
         if ( len )
             *len = s.length();
     {
         if ( len )
             *len = s.length();

-        return wxWCharBuffer::CreateNonOwned(s.wx_str());
+        return wxScopedWCharBuffer::CreateNonOwned(s.wx_str());

     }
 };
 
     }
 };
 


@@ -3460,20 +3551,20 @@ 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)

     {
         if ( len )
             *len = s.utf8_length();
     {
         if ( len )
             *len = s.utf8_length();

-        return wxCharBuffer::CreateNonOwned(s.wx_str());
+        return wxScopedCharBuffer::CreateNonOwned(s.wx_str());

     }
 };
 
 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;


@@ -3508,7 +3599,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


@@ -3538,13 +3629,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;


@@ -3584,8 +3675,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)


@@ -3619,7 +3709,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>


@@ -3635,7 +3725,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


@@ -3650,7 +3740,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(


@@ -3668,7 +3758,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


@@ -3689,27 +3779,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");
+
+        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?" );

 
 

-    DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
+        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
 


@@ -3746,32 +3868,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


@@ -3829,16 +3951,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)
 


@@ -3863,7 +3985,7 @@ 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
 }
 
 // simple cases for AsChar() and AsWChar(), the complicated ones are


@@ -3889,19 +4011,19 @@ inline const char* wxCStrData::AsChar() const
 }
 #endif // wxUSE_UTF8_LOCALE_ONLY
 
 }
 #endif // wxUSE_UTF8_LOCALE_ONLY
 

-inline const wxCharBuffer wxCStrData::AsCharBuf() const
+inline const wxScopedCharBuffer wxCStrData::AsCharBuf() const

 {
 #if !wxUSE_UNICODE
 {
 #if !wxUSE_UNICODE

-    return wxCharBuffer::CreateNonOwned(AsChar());
+    return wxScopedCharBuffer::CreateNonOwned(AsChar());

 #else
     return AsString().mb_str();
 #endif
 }
 
 #else
     return AsString().mb_str();
 #endif
 }
 

-inline const wxWCharBuffer wxCStrData::AsWCharBuf() const
+inline const wxScopedWCharBuffer wxCStrData::AsWCharBuf() const

 {
 #if wxUSE_UNICODE_WCHAR
 {
 #if wxUSE_UNICODE_WCHAR

-    return wxWCharBuffer::CreateNonOwned(AsWChar());
+    return wxScopedWCharBuffer::CreateNonOwned(AsWChar());

 #else
     return AsString().wc_str();
 #endif
 #else
     return AsString().wc_str();
 #endif


@@ -3986,7 +4108,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;
     }


@@ -4003,7 +4125,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;


@@ -4020,4 +4142,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_