wxFAIL_MSG( _T("out of memory in wxStringBase::InitWith") );
return;
}
- memcpy(m_pchData, psz + nPos, nLength*sizeof(wxChar));
+ wxMemcpy(m_pchData, psz + nPos, nLength);
}
}
wxASSERT( str.GetStringData()->IsValid() );
wxASSERT( nStart <= length() );
- const wxChar *p = wxStrstr(c_str() + nStart, str.c_str());
+ //anchor
+ const wxChar* p = (const wxChar*)wxMemchr(c_str() + nStart,
+ str.c_str()[0],
+ length() - nStart);
- return p == NULL ? npos : p - c_str();
+ if(!p)
+ return npos;
+
+ while(p - c_str() + str.length() <= length() &&
+ wxMemcmp(p, str.c_str(), str.length()) )
+ {
+ //anchor again
+ p = (const wxChar*)wxMemchr(++p,
+ str.c_str()[0],
+ length() - (p - c_str()));
+
+ if(!p)
+ return npos;
+ }
+
+ return (p - c_str() + str.length() <= length()) ? p - c_str() : npos;
}
size_t wxStringBase::find(const wxChar* sz, size_t nStart, size_t n) const
{
wxASSERT( nStart <= length() );
- const wxChar *p = wxStrchr(c_str() + nStart, ch);
+ const wxChar *p = (const wxChar*)wxMemchr(c_str() + nStart, ch, length() - nStart);
return p == NULL ? npos : p - c_str();
}
const wxChar *cursor = c_str() + top;
do
{
- if ( memcmp(cursor, str.c_str(),
- str.length() * sizeof(wxChar)) == 0 )
+ if ( wxMemcmp(cursor, str.c_str(),
+ str.length()) == 0 )
{
return cursor - c_str();
}
size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart) const
{
- const wxChar *start = c_str() + nStart;
- const wxChar *firstOf = wxStrpbrk(start, sz);
- if ( firstOf )
- return firstOf - c_str();
- else
+ wxASSERT(nStart <= length());
+
+ size_t len = wxStrlen(sz);
+
+ size_t i;
+ for(i = nStart; i < this->length(); ++i)
+ {
+ if (wxMemchr(sz, *(c_str() + i), len))
+ break;
+ }
+
+ if(i == this->length())
return npos;
+ else
+ return i;
}
size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart,
_T("invalid index in find_last_of()") );
}
+ size_t len = wxStrlen(sz);
+
for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
{
- if ( wxStrchr(sz, *p) )
+ if ( wxMemchr(sz, *p, len) )
return p - c_str();
}
wxASSERT( nStart <= length() );
}
- size_t nAccept = wxStrspn(c_str() + nStart, sz);
- if ( nAccept >= length() - nStart )
- return npos;
- else
- return nStart + nAccept;
+ size_t len = wxStrlen(sz);
+
+ size_t i;
+ for(i = nStart; i < this->length(); ++i)
+ {
+ if (!wxMemchr(sz, *(c_str() + i), len))
+ break;
+ }
+
+ if(i == this->length())
+ return npos;
+ else
+ return i;
}
size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart,
wxASSERT( nStart <= length() );
}
+ size_t len = wxStrlen(sz);
+
for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
{
- if ( !wxStrchr(sz, *p) )
- return p - c_str();
+ if ( !wxMemchr(sz, *p,len) )
+ return p - c_str();
}
return npos;
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,
const wxChar* s2, size_t l2)
{
if( l1 == l2 )
- return wxStrncmp(s1, s2, l1);
+ return wxMemcmp(s1, s2, l1);
else if( l1 < l2 )
{
- int ret = wxStrncmp(s1, s2, l1);
+ int ret = wxMemcmp(s1, s2, l1);
return ret == 0 ? -1 : ret;
}
else if( l1 > l2 )
{
- int ret = wxStrncmp(s1, s2, l2);
+ int ret = wxMemcmp(s1, s2, l2);
return ret == 0 ? +1 : ret;
}
return 0; // quiet compilers
}
-#if wxUSE_STL
-
int STRINGCLASS::compare(const wxStringBase& str) const
{
return ::wxDoCmp(data(), length(), str.data(), str.length());
}
-#endif
-
int STRINGCLASS::compare(size_t nStart, size_t nLen,
const wxStringBase& str) const
{
return ::wxDoCmp(data() + nStart, nLen, str.data() + nStart2, nLen2);
}
-#if wxUSE_STL
-
int STRINGCLASS::compare(const wxChar* sz) const
{
size_t nLen = wxStrlen(sz);
return ::wxDoCmp(data(), length(), sz, nLen);
}
-#endif
-
int STRINGCLASS::compare(size_t nStart, size_t nLen,
const wxChar* sz, size_t nCount) const
{
// ===========================================================================
// ---------------------------------------------------------------------------
-// construction
+// common conversion routines
+// ---------------------------------------------------------------------------
+
+#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,
+ 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;
+
+ //Convert the string until the length() is reached, continuing the
+ //loop every time a null character is reached
+ while(szPos != szEnd)
+ {
+ wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
+
+ //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
+
+ nActualLength += nLen + 1;
+
+ wxASSERT(nActualLength <= (nStringLen<<1) + 1); //If this is true it means buffer overflow
+
+ //Convert the current (sub)string
+ if ( conv.WC2MB(&buffer.data()[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';
+ 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;
+ }
+
+ 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)
+{
+ 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)
+ {
+ wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
+
+ //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
+
+ nActualLength += nLen + 1;
+
+ wxASSERT(nActualLength <= nStringLen + 1); //If this is true it means buffer overflow
+
+ //Convert the current (sub)string
+ if ( conv.MB2WC(&buffer.data()[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';
+ 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;
+ }
+
+ return nActualLength - 1; //success - return actual length
+}
+
+#endif //wxUSE_WCHAR_T
+
+// ---------------------------------------------------------------------------
+// construction and conversion
// ---------------------------------------------------------------------------
#if wxUSE_UNICODE
if ( psz )
{
// calculate the needed size ourselves or use the provided one
- nLen = conv.MB2WC(NULL, psz, 0);
+ if (nLength == npos)
+ nLen = strlen(psz);
+ else
+ nLen = nLength;
}
else
{
// anything to do?
if ( (nLen != 0) && (nLen != (size_t)-1) )
{
- if ( !Alloc(nLen) )
+ //When converting mb->wc it never inflates to more characters than the length
+ wxWCharBuffer buffer(nLen + 1);
+
+ //Convert the string
+ size_t nActualLength = wxWcstr(buffer, psz, nLen, conv);
+
+ if ( !Alloc(nActualLength + 1) )
{
- wxFAIL_MSG( _T("out of memory in wxString::wxString") );
+ wxFAIL_MSG(wxT("Out of memory in wxString"));
}
else
{
- wxWCharBuffer buf(nLen);
- // MB2WC wants the buffer size, not the string length hence +1
- nLen = conv.MB2WC(buf.data(), psz, nLen + 1);
-
- if ( nLen != (size_t)-1 )
- {
- // initialized ok, set the real length as nLength specified by
- // the caller could be greater than the real string length
- assign(buf.data(), nLen);
- return;
- }
- //else: the conversion failed -- leave the string empty (what else?)
+ //Copy the data
+ assign(buffer.data(), nActualLength);
}
}
}
+//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);
+
+ //Do the actual conversion (will return a blank string on error)
+ wxMbstr(buffer, (*this).c_str(), length(), conv);
+
+ return buffer;
+}
+
#else // ANSI
#if wxUSE_WCHAR_T
if ( pwz )
{
// calculate the needed size ourselves or use the provided one
- nLen = conv.WC2MB(NULL, pwz, 0);
+ if (nLength == npos)
+ nLen = wxWcslen(pwz);
+ else
+ nLen = nLength;
}
else
{
// anything to do?
if ( (nLen != 0) && (nLen != (size_t)-1) )
{
- if ( !Alloc(nLen) )
+ //*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( _T("out of memory in wxString::wxString") );
+ wxFAIL_MSG(wxT("Out of memory in wxString"));
}
else
{
- wxCharBuffer buf(nLen);
- // WC2MB wants the buffer size, not the string length
- if ( conv.WC2MB(buf.data(), pwz, nLen + 1) != (size_t)-1 )
- {
- // initialized ok
- assign(buf.data(), nLen);
- return;
- }
- //else: the conversion failed -- leave the string empty (what else?)
+ //copy the data
+ assign(buffer.data(), nActualLength);
}
}
+}
+
+//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);
- // leave empty
+ //Do the actual conversion (will return a blank string on error)
+ wxWcstr(buffer, (*this).c_str(), length(), conv);
+
+ return buffer;
}
+
#endif // wxUSE_WCHAR_T
#endif // Unicode/ANSI
// other common string functions
// ===========================================================================
+int wxString::Cmp(const wxString& s) const
+{
+ return compare(s);
+}
+
+int wxString::Cmp(const wxChar* psz) const
+{
+ return compare(psz);
+}
+
+static inline int wxDoCmpNoCase(const wxChar* s1, size_t l1,
+ const wxChar* s2, size_t l2)
+{
+ size_t i;
+
+ if( l1 == l2 )
+ {
+ for(i = 0; i < l1; ++i)
+ {
+ if(wxTolower(s1[i]) != wxTolower(s2[i]))
+ break;
+ }
+ return i == l1 ? 0 : s1[i] < s2[i] ? -1 : 1;
+ }
+ else if( l1 < l2 )
+ {
+ for(i = 0; i < l1; ++i)
+ {
+ if(wxTolower(s1[i]) != wxTolower(s2[i]))
+ break;
+ }
+ return i == l1 ? -1 : s1[i] < s2[i] ? -1 : 1;
+ }
+ else if( l1 > l2 )
+ {
+ for(i = 0; i < l2; ++i)
+ {
+ if(wxTolower(s1[i]) != wxTolower(s2[i]))
+ break;
+ }
+ return i == l2 ? 1 : s1[i] < s2[i] ? -1 : 1;
+ }
+
+ wxFAIL; // must never get there
+ return 0; // quiet compilers
+}
+
+int wxString::CmpNoCase(const wxString& s) const
+{
+ return wxDoCmpNoCase(data(), length(), s.data(), s.length());
+}
+
+int wxString::CmpNoCase(const wxChar* psz) const
+{
+ int nLen = wxStrlen(psz);
+
+ return wxDoCmpNoCase(data(), length(), psz, nLen);
+}
+
+
#if wxUSE_UNICODE
#ifdef __MWERKS__
while ( lo < hi ) {
i = (lo + hi)/2;
- res = wxStrcmp(str, m_pItems[i]);
+ res = str.Cmp(m_pItems[i]);
if ( res < 0 )
hi = i;
else if ( res > 0 )
}
else {
// maybe we should use wxStrcoll
- int result = wxStrcmp(strFirst->c_str(), strSecond->c_str());
+ int result = strFirst->Cmp(*strSecond);
return gs_sortAscending ? result : -result;
}
int wxCMPFUNC_CONV wxStringSortAscending(wxString* s1, wxString* s2)
{
- return wxStrcmp(s1->c_str(), s2->c_str());
+ return s1->Cmp(*s2);
}
int wxCMPFUNC_CONV wxStringSortDescending(wxString* s1, wxString* s2)
{
- return -wxStrcmp(s1->c_str(), s2->c_str());
+ return -s1->Cmp(*s2);
}