Fixed OS/2 compilation problems.

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

diff --git a/include/wx/string.h b/include/wx/string.h
index d469d96866ffa71c09ced4f79aaf57b7ace26d55..998946f7dcd905eeccac59cd1db3ead7c0f37fda 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -29,15 +29,12 @@
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 

-// define to derive wxString from wxObject (deprecated!)
-#ifdef WXSTRING_IS_WXOBJECT
-    #undef WXSTRING_IS_WXOBJECT
-#endif
-

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

+#include "wx/defs.h"        // everybody should include this
+

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


@@ -63,41 +60,42 @@
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()

-#endif // AIX
+#endif // HAVE_STRINGS_H

 
 

-#include "wx/defs.h"        // everybody should include this
-#include "wx/debug.h"       // for wxASSERT()

 #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
 

-#ifndef  WX_PRECOMP
-  #ifdef    WXSTRING_IS_WXOBJECT
-    #include "wx/object.h" // base class
-  #endif
-#endif // !PCH
-

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

-// 'naughty' cast
+// casts [unfortunately!] needed to call some broken functions which require
+// "char *" instead of "const char *"

 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only
 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only

-#define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
+#define   wxASSERT_VALID_INDEX(i) \
+    wxASSERT_MSG( (size_t)(i) <= Len(), _T("invaid index in wxString") )

 
 // ----------------------------------------------------------------------------
 // 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
 //  (as sizeof(StringData) is unknown here, we substract 100)
 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
 
 // 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
+

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


@@ -114,14 +112,14 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
 // backwards compatibility only.
 
 // checks whether the passed in pointer is NULL and if the string is empty
 // backwards compatibility only.
 
 // checks whether the passed in pointer is NULL and if the string is empty

-inline bool WXDLLEXPORT IsEmpty(const char *p) { return (!p || !*p); }
+inline bool IsEmpty(const char *p) { return (!p || !*p); }

 
 // safe version of strlen() (returns 0 if passed NULL pointer)
 
 // safe version of strlen() (returns 0 if passed NULL pointer)

-inline size_t WXDLLEXPORT Strlen(const char *psz)
+inline size_t Strlen(const char *psz)

   { return psz ? strlen(psz) : 0; }
 
 // portable strcasecmp/_stricmp
   { return psz ? strlen(psz) : 0; }
 
 // portable strcasecmp/_stricmp

-inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
+inline int Stricmp(const char *psz1, const char *psz2)

 {
 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
   return _stricmp(psz1, psz2);
 {
 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
   return _stricmp(psz1, psz2);


@@ -133,6 +131,8 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);

+#elif defined(__DJGPP__)
+  return stricmp(psz1, psz2);

 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)


@@ -198,6 +198,12 @@ struct WXDLLEXPORT wxStringData
 
   // lock/unlock
   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 
   // lock/unlock
   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }

+
+  // VC++ will refuse to inline this function but profiling shows that it
+  // is wrong
+#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
+  __forceinline
+#endif

   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 
   // if we had taken control over string memory (GetWriteBuf), it's
   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 
   // if we had taken control over string memory (GetWriteBuf), it's


@@ -229,15 +235,8 @@ struct WXDLLEXPORT wxStringData
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 

-#ifdef  WXSTRING_IS_WXOBJECT
-class WXDLLEXPORT wxString : public wxObject
-{
-    DECLARE_DYNAMIC_CLASS(wxString)
-#else   //WXSTRING_IS_WXOBJECT

 class WXDLLEXPORT wxString
 {
 class WXDLLEXPORT wxString
 {

-#endif  //WXSTRING_IS_WXOBJECT
-

 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order
 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order


@@ -275,12 +274,20 @@ private:
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 

-  // this method is not implemented - there is _no_ conversion from int to
+  // 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
+  // converted to char in C and we do have operator=(char)
+  //
+  // NB: we don't need other versions (short/long and unsigned) as attempt
+  //     to assign another numeric type to wxString will now result in
+  //     ambiguity between operator=(char) and operator=(int)
+  wxString& operator=(int);
+
+  // these methods are not implemented - there is _no_ conversion from int to

   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);
   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);

-  wxString(long);

 
 public:
   // constructors and destructor
 
 public:
   // constructors and destructor


@@ -306,6 +313,8 @@ public:
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith(psz, 0, nLength); }
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith(psz, 0, nLength); }

+  wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
+    { InitWith(psz, 0, nLength); }

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


@@ -319,13 +328,10 @@ public:
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith((const char*)psz, 0, nLength); }
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith((const char*)psz, 0, nLength); }

-    // from multibyte string
-  wxString(const char *psz, wxMBConv& WXUNUSED(conv) , size_t nLength = wxSTRING_MAXLEN)
-    { InitWith(psz, 0, nLength); }

 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

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

 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer


@@ -343,14 +349,14 @@ public:
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }

+    // truncate the string to given length
+  wxString& Truncate(size_t uiLen);

     // empty string contents
   void Empty()
   {
     // empty string contents
   void Empty()
   {

-    if ( !IsEmpty() )
-      Reinit();
+    Truncate(0);

 
 

-    // should be empty
-    wxASSERT( GetStringData()->nDataLength == 0 );
+    wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );

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


@@ -373,13 +379,13 @@ 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

-      { ASSERT_VALID_INDEX( n );  return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n );  return m_pchData[n]; }

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

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

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

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }

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


@@ -388,44 +394,78 @@ public:
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
 
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-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...
+     */
+

     // operator version of GetChar
     wxChar  operator[](size_t n) const
     // operator version of GetChar
     wxChar  operator[](size_t n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetChar
     wxChar  operator[](int n) const
 
     // operator version of GetChar
     wxChar  operator[](int n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
-#ifdef __alpha__
-    // operator version of GetChar
-    wxChar  operator[](unsigned int n) const
-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
-#endif
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)
 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
-#ifdef __alpha__
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+
+#ifndef wxSIZE_T_IS_UINT
+    // operator version of GetChar
+    wxChar operator[](unsigned int n) const
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+

     // operator version of GetWriteableChar
     // operator version of GetWriteableChar

-    wxChar&  operator[](unsigned int n)
-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
-#endif
+    wxChar& operator[](unsigned int n)
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+#endif // size_t != unsigned int

 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }
     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }
 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }
     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }

-    // (and this with [wx]Printf()!)
+    // identical to c_str()

     const wxChar* wx_str()  const { return m_pchData; }
     // identical to c_str()
     const wxChar* GetData() const { return m_pchData; }
 
     // conversions with (possible) format convertions: have to return a
     // buffer with temporary data
     const wxChar* wx_str()  const { return m_pchData; }
     // identical to c_str()
     const wxChar* GetData() const { return m_pchData; }
 
     // conversions with (possible) format convertions: have to return a
     // buffer with temporary data

+    //
+    // the functions defined (in either Unicode or ANSI) mode are mb_str() to
+    // return an ANSI (multibyte) string, wc_str() to return a wide string and
+    // fn_str() to return a string which should be used with the OS APIs
+    // accepting the file names. The return value is always the same, but the
+    // type differs because a function may either return pointer to the buffer
+    // directly or have to use intermediate buffer for translation.

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

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

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

-    const wxChar* wc_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const { return m_pchData; }
+    const wxChar* wc_str() const { return m_pchData; }
+
+    // for compatibility with !wxUSE_UNICODE version
+    const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }

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


@@ -433,17 +473,18 @@ public:
     const wxChar* fn_str() const { return m_pchData; }
 #endif // wxMBFILES/!wxMBFILES
 #else // ANSI
     const wxChar* fn_str() const { return m_pchData; }
 #endif // wxMBFILES/!wxMBFILES
 #else // ANSI

-#if wxUSE_MULTIBYTE
-    const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const
-        { return m_pchData; }
-    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
-#else // !mmultibyte

     const wxChar* mb_str() const { return m_pchData; }
     const wxChar* mb_str() const { return m_pchData; }

+
+    // for compatibility with wxUSE_UNICODE version
+    const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
+

     const wxWX2MBbuf mbc_str() const { return mb_str(); }
     const wxWX2MBbuf mbc_str() const { return mb_str(); }

-#endif // multibyte/!multibyte
+

 #if wxUSE_WCHAR_T
 #if wxUSE_WCHAR_T

-    const wxWCharBuffer wc_str(wxMBConv& conv) const { return conv.cMB2WC(m_pchData); }
+    const wxWCharBuffer wc_str(wxMBConv& conv) const
+        { return conv.cMB2WC(m_pchData); }

 #endif // wxUSE_WCHAR_T
 #endif // wxUSE_WCHAR_T

+

     const wxChar* fn_str() const { return m_pchData; }
 #endif // Unicode/ANSI
 
     const wxChar* fn_str() const { return m_pchData; }
 #endif // Unicode/ANSI
 


@@ -511,6 +552,8 @@ public:
     // append count copies of given character
   wxString& Append(wxChar ch, size_t count = 1u)
     { wxString str(ch, count); return *this << str; }
     // append count copies of given character
   wxString& Append(wxChar ch, size_t count = 1u)
     { wxString str(ch, count); return *this << str; }

+  wxString& Append(const wxChar* psz, size_t nLen)
+    { ConcatSelf(nLen, psz); return *this; }

 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)
 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)


@@ -530,11 +573,23 @@ public:
 
   // stream-like functions
       // insert an int into string
 
   // stream-like functions
       // insert an int into string

-  wxString& operator<<(int i);
+  wxString& operator<<(int i)
+    { return (*this) << Format(_T("%d"), i); }
+      // insert an unsigned int into string
+  wxString& operator<<(unsigned int ui)
+    { return (*this) << Format(_T("%u"), ui); }
+      // insert a long into string
+  wxString& operator<<(long l)
+    { return (*this) << Format(_T("%ld"), l); }
+      // insert an unsigned long into string
+  wxString& operator<<(unsigned long ul)
+    { return (*this) << Format(_T("%lu"), ul); }

       // insert a float into string
       // insert a float into string

-  wxString& operator<<(float f);
+  wxString& operator<<(float f)
+    { return (*this) << Format(_T("%f"), f); }

       // insert a double into string
       // insert a double into string

-  wxString& operator<<(double d);
+  wxString& operator<<(double d)
+    { return (*this) << Format(_T("%g"), d); }

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


@@ -557,15 +612,20 @@ public:
       // if nCount = default value)
   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
 
       // if nCount = default value)
   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
 

-    // operator version of Mid()
+      // operator version of Mid()

   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 
   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 

+      // 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
+  bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
+

       // get first nCount characters
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;
       // get first nCount characters
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;

-      // get all characters before the first occurence of ch
+      // get all characters before the first occurance of ch

       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch
       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch


@@ -598,8 +658,6 @@ public:
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);

-      // truncate string to given length
-  wxString& Truncate(size_t uiLen);

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


@@ -618,9 +676,9 @@ public:
     // 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
         // convert to a signed integer
     // 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
         // convert to a signed integer

-    bool ToLong(long *val) const;
+    bool ToLong(long *val, int base = 0) const;

         // convert to an unsigned integer
         // convert to an unsigned integer

-    bool ToULong(unsigned long *val) const;
+    bool ToULong(unsigned long *val, int base = 0) const;

         // convert to a double
     bool ToDouble(double *val) const;
 
         // convert to a double
     bool ToDouble(double *val) const;
 


@@ -647,6 +705,7 @@ public:
   wxChar *GetWriteBuf(size_t nLen);
     // call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();
   wxChar *GetWriteBuf(size_t nLen);
     // call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();

+  void UngetWriteBuf(size_t nLen);

 
   // wxWindows version 1 compatibility functions
 
 
   // wxWindows version 1 compatibility functions
 


@@ -681,7 +740,7 @@ public:
   size_t Index(wxChar ch)         const { return Find(ch);  }
     // use Truncate
   wxString& Remove(size_t pos) { return Truncate(pos); }
   size_t Index(wxChar ch)         const { return Find(ch);  }
     // use Truncate
   wxString& Remove(size_t pos) { return Truncate(pos); }

-  wxString& RemoveLast() { return Truncate(Len() - 1); }
+  wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }

 
   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 
 
   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 


@@ -757,16 +816,17 @@ public:
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'

-  wxString& assign(const wxString& str) { return (*this) = str; }
+  wxString& assign(const wxString& str)
+    { return *this = str; }

     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)
     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)

-    { return *this = wxString((const wxChar *)str + pos, n); }
+    { Empty(); return Append(str.c_str() + pos, n); }

     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)
     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)

-    { return *this = wxString(sz, n); }
+    { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }

     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)
     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)

-    { return *this = wxString(ch, n); }
+    { Empty(); return Append(ch, n); }

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


@@ -792,8 +852,8 @@ public:
   wxString& replace(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2);
     // replaces the substring with first nCount chars of sz
   wxString& replace(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2);
     // replaces the substring with first nCount chars of sz

-    wxString& replace(size_t nStart, size_t nLen,
-                      const wxChar* sz, size_t nCount);
+  wxString& replace(size_t nStart, size_t nLen,
+                    const wxChar* sz, size_t nCount);

 
     // swap two strings
   void swap(wxString& str);
 
     // swap two strings
   void swap(wxString& str);


@@ -809,7 +869,7 @@ public:
 #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;
 #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;

-#endif
+#endif // VC++ 1.5

 
   // Gives a duplicate symbol (presumably a case-insensitivity problem)
 #if !defined(__BORLANDC__)
 
   // Gives a duplicate symbol (presumably a case-insensitivity problem)
 #if !defined(__BORLANDC__)


@@ -828,7 +888,7 @@ public:
           size_t n = npos) const;
     // as find, but from the end
   size_t rfind(wxChar ch, size_t nStart = npos) const;
           size_t n = npos) const;
     // as find, but from the end
   size_t rfind(wxChar ch, size_t nStart = npos) const;

-#endif
+#endif // VC++ 1.5

 
     // find first/last occurence of any character in the set
 
 
     // find first/last occurence of any character in the set
 


@@ -859,7 +919,8 @@ public:
     // same as above
   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
     //  as strcspn()
     // 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 wxString& str, size_t nStart=npos) const;
+  size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
+    { return find_first_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
     // same as above
   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
     // same as above


@@ -871,15 +932,18 @@ public:
     // just like strcmp()
   int compare(const wxString& str) const { return Cmp(str); }
     // comparison with a substring
     // just like strcmp()
   int compare(const wxString& str) const { return Cmp(str); }
     // comparison with a substring

-  int compare(size_t nStart, size_t nLen, const wxString& str) const;
+  int compare(size_t nStart, size_t nLen, const wxString& str) const
+    { return Mid(nStart, nLen).Cmp(str); }

     // comparison of 2 substrings
   int compare(size_t nStart, size_t nLen,
     // comparison of 2 substrings
   int compare(size_t nStart, size_t nLen,

-              const wxString& str, size_t nStart2, size_t nLen2) const;
+              const wxString& str, size_t nStart2, size_t nLen2) const
+    { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }

     // just like strcmp()
   int compare(const wxChar* sz) const { return Cmp(sz); }
     // substring comparison with first nCount characters of sz
   int compare(size_t nStart, size_t nLen,
     // just like strcmp()
   int compare(const wxChar* sz) const { return Cmp(sz); }
     // substring comparison with first nCount characters of sz
   int compare(size_t nStart, size_t nLen,

-              const wxChar* sz, size_t nCount = npos) const;
+              const wxChar* sz, size_t nCount = npos) const
+    { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }

 
   // substring extraction
   wxString substr(size_t nStart = 0, size_t nLen = npos) const
 
   // substring extraction
   wxString substr(size_t nStart = 0, size_t nLen = npos) const


@@ -910,9 +974,17 @@ public:
                                  const wxString& second);
 
   // constructors and destructor
                                  const wxString& second);
 
   // constructors and destructor

-    // default ctor: if autoSort is TRUE, the array is always sorted (in
-    // alphabetical order)
-  wxArrayString(bool autoSort = FALSE);
+    // default ctor
+  wxArrayString() { Init(FALSE); }
+    // if autoSort is TRUE, the array is always sorted (in alphabetical order)
+    //
+    // NB: the reason for using int and not bool is that like this we can avoid
+    //     using this ctor for implicit conversions from "const char *" (which
+    //     we'd like to be implicitly converted to wxString instead!)
+    //
+    //     of course, using explicit would be even better - if all compilers
+    //     supported it...
+  wxArrayString(int autoSort) { Init(autoSort != 0); }

     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator
     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator


@@ -947,6 +1019,12 @@ public:
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 

+    // return a wxString[], useful for the controls which
+    // take one in their ctor.  You must delete[] it yourself
+    // once you are done with it.  Will return NULL if the
+    // ArrayString was empty.
+  wxString* GetStringArray() const;
+

   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case


@@ -958,10 +1036,13 @@ public:
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);

+    // expand the array to have count elements
+  void SetCount(size_t count);

     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
   void Remove(size_t nIndex);
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
   void Remove(size_t nIndex);

+  void RemoveAt(size_t nIndex) { Remove(nIndex); }

 
   // sorting
     // sort array elements in alphabetical order (or reversed alphabetical
 
   // sorting
     // sort array elements in alphabetical order (or reversed alphabetical


@@ -970,7 +1051,14 @@ public:
     // sort array elements using specified comparaison function
   void Sort(CompareFunction compareFunction);
 
     // sort array elements using specified comparaison function
   void Sort(CompareFunction compareFunction);
 

+  // comparison
+    // compare two arrays case sensitively
+  bool operator==(const wxArrayString& a) const;
+    // compare two arrays case sensitively
+  bool operator!=(const wxArrayString& a) const { return !(*this == a); }
+

 protected:
 protected:

+  void Init(bool autoSort);             // common part of all ctors

   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:
   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:


@@ -996,46 +1084,65 @@ public:
     { Copy(array); }
 };
 
     { Copy(array); }
 };
 

+// ----------------------------------------------------------------------------
+// wxStringBuffer: a tiny class allowing to get a writable pointer into string
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStringBuffer
+{
+public:
+    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
+        : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); }
+
+    ~wxStringBuffer() { m_str.UngetWriteBuf(); }
+
+    operator wxChar*() const { return m_buf; }
+
+private:
+    wxString& m_str;
+    wxChar   *m_buf;
+};
+

 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 

-//
-inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); }
-//
-inline bool operator==(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) == 0); }
-//
-inline bool operator==(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) == 0); }
-//
-inline bool operator!=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) != 0); }
-//
-inline bool operator!=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) != 0); }
-//
-inline bool operator!=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) != 0); }
-//
-inline bool operator< (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) < 0); }
-//
-inline bool operator< (const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) <  0); }
-//
-inline bool operator< (const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) >  0); }
-//
-inline bool operator> (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) >  0); }
-//
-inline bool operator> (const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) >  0); }
-//
-inline bool operator> (const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <  0); }
-//
-inline bool operator<=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) <= 0); }
-//
-inline bool operator<=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) <= 0); }
-//
-inline bool operator<=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) >= 0); }
-//
-inline bool operator>=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) >= 0); }
-//
-inline bool operator>=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) >= 0); }
-//
-inline bool operator>=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <= 0); }
+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 wxChar  * s2)
+    { return s1.Cmp(s2) == 0; }
+inline bool operator==(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) == 0; }
+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 wxChar  * s2)
+    { return s1.Cmp(s2) != 0; }
+inline bool operator!=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) != 0; }
+inline bool operator< (const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) < 0; }
+inline bool operator< (const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) <  0; }
+inline bool operator< (const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) >  0; }
+inline bool operator> (const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) >  0; }
+inline bool operator> (const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) >  0; }
+inline bool operator> (const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) <  0; }
+inline bool operator<=(const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) <= 0; }
+inline bool operator<=(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) <= 0; }
+inline bool operator<=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) >= 0; }
+inline bool operator>=(const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) >= 0; }
+inline bool operator>=(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) >= 0; }
+inline bool operator>=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) <= 0; }

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


@@ -1048,12 +1155,20 @@ inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
     { return (s1.Cmp((const wchar_t *)s2) == 0); }
 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) == 0); }
     { return (s1.Cmp((const wchar_t *)s2) == 0); }
 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) == 0); }

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

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

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

 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);


@@ -1061,30 +1176,30 @@ wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
 #if wxUSE_UNICODE
 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
 #if wxUSE_UNICODE

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

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

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

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

-#else
-inline wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer& buf)
+#else // !wxUSE_UNICODE
+inline wxString operator+(const wxString& string, const wxCharBuffer& buf)

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

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

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

-#endif
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE

 
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space
 
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space

-#undef ASSERT_VALID_INDEX
+#undef wxASSERT_VALID_INDEX

 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 
 #include "wx/ioswrap.h"
 
 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 
 #include "wx/ioswrap.h"
 

-WXDLLEXPORT istream& operator>>(istream&, wxString&);
-WXDLLEXPORT ostream& operator<<(ostream&, const wxString&);
+WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
+WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);

 
 #endif  // wxSTD_STRING_COMPATIBILITY
 
 
 #endif  // wxSTD_STRING_COMPATIBILITY