// 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
// 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
-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;
//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;
- 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
- 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"));
- buffer.data()[0] = '\0';
+ szBuffer[0] = '\0';
return 0;
}
//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;
//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;
- 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
- 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"));
- buffer.data()[0] = '\0';
+ szBuffer[0] = '\0';
return 0;
}
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
{
- //*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)
- wxMbstr(buffer, (*this).c_str(), length(), conv);
+ wxMbstr(buffer.data(), (*this).c_str(), length(), conv);
return buffer;
}
// 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)
+ );
}
}
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;
}
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
{
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++;
projects / wxWidgets.git / blobdiff