applying patch 1411230

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 618b51f855c226a5f32190708c0e94a9a1723af6..6cf19b5022d671cff06cd31e1fc885309af21541 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        string.h
+// Name:        wx/string.h

 // Purpose:     wxString and wxArrayString classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     wxString and wxArrayString classes
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -11,17 +11,13 @@
 
 /*
     Efficient string class [more or less] compatible with MFC CString,
 
 /*
     Efficient string class [more or less] compatible with MFC CString,

-    wxWindows version 1 wxString and std::string and some handy functions
+    wxWidgets version 1 wxString and std::string and some handy functions

     missing from string.h.
 */
 
 #ifndef _WX_WXSTRINGH__
 #define _WX_WXSTRINGH__
 
     missing from string.h.
 */
 
 #ifndef _WX_WXSTRINGH__
 #define _WX_WXSTRINGH__
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma interface "string.h"
-#endif
-

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------


@@ -32,10 +28,6 @@
     #include <ctype.h>
 #endif
 
     #include <ctype.h>
 #endif
 

-#ifdef __EMX__
-    #include <std.h>
-#endif
-

 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
    // problem in VACPP V4 with including stdlib.h multiple times
    // strconv includes it anyway
 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
    // problem in VACPP V4 with including stdlib.h multiple times
    // strconv includes it anyway


@@ -51,14 +43,20 @@
 #  include <stdlib.h>
 #endif
 
 #  include <stdlib.h>
 #endif
 

-#ifdef HAVE_STRINGS_H
+#ifdef HAVE_STRCASECMP_IN_STRINGS_H

     #include <strings.h>    // for strcasecmp()
     #include <strings.h>    // for strcasecmp()

-#endif // HAVE_STRINGS_H
+#endif // HAVE_STRCASECMP_IN_STRINGS_H
+
+#ifdef __WXPALMOS__
+    #include <StringMgr.h>
+#endif

 
 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 
 
 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 

+class WXDLLIMPEXP_BASE wxString;
+

 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------


@@ -78,16 +76,8 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

-#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
-// must define this static for VA or else you get multiply defined symbols everywhere
-extern const unsigned int wxSTRING_MAXLEN;
-
-#else

 // maximum possible length for a string means "take all string" everywhere
 // maximum possible length for a string means "take all string" everywhere

-//  (as sizeof(StringData) is unknown here, we substract 100)
-const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
-
-#endif
+#define wxSTRING_MAXLEN wxStringBase::npos

 
 // ----------------------------------------------------------------------------
 // global data
 
 // ----------------------------------------------------------------------------
 // global data


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

-#elif defined(__UNIX__) || defined(__GNUWIN32__)
+#elif defined(__WXPALMOS__) || \
+      defined(HAVE_STRCASECMP_IN_STRING_H) || \
+      defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
+      defined(__GNUWIN32__)

   return strcasecmp(psz1, psz2);
 #elif defined(__MWERKS__) && !defined(__INTEL__)
   register char c1, c2;
   return strcasecmp(psz1, psz2);
 #elif defined(__MWERKS__) && !defined(__INTEL__)
   register char c1, c2;


@@ -166,34 +159,46 @@ inline int Stricmp(const char *psz1, const char *psz2)
 #endif  // OS/compiler
 }
 
 #endif  // OS/compiler
 }
 

-// return an empty wxString
-class WXDLLIMPEXP_BASE wxString; // not yet defined
-inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
+// ----------------------------------------------------------------------------
+// deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING
+// ----------------------------------------------------------------------------

 
 

-#if wxUSE_STL
+// in both cases we need to define wxStdString
+#if wxUSE_STL || wxUSE_STD_STRING

 
 #include "wx/beforestd.h"
 #include <string>
 #include "wx/afterstd.h"
 
 #if wxUSE_UNICODE
 
 #include "wx/beforestd.h"
 #include <string>
 #include "wx/afterstd.h"
 
 #if wxUSE_UNICODE

-    #if HAVE_STD_WSTRING
-        typedef std::wstring wxStringBase;
+    #ifdef HAVE_STD_WSTRING
+        typedef std::wstring wxStdString;

     #else
     #else

-        typedef std::basic_string<wxChar> wxStringBase;
+        typedef std::basic_string<wxChar> wxStdString;

     #endif
 #else
     #endif
 #else

-    typedef std::string wxStringBase;
+    typedef std::string wxStdString;

 #endif
 
 #endif
 

-#if (defined(__GNUG__) && (__GNUG__ < 3)) || \
-    (defined(_MSC_VER) && (_MSC_VER <= 1100))
-    #define wxSTRING_BASE_HASNT_CLEAR
-#endif
+#endif // need <string>
+
+#if wxUSE_STL
+
+    // we don't need an extra ctor from std::string when copy ctor already does
+    // the work
+    #undef wxUSE_STD_STRING
+    #define wxUSE_STD_STRING 0

 
 

+    #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
+        (defined(_MSC_VER) && (_MSC_VER <= 1200))
+        #define wxSTRING_BASE_HASNT_CLEAR
+    #endif
+
+    typedef wxStdString wxStringBase;

 #else // if !wxUSE_STL
 
 #else // if !wxUSE_STL
 

-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE) && \
+    (!defined(__WX_SETUP_H__) || wxUSE_STL == 0)

     #define HAVE_STD_STRING_COMPARE
 #endif
 
     #define HAVE_STD_STRING_COMPARE
 #endif
 


@@ -257,7 +262,7 @@ protected:
     // initializes the string to the empty value (must be called only from
     // ctors, use Reinit() otherwise)
   void Init() { m_pchData = (wxChar *)wxEmptyString; }
     // initializes the string to the empty value (must be called only from
     // ctors, use Reinit() otherwise)
   void Init() { m_pchData = (wxChar *)wxEmptyString; }

-    // initializaes the string with (a part of) C-string
+    // initializes the string with (a part of) C-string

   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
     // as Init, but also frees old data
   void Reinit() { GetStringData()->Unlock(); Init(); }
   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
     // as Init, but also frees old data
   void Reinit() { GetStringData()->Unlock(); Init(); }


@@ -320,7 +325,9 @@ public:
       { InitWith(psz, 0, npos); }
   wxStringBase(const wxChar *psz, size_t nLength)
       { InitWith(psz, 0, nLength); }
       { InitWith(psz, 0, npos); }
   wxStringBase(const wxChar *psz, size_t nLength)
       { InitWith(psz, 0, nLength); }

-  wxStringBase(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+  wxStringBase(const wxChar *psz,
+               const wxMBConv& WXUNUSED(conv),
+               size_t nLength = npos)

       { InitWith(psz, 0, nLength); }
     // take nLen chars starting at nPos
   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)
       { InitWith(psz, 0, nLength); }
     // take nLen chars starting at nPos
   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)


@@ -335,8 +342,21 @@ public:
   wxStringBase(const void *pStart, const void *pEnd);
 
     // dtor is not virtual, this class must not be inherited from!
   wxStringBase(const void *pStart, const void *pEnd);
 
     // dtor is not virtual, this class must not be inherited from!

-  ~wxStringBase() { GetStringData()->Unlock(); }
+  ~wxStringBase()
+  {
+#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
+      //RN - according to the above VC++ does indeed inline this,
+      //even though it spits out two warnings
+      #pragma warning (disable:4714)
+#endif
+
+      GetStringData()->Unlock();
+  }

 
 

+#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
+    //re-enable inlining warning
+    #pragma warning (default:4714)
+#endif

   // overloaded assignment
     // from another wxString
   wxStringBase& operator=(const wxStringBase& stringSrc);
   // overloaded assignment
     // from another wxString
   wxStringBase& operator=(const wxStringBase& stringSrc);


@@ -346,9 +366,9 @@ public:
   wxStringBase& operator=(const wxChar *psz);
 
     // return the length of the string
   wxStringBase& operator=(const wxChar *psz);
 
     // return the length of the string

-  size_type size() const { return GetStringData()->nDataLength; }
+  size_type length() const { return GetStringData()->nDataLength; }

     // return the length of the string
     // return the length of the string

-  size_type length() const { return size(); }
+  size_type size() const { return length(); }

     // return the maximum size of the string
   size_type max_size() const { return wxSTRING_MAXLEN; }
     // resize the string, filling the space with c if c != 0
     // return the maximum size of the string
   size_type max_size() const { return wxSTRING_MAXLEN; }
     // resize the string, filling the space with c if c != 0


@@ -356,7 +376,7 @@ public:
     // delete the contents of the string
   void clear() { erase(0, npos); }
     // returns true if the string is empty
     // delete the contents of the string
   void clear() { erase(0, npos); }
     // returns true if the string is empty

-  bool empty() const { return size() == 0; }
+  bool empty() const { return length() == 0; }

     // inform string about planned change in size
   void reserve(size_t sz) { Alloc(sz); }
   size_type capacity() const { return GetStringData()->nAllocLength; }
     // inform string about planned change in size
   void reserve(size_t sz) { Alloc(sz); }
   size_type capacity() const { return GetStringData()->nAllocLength; }


@@ -365,12 +385,9 @@ public:
     // return the character at position n
   value_type at(size_type n) const
     { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
     // return the character at position n
   value_type at(size_type n) const
     { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

-  value_type operator[](size_type n) const { return at(n); }

     // returns the writable character at position n
   reference at(size_type n)
     { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
     // returns the writable character at position n
   reference at(size_type n)
     { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

-  reference operator[](size_type n)
-    { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

 
   // lib.string.modifiers
     // append elements str[pos], ..., str[pos+n]
 
   // lib.string.modifiers
     // append elements str[pos], ..., str[pos+n]


@@ -418,9 +435,9 @@ public:
   const_iterator end() const { return m_pchData + length(); }
 
   // first valid index position
   const_iterator end() const { return m_pchData + length(); }
 
   // first valid index position

-  iterator begin() { CopyBeforeWrite(); return m_pchData; }
+  iterator begin();

   // position one after the last valid one
   // position one after the last valid one

-  iterator end() { CopyBeforeWrite(); return m_pchData + length(); }
+  iterator end();

 
     // insert another string
   wxStringBase& insert(size_t nPos, const wxStringBase& str)
 
     // insert another string
   wxStringBase& insert(size_t nPos, const wxStringBase& str)


@@ -443,7 +460,7 @@ public:
   wxStringBase& insert(size_t nPos, size_t n, wxChar ch)
     { return insert(nPos, wxStringBase(n, ch)); }
   iterator insert(iterator it, wxChar ch)
   wxStringBase& insert(size_t nPos, size_t n, wxChar ch)
     { return insert(nPos, wxStringBase(n, ch)); }
   iterator insert(iterator it, wxChar ch)

-    { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; } 
+    { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; }

   void insert(iterator it, const_iterator first, const_iterator last)
     { insert(it - begin(), first, last - first); }
   void insert(iterator it, size_type n, wxChar ch)
   void insert(iterator it, const_iterator first, const_iterator last)
     { insert(it - begin(), first, last - first); }
   void insert(iterator it, size_type n, wxChar ch)


@@ -499,11 +516,8 @@ public:
     // find a substring
   size_t find(const wxStringBase& str, size_t nStart = 0) const;
 
     // find a substring
   size_t find(const wxStringBase& str, size_t nStart = 0) const;
 

-  // VC++ 1.5 can't cope with this syntax.
-#if !defined(__VISUALC__) || defined(__WIN32__)

     // find first n characters of sz
   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
     // find first n characters of sz
   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;

-#endif // VC++ 1.5

 
     // find the first occurence of character ch after nStart
   size_t find(wxChar ch, size_t nStart = 0) const;
 
     // find the first occurence of character ch after nStart
   size_t find(wxChar ch, size_t nStart = 0) const;


@@ -513,7 +527,6 @@ public:
     // as find, but from the end
   size_t rfind(const wxStringBase& str, size_t nStart = npos) const;
 
     // as find, but from the end
   size_t rfind(const wxStringBase& str, size_t nStart = npos) const;
 

-  // VC++ 1.5 can't cope with this syntax.

     // as find, but from the end
   size_t rfind(const wxChar* sz, size_t nStart = npos,
                size_t n = npos) const;
     // as find, but from the end
   size_t rfind(const wxChar* sz, size_t nStart = npos,
                size_t n = npos) const;


@@ -527,6 +540,7 @@ public:
     { return find_first_of(str.c_str(), nStart); }
     // same as above
   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
     { return find_first_of(str.c_str(), nStart); }
     // same as above
   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;

+  size_t find_first_of(const wxChar* sz, size_t nStart, size_t n) const;

     // same as find(char, size_t)
   size_t find_first_of(wxChar c, size_t nStart = 0) const
     { return find(c, nStart); }
     // same as find(char, size_t)
   size_t find_first_of(wxChar c, size_t nStart = 0) const
     { return find(c, nStart); }


@@ -535,6 +549,7 @@ public:
     { return find_last_of(str.c_str(), nStart); }
     // same as above
   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
     { return find_last_of(str.c_str(), nStart); }
     // same as above
   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;

+  size_t find_last_of(const wxChar* sz, size_t nStart, size_t n) const;

     // same as above
   size_t find_last_of(wxChar c, size_t nStart = npos) const
     { return rfind(c, nStart); }
     // same as above
   size_t find_last_of(wxChar c, size_t nStart = npos) const
     { return rfind(c, nStart); }


@@ -546,30 +561,30 @@ public:
     { return find_first_not_of(str.c_str(), nStart); }
     // same as above
   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
     { return find_first_not_of(str.c_str(), nStart); }
     // same as above
   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;

+  size_t find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const;

     // same as above
   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
     //  as strcspn()
   size_t find_last_not_of(const wxStringBase& str, size_t nStart = npos) const
     // same as above
   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
     //  as strcspn()
   size_t find_last_not_of(const wxStringBase& str, size_t nStart = npos) const

-    { return find_first_not_of(str.c_str(), nStart); }
+    { return find_last_not_of(str.c_str(), nStart); }

     // same as above
   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
     // same as above
   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;

+  size_t find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const;

     // same as above
   size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
 
     // All compare functions return -1, 0 or 1 if the [sub]string is less,
     // equal or greater than the compare() argument.
 
     // same as above
   size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
 
     // All compare functions return -1, 0 or 1 if the [sub]string is less,
     // equal or greater than the compare() argument.
 

-    // just like strcmp()
-  int compare(const wxStringBase& str) const
-    { return wxStrcmp(c_str(), str.c_str()); }
+    // comparison with another string
+  int compare(const wxStringBase& str) const;

     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
     // comparison of 2 substrings
   int compare(size_t nStart, size_t nLen,
               const wxStringBase& str, size_t nStart2, size_t nLen2) const;
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
     // comparison of 2 substrings
   int compare(size_t nStart, size_t nLen,
               const wxStringBase& str, size_t nStart2, size_t nLen2) const;

-    // just like strcmp()
-  int compare(const wxChar* sz) const
-    { return wxStrcmp(c_str(), sz); }
+    // comparison with a c string
+  int compare(const wxChar* sz) const;

     // substring comparison with first nCount characters of sz
   int compare(size_t nStart, size_t nLen,
               const wxChar* sz, size_t nCount = npos) const;
     // substring comparison with first nCount characters of sz
   int compare(size_t nStart, size_t nLen,
               const wxChar* sz, size_t nCount = npos) const;


@@ -589,27 +604,9 @@ public:
 
 #endif // !wxUSE_STL
 
 
 #endif // !wxUSE_STL
 

-// ---------------------------------------------------------------------------
-// This is (yet another one) String class for C++ programmers. It doesn't use
-// any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
-// thus you should be able to compile it with practicaly any C++ compiler.
-// This class uses copy-on-write technique, i.e. identical strings share the
-// same memory as long as neither of them is changed.
-//
-// This class aims to be as compatible as possible with the new standard
-// std::string class, but adds some additional functions and should be at
-// least as efficient than the standard implementation.
-//
-// Performance note: it's more efficient to write functions which take "const
-// String&" arguments than "const char *" if you assign the argument to
-// another string.
-//
-// It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
-//
-// To do:
-//  - ressource support (string tables in ressources)
-//  - more wide character (UNICODE) support
-//  - regular expressions support
+// ----------------------------------------------------------------------------
+// wxString: string class trying to be compatible with std::string, MFC
+//           CString and wxWindows 1.x wxString all at once

 // ---------------------------------------------------------------------------
 
 class WXDLLIMPEXP_BASE wxString : public wxStringBase
 // ---------------------------------------------------------------------------
 
 class WXDLLIMPEXP_BASE wxString : public wxStringBase


@@ -620,7 +617,7 @@ friend class WXDLLIMPEXP_BASE wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all
 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all

-  //     performace critical functions are still inlined if you change order!
+  //     performance critical functions are still inlined if you change order!

 private:
   // if we hadn't made these operators private, it would be possible to
   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
 private:
   // if we hadn't made these operators private, it would be possible to
   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly


@@ -655,29 +652,45 @@ public:
       : wxStringBase(psz ? psz : wxT("")) { }
   wxString(const wxChar *psz, size_t nLength)
       : wxStringBase(psz, nLength) { }
       : wxStringBase(psz ? psz : wxT("")) { }
   wxString(const wxChar *psz, size_t nLength)
       : wxStringBase(psz, nLength) { }

-  wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+  wxString(const wxChar *psz,
+           const wxMBConv& WXUNUSED(conv),
+           size_t nLength = npos)

       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 
       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 

+  // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
+  // implicit conversions from std::string to wxString as this allows to use
+  // the same strings in non-GUI and GUI code, however we don't want to
+  // unconditionally add this ctor as it would make wx lib dependent on
+  // libstdc++ on some Linux versions which is bad, so instead we ask the
+  // client code to define this wxUSE_STD_STRING symbol if they need it
+#if wxUSE_STD_STRING
+  wxString(const wxStdString& s)
+      : wxStringBase(s.c_str()) { }
+#endif // wxUSE_STD_STRING
+

 #if wxUSE_UNICODE
     // from multibyte string
 #if wxUSE_UNICODE
     // from multibyte string

-    // (NB: nLength is right now number of Unicode characters, not
-    //  characters in psz! So try not to use it yet!)
-  wxString(const char *psz, wxMBConv& conv, size_t nLength = npos);
+  wxString(const char *psz, const wxMBConv& conv, size_t nLength = npos);

     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 #else // ANSI
     // from C string (for compilers using unsigned char)
     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 #else // ANSI
     // from C string (for compilers using unsigned char)

-  wxString(const unsigned char* psz, size_t nLength = npos)
+  wxString(const unsigned char* psz)
+      : wxStringBase((const char*)psz) { }
+    // from part of C string (for compilers using unsigned char)
+  wxString(const unsigned char* psz, size_t nLength)

       : wxStringBase((const char*)psz, nLength) { }
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
       : wxStringBase((const char*)psz, nLength) { }
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

-  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = npos);
+  wxString(const wchar_t *pwz,
+           const wxMBConv& conv = wxConvLibc,
+           size_t nLength = npos);

 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)
 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)

-      : wxStringBase(psz, npos) { }
+      : wxStringBase(psz) { }

 #endif // Unicode/ANSI
 
   // generic attributes & operations
 #endif // Unicode/ANSI
 
   // generic attributes & operations


@@ -685,8 +698,8 @@ public:
   size_t Len() const { return length(); }
     // string contains any characters?
   bool IsEmpty() const { return empty(); }
   size_t Len() const { return length(); }
     // string contains any characters?
   bool IsEmpty() const { return empty(); }

-    // empty string is "FALSE", so !str will return TRUE
-  bool operator!() const { return IsEmpty(); }
+    // empty string is "false", so !str will return true
+  bool operator!() const { return empty(); }

     // 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


@@ -694,7 +707,7 @@ public:
   {
     Truncate(0);
 
   {
     Truncate(0);
 

-    wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );
+    wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );

   }
     // empty the string and free memory
   void Clear()
   }
     // empty the string and free memory
   void Clear()


@@ -714,66 +727,58 @@ public:
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const

-      { return operator[](n); }
+      { return at(n); }

     // read/write access
     wxChar& GetWritableChar(size_t n)
     // read/write access
     wxChar& GetWritableChar(size_t n)

-      { return operator[](n); }
+      { return at(n); }

     // write access
     void  SetChar(size_t n, wxChar ch)
     // write access
     void  SetChar(size_t n, wxChar ch)

-      { operator[](n) = ch; }
+      { at(n) = ch; }

 
     // get last character
     wxChar  Last() const
       {
 
     // get last character
     wxChar  Last() const
       {

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

 
 

-          return operator[](length() - 1);
+          return at(length() - 1);

       }
 
     // get writable last character
     wxChar& Last()
       {
       }
 
     // get writable last character
     wxChar& Last()
       {

-          wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
-          return operator[](length() - 1);
+          wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+          return at(length() - 1);

       }
 
     /*
       }
 
     /*

-        So why do we have all these overloaded operator[]s? A bit of history:
-        initially there was only one of them, taking size_t. Then people
-        started complaining because they wanted to use ints as indices (I
-        wonder why) and compilers were giving warnings about it, so we had to
-        add the operator[](int). Then it became apparent that you couldn't
-        write str[0] any longer because there was ambiguity between two
-        overloads and so you now had to write str[0u] (or, of course, use the
-        explicit casts to either int or size_t but nobody did this).
-
-        Finally, someone decided to compile wxWin on an Alpha machine and got
-        a surprize: str[0u] didn't compile there because it is of type
-        unsigned int and size_t is unsigned _long_ on Alpha and so there was
-        ambiguity between converting uint to int or ulong. To fix this one we
-        now add operator[](uint) for the machines where size_t is not already
-        the same as unsigned int - hopefully this fixes the problem (for some
-        time)
-
-        The only real fix is, of course, to remove all versions but the one
-        taking size_t...
+       Note that we we must define all of the overloads below to avoid
+       ambiguity when using str[0]. Also note that for a conforming compiler we
+       don't need const version of operatorp[] at all as indexed access to
+       const string is provided by implicit conversion to "const wxChar *"
+       below and defining them would only result in ambiguities, but some other
+       compilers refuse to compile "str[0]" without them.

      */
 
      */
 

-    // operator version of GetChar
-    wxChar  operator[](int n) const
-      { return wxStringBase::operator[](n); }
-    wxChar& operator[](size_type n)
-      { return wxStringBase::operator[](n); }
+#if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__MWERKS__)
+    wxChar operator[](int n) const
+      { return wxStringBase::at(n); }

     wxChar operator[](size_type n) const
     wxChar operator[](size_type n) const

-      { return wxStringBase::operator[](n); }
+      { return wxStringBase::at(n); }

 #ifndef wxSIZE_T_IS_UINT
 #ifndef wxSIZE_T_IS_UINT

-    // operator version of GetChar

     wxChar operator[](unsigned int n) const
     wxChar operator[](unsigned int n) const

-      { return wxStringBase::operator[](n); }
+      { return wxStringBase::at(n); }
+#endif // size_t != unsigned int
+#endif // broken compiler
+

 
 

-    // operator version of GetWriteableChar
+    // operator versions of GetWriteableChar()
+    wxChar& operator[](int n)
+      { return wxStringBase::at(n); }
+    wxChar& operator[](size_type n)
+      { return wxStringBase::at(n); }
+#ifndef wxSIZE_T_IS_UINT

     wxChar& operator[](unsigned int n)
     wxChar& operator[](unsigned int n)

-      { return wxStringBase::operator[](n); }
+      { return wxStringBase::at(n); }

 #endif // size_t != unsigned int
 
     // implicit conversion to C string
 #endif // size_t != unsigned int
 
     // implicit conversion to C string


@@ -810,15 +815,14 @@ public:
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.
 #if wxUSE_UNICODE
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.
 #if wxUSE_UNICODE

-    const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
-        { return conv.cWC2MB(c_str()); }
+    const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;

 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
     const wxChar* wc_str() const { return c_str(); }
 
     // for compatibility with !wxUSE_UNICODE version
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
     const wxChar* wc_str() const { return c_str(); }
 
     // for compatibility with !wxUSE_UNICODE version

-    const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }

 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }


@@ -829,16 +833,18 @@ public:
     const wxChar* mb_str() const { return c_str(); }
 
     // for compatibility with wxUSE_UNICODE version
     const wxChar* mb_str() const { return c_str(); }
 
     // for compatibility with wxUSE_UNICODE version

-    const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }

 
     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(wxMBConv& conv) const
-        { return conv.cMB2WC(c_str()); }
+    const wxWCharBuffer wc_str(const wxMBConv& conv) const;

 #endif // wxUSE_WCHAR_T
 #endif // wxUSE_WCHAR_T

-
+#ifdef __WXOSX__
+    const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); }
+#else

     const wxChar* fn_str() const { return c_str(); }
     const wxChar* fn_str() const { return c_str(); }

+#endif

 #endif // Unicode/ANSI
 
   // overloaded assignment
 #endif // Unicode/ANSI
 
   // overloaded assignment


@@ -848,9 +854,16 @@ public:
     // from a character
   wxString& operator=(wxChar ch)
     { return (wxString&)wxStringBase::operator=(ch); }
     // from a character
   wxString& operator=(wxChar ch)
     { return (wxString&)wxStringBase::operator=(ch); }

-    // from a C string
+    // from a C string - STL probably will crash on NULL,
+    // so we need to compensate in that case
+#if wxUSE_STL
+  wxString& operator=(const wxChar *psz)
+    { if(psz) wxStringBase::operator=(psz); else Clear(); return *this; }
+#else

   wxString& operator=(const wxChar *psz)
     { return (wxString&)wxStringBase::operator=(psz); }
   wxString& operator=(const wxChar *psz)
     { return (wxString&)wxStringBase::operator=(psz); }

+#endif
+

 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& psz)
 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& psz)


@@ -907,8 +920,8 @@ public:
     // string += C string
   wxString& Append(const wxString& s)
     {
     // string += C string
   wxString& Append(const wxString& s)
     {

-        // test for IsEmpty() to share the string if possible
-        if ( IsEmpty() )
+        // test for empty() to share the string if possible
+        if ( empty() )

             *this = s;
         else
             append(s);
             *this = s;
         else
             append(s);


@@ -927,16 +940,19 @@ public:
     { *this = str + *this; return *this; }
 
     // non-destructive concatenation
     { *this = str + *this; return *this; }
 
     // non-destructive concatenation

-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
-      //
+      // two strings
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,
+                                             const wxString& string2);
+      // string with a single char

   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);

-      //
+      // char with a string

   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);

-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+      // string with C string
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
+                                             const wxChar *psz);
+      // C string with string
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz,
+                                             const wxString& string);

 
   // stream-like functions
       // insert an int into string
 
   // stream-like functions
       // insert an int into string


@@ -951,6 +967,20 @@ public:
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
     { return (*this) << Format(_T("%lu"), ul); }
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
     { return (*this) << Format(_T("%lu"), ul); }

+#if defined wxLongLong_t && !defined wxLongLongIsLong
+      // insert a long long if they exist and aren't longs
+  wxString& operator<<(wxLongLong_t ll)
+    {
+      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
+      return (*this) << Format(fmt, ll);
+    }
+      // insert an unsigned long long
+  wxString& operator<<(wxULongLong_t ull)
+    {
+      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
+      return (*this) << Format(fmt , ull);
+    }
+#endif

       // insert a float into string
   wxString& operator<<(float f)
     { return (*this) << Format(_T("%f"), f); }
       // insert a float into string
   wxString& operator<<(float f)
     { return (*this) << Format(_T("%f"), f); }


@@ -960,15 +990,17 @@ public:
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)

-  int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
+  int Cmp(const wxChar *psz) const;
+  int Cmp(const wxString& s) const;

     // same as Cmp() but not case-sensitive
     // same as Cmp() but not case-sensitive

-  int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
+  int CmpNoCase(const wxChar *psz) const;
+  int CmpNoCase(const wxString& s) const;

     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)
     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)

-  bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
+  bool IsSameAs(const wxChar *psz, bool compareWithCase = true) const

     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }

-    // comparison with a signle character: returns TRUE if equal
-  bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
+    // comparison with a single character: returns true if equal
+  bool IsSameAs(wxChar c, bool compareWithCase = true) const

     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
                               : wxToupper(GetChar(0u)) == wxToupper(c));
     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
                               : wxToupper(GetChar(0u)) == wxToupper(c));


@@ -985,7 +1017,7 @@ public:
 
       // check that the string starts with prefix and return the rest of the
       // string in the provided pointer if it is not NULL, otherwise return
 
       // check that the string starts with prefix and return the rest of the
       // string in the provided pointer if it is not NULL, otherwise return

-      // FALSE
+      // false

   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
 
       // get first nCount characters
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
 
       // get first nCount characters


@@ -1022,25 +1054,25 @@ public:
 
   // trimming/padding whitespace (either side) and truncating
       // remove spaces from left or from right (default) side
 
   // trimming/padding whitespace (either side) and truncating
       // remove spaces from left or from right (default) side

-  wxString& Trim(bool bFromRight = TRUE);
+  wxString& Trim(bool bFromRight = true);

       // add nCount copies chPad in the beginning or at the end (default)
       // add nCount copies chPad in the beginning or at the end (default)

-  wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
+  wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = true);

 
   // searching and replacing
       // searching (return starting index, or -1 if not found)
 
   // searching and replacing
       // searching (return starting index, or -1 if not found)

-  int Find(wxChar ch, bool bFromEnd = FALSE) const;   // like strchr/strrchr
+  int Find(wxChar ch, bool bFromEnd = false) const;   // like strchr/strrchr

       // searching (return starting index, or -1 if not found)
   int Find(const wxChar *pszSub) const;               // like strstr
       // replace first (or all of bReplaceAll) occurences of substring with
       // another string, returns the number of replacements made
   size_t Replace(const wxChar *szOld,
                  const wxChar *szNew,
       // searching (return starting index, or -1 if not found)
   int Find(const wxChar *pszSub) const;               // like strstr
       // replace first (or all of bReplaceAll) occurences of substring with
       // another string, returns the number of replacements made
   size_t Replace(const wxChar *szOld,
                  const wxChar *szNew,

-                 bool bReplaceAll = TRUE);
+                 bool bReplaceAll = true);

 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 
 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 

-    // conversion to numbers: all functions return TRUE only if the whole
+    // 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
     // 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


@@ -1052,7 +1084,7 @@ public:
         // convert to a double
     bool ToDouble(double *val) const;
 
         // convert to a double
     bool ToDouble(double *val) const;
 

-  // formated input/output
+  // formatted input/output

     // as sprintf(), returns the number of characters written or < 0 on error
     // (take 'this' into account in attribute parameter count)
   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
     // as sprintf(), returns the number of characters written or < 0 on error
     // (take 'this' into account in attribute parameter count)
   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;


@@ -1080,7 +1112,7 @@ public:
   void UngetWriteBuf(size_t nLen);
 #endif
 
   void UngetWriteBuf(size_t nLen);
 #endif
 

-  // wxWindows version 1 compatibility functions
+  // wxWidgets version 1 compatibility functions

 
   // use Mid()
   wxString SubString(size_t from, size_t to) const
 
   // use Mid()
   wxString SubString(size_t from, size_t to) const


@@ -1123,11 +1155,11 @@ public:
   int First( const wxChar ch ) const { return Find(ch); }
   int First( const wxChar* psz ) const { return Find(psz); }
   int First( const wxString &str ) const { return Find(str); }
   int First( const wxChar ch ) const { return Find(ch); }
   int First( const wxChar* psz ) const { return Find(psz); }
   int First( const wxString &str ) const { return Find(str); }

-  int Last( const wxChar ch ) const { return Find(ch, TRUE); }
-  bool Contains(const wxString& str) const { return Find(str) != -1; }
+  int Last( const wxChar ch ) const { return Find(ch, true); }
+  bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }

 
 

-    // use IsEmpty()
-  bool IsNull() const { return IsEmpty(); }
+    // use empty()
+  bool IsNull() const { return empty(); }

 
   // std::string compatibility functions
 
 
   // std::string compatibility functions
 


@@ -1136,7 +1168,7 @@ public:
       : wxStringBase(str, nPos, nLen) { }
     // take all characters from pStart to pEnd
   wxString(const void *pStart, const void *pEnd)
       : wxStringBase(str, nPos, nLen) { }
     // take all characters from pStart to pEnd
   wxString(const void *pStart, const void *pEnd)

-      : wxStringBase((const char*)pStart, (const char*)pEnd) { }
+      : wxStringBase((const wxChar*)pStart, (const wxChar*)pEnd) { }

 #if wxUSE_STL
   wxString(const_iterator first, const_iterator last)
       : wxStringBase(first, last) { }
 #if wxUSE_STL
   wxString(const_iterator first, const_iterator last)
       : wxStringBase(first, last) { }


@@ -1180,7 +1212,7 @@ public:
     { return (wxString&)wxStringBase::assign(first, last); }
 
     // string comparison
     { return (wxString&)wxStringBase::assign(first, last); }
 
     // string comparison

-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE)

   int compare(const wxStringBase& str) const;
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
   int compare(const wxStringBase& str) const;
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;


@@ -1209,7 +1241,7 @@ public:
   wxString& insert(size_t nPos, size_t n, wxChar ch)
     { return (wxString&)wxStringBase::insert(nPos, n, ch); }
   iterator insert(iterator it, wxChar ch)
   wxString& insert(size_t nPos, size_t n, wxChar ch)
     { return (wxString&)wxStringBase::insert(nPos, n, ch); }
   iterator insert(iterator it, wxChar ch)

-    { return wxStringBase::insert(it, ch); } 
+    { return wxStringBase::insert(it, ch); }

   void insert(iterator it, const_iterator first, const_iterator last)
     { wxStringBase::insert(it, first, last); }
   void insert(iterator it, size_type n, wxChar ch)
   void insert(iterator it, const_iterator first, const_iterator last)
     { wxStringBase::insert(it, first, last); }
   void insert(iterator it, size_type n, wxChar ch)


@@ -1269,11 +1301,33 @@ public:
     { return (wxString&)wxStringBase::operator+=(ch); }
 };
 
     { return (wxString&)wxStringBase::operator+=(ch); }
 };
 

+// notice that even though for many compilers the friend declarations above are
+// enough, from the point of view of C++ standard we must have the declarations
+// here as friend ones are not injected in the enclosing namespace and without
+// them the code fails to compile with conforming compilers such as xlC or g++4
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
+wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
+wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+
+

 // define wxArrayString, for compatibility
 #if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
     #include "wx/arrstr.h"
 #endif
 
 // define wxArrayString, for compatibility
 #if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
     #include "wx/arrstr.h"
 #endif
 

+#if wxUSE_STL
+    // return an empty wxString (not very useful with wxUSE_STL == 1)
+    inline const wxString wxGetEmptyString() { return wxString(); }
+#else // !wxUSE_STL
+    // return an empty wxString (more efficient than wxString() here)
+    inline const wxString& wxGetEmptyString()
+    {
+        return *(wxString *)&wxEmptyString;
+    }
+#endif // wxUSE_STL/!wxUSE_STL
+

 // ----------------------------------------------------------------------------
 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
 // ----------------------------------------------------------------------------


@@ -1356,7 +1410,10 @@ class WXDLLIMPEXP_BASE wxStringBufferLength
 public:
     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
 public:
     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)

-        { m_buf = m_str.GetWriteBuf(lenWanted); }
+    {
+        m_buf = m_str.GetWriteBuf(lenWanted);
+        wxASSERT(m_buf != NULL);
+    }

 
     ~wxStringBufferLength()
     {
 
     ~wxStringBufferLength()
     {


@@ -1382,46 +1439,10 @@ private:
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 

-#if wxUSE_STL
-
-inline bool operator==(const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) == 0; }
-inline bool operator==(const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) == 0; }
-inline bool operator==(const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) == 0; }
-inline bool operator!=(const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) != 0; }
-inline bool operator!=(const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) != 0; }
-inline bool operator!=(const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) != 0; }
-inline bool operator< (const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) <  0; }
-inline bool operator< (const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) <  0; }
-inline bool operator< (const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) >  0; }
-inline bool operator> (const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) >  0; }
-inline bool operator> (const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) >  0; }
-inline bool operator> (const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) <  0; }
-inline bool operator<=(const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) <= 0; }
-inline bool operator<=(const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) <= 0; }
-inline bool operator<=(const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) >= 0; }
-inline bool operator>=(const wxString& s1, const wxString& s2)
-    { return s1.compare(s2) >= 0; }
-inline bool operator>=(const wxString& s1, const wxChar  * s2)
-    { return s1.compare(s2) >= 0; }
-inline bool operator>=(const wxChar  * s1, const wxString& s2)
-    { return s2.compare(s1) <= 0; }
-
-#else // if !wxUSE_STL
+// note that when wxUSE_STL == 1 the comparison operators taking std::string
+// are used and defining them also for wxString would only result in
+// compilation ambiguities when comparing std::string and wxString
+#if !wxUSE_STL

 
 inline bool operator==(const wxString& s1, const wxString& s2)
     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
 
 inline bool operator==(const wxString& s1, const wxString& s2)
     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }


@@ -1460,14 +1481,6 @@ inline bool operator>=(const wxString& s1, const wxChar  * s2)
 inline bool operator>=(const wxChar  * s1, const wxString& s2)
     { return s2.Cmp(s1) <= 0; }
 
 inline bool operator>=(const wxChar  * s1, const wxString& s2)
     { return s2.Cmp(s1) <= 0; }
 

-#endif // !wxUSE_STL
-
-// comparison with char
-inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
-inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
-inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
-inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
-

 #if wxUSE_UNICODE
 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
     { return (s1.Cmp((const wchar_t *)s2) == 0); }
 #if wxUSE_UNICODE
 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
     { return (s1.Cmp((const wchar_t *)s2) == 0); }


@@ -1488,16 +1501,6 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 

-#if !wxUSE_STL
-
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
-wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
-wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
-
-#endif // !wxUSE_STL
-

 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }
 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }


@@ -1510,6 +1513,15 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
     { return (const char *)buf + string; }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
     { return (const char *)buf + string; }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 

+#endif // !wxUSE_STL
+
+// comparison with char (those are not defined by std::[w]string and so should
+// be always available)
+inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
+inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
+inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
+inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
+

 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------