X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/eae4425db65fd3399aecdc70a8a05cc4f82d1eec..75a2645e11fe191cc812cd768b61322456b5f8b8:/src/common/string.cpp?ds=sidebyside diff --git a/src/common/string.cpp b/src/common/string.cpp index aa461904f4..2d608d1eb8 100644 --- a/src/common/string.cpp +++ b/src/common/string.cpp @@ -1,18 +1,15 @@ ///////////////////////////////////////////////////////////////////////////// // Name: string.cpp // Purpose: wxString class -// Author: Vadim Zeitlin +// Author: Vadim Zeitlin, Ryan Norton // Modified by: // Created: 29/01/98 // RCS-ID: $Id$ // Copyright: (c) 1998 Vadim Zeitlin +// (c) 2004 Ryan Norton // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "string.h" -#endif - /* * About ref counting: * 1) all empty strings use g_strEmpty, nRefs = -1 (set in Init()) @@ -42,6 +39,10 @@ #include #include +#ifndef __WXMSW__ +#include +#endif + #ifdef __SALFORDC__ #include #endif @@ -55,14 +56,9 @@ // static class variables definition // --------------------------------------------------------------------------- -#if defined(__VISAGECPP__) && __IBMCPP__ >= 400 -// must define this static for VA or else you get multiply defined symbols -// everywhere -const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100; -#endif // Visual Age - #if !wxUSE_STL - const size_t wxStringBase::npos = wxSTRING_MAXLEN; + //According to STL _must_ be a -1 size_t + const size_t wxStringBase::npos = (size_t) -1; #endif // ---------------------------------------------------------------------------- @@ -100,6 +96,8 @@ extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy; // // ATTN: you can _not_ use both of these in the same program! +#include + wxSTD istream& operator>>(wxSTD istream& is, wxString& WXUNUSED(str)) { #if 0 @@ -206,7 +204,7 @@ void wxStringBase::InitWith(const wxChar *psz, size_t nPos, size_t nLength) wxFAIL_MSG( _T("out of memory in wxStringBase::InitWith") ); return; } - memcpy(m_pchData, psz + nPos, nLength*sizeof(wxChar)); + wxTmemcpy(m_pchData, psz + nPos, nLength); } } @@ -248,7 +246,7 @@ bool wxStringBase::AllocBuffer(size_t nLen) if ( pData == NULL ) { // allocation failures are handled by the caller - return FALSE; + return false; } pData->nRefs = 1; @@ -256,7 +254,7 @@ bool wxStringBase::AllocBuffer(size_t nLen) pData->nAllocLength = nLen + EXTRA_ALLOC; m_pchData = pData->data(); // data starts after wxStringData m_pchData[nLen] = wxT('\0'); - return TRUE; + return true; } // must be called before changing this string @@ -269,14 +267,14 @@ bool wxStringBase::CopyBeforeWrite() size_t nLen = pData->nDataLength; if ( !AllocBuffer(nLen) ) { // allocation failures are handled by the caller - return FALSE; + return false; } - memcpy(m_pchData, pData->data(), nLen*sizeof(wxChar)); + wxTmemcpy(m_pchData, pData->data(), nLen); } wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner - return TRUE; + return true; } // must be called before replacing contents of this string @@ -291,7 +289,7 @@ bool wxStringBase::AllocBeforeWrite(size_t nLen) pData->Unlock(); if ( !AllocBuffer(nLen) ) { // allocation failures are handled by the caller - return FALSE; + return false; } } else { @@ -308,27 +306,29 @@ bool wxStringBase::AllocBeforeWrite(size_t nLen) if ( pData == NULL ) { // allocation failures are handled by the caller // keep previous data since reallocation failed - return FALSE; + return false; } pData->nAllocLength = nLen; m_pchData = pData->data(); } - - // now we have enough space, just update the string length - pData->nDataLength = nLen; } wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner - return TRUE; + // it doesn't really matter what the string length is as it's going to be + // overwritten later but, for extra safety, set it to 0 for now as we may + // have some junk in m_pchData + GetStringData()->nDataLength = 0; + + return true; } wxStringBase& wxStringBase::append(size_t n, wxChar ch) { size_type len = length(); - if ( !CopyBeforeWrite() || !Alloc(len + n) ) { + if ( !Alloc(len + n) || !CopyBeforeWrite() ) { wxFAIL_MSG( _T("out of memory in wxStringBase::append") ); } GetStringData()->nDataLength = len + n; @@ -366,7 +366,7 @@ bool wxStringBase::Alloc(size_t nLen) if ( pData == NULL ) { // allocation failure handled by caller - return FALSE; + return false; } pData->nRefs = 1; @@ -380,9 +380,11 @@ bool wxStringBase::Alloc(size_t nLen) size_t nOldLen = pData->nDataLength; if ( !AllocBuffer(nLen) ) { // allocation failure handled by caller - return FALSE; + return false; } - memcpy(m_pchData, pData->data(), nOldLen*sizeof(wxChar)); + // +1 to copy the terminator, too + memcpy(m_pchData, pData->data(), (nOldLen+1)*sizeof(wxChar)); + GetStringData()->nDataLength = nOldLen; } else { nLen += EXTRA_ALLOC; @@ -393,7 +395,7 @@ bool wxStringBase::Alloc(size_t nLen) if ( pData == NULL ) { // allocation failure handled by caller // keep previous data since reallocation failed - return FALSE; + return false; } // it's not important if the pointer changed or not (the check for this @@ -403,7 +405,21 @@ bool wxStringBase::Alloc(size_t nLen) } } //else: we've already got enough - return TRUE; + return true; +} + +wxStringBase::iterator wxStringBase::begin() +{ + if (length() > 0) + CopyBeforeWrite(); + return m_pchData; +} + +wxStringBase::iterator wxStringBase::end() +{ + if (length() > 0) + CopyBeforeWrite(); + return m_pchData + length(); } wxStringBase::iterator wxStringBase::erase(iterator it) @@ -433,7 +449,7 @@ wxStringBase& wxStringBase::insert(size_t nPos, const wxChar *sz, size_t n) if ( n == npos ) n = wxStrlen(sz); if ( n == 0 ) return *this; - if ( !CopyBeforeWrite() || !Alloc(length() + n) ) { + if ( !Alloc(length() + n) || !CopyBeforeWrite() ) { wxFAIL_MSG( _T("out of memory in wxStringBase::insert") ); } @@ -458,9 +474,33 @@ size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const wxASSERT( str.GetStringData()->IsValid() ); wxASSERT( nStart <= length() ); - const wxChar *p = wxStrstr(c_str() + nStart, str.c_str()); + //anchor + const wxChar* p = (const wxChar*)wxTmemchr(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() && + wxTmemcmp(p, str.c_str(), str.length()) ) + { + //Previosly passed as the first argument to wxTmemchr, + //but C/C++ standard does not specify evaluation order + //of arguments to functions - + //http://embedded.com/showArticle.jhtml?articleID=9900607 + ++p; + + //anchor again + p = (const wxChar*)wxTmemchr(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 @@ -472,7 +512,7 @@ size_t wxStringBase::find(wxChar ch, size_t nStart) const { wxASSERT( nStart <= length() ); - const wxChar *p = wxStrchr(c_str() + nStart, ch); + const wxChar *p = (const wxChar*)wxTmemchr(c_str() + nStart, ch, length() - nStart); return p == NULL ? npos : p - c_str(); } @@ -499,14 +539,14 @@ size_t wxStringBase::rfind(const wxStringBase& str, size_t nStart) const const wxChar *cursor = c_str() + top; do { - if ( memcmp(cursor, str.c_str(), - str.length() * sizeof(wxChar)) == 0 ) + if ( wxTmemcmp(cursor, str.c_str(), + str.length()) == 0 ) { return cursor - c_str(); } } while ( cursor-- > c_str() ); } - + return npos; } @@ -539,12 +579,21 @@ size_t wxStringBase::rfind(wxChar ch, size_t nStart) const 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 (wxTmemchr(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, @@ -565,9 +614,11 @@ size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart) const _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 ( wxTmemchr(sz, *p, len) ) return p - c_str(); } @@ -591,11 +642,19 @@ size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart) const 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 (!wxTmemchr(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, @@ -628,10 +687,12 @@ size_t wxStringBase::find_last_not_of(const wxChar* sz, size_t nStart) const 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 ( !wxTmemchr(sz, *p,len) ) + return p - c_str(); } return npos; @@ -674,10 +735,22 @@ wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen, wxStringBase strTmp; strTmp.reserve(length()); // micro optimisation to avoid multiple mem allocs - if ( nStart != 0 ) - strTmp.append(c_str(), nStart); + //This is kind of inefficient, but its pretty good considering... + //we don't want to use character access operators here because on STL + //it will freeze the reference count of strTmp, which means a deep copy + //at the end when swap is called + // + //Also, we can't use append with the full character pointer and must + //do it manually because this string can contain null characters + for(size_t i1 = 0; i1 < nStart; ++i1) + strTmp.append(1, this->c_str()[i1]); + + //its safe to do the full version here because + //sz must be a normal c string strTmp.append(sz); - strTmp.append(c_str() + nStart + nLen); + + for(size_t i2 = nStart + nLen; i2 < length(); ++i2) + strTmp.append(1, this->c_str()[i2]); swap(strTmp); return *this; @@ -686,7 +759,7 @@ wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen, 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, @@ -757,13 +830,13 @@ bool wxStringBase::AssignCopy(size_t nSrcLen, const wxChar *pszSrcData) else { if ( !AllocBeforeWrite(nSrcLen) ) { // allocation failure handled by caller - return FALSE; + return false; } memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar)); GetStringData()->nDataLength = nSrcLen; m_pchData[nSrcLen] = wxT('\0'); } - return TRUE; + return true; } // --------------------------------------------------------------------------- @@ -792,7 +865,7 @@ bool wxStringBase::ConcatSelf(size_t nSrcLen, const wxChar *pszSrcData, wxStringData* pOldData = GetStringData(); if ( !AllocBuffer(nNewLen) ) { // allocation failure handled by caller - return FALSE; + return false; } memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxChar)); pOldData->Unlock(); @@ -804,7 +877,7 @@ bool wxStringBase::ConcatSelf(size_t nSrcLen, const wxChar *pszSrcData, // we have to grow the buffer if ( capacity() < nNewLen ) { // allocation failure handled by caller - return FALSE; + return false; } } else { @@ -823,7 +896,7 @@ bool wxStringBase::ConcatSelf(size_t nSrcLen, const wxChar *pszSrcData, GetStringData()->nDataLength = nNewLen; // and fix the length } //else: the string to append was empty - return TRUE; + return true; } // --------------------------------------------------------------------------- @@ -839,11 +912,11 @@ bool wxStringBase::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const else { if ( !dest.AllocBuffer(nCopyLen) ) { // allocation failure handled by caller - return FALSE; + return false; } memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(wxChar)); } - return TRUE; + return true; } #endif // !wxUSE_STL @@ -860,31 +933,24 @@ static inline int wxDoCmp(const wxChar* s1, size_t l1, const wxChar* s2, size_t l2) { if( l1 == l2 ) - return wxStrncmp(s1, s2, l1); + return wxTmemcmp(s1, s2, l1); else if( l1 < l2 ) { - int ret = wxStrncmp(s1, s2, l1); + int ret = wxTmemcmp(s1, s2, l1); return ret == 0 ? -1 : ret; } - else if( l1 > l2 ) + else { - int ret = wxStrncmp(s1, s2, l2); + int ret = wxTmemcmp(s1, s2, l2); return ret == 0 ? +1 : ret; } - - wxFAIL; // must never get there - 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 { @@ -907,16 +973,12 @@ int STRINGCLASS::compare(size_t nStart, size_t nLen, 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 { @@ -938,7 +1000,7 @@ int STRINGCLASS::compare(size_t nStart, size_t nLen, // =========================================================================== // --------------------------------------------------------------------------- -// construction +// construction and conversion // --------------------------------------------------------------------------- #if wxUSE_UNICODE @@ -946,12 +1008,29 @@ int STRINGCLASS::compare(size_t nStart, size_t nLen, // from multibyte string wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength) { + // if nLength != npos, then we have to make a NULL-terminated copy + // of first nLength bytes of psz first because the input buffer to MB2WC + // must always be NULL-terminated: + wxCharBuffer inBuf((const char *)NULL); + if (nLength != npos) + { + wxASSERT( psz != NULL ); + wxCharBuffer tmp(nLength); + memcpy(tmp.data(), psz, nLength); + tmp.data()[nLength] = '\0'; + inBuf = tmp; + psz = inBuf.data(); + } + // first get the size of the buffer we need size_t nLen; if ( psz ) { // calculate the needed size ourselves or use the provided one - nLen = nLength == npos ? conv.MB2WC(NULL, psz, 0) : nLength; + if (nLength == npos) + nLen = strlen(psz); + else + nLen = nLength; } else { @@ -959,43 +1038,56 @@ wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength) nLen = 0; } + // anything to do? if ( (nLen != 0) && (nLen != (size_t)-1) ) { - if ( !Alloc(nLen) ) - { - wxFAIL_MSG( _T("out of memory in wxString::wxString") ); - } - else - { - wxWCharBuffer buf(nLen + 1); - // MB2WC wants the buffer size, not the string length hence +1 - nLen = conv.MB2WC(buf.data(), psz, nLen + 1); + //Convert string + size_t nRealSize; + wxWCharBuffer theBuffer = conv.cMB2WC(psz, nLen, &nRealSize); - 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 + if (nRealSize) + assign( theBuffer.data() , nRealSize - 1 ); } } +//Convert wxString in Unicode mode to a multi-byte string +const wxCharBuffer wxString::mb_str(wxMBConv& conv) const +{ + size_t dwOutSize; + return conv.cWC2MB(c_str(), length(), &dwOutSize); +} + #else // ANSI #if wxUSE_WCHAR_T // from wide string wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength) { + // if nLength != npos, then we have to make a NULL-terminated copy + // of first nLength chars of psz first because the input buffer to WC2MB + // must always be NULL-terminated: + wxWCharBuffer inBuf((const wchar_t *)NULL); + if (nLength != npos) + { + wxASSERT( pwz != NULL ); + wxWCharBuffer tmp(nLength); + memcpy(tmp.data(), pwz, nLength * sizeof(wchar_t)); + tmp.data()[nLength] = '\0'; + inBuf = tmp; + pwz = inBuf.data(); + } + // first get the size of the buffer we need size_t nLen; if ( pwz ) { // calculate the needed size ourselves or use the provided one - nLen = nLength == npos ? conv.WC2MB(NULL, pwz, 0) : nLength; + if (nLength == npos) + nLen = wxWcslen(pwz); + else + nLen = nLength; } else { @@ -1006,26 +1098,24 @@ wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength) // anything to do? if ( (nLen != 0) && (nLen != (size_t)-1) ) { - if ( !Alloc(nLen) ) - { - wxFAIL_MSG( _T("out of memory in wxString::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?) - } + //Convert string + size_t nRealSize; + wxCharBuffer theBuffer = conv.cWC2MB(pwz, nLen, &nRealSize); + + //Copy + if (nRealSize) + assign( theBuffer.data() , nRealSize - 1 ); } +} - // leave empty +//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 +{ + size_t dwOutSize; + return conv.cMB2WC(c_str(), length(), &dwOutSize); } + #endif // wxUSE_WCHAR_T #endif // Unicode/ANSI @@ -1048,7 +1138,7 @@ wxChar *wxString::GetWriteBuf(size_t nLen) } wxASSERT( GetStringData()->nRefs == 1 ); - GetStringData()->Validate(FALSE); + GetStringData()->Validate(false); return m_pchData; } @@ -1057,13 +1147,13 @@ wxChar *wxString::GetWriteBuf(size_t nLen) void wxString::UngetWriteBuf() { GetStringData()->nDataLength = wxStrlen(m_pchData); - GetStringData()->Validate(TRUE); + GetStringData()->Validate(true); } void wxString::UngetWriteBuf(size_t nLen) { GetStringData()->nDataLength = nLen; - GetStringData()->Validate(TRUE); + GetStringData()->Validate(true); } #endif @@ -1151,7 +1241,7 @@ wxString operator+(const wxString& str, const wxChar *psz) if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) { wxFAIL_MSG( _T("out of memory in wxString::operator+") ); } - s = str; + s += str; s += psz; return s; @@ -1177,8 +1267,71 @@ wxString operator+(const wxChar *psz, const wxString& str) // 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 : wxTolower(s1[i]) < wxTolower(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 : wxTolower(s1[i]) < wxTolower(s2[i]) ? -1 : 1; + } + else + { + for(i = 0; i < l2; ++i) + { + if(wxTolower(s1[i]) != wxTolower(s2[i])) + break; + } + return i == l2 ? 1 : wxTolower(s1[i]) < wxTolower(s2[i]) ? -1 : 1; + } +} + +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__ +#ifndef __SCHAR_MAX__ +#define __SCHAR_MAX__ 127 +#endif +#endif + wxString wxString::FromAscii(const char *ascii) { if (!ascii) @@ -1218,12 +1371,13 @@ const wxCharBuffer wxString::ToAscii() const // this will allocate enough space for the terminating NUL too wxCharBuffer buffer(length()); - signed char *dest = (signed char *)buffer.data(); + + char *dest = buffer.data(); const wchar_t *pwc = c_str(); for ( ;; ) { - *dest++ = *pwc > SCHAR_MAX ? '_' : *pwc; + *dest++ = (char)(*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 @@ -1268,7 +1422,7 @@ wxString wxString::Mid(size_t nFirst, size_t nCount) const } // check that the string starts with prefix and return the rest of the string -// in the provided pointer if it is not NULL, otherwise return FALSE +// in the provided pointer if it is not NULL, otherwise return false bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const { wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") ); @@ -1283,7 +1437,7 @@ bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const if ( *prefix++ != *p++ ) { // no match - return FALSE; + return false; } } @@ -1293,7 +1447,7 @@ bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const *rest = p; } - return TRUE; + return true; } // extract nCount last (rightmost) characters @@ -1314,7 +1468,7 @@ wxString wxString::Right(size_t nCount) const wxString wxString::AfterLast(wxChar ch) const { wxString str; - int iPos = Find(ch, TRUE); + int iPos = Find(ch, true); if ( iPos == wxNOT_FOUND ) str = *this; else @@ -1350,7 +1504,7 @@ wxString wxString::BeforeFirst(wxChar ch) const wxString wxString::BeforeLast(wxChar ch) const { wxString str; - int iPos = Find(ch, TRUE); + int iPos = Find(ch, true); if ( iPos != wxNOT_FOUND && iPos != 0 ) str = wxString(c_str(), iPos); @@ -1370,94 +1524,85 @@ wxString wxString::AfterFirst(wxChar ch) const } // replace first (or all) occurences of some substring with another one -size_t -wxString::Replace(const wxChar *szOld, const wxChar *szNew, bool bReplaceAll) +size_t wxString::Replace(const wxChar *szOld, + const wxChar *szNew, bool bReplaceAll) { // if we tried to replace an empty string we'd enter an infinite loop below wxCHECK_MSG( szOld && *szOld && szNew, 0, _T("wxString::Replace(): invalid parameter") ); - size_t uiCount = 0; // count of replacements made + size_t uiCount = 0; // count of replacements made - size_t uiOldLen = wxStrlen(szOld); + size_t uiOldLen = wxStrlen(szOld); + size_t uiNewLen = wxStrlen(szNew); - wxString strTemp; - const wxChar *pCurrent = c_str(); - const wxChar *pSubstr; - while ( *pCurrent != wxT('\0') ) { - pSubstr = wxStrstr(pCurrent, szOld); - if ( pSubstr == NULL ) { - // strTemp is unused if no replacements were made, so avoid the copy - if ( uiCount == 0 ) - return 0; + size_t dwPos = 0; - strTemp += pCurrent; // copy the rest - break; // exit the loop - } - else { - // take chars before match - size_type len = strTemp.length(); - strTemp.append(pCurrent, pSubstr - pCurrent); - if ( strTemp.length() != (size_t)(len + pSubstr - pCurrent) ) { - wxFAIL_MSG( _T("out of memory in wxString::Replace") ); - return 0; - } - strTemp += szNew; - pCurrent = pSubstr + uiOldLen; // restart after match + while ( this->c_str()[dwPos] != wxT('\0') ) + { + //DO NOT USE STRSTR HERE + //this string can contain embedded null characters, + //so strstr will function incorrectly + dwPos = find(szOld, dwPos); + if ( dwPos == npos ) + break; // exit the loop + else + { + //replace this occurance of the old string with the new one + replace(dwPos, uiOldLen, szNew, uiNewLen); - uiCount++; + //move up pos past the old string + dwPos += uiOldLen; - // stop now? - if ( !bReplaceAll ) { - strTemp += pCurrent; // copy the rest - break; // exit the loop - } + //increase replace count + ++uiCount; + + // stop now? + if ( !bReplaceAll ) + break; // exit the loop + } } - } - // only done if there were replacements, otherwise would have returned above - swap(strTemp); - - return uiCount; + return uiCount; } bool wxString::IsAscii() const { const wxChar *s = (const wxChar*) *this; while(*s){ - if(!isascii(*s)) return(FALSE); + if(!isascii(*s)) return(false); s++; } - return(TRUE); + return(true); } bool wxString::IsWord() const { const wxChar *s = (const wxChar*) *this; while(*s){ - if(!wxIsalpha(*s)) return(FALSE); + if(!wxIsalpha(*s)) return(false); s++; } - return(TRUE); + return(true); } bool wxString::IsNumber() const { 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); + if(!wxIsdigit(*s)) return(false); s++; } - return(TRUE); + return(true); } wxString wxString::Strip(stripType w) const { wxString s = *this; - if ( w & leading ) s.Trim(FALSE); - if ( w & trailing ) s.Trim(TRUE); + if ( w & leading ) s.Trim(false); + if ( w & trailing ) s.Trim(true); return s; } @@ -1485,7 +1630,7 @@ wxString& wxString::MakeLower() // trimming and padding // --------------------------------------------------------------------------- -// some compilers (VC++ 6.0 not to name them) return TRUE for a call to +// some compilers (VC++ 6.0 not to name them) return true for a call to // isspace('ê') in the C locale which seems to be broken to me, but we have to // live with this by checking that the character is a 7 bit one - even if this // may fail to detect some spaces (I don't know if Unicode doesn't have @@ -1497,7 +1642,7 @@ inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); } wxString& wxString::Trim(bool bFromRight) { // first check if we're going to modify the string at all - if ( !IsEmpty() && + if ( !empty() && ( (bFromRight && wxSafeIsspace(GetChar(Len() - 1))) || (!bFromRight && wxSafeIsspace(GetChar(0u))) @@ -1583,41 +1728,41 @@ int wxString::Find(const wxChar *pszSub) const bool wxString::ToLong(long *val, int base) const { - wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToLong") ); + wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToLong") ); wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") ); const wxChar *start = c_str(); wxChar *end; *val = wxStrtol(start, &end, base); - // return TRUE only if scan was stopped by the terminating NUL and if the + // return true only if scan was stopped by the terminating NUL and if the // string was not empty to start with return !*end && (end != start); } bool wxString::ToULong(unsigned long *val, int base) const { - wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToULong") ); + wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToULong") ); wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") ); const wxChar *start = c_str(); wxChar *end; *val = wxStrtoul(start, &end, base); - // return TRUE only if scan was stopped by the terminating NUL and if the + // return true only if scan was stopped by the terminating NUL and if the // string was not empty to start with return !*end && (end != start); } bool wxString::ToDouble(double *val) const { - wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToDouble") ); + wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") ); const wxChar *start = c_str(); wxChar *end; *val = wxStrtod(start, &end); - // return TRUE only if scan was stopped by the terminating NUL and if the + // return true only if scan was stopped by the terminating NUL and if the // string was not empty to start with return !*end && (end != start); } @@ -1650,45 +1795,55 @@ wxString wxString::FormatV(const wxChar *pszFormat, va_list argptr) int wxString::Printf(const wxChar *pszFormat, ...) { - va_list argptr; - va_start(argptr, pszFormat); + va_list argptr; + va_start(argptr, pszFormat); - int iLen = PrintfV(pszFormat, argptr); + int iLen = PrintfV(pszFormat, argptr); - va_end(argptr); + va_end(argptr); - return iLen; + return iLen; } int wxString::PrintfV(const wxChar* pszFormat, va_list argptr) { int size = 1024; - int len; for ( ;; ) { - { - wxStringBuffer tmp(*this, size + 1); - wxChar* buf = tmp; + wxStringBuffer tmp(*this, size + 1); + wxChar* buf = tmp; - if ( !buf ) - { - // out of memory - return -1; - } + if ( !buf ) + { + // out of memory + return -1; + } - len = wxVsnprintf(buf, size, pszFormat, argptr); + // wxVsnprintf() may modify the original arg pointer, so pass it + // only a copy + va_list argptrcopy; + wxVaCopy(argptrcopy, argptr); + int len = wxVsnprintf(buf, size, pszFormat, argptrcopy); + va_end(argptrcopy); - // some implementations of vsnprintf() don't NUL terminate - // the string if there is not enough space for it so - // always do it manually - buf[size] = _T('\0'); - } + // some implementations of vsnprintf() don't NUL terminate + // the string if there is not enough space for it so + // always do it manually + buf[size] = _T('\0'); // vsnprintf() may return either -1 (traditional Unix behaviour) or the // total number of characters which would have been written if the // buffer were large enough - if ( len >= 0 && len <= size ) + // also, it may return an errno may be something like EILSEQ, + // in which case we need to break out + if ( (len >= 0 && len <= size) + // No EOVERFLOW on Windows nor Palm 6.0 nor OpenVMS nor MacOS (not X) + // not OS/2 (not Innotek libc). +#if !defined(__WXMSW__) && !defined(__WXPALMOS__) && !defined( __VMS ) && !(defined(__WXMAC__) && !defined(__WXMAC_OSX__)) && !(defined(__EMX__) && !defined(__INNOTEK_LIBC__)) + || errno != EOVERFLOW +#endif + ) { // ok, there was enough space break; @@ -1708,7 +1863,7 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr) // misc other operations // ---------------------------------------------------------------------------- -// returns TRUE if the string matches the pattern which may contain '*' and +// returns true if the string matches the pattern which may contain '*' and // '?' metacharacters (as usual, '?' matches any character and '*' any number // of them) bool wxString::Matches(const wxChar *pszMask) const @@ -1774,7 +1929,7 @@ match: switch ( *pszMask ) { case wxT('?'): if ( *pszTxt == wxT('\0') ) - return FALSE; + return false; // pszTxt and pszMask will be incremented in the loop statement @@ -1793,7 +1948,7 @@ match: // if there is nothing more, match if ( *pszMask == wxT('\0') ) - return TRUE; + return true; // are there any other metacharacters in the mask? size_t uiLenMask; @@ -1811,7 +1966,7 @@ match: wxString strToMatch(pszMask, uiLenMask); const wxChar* pMatch = wxStrstr(pszTxt, strToMatch); if ( pMatch == NULL ) - return FALSE; + return false; // -1 to compensate "++" in the loop pszTxt = pMatch + uiLenMask - 1; @@ -1821,14 +1976,14 @@ match: default: if ( *pszMask != *pszTxt ) - return FALSE; + return false; break; } } // match only if nothing left if ( *pszTxt == wxT('\0') ) - return TRUE; + return true; // if we failed to match, backtrack if we can if ( pszLastStarInText ) { @@ -1842,7 +1997,7 @@ match: goto match; } - return FALSE; + return false; #endif // wxUSE_REGEX/!wxUSE_REGEX } @@ -1881,6 +2036,24 @@ int wxString::sprintf(const wxChar *pszFormat, ...) #include "wx/arrstr.h" +wxArrayString::wxArrayString(size_t sz, const wxChar** a) +{ +#if !wxUSE_STL + Init(false); +#endif + for (size_t i=0; i < sz; i++) + Add(a[i]); +} + +wxArrayString::wxArrayString(size_t sz, const wxString* a) +{ +#if !wxUSE_STL + Init(false); +#endif + for (size_t i=0; i < sz; i++) + Add(a[i]); +} + #if !wxUSE_STL // size increment = min(50% of current size, ARRAY_MAXSIZE_INCREMENT) @@ -2058,6 +2231,11 @@ wxString* wxArrayString::GetStringArray() const return array; } +void wxArrayString::Remove(size_t nIndex, size_t nRemove) +{ + RemoveAt(nIndex, nRemove); +} + #endif // WXWIN_COMPATIBILITY_2_4 // searches the array for an item (forward or backwards) @@ -2121,7 +2299,7 @@ size_t wxArrayString::Add(const wxString& str, size_t nInsert) 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 ) @@ -2179,6 +2357,30 @@ void wxArrayString::Insert(const wxString& str, size_t nIndex, size_t nInsert) m_nCount += nInsert; } +// range insert (STL 23.2.4.3) +void +wxArrayString::insert(iterator it, const_iterator first, const_iterator last) +{ + const int idx = it - begin(); + + // grow it once + Grow(last - first); + + // reset "it" since it can change inside Grow() + it = begin() + idx; + + while ( first != last ) + { + it = insert(it, *first); + + // insert returns an iterator to the last element inserted but we need + // insert the next after this one, that is before the next one + ++it; + + ++first; + } +} + // expand the array void wxArrayString::SetCount(size_t count) { @@ -2252,7 +2454,7 @@ static wxArrayString::CompareFunction gs_compareFunction = NULL; // if we don't use the compare function, this flag tells us if we sort the // array in ascending or descending order -static bool gs_sortAscending = TRUE; +static bool gs_sortAscending = true; // function which is called by quick sort extern "C" int wxC_CALLING_CONV // LINKAGEMODE @@ -2266,7 +2468,7 @@ wxStringCompareFunction(const void *first, const void *second) } 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; } @@ -2312,25 +2514,25 @@ void wxArrayString::DoSort() bool wxArrayString::operator==(const wxArrayString& a) const { if ( m_nCount != a.m_nCount ) - return FALSE; + return false; for ( size_t n = 0; n < m_nCount; n++ ) { if ( Item(n) != a[n] ) - return FALSE; + return false; } - return TRUE; + return true; } #endif // !wxUSE_STL 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); }