avoiding nesting dcs on the same window concurrently

[wxWidgets.git] / src / common / string.cpp

diff --git a/src/common/string.cpp b/src/common/string.cpp
index 04969d3246ef660245d303f0a5c9b27e91dbc165..c2bab603e26cf52cb7844689add9f9fdfc078df7 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -86,44 +86,8 @@ extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy;
 
 #if wxUSE_STD_IOSTREAM
 
 
 #if wxUSE_STD_IOSTREAM
 

-// MS Visual C++ version 5.0 provides the new STL headers as well as the old
-// iostream ones.
-//
-// ATTN: you can _not_ use both of these in the same program!
-

 #include <iostream>
 
 #include <iostream>
 

-wxSTD istream& operator>>(wxSTD istream& is, wxString& WXUNUSED(str))
-{
-#if 0
-  int w = is.width(0);
-  if ( is.ipfx(0) ) {
-    streambuf *sb = is.rdbuf();
-    str.erase();
-    while ( true ) {
-      int ch = sb->sbumpc ();
-      if ( ch == EOF ) {
-        is.setstate(ios::eofbit);
-        break;
-      }
-      else if ( isspace(ch) ) {
-        sb->sungetc();
-        break;
-      }
-
-      str += ch;
-      if ( --w == 1 )
-        break;
-    }
-  }
-
-  is.isfx();
-  if ( str.length() == 0 )
-    is.setstate(ios::failbit);
-#endif
-  return is;
-}
-

 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
 {
 #ifdef __BORLANDC__
 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
 {
 #ifdef __BORLANDC__


@@ -210,8 +174,16 @@ void wxStringBase::InitWith(const wxChar *psz, size_t nPos, size_t nLength)
 // poor man's iterators are "void *" pointers
 wxStringBase::wxStringBase(const void *pStart, const void *pEnd)
 {
 // poor man's iterators are "void *" pointers
 wxStringBase::wxStringBase(const void *pStart, const void *pEnd)
 {

-  InitWith((const wxChar *)pStart, 0,
-           (const wxChar *)pEnd - (const wxChar *)pStart);
+  if ( pEnd >= pStart )
+  {
+    InitWith((const wxChar *)pStart, 0,
+             (const wxChar *)pEnd - (const wxChar *)pStart);
+  }
+  else
+  {
+    wxFAIL_MSG( _T("pStart is not before pEnd") );
+    Init();
+  }

 }
 
 wxStringBase::wxStringBase(size_type n, wxChar ch)
 }
 
 wxStringBase::wxStringBase(size_type n, wxChar ch)


@@ -470,36 +442,47 @@ void wxStringBase::swap(wxStringBase& str)
 
 size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
 {
 
 size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
 {

+    // deal with the special case of empty string first
+    const size_t nLen = length();
+    const size_t nLenOther = str.length();
+
+    if ( !nLenOther )
+    {
+        // empty string is a substring of anything
+        return 0;
+    }
+
+    if ( !nLen )
+    {
+        // the other string is non empty so can't be our substring
+        return npos;
+    }
+

     wxASSERT( str.GetStringData()->IsValid() );
     wxASSERT( str.GetStringData()->IsValid() );

-    wxASSERT( nStart <= length() );
+    wxASSERT( nStart <= nLen );
+
+    const wxChar * const other = str.c_str();

 
 

-    //anchor
+    // anchor

     const wxChar* p = (const wxChar*)wxTmemchr(c_str() + nStart,
     const wxChar* p = (const wxChar*)wxTmemchr(c_str() + nStart,

-                                               str.c_str()[0],
-                                               length() - nStart);
+                                               *other,
+                                               nLen - nStart);

 
 

-    if(!p)
+    if ( !p )

         return npos;
 
         return npos;
 

-    while(p - c_str() + str.length() <= length() &&
-          wxTmemcmp(p, str.c_str(), str.length()) )
+    while ( p - c_str() + nLenOther <= nLen && wxTmemcmp(p, other, nLenOther) )

     {
     {

-        //Previosly passed as the first argument to wxTmemchr,
-        //but C/C++ standard does not specify evaluation order
-        //of arguments to functions -
-        //http://embedded.com/showArticle.jhtml?articleID=9900607
-        ++p;
-
-        //anchor again
-        p = (const wxChar*)wxTmemchr(p,
-                                     str.c_str()[0],
-                                     length() - (p - c_str()));
-
-        if(!p)
+        p++;
+
+        // anchor again
+        p = (const wxChar*)wxTmemchr(p, *other, nLen - (p - c_str()));
+
+        if ( !p )

             return npos;
     }
 
             return npos;
     }
 

-    return (p - c_str() + str.length() <= length()) ? p - c_str() : npos;
+    return p - c_str() + nLenOther <= nLen ? p - c_str() : npos;

 }
 
 size_t wxStringBase::find(const wxChar* sz, size_t nStart, size_t n) const
 }
 
 size_t wxStringBase::find(const wxChar* sz, size_t nStart, size_t n) const


@@ -1140,70 +1123,70 @@ wxString& wxString::operator=(const wchar_t *pwz)
 wxString operator+(const wxString& str1, const wxString& str2)
 {
 #if !wxUSE_STL
 wxString operator+(const wxString& str1, const wxString& str2)
 {
 #if !wxUSE_STL

-  wxASSERT( str1.GetStringData()->IsValid() );
-  wxASSERT( str2.GetStringData()->IsValid() );
+    wxASSERT( str1.GetStringData()->IsValid() );
+    wxASSERT( str2.GetStringData()->IsValid() );

 #endif
 
 #endif
 

-  wxString s = str1;
-  s += str2;
+    wxString s = str1;
+    s += str2;

 
 

-  return s;
+    return s;

 }
 
 wxString operator+(const wxString& str, wxChar ch)
 {
 #if !wxUSE_STL
 }
 
 wxString operator+(const wxString& str, wxChar ch)
 {
 #if !wxUSE_STL

-  wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT( str.GetStringData()->IsValid() );

 #endif
 
 #endif
 

-  wxString s = str;
-  s += ch;
+    wxString s = str;
+    s += ch;

 
 

-  return s;
+    return s;

 }
 
 wxString operator+(wxChar ch, const wxString& str)
 {
 #if !wxUSE_STL
 }
 
 wxString operator+(wxChar ch, const wxString& str)
 {
 #if !wxUSE_STL

-  wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT( str.GetStringData()->IsValid() );

 #endif
 
 #endif
 

-  wxString s = ch;
-  s += str;
+    wxString s = ch;
+    s += str;

 
 

-  return s;
+    return s;

 }
 
 wxString operator+(const wxString& str, const wxChar *psz)
 {
 #if !wxUSE_STL
 }
 
 wxString operator+(const wxString& str, const wxChar *psz)
 {
 #if !wxUSE_STL

-  wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT( str.GetStringData()->IsValid() );

 #endif
 
 #endif
 

-  wxString s;
-  if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
-    wxFAIL_MSG( _T("out of memory in wxString::operator+") );
-  }
-  s += str;
-  s += psz;
+    wxString s;
+    if ( !s.Alloc(wxStrlen(psz) + str.length()) ) {
+        wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+    }
+    s += str;
+    s += psz;

 
 

-  return s;
+    return s;

 }
 
 wxString operator+(const wxChar *psz, const wxString& str)
 {
 #if !wxUSE_STL
 }
 
 wxString operator+(const wxChar *psz, const wxString& str)
 {
 #if !wxUSE_STL

-  wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT( str.GetStringData()->IsValid() );

 #endif
 
 #endif
 

-  wxString s;
-  if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
-    wxFAIL_MSG( _T("out of memory in wxString::operator+") );
-  }
-  s = psz;
-  s += str;
+    wxString s;
+    if ( !s.Alloc(wxStrlen(psz) + str.length()) ) {
+        wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+    }
+    s = psz;
+    s += str;

 
 

-  return s;
+    return s;

 }
 
 // ===========================================================================
 }
 
 // ===========================================================================


@@ -1606,65 +1589,65 @@ inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
 // trims spaces (in the sense of isspace) from left or right side
 wxString& wxString::Trim(bool bFromRight)
 {
 // trims spaces (in the sense of isspace) from left or right side
 wxString& wxString::Trim(bool bFromRight)
 {

-  // first check if we're going to modify the string at all
-  if ( !empty() &&
-       (
-        (bFromRight && wxSafeIsspace(GetChar(Len() - 1))) ||
-        (!bFromRight && wxSafeIsspace(GetChar(0u)))
+    // first check if we're going to modify the string at all
+    if ( !empty() &&
+         (
+          (bFromRight && wxSafeIsspace(GetChar(length() - 1))) ||
+          (!bFromRight && wxSafeIsspace(GetChar(0u)))
+         )

        )
        )

-     )
-  {
-    if ( bFromRight )
-    {
-      // find last non-space character
-      iterator psz = begin() + length() - 1;
-      while ( wxSafeIsspace(*psz) && (psz >= begin()) )
-        psz--;
-
-      // truncate at trailing space start
-      *++psz = wxT('\0');
-      erase(psz, end());
-    }
-    else

     {
     {

-      // find first non-space character
-      iterator psz = begin();
-      while ( wxSafeIsspace(*psz) )
-        psz++;
+        if ( bFromRight )
+        {
+            // find last non-space character
+            reverse_iterator psz = rbegin();
+            while ( (psz != rend()) && wxSafeIsspace(*psz) )
+                psz++;
+            
+            // truncate at trailing space start
+            erase(psz.base(), end());
+        }
+        else
+        {
+            // find first non-space character
+            iterator psz = begin();
+            while ( (psz != end()) && wxSafeIsspace(*psz) )
+                psz++;

 
 

-      // fix up data and length
-      erase(begin(), psz);
+            // fix up data and length
+            erase(begin(), psz);
+        }

     }
     }

-  }

 
 

-  return *this;
+    return *this;

 }
 
 // adds nCount characters chPad to the string from either side
 wxString& wxString::Pad(size_t nCount, wxChar chPad, bool bFromRight)
 {
 }
 
 // adds nCount characters chPad to the string from either side
 wxString& wxString::Pad(size_t nCount, wxChar chPad, bool bFromRight)
 {

-  wxString s(chPad, nCount);
+    wxString s(chPad, nCount);

 
 

-  if ( bFromRight )
-    *this += s;
-  else
-  {
-    s += *this;
-    swap(s);
-  }
+    if ( bFromRight )
+        *this += s;
+    else
+    {
+        s += *this;
+        swap(s);
+    }

 
 

-  return *this;
+    return *this;

 }
 
 // truncate the string
 wxString& wxString::Truncate(size_t uiLen)
 {
 }
 
 // truncate the string
 wxString& wxString::Truncate(size_t uiLen)
 {

-  if ( uiLen < Len() ) {
-    erase(begin() + uiLen, end());
-  }
-  //else: nothing to do, string is already short enough
+    if ( uiLen < length() )
+    {
+        erase(begin() + uiLen, end());
+    }
+    //else: nothing to do, string is already short enough

 
 

-  return *this;
+    return *this;

 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------


@@ -1674,17 +1657,17 @@ wxString& wxString::Truncate(size_t uiLen)
 // find a character
 int wxString::Find(wxChar ch, bool bFromEnd) const
 {
 // find a character
 int wxString::Find(wxChar ch, bool bFromEnd) const
 {

-  size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);
+    size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);

 
 

-  return (idx == npos) ? wxNOT_FOUND : (int)idx;
+    return (idx == npos) ? wxNOT_FOUND : (int)idx;

 }
 
 // find a sub-string (like strstr)
 int wxString::Find(const wxChar *pszSub) const
 {
 }
 
 // find a sub-string (like strstr)
 int wxString::Find(const wxChar *pszSub) const
 {

-  size_type idx = find(pszSub);
+    size_type idx = find(pszSub);

 
 

-  return (idx == npos) ? wxNOT_FOUND : (int)idx;
+    return (idx == npos) ? wxNOT_FOUND : (int)idx;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1819,7 +1802,7 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
     // we could have overshot
     Shrink();
 
     // we could have overshot
     Shrink();
 

-    return Len();
+    return length();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1968,7 +1951,7 @@ match:
 int wxString::Freq(wxChar ch) const
 {
     int count = 0;
 int wxString::Freq(wxChar ch) const
 {
     int count = 0;

-    int len = Len();
+    int len = length();

     for (int i = 0; i < len; i++)
     {
         if (GetChar(i) == ch)
     for (int i = 0; i < len; i++)
     {
         if (GetChar(i) == ch)


@@ -2397,19 +2380,7 @@ void wxArrayString::assign(const_iterator first, const_iterator last)
 #if wxUSE_THREADS
   // need a critical section to protect access to gs_compareFunction and
   // gs_sortAscending variables
 #if wxUSE_THREADS
   // need a critical section to protect access to gs_compareFunction and
   // gs_sortAscending variables

-  static wxCriticalSection *gs_critsectStringSort = NULL;
-
-  // call this before the value of the global sort vars is changed/after
-  // you're finished with them
-  #define START_SORT()     wxASSERT( !gs_critsectStringSort );                \
-                           gs_critsectStringSort = new wxCriticalSection;     \
-                           gs_critsectStringSort->Enter()
-  #define END_SORT()       gs_critsectStringSort->Leave();                    \
-                           delete gs_critsectStringSort;                      \
-                           gs_critsectStringSort = NULL
-#else // !threads
-  #define START_SORT()
-  #define END_SORT()
+  static wxCriticalSection gs_critsectStringSort;

 #endif // wxUSE_THREADS
 
 // function to use for string comparaison
 #endif // wxUSE_THREADS
 
 // function to use for string comparaison


@@ -2440,7 +2411,7 @@ wxStringCompareFunction(const void *first, const void *second)
 // sort array elements using passed comparaison function
 void wxArrayString::Sort(CompareFunction compareFunction)
 {
 // sort array elements using passed comparaison function
 void wxArrayString::Sort(CompareFunction compareFunction)
 {

-  START_SORT();
+  wxCRIT_SECT_LOCKER(lockCmpFunc, gs_critsectStringSort);

 
   wxASSERT( !gs_compareFunction );  // must have been reset to NULL
   gs_compareFunction = compareFunction;
 
   wxASSERT( !gs_compareFunction );  // must have been reset to NULL
   gs_compareFunction = compareFunction;


@@ -2449,8 +2420,6 @@ void wxArrayString::Sort(CompareFunction compareFunction)
 
   // reset it to NULL so that Sort(bool) will work the next time
   gs_compareFunction = NULL;
 
   // reset it to NULL so that Sort(bool) will work the next time
   gs_compareFunction = NULL;

-
-  END_SORT();

 }
 
 extern "C"
 }
 
 extern "C"