wxMac uses wxStandardPathsCF to mean wxStandardPaths in its wxBase

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

diff --git a/src/common/string.cpp b/src/common/string.cpp
index b0060120421e565cc59df39952a983ec875eb23c..f6b388e45b4beec140603d250197c56a5524aa65 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -273,7 +273,7 @@ bool wxStringBase::CopyBeforeWrite()
       // allocation failures are handled by the caller
       return false;
     }
       // allocation failures are handled by the caller
       return false;
     }

-    memcpy(m_pchData, pData->data(), nLen*sizeof(wxChar));
+    wxMemcpy(m_pchData, pData->data(), nLen);

   }
 
   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner
   }
 
   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner


@@ -475,10 +475,10 @@ size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
   wxASSERT( nStart <= length() );
 
   //anchor
   wxASSERT( nStart <= length() );
 
   //anchor

-  const wxChar* p = (const wxChar*)wxMemchr(c_str() + nStart, 
-                                            str.c_str()[0], 
+  const wxChar* p = (const wxChar*)wxMemchr(c_str() + nStart,
+                                            str.c_str()[0],

                                             length() - nStart);
                                             length() - nStart);

- 
+

   if(!p)
       return npos;
 
   if(!p)
       return npos;
 


@@ -486,14 +486,14 @@ size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
         wxMemcmp(p, str.c_str(), str.length()) )
   {
       //anchor again
         wxMemcmp(p, str.c_str(), str.length()) )
   {
       //anchor again

-      p = (const wxChar*)wxMemchr(++p, 
-                                  str.c_str()[0], 
+      p = (const wxChar*)wxMemchr(++p,
+                                  str.c_str()[0],

                                   length() - (p - c_str()));
 
       if(!p)
           return npos;
   }
                                   length() - (p - c_str()));
 
       if(!p)
           return npos;
   }

-       
+

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


@@ -609,7 +609,7 @@ size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart) const
     }
 
     size_t len = wxStrlen(sz);
     }
 
     size_t len = wxStrlen(sz);

-    
+

     for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
     {
         if ( wxMemchr(sz, *p, len) )
     for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
     {
         if ( wxMemchr(sz, *p, len) )


@@ -741,7 +741,7 @@ wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
 wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
                                     size_t nCount, wxChar ch)
 {
 wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
                                     size_t nCount, wxChar ch)
 {

-  return replace(nStart, nLen, wxStringBase(ch, nCount).c_str());
+  return replace(nStart, nLen, wxStringBase(nCount, ch).c_str());

 }
 
 wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
 }
 
 wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,


@@ -988,20 +988,26 @@ int STRINGCLASS::compare(size_t nStart, size_t nLen,
 // common conversion routines
 // ---------------------------------------------------------------------------
 
 // common conversion routines
 // ---------------------------------------------------------------------------
 

+size_t wxString::WorstEncodingCase(size_t len, const wxMBConv& WXUNUSED(conv))
+{
+    //Worst case for UTF7
+    return len * 5;
+}
+

 #if wxUSE_WCHAR_T
 
 //Convert a wide character string of a specified length
 //to a multi-byte character string, ignoring intermittent null characters
 //returns the actual length of the string
 #if wxUSE_WCHAR_T
 
 //Convert a wide character string of a specified length
 //to a multi-byte character string, ignoring intermittent null characters
 //returns the actual length of the string

-inline size_t wxMbstr(wxCharBuffer& buffer, const wchar_t* szString, 
+inline size_t wxMbstr(char* szBuffer, const wchar_t* szString,

                       size_t nStringLen, wxMBConv& conv)
 {
     const wchar_t* szEnd = szString + nStringLen + 1;
     const wchar_t* szPos = szString;
     const wchar_t* szStart = szPos;
                       size_t nStringLen, wxMBConv& conv)
 {
     const wchar_t* szEnd = szString + nStringLen + 1;
     const wchar_t* szPos = szString;
     const wchar_t* szStart = szPos;

-    
+

     size_t nActualLength = 0;
     size_t nActualLength = 0;

-        
+

     //Convert the string until the length() is reached, continuing the
     //loop every time a null character is reached
     while(szPos != szEnd)
     //Convert the string until the length() is reached, continuing the
     //loop every time a null character is reached
     while(szPos != szEnd)


@@ -1010,44 +1016,51 @@ inline size_t wxMbstr(wxCharBuffer& buffer, const wchar_t* szString,
 
         //Get the length of the current (sub)string
         size_t nLen = conv.WC2MB(NULL, szPos, 0);
 
         //Get the length of the current (sub)string
         size_t nLen = conv.WC2MB(NULL, szPos, 0);

-        
-        wxASSERT(nLen != (size_t)-1); //should not be true!  If it is system wctomb could be bad
-        
+
+        //Invalid conversion?
+        if( nLen == (size_t)-1 )
+        {
+            szBuffer[0] = '\0';
+            return 0;
+        }
+
+        //Increase the actual length (+1 for current null character)

         nActualLength += nLen + 1;
         nActualLength += nLen + 1;

-        
-        wxASSERT(nActualLength <= (nStringLen<<1) + 1); //If this is true it means buffer overflow
-        
+
+        //If this is true it means buffer overflow
+        wxASSERT( nActualLength <= wxString::WorstEncodingCase(nStringLen, conv) + 1 ); 
+

         //Convert the current (sub)string
         //Convert the current (sub)string

-        if ( conv.WC2MB(&buffer.data()[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
+        if(conv.WC2MB(&szBuffer[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )

         {
             //error - return empty buffer
             wxFAIL_MSG(wxT("Error converting wide-character string to a multi-byte string"));
         {
             //error - return empty buffer
             wxFAIL_MSG(wxT("Error converting wide-character string to a multi-byte string"));

-            buffer.data()[0] = '\0';
+            szBuffer[0] = '\0';

             return 0;
             return 0;

-        }        
-        
+        }
+

         //Increment to next (sub)string
         //Note that we have to use wxWcslen here instead of nLen
         //here because XX2XX gives us the size of the output buffer,
         //not neccessarly the length of the string
         szPos += wxWcslen(szPos) + 1;
     }
         //Increment to next (sub)string
         //Note that we have to use wxWcslen here instead of nLen
         //here because XX2XX gives us the size of the output buffer,
         //not neccessarly the length of the string
         szPos += wxWcslen(szPos) + 1;
     }

-    
+

     return nActualLength - 1;  //success - return actual length
 }
 
 //Convert a multi-byte character string of a specified length
 //to a wide character string, ignoring intermittent null characters
     return nActualLength - 1;  //success - return actual length
 }
 
 //Convert a multi-byte character string of a specified length
 //to a wide character string, ignoring intermittent null characters

-//returns the actual length 
-inline size_t wxWcstr( wxWCharBuffer& buffer, const char* szString, 
-                        size_t nStringLen, wxMBConv& conv)
+//returns the actual length
+inline size_t wxWcstr( wchar_t* szBuffer, const char* szString,
+                       size_t nStringLen, wxMBConv& conv)

 {
     const char* szEnd = szString + nStringLen + 1;
     const char* szPos = szString;
     const char* szStart = szPos;
 
     size_t nActualLength = 0;
 {
     const char* szEnd = szString + nStringLen + 1;
     const char* szPos = szString;
     const char* szStart = szPos;
 
     size_t nActualLength = 0;

-    
+

     //Convert the string until the length() is reached, continuing the
     //loop every time a null character is reached
     while(szPos != szEnd)
     //Convert the string until the length() is reached, continuing the
     //loop every time a null character is reached
     while(szPos != szEnd)


@@ -1056,29 +1069,36 @@ inline size_t wxWcstr(  wxWCharBuffer& buffer, const char* szString,
 
         //Get the length of the current (sub)string
         size_t nLen = conv.MB2WC(NULL, szPos, 0);
 
         //Get the length of the current (sub)string
         size_t nLen = conv.MB2WC(NULL, szPos, 0);

-        
-        wxASSERT(nLen != (size_t)-1); //should not be true!  If it is system mbtowc could be bad
-        
+
+        //Invalid conversion?
+        if( nLen == (size_t)-1 )
+        {
+            szBuffer[0] = '\0';
+            return 0;
+        }
+
+        //Increase the actual length (+1 for current null character)

         nActualLength += nLen + 1;
         nActualLength += nLen + 1;

-        
-        wxASSERT(nActualLength <= nStringLen + 1); //If this is true it means buffer overflow
+
+        //If this is true it means buffer overflow
+        wxASSERT(nActualLength <= nStringLen + 1); 

 
         //Convert the current (sub)string
 
         //Convert the current (sub)string

-        if ( conv.MB2WC(&buffer.data()[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
+        if ( conv.MB2WC(&szBuffer[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )

         {
             //error - return empty buffer
             wxFAIL_MSG(wxT("Error converting multi-byte string to a wide-character string"));
         {
             //error - return empty buffer
             wxFAIL_MSG(wxT("Error converting multi-byte string to a wide-character string"));

-            buffer.data()[0] = '\0';
+            szBuffer[0] = '\0';

             return 0;
             return 0;

-        }        
-        
+        }
+

         //Increment to next (sub)string
         //Note that we have to use strlen here instead of nLen
         //here because XX2XX gives us the size of the output buffer,
         //not neccessarly the length of the string
         szPos += strlen(szPos) + 1;
     }
         //Increment to next (sub)string
         //Note that we have to use strlen here instead of nLen
         //here because XX2XX gives us the size of the output buffer,
         //not neccessarly the length of the string
         szPos += strlen(szPos) + 1;
     }

-    
+

     return nActualLength - 1; //success - return actual length
 }
 
     return nActualLength - 1; //success - return actual length
 }
 


@@ -1127,32 +1147,24 @@ wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
     if ( (nLen != 0) && (nLen != (size_t)-1) )
     {
         //When converting mb->wc it never inflates to more characters than the length
     if ( (nLen != 0) && (nLen != (size_t)-1) )
     {
         //When converting mb->wc it never inflates to more characters than the length

-        wxWCharBuffer buffer(nLen + 1);
+        wxStringBufferLength internalBuffer(*this, nLen + 1);

 
 

-        //Convert the string
-        size_t nActualLength = wxWcstr(buffer, psz, nLen, conv);
-        
-        if ( !Alloc(nActualLength + 1) )
-        {
-            wxFAIL_MSG(wxT("Out of memory in wxString"));
-        }
-        else
-        {
-            //Copy the data
-            assign(buffer.data(), nActualLength);
-        }
+        //Do the actual conversion & Set the length of the buffer
+        internalBuffer.SetLength(
+               wxWcstr(internalBuffer, psz, nLen, conv)
+                                );

     }
     }

-}        
+}

 
 //Convert wxString in Unicode mode to a multi-byte string
 const wxCharBuffer wxString::mb_str(wxMBConv& conv) const
 {
 
 //Convert wxString in Unicode mode to a multi-byte string
 const wxCharBuffer wxString::mb_str(wxMBConv& conv) const
 {

-    //*2 is the worst case - probably for UTF8
-    wxCharBuffer buffer((length() << 1) + 1);
+    //Create the buffer
+    wxCharBuffer buffer( wxString::WorstEncodingCase(length(), conv) + 1);

 
     //Do the actual conversion (will return a blank string on error)
 
     //Do the actual conversion (will return a blank string on error)

-    wxMbstr(buffer, (*this).c_str(), length(), conv);
-    
+    wxMbstr(buffer.data(), (*this).c_str(), length(), conv);
+

     return buffer;
 }
 
     return buffer;
 }
 


@@ -1195,37 +1207,30 @@ wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength)
     // anything to do?
     if ( (nLen != 0) && (nLen != (size_t)-1) )
     {
     // anything to do?
     if ( (nLen != 0) && (nLen != (size_t)-1) )
     {

-        //*2 is the worst case - probably for UTF8
-        wxCharBuffer buffer((nLen << 1) + 1);
-        
-        //do the actual conversion (if it fails we get an empty string)
-        size_t nActualLength = wxMbstr(buffer, pwz, nLen, conv);
-        
-        if ( !Alloc(nActualLength + 1) )
-        {
-            wxFAIL_MSG(wxT("Out of memory in wxString"));
-        }
-        else
-        {
-            //copy the data
-            assign(buffer.data(), nActualLength);
-        }
+        //Create a wxStringBufferLength which will access the internal
+        //C char pointer in non-stl mode
+        wxStringBufferLength internalBuffer(*this, wxString::WorstEncodingCase(nLen, conv) + 1);
+
+        //Do the actual conversion & Set the length of the buffer
+        internalBuffer.SetLength(
+               wxMbstr(internalBuffer, pwz, nLen, conv)
+                                );

     }
 }
 
     }
 }
 

-//Converts this string to a wide character string if unicode 
+//Converts this string to a wide character string if unicode

 //mode is not enabled and wxUSE_WCHAR_T is enabled
 const wxWCharBuffer wxString::wc_str(wxMBConv& conv) const
 {
     //mb->wc never inflates to more than the length
     wxWCharBuffer buffer(length() + 1);
 //mode is not enabled and wxUSE_WCHAR_T is enabled
 const wxWCharBuffer wxString::wc_str(wxMBConv& conv) const
 {
     //mb->wc never inflates to more than the length
     wxWCharBuffer buffer(length() + 1);

-    
+

     //Do the actual conversion (will return a blank string on error)
     //Do the actual conversion (will return a blank string on error)

-    wxWcstr(buffer, (*this).c_str(), length(), conv);
-    
+    wxWcstr(buffer.data(), (*this).c_str(), length(), conv);
+

     return buffer;
 }
     return buffer;
 }

-    
+

 #endif // wxUSE_WCHAR_T
 
 #endif // Unicode/ANSI
 #endif // wxUSE_WCHAR_T
 
 #endif // Unicode/ANSI


@@ -1489,7 +1494,7 @@ const wxCharBuffer wxString::ToAscii() const
     const wchar_t *pwc = c_str();
     for ( ;; )
     {
     const wchar_t *pwc = c_str();
     for ( ;; )
     {

-        *dest++ = *pwc > SCHAR_MAX ? '_' : *pwc;
+        *dest++ = *pwc > SCHAR_MAX ? wxT('_') : *pwc;

 
         // the output string can't have embedded NULs anyhow, so we can safely
         // stop at first of them even if we do have any
 
         // the output string can't have embedded NULs anyhow, so we can safely
         // stop at first of them even if we do have any


@@ -1711,7 +1716,7 @@ bool wxString::IsNumber() const
 {
   const wxChar *s = (const wxChar*) *this;
   if (wxStrlen(s))
 {
   const wxChar *s = (const wxChar*) *this;
   if (wxStrlen(s))

-     if ((s[0] == '-') || (s[0] == '+')) s++;
+     if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++;

   while(*s){
     if(!wxIsdigit(*s)) return(false);
     s++;
   while(*s){
     if(!wxIsdigit(*s)) return(false);
     s++;