make the length of string proportional to the parameter to study test time dependency...

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

diff --git a/src/common/string.cpp b/src/common/string.cpp
index f413b031fd79c9c1b92e58e28794f5d40a26fe38..c97125d2c46b1c6bd73fa3cd270ea54bae912297 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -35,10 +35,6 @@
 #include <string.h>
 #include <stdlib.h>
 
 #include <string.h>
 #include <stdlib.h>
 

-#ifdef __SALFORDC__
-    #include <clib.h>
-#endif
-

 #include "wx/hashmap.h"
 
 // string handling functions used by wxString:
 #include "wx/hashmap.h"
 
 // string handling functions used by wxString:


@@ -62,6 +58,80 @@
 //According to STL _must_ be a -1 size_t
 const size_t wxString::npos = (size_t) -1;
 
 //According to STL _must_ be a -1 size_t
 const size_t wxString::npos = (size_t) -1;
 

+#if wxUSE_STRING_POS_CACHE
+wxTLS_TYPE(wxString::Cache) wxString::ms_cache;
+
+// gdb seems to be unable to display thread-local variables correctly, at least
+// not my 6.4.98 version under amd64, so provide this debugging helper to do it
+#ifdef __WXDEBUG__
+
+struct wxStrCacheDumper
+{
+    static void ShowAll()
+    {
+        puts("*** wxString cache dump:");
+        for ( unsigned n = 0; n < wxString::Cache::SIZE; n++ )
+        {
+            const wxString::Cache::Element&
+                c = wxString::ms_cache.cached[n];
+
+            printf("\t%u%s\t%p: pos=(%lu, %lu), len=%ld\n",
+                   n,
+                   n == wxString::ms_cache.lastUsed ? " [*]" : "",
+                   c.str,
+                   (unsigned long)c.pos,
+                   (unsigned long)c.impl,
+                   (long)c.len);
+        }
+    }
+};
+
+void wxDumpStrCache() { wxStrCacheDumper::ShowAll(); }
+
+#endif // __WXDEBUG__
+
+#ifdef wxPROFILE_STRING_CACHE
+
+wxString::CacheStats wxString::ms_cacheStats;
+
+namespace
+{
+
+struct ShowCacheStats
+{
+    ~ShowCacheStats()
+    {
+        const wxString::CacheStats& stats = wxString::ms_cacheStats;
+
+        if ( stats.postot )
+        {
+            puts("*** wxString cache statistics:");
+            printf("\tTotal non-trivial calls to PosToImpl(): %u\n",
+                   stats.postot);
+            printf("\tHits %u (of which %u not used) or %.2f%%\n",
+                   stats.poshits,
+                   stats.mishits,
+                   100.*float(stats.poshits - stats.mishits)/stats.postot);
+            printf("\tAverage position requested: %.2f\n",
+                   float(stats.sumpos) / stats.postot);
+            printf("\tAverage offset after cached hint: %.2f\n",
+                   float(stats.sumofs) / stats.postot);
+        }
+
+        if ( stats.lentot )
+        {
+            printf("\tNumber of calls to length(): %u, hits=%.2f%%\n",
+                   stats.lentot, 100.*float(stats.lenhits)/stats.lentot);
+        }
+    }
+} s_showCacheStats;
+
+} // anonymous namespace
+
+#endif // wxPROFILE_STRING_CACHE
+
+#endif // wxUSE_STRING_POS_CACHE
+

 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------


@@ -127,22 +197,30 @@ void wxString::PosLenToImpl(size_t pos, size_t len,
                             size_t *implPos, size_t *implLen) const
 {
     if ( pos == npos )
                             size_t *implPos, size_t *implLen) const
 {
     if ( pos == npos )

+    {

         *implPos = npos;
         *implPos = npos;

-    else
+    }
+    else // have valid start position

     {
     {

-        const_iterator i = begin() + pos;
-        *implPos = wxStringImpl::const_iterator(i.impl()) - m_impl.begin();
+        const const_iterator b = GetIterForNthChar(pos);
+        *implPos = wxStringImpl::const_iterator(b.impl()) - m_impl.begin();

         if ( len == npos )
         if ( len == npos )

+        {

             *implLen = npos;
             *implLen = npos;

-        else
+        }
+        else // have valid length too

         {
         {

-            // too large length is interpreted as "to the end of the string"
-            // FIXME-UTF8: verify this is the case in std::string, assert
-            // otherwise
-            if ( pos + len > length() )
-                len = length() - pos;
-
-            *implLen = (i + len).impl() - i.impl();
+            // we need to handle the case of length specifying a substring
+            // going beyond the end of the string, just as std::string does
+            const const_iterator e(end());
+            const_iterator i(b);
+            while ( len && i <= e )
+            {
+                ++i;
+                --len;
+            }
+
+            *implLen = i.impl() - b.impl();

         }
     }
 }
         }
     }
 }


@@ -373,6 +451,9 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
         // UTF-8 sequence and psz may be invalid:
         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
         {
         // UTF-8 sequence and psz may be invalid:
         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
         {

+            // we must pass the real string length to SubstrBufFromMB ctor
+            if ( nLength == npos )
+                nLength = psz ? strlen(psz) : 0;

             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
         }
         // else: do the roundtrip through wchar_t*
             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
         }
         // else: do the roundtrip through wchar_t*


@@ -1238,35 +1319,59 @@ size_t wxString::Replace(const wxString& strOld,
     wxCHECK_MSG( !strOld.empty(), 0,
                  _T("wxString::Replace(): invalid parameter") );
 
     wxCHECK_MSG( !strOld.empty(), 0,
                  _T("wxString::Replace(): invalid parameter") );
 

+    wxSTRING_INVALIDATE_CACHE();
+

     size_t uiCount = 0;   // count of replacements made
 
     size_t uiCount = 0;   // count of replacements made
 

-    size_t uiOldLen = strOld.length();
-    size_t uiNewLen = strNew.length();
+    // optimize the special common case: replacement of one character by
+    // another one (in UTF-8 case we can only do this for ASCII characters)
+    //
+    // benchmarks show that this special version is around 3 times faster
+    // (depending on the proportion of matching characters and UTF-8/wchar_t
+    // build)
+    if ( strOld.m_impl.length() == 1 && strNew.m_impl.length() == 1 )
+    {
+        const wxStringCharType chOld = strOld.m_impl[0],
+                               chNew = strNew.m_impl[0];
+
+        // this loop is the simplified version of the one below
+        for ( size_t pos = 0; ; )
+        {
+            pos = m_impl.find(chOld, pos);
+            if ( pos == npos )
+                break;

 
 

-    size_t dwPos = 0;
+            m_impl[pos++] = chNew;

 
 

-    while ( (*this)[dwPos] != wxT('\0') )
+            uiCount++;
+
+            if ( !bReplaceAll )
+                break;
+        }
+    }
+    else // general case

     {
     {

-        //DO NOT USE STRSTR HERE
-        //this string can contain embedded null characters,
-        //so strstr will function incorrectly
-        dwPos = find(strOld, dwPos);
-        if ( dwPos == npos )
-            break;                  // exit the loop
-        else
+        const size_t uiOldLen = strOld.m_impl.length();
+        const size_t uiNewLen = strNew.m_impl.length();
+
+        for ( size_t pos = 0; ; )

         {
         {

-            //replace this occurance of the old string with the new one
-            replace(dwPos, uiOldLen, strNew, uiNewLen);
+            pos = m_impl.find(strOld.m_impl, pos);
+            if ( pos == npos )
+                break;

 
 

-            //move up pos past the string that was replaced
-            dwPos += uiNewLen;
+            // replace this occurrence of the old string with the new one
+            m_impl.replace(pos, uiOldLen, strNew.m_impl);

 
 

-            //increase replace count
-            ++uiCount;
+            // move up pos past the string that was replaced
+            pos += uiNewLen;

 
 

-            // stop now?
+            // increase replace count
+            uiCount++;
+
+            // stop after the first one?

             if ( !bReplaceAll )
             if ( !bReplaceAll )

-                break;                  // exit the loop
+                break;

         }
     }
 
         }
     }
 


@@ -1342,6 +1447,20 @@ wxString& wxString::MakeLower()
   return *this;
 }
 
   return *this;
 }
 

+wxString& wxString::MakeCapitalized()
+{
+    const iterator en = end();
+    iterator it = begin();
+    if ( it != en )
+    {
+        *it = (wxChar)wxToupper(*it);
+        for ( ++it; it != en; ++it )
+            *it = (wxChar)wxTolower(*it);
+    }
+
+    return *this;
+}
+

 // ---------------------------------------------------------------------------
 // trimming and padding
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // trimming and padding
 // ---------------------------------------------------------------------------


@@ -1946,13 +2065,6 @@ int wxString::Freq(wxUniChar ch) const
     return count;
 }
 
     return count;
 }
 

-// convert to upper case, return the copy of the string
-wxString wxString::Upper() const
-{ wxString s(*this); return s.MakeUpper(); }
-
-// convert to lower case, return the copy of the string
-wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }
-

 // ----------------------------------------------------------------------------
 // wxUTF8StringBuffer
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxUTF8StringBuffer
 // ----------------------------------------------------------------------------


@@ -1981,3 +2093,15 @@ wxUTF8StringBufferLength::~wxUTF8StringBufferLength()
     wbuf.SetLength(wlen);
 }
 #endif // wxUSE_UNICODE_WCHAR
     wbuf.SetLength(wlen);
 }
 #endif // wxUSE_UNICODE_WCHAR

+
+// ----------------------------------------------------------------------------
+// wxCharBufferType<T>
+// ----------------------------------------------------------------------------
+
+template<>
+wxCharTypeBuffer<char>::Data
+wxCharTypeBuffer<char>::NullData(NULL);
+
+template<>
+wxCharTypeBuffer<wchar_t>::Data
+wxCharTypeBuffer<wchar_t>::NullData(NULL);