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 c199f98b4ce464a73cea24c2ee928e26d5bcd103..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


@@ -988,12 +988,18 @@ 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;
                       size_t nStringLen, wxMBConv& conv)
 {
     const wchar_t* szEnd = szString + nStringLen + 1;


@@ -1011,18 +1017,25 @@ 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;
         }
 


@@ -1039,7 +1052,7 @@ inline size_t wxMbstr(wxCharBuffer& buffer, const wchar_t* szString,
 //Convert a multi-byte character string of a specified length
 //to a wide character string, ignoring intermittent null characters
 //returns the 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,
+inline size_t wxWcstr( wchar_t* szBuffer, const char* szString,

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


@@ -1057,18 +1070,25 @@ 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;
         }
 


@@ -1127,31 +1147,23 @@ 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,21 +1207,14 @@ 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);
+        //Create a wxStringBufferLength which will access the internal
+        //C char pointer in non-stl mode
+        wxStringBufferLength internalBuffer(*this, wxString::WorstEncodingCase(nLen, conv) + 1);

 
 

-        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(
+               wxMbstr(internalBuffer, pwz, nLen, conv)
+                                );

     }
 }
 
     }
 }
 


@@ -1221,7 +1226,7 @@ const wxWCharBuffer wxString::wc_str(wxMBConv& conv) const
     wxWCharBuffer buffer(length() + 1);
 
     //Do the actual conversion (will return a blank string on error)
     wxWCharBuffer buffer(length() + 1);
 
     //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;
 }


@@ -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++;