#ifndef WX_PRECOMP
#include "wx/stringimpl.h"
+ #include "wx/wxcrt.h"
#endif
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
-#ifdef __SALFORDC__
- #include <clib.h>
-#endif
-
// allocating extra space for each string consumes more memory but speeds up
// the concatenation operations (nLen is the current string's length)
// NB: EXTRA_ALLOC must be >= 0!
// FIXME-UTF8: get rid of this, have only one wxEmptyString
#if wxUSE_UNICODE_UTF8
-extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = "";
+const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = "";
#endif
-extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = _T("");
+const wxChar WXDLLIMPEXP_BASE *wxEmptyString = wxT("");
#else
// empty C style string: points to 'string data' byte of g_strEmpty
#if wxUSE_UNICODE_UTF8
// FIXME-UTF8: get rid of this, have only one wxEmptyString
-extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = &g_strEmpty.dummy;
-extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = _T("");
+const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = &g_strEmpty.dummy;
+const wxChar WXDLLIMPEXP_BASE *wxEmptyString = wxT("");
#else
-extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy;
+const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy;
#endif
#endif
// ----------------------------------------------------------------------------
// this small class is used to gather statistics for performance tuning
+
+// uncomment this to enable gathering of some statistics about wxString
+// efficiency
//#define WXSTRING_STATISTICS
+
#ifdef WXSTRING_STATISTICS
class Averager
{
public:
Averager(const wxStringCharType *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
~Averager()
- { wxPrintf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
+ {
+ wxPrintf("wxString %s: total = %lu, average = %f\n",
+ m_sz, m_nTotal, ((float)m_nTotal)/m_nCount);
+ }
void Add(size_t n) { m_nTotal += n; m_nCount++; }
private:
- size_t m_nCount, m_nTotal;
+ unsigned long m_nCount, m_nTotal;
const wxStringCharType *m_sz;
} g_averageLength("allocation size"),
g_averageSummandLength("summand length"),
// if the length is not given, assume the string to be NUL terminated
if ( nLength == npos ) {
- wxASSERT_MSG( nPos <= Strsize(psz), _T("index out of bounds") );
+ wxASSERT_MSG( nPos <= wxStrlen(psz), wxT("index out of bounds") );
- nLength = Strsize(psz + nPos);
+ nLength = wxStrlen(psz + nPos);
}
STATISTICS_ADD(InitialLength, nLength);
if ( nLength > 0 ) {
// trailing '\0' is written in AllocBuffer()
if ( !AllocBuffer(nLength) ) {
- wxFAIL_MSG( _T("out of memory in wxStringImpl::InitWith") );
+ wxFAIL_MSG( wxT("out of memory in wxStringImpl::InitWith") );
return;
}
wxStringMemcpy(m_pchData, psz + nPos, nLength);
{
if ( last >= first )
{
- InitWith(first, 0, last - first);
+ InitWith(first.GetPtr(), 0, last - first);
}
else
{
- wxFAIL_MSG( _T("first must be before last") );
+ wxFAIL_MSG( wxT("first must be before last") );
Init();
}
}
wxASSERT( nLen > 0 );
// make sure that we don't overflow
- wxASSERT( nLen < (INT_MAX / sizeof(wxStringCharType)) -
- (sizeof(wxStringData) + EXTRA_ALLOC + 1) );
+ wxCHECK( nLen < (INT_MAX / sizeof(wxStringCharType)) -
+ (sizeof(wxStringData) + EXTRA_ALLOC + 1), false );
STATISTICS_ADD(Length, nLen);
size_type len = length();
if ( !Alloc(len + n) || !CopyBeforeWrite() ) {
- wxFAIL_MSG( _T("out of memory in wxStringImpl::append") );
+ wxFAIL_MSG( wxT("out of memory in wxStringImpl::append") );
return *this;
}
GetStringData()->nDataLength = len + n;
wxStringData *pData = GetStringData();
if ( pData->nAllocLength <= nLen ) {
if ( pData->IsEmpty() ) {
+ STATISTICS_ADD(Length, nLen);
+
nLen += EXTRA_ALLOC;
pData = (wxStringData *)
wxStringImpl::iterator wxStringImpl::begin()
{
- if (length() > 0)
+ if ( !empty() )
CopyBeforeWrite();
return m_pchData;
}
wxStringImpl::iterator wxStringImpl::end()
{
- if (length() > 0)
+ if ( !empty() )
CopyBeforeWrite();
return m_pchData + length();
}
{
wxASSERT( nPos <= length() );
- if ( n == npos ) n = Strsize(sz);
+ if ( n == npos ) n = wxStrlen(sz);
if ( n == 0 ) return *this;
if ( !Alloc(length() + n) || !CopyBeforeWrite() ) {
- wxFAIL_MSG( _T("out of memory in wxStringImpl::insert") );
+ wxFAIL_MSG( wxT("out of memory in wxStringImpl::insert") );
return *this;
}
if ( length() >= str.length() )
{
// avoids a corner case later
- if ( length() == 0 && str.length() == 0 )
+ if ( empty() && str.empty() )
return 0;
// "top" is the point where search starts from
}
wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
- const wxStringCharType *sz)
-{
- wxASSERT_MSG( nStart <= length(),
- _T("index out of bounds in wxStringImpl::replace") );
- size_t strLen = length() - nStart;
- nLen = strLen < nLen ? strLen : nLen;
-
- wxStringImpl strTmp;
- strTmp.reserve(length()); // micro optimisation to avoid multiple mem allocs
-
- //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);
-
- for(size_t i2 = nStart + nLen; i2 < length(); ++i2)
- strTmp.append(1, this->c_str()[i2]);
-
- swap(strTmp);
- return *this;
-}
-
-wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
- size_t nCount, wxStringCharType ch)
+ const wxStringCharType *sz, size_t nCount)
{
- return replace(nStart, nLen, wxStringImpl(nCount, ch).c_str());
-}
+ // check and adjust parameters
+ const size_t lenOld = length();
-wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
- const wxStringImpl& str,
- size_t nStart2, size_t nLen2)
-{
- return replace(nStart, nLen, str.substr(nStart2, nLen2));
-}
+ wxASSERT_MSG( nStart <= lenOld,
+ wxT("index out of bounds in wxStringImpl::replace") );
+ size_t nEnd = nStart + nLen;
+ if ( nLen > lenOld - nStart )
+ {
+ // nLen may be out of range, as it can be npos, just clump it down
+ nLen = lenOld - nStart;
+ nEnd = lenOld;
+ }
-wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
- const wxStringCharType* sz, size_t nCount)
-{
- return replace(nStart, nLen, wxStringImpl(sz, nCount).c_str());
+ if ( nCount == npos )
+ nCount = wxStrlen(sz);
+
+ // build the new string from 3 pieces: part of this string before nStart,
+ // the new substring and the part of this string after nStart+nLen
+ wxStringImpl tmp;
+ const size_t lenNew = lenOld + nCount - nLen;
+ if ( lenNew )
+ {
+ tmp.AllocBuffer(lenOld + nCount - nLen);
+
+ wxStringCharType *dst = tmp.m_pchData;
+ memcpy(dst, m_pchData, nStart*sizeof(wxStringCharType));
+ dst += nStart;
+
+ memcpy(dst, sz, nCount*sizeof(wxStringCharType));
+ dst += nCount;
+
+ memcpy(dst, m_pchData + nEnd, (lenOld - nEnd)*sizeof(wxStringCharType));
+ }
+
+ // and replace this string contents with the new one
+ swap(tmp);
+ return *this;
}
wxStringImpl wxStringImpl::substr(size_t nStart, size_t nLen) const
{
wxStringCharType c(ch);
if ( !AssignCopy(1, &c) ) {
- wxFAIL_MSG( _T("out of memory in wxStringImpl::operator=(wxStringCharType)") );
+ wxFAIL_MSG( wxT("out of memory in wxStringImpl::operator=(wxStringCharType)") );
}
return *this;
}
// assigns C string
wxStringImpl& wxStringImpl::operator=(const wxStringCharType *psz)
{
- if ( !AssignCopy(Strsize(psz), psz) ) {
- wxFAIL_MSG( _T("out of memory in wxStringImpl::operator=(const wxStringCharType *)") );
+ if ( !AssignCopy(wxStrlen(psz), psz) ) {
+ wxFAIL_MSG( wxT("out of memory in wxStringImpl::operator=(const wxStringCharType *)") );
}
return *this;
}
if ( nSrcLen > 0 ) {
wxStringData *pData = GetStringData();
size_t nLen = pData->nDataLength;
+
+ // take special care when appending part of this string to itself: the code
+ // below reallocates our buffer and this invalidates pszSrcData pointer so
+ // we have to copy it in another temporary string in this case (but avoid
+ // doing this unnecessarily)
+ if ( pszSrcData >= m_pchData && pszSrcData < m_pchData + nLen )
+ {
+ wxStringImpl tmp(pszSrcData, nSrcLen);
+ return ConcatSelf(nSrcLen, tmp.m_pchData, nSrcLen);
+ }
+
size_t nNewLen = nLen + nSrcLen;
// alloc new buffer if current is too small
return true;
}
-#if !wxUSE_UNICODE_UTF8
// get the pointer to writable buffer of (at least) nLen bytes
-wxChar *wxStringImpl::DoGetWriteBuf(size_t nLen)
+wxStringCharType *wxStringImpl::DoGetWriteBuf(size_t nLen)
{
if ( !AllocBeforeWrite(nLen) ) {
// allocation failure handled by caller
// put string back in a reasonable state after GetWriteBuf
void wxStringImpl::DoUngetWriteBuf()
{
- DoUngetWriteBuf(Strsize(m_pchData));
+ DoUngetWriteBuf(wxStrlen(m_pchData));
}
void wxStringImpl::DoUngetWriteBuf(size_t nLen)
{
wxStringData * const pData = GetStringData();
- wxASSERT_MSG( nLen < pData->nAllocLength, _T("buffer overrun") );
+ wxASSERT_MSG( nLen < pData->nAllocLength, wxT("buffer overrun") );
// the strings we store are always NUL-terminated
- pData->data()[nLen] = _T('\0');
+ pData->data()[nLen] = wxT('\0');
pData->nDataLength = nLen;
pData->Validate(true);
}
-#endif // !wxUSE_UNICODE_UTF8
#endif // !wxUSE_STL_BASED_WXSTRING
projects / wxWidgets.git / blobdiff