/////////////////////////////////////////////////////////////////////////////
// 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 <zeitlin@dptmaths.ens-cachan.fr>
+// (c) 2004 Ryan Norton <wxprojects@comcast.net>
// 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())
#include <string.h>
#include <stdlib.h>
+#ifndef __WXMSW__
+#include <errno.h>
+#endif
+
#ifdef __SALFORDC__
#include <clib.h>
#endif
// 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
// ----------------------------------------------------------------------------
wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
{
- os << str.c_str();
- return os;
+#ifdef __BORLANDC__
+ os << str.mb_str();
+#else
+ os << str.c_str();
+#endif
+ return os;
}
#endif // wxUSE_STD_IOSTREAM
wxFAIL_MSG( _T("out of memory in wxStringBase::InitWith") );
return;
}
- wxMemcpy(m_pchData, psz + nPos, nLength);
+ wxTmemcpy(m_pchData, psz + nPos, nLength);
}
}
// allocation failures are handled by the caller
return false;
}
- wxMemcpy(m_pchData, pData->data(), nLen);
+ wxTmemcpy(m_pchData, pData->data(), nLen);
}
wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
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
+ // 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;
}
{
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;
if ( pData->IsEmpty() ) {
nLen += EXTRA_ALLOC;
- wxStringData* pData = (wxStringData*)
- malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
+ pData = (wxStringData *)
+ malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
if ( pData == NULL ) {
// allocation failure handled by caller
// allocation failure handled by caller
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;
wxStringBase& wxStringBase::erase(size_t nStart, size_t nLen)
{
- wxASSERT(nStart <= length());
- size_t strLen = length() - nStart;
- // delete nLen or up to the end of the string characters
- nLen = strLen < nLen ? strLen : nLen;
- wxString strTmp(c_str(), nStart);
- strTmp.append(c_str() + nStart + nLen, length() - nStart - nLen);
+ wxASSERT(nStart <= length());
+ size_t strLen = length() - nStart;
+ // delete nLen or up to the end of the string characters
+ nLen = strLen < nLen ? strLen : nLen;
+ wxString strTmp(c_str(), nStart);
+ strTmp.append(c_str() + nStart + nLen, length() - nStart - nLen);
- swap(strTmp);
- return *this;
+ swap(strTmp);
+ return *this;
}
wxStringBase& wxStringBase::insert(size_t nPos, const wxChar *sz, size_t n)
{
- wxASSERT( nPos <= length() );
+ wxASSERT( nPos <= length() );
- if ( n == npos ) n = wxStrlen(sz);
- if ( n == 0 ) return *this;
+ if ( n == npos ) n = wxStrlen(sz);
+ if ( n == 0 ) return *this;
- if ( !CopyBeforeWrite() || !Alloc(length() + n) ) {
- wxFAIL_MSG( _T("out of memory in wxStringBase::insert") );
- }
+ if ( !Alloc(length() + n) || !CopyBeforeWrite() ) {
+ wxFAIL_MSG( _T("out of memory in wxStringBase::insert") );
+ }
- memmove(m_pchData + nPos + n, m_pchData + nPos,
- (length() - nPos) * sizeof(wxChar));
- memcpy(m_pchData + nPos, sz, n * sizeof(wxChar));
- GetStringData()->nDataLength = length() + n;
- m_pchData[length()] = '\0';
+ memmove(m_pchData + nPos + n, m_pchData + nPos,
+ (length() - nPos) * sizeof(wxChar));
+ memcpy(m_pchData + nPos, sz, n * sizeof(wxChar));
+ GetStringData()->nDataLength = length() + n;
+ m_pchData[length()] = '\0';
- return *this;
+ return *this;
}
void wxStringBase::swap(wxStringBase& str)
size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
{
- wxASSERT( str.GetStringData()->IsValid() );
- wxASSERT( nStart <= length() );
+ wxASSERT( str.GetStringData()->IsValid() );
+ wxASSERT( nStart <= length() );
- //anchor
- const wxChar* p = (const wxChar*)wxMemchr(c_str() + nStart,
- str.c_str()[0],
- length() - nStart);
+ //anchor
+ const wxChar* p = (const wxChar*)wxTmemchr(c_str() + nStart,
+ str.c_str()[0],
+ length() - nStart);
- if(!p)
- return npos;
+ 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()));
+ 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;
- if(!p)
- return npos;
- }
+ //anchor again
+ p = (const wxChar*)wxTmemchr(p,
+ str.c_str()[0],
+ length() - (p - c_str()));
- return (p - c_str() + str.length() <= length()) ? p - c_str() : npos;
+ 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
{
- return find(wxStringBase(sz, n), nStart);
+ return find(wxStringBase(sz, n), nStart);
}
size_t wxStringBase::find(wxChar ch, size_t nStart) const
{
- wxASSERT( nStart <= length() );
+ wxASSERT( nStart <= length() );
- const wxChar *p = (const wxChar*)wxMemchr(c_str() + nStart, ch, length() - nStart);
+ const wxChar *p = (const wxChar*)wxTmemchr(c_str() + nStart, ch, length() - nStart);
- return p == NULL ? npos : p - c_str();
+ return p == NULL ? npos : p - c_str();
}
size_t wxStringBase::rfind(const wxStringBase& str, size_t nStart) const
const wxChar *cursor = c_str() + top;
do
{
- if ( wxMemcmp(cursor, str.c_str(),
+ if ( wxTmemcmp(cursor, str.c_str(),
str.length()) == 0 )
{
return cursor - c_str();
size_t i;
for(i = nStart; i < this->length(); ++i)
{
- if (wxMemchr(sz, *(c_str() + i), len))
+ if (wxTmemchr(sz, *(c_str() + i), len))
break;
}
for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
{
- if ( wxMemchr(sz, *p, len) )
+ if ( wxTmemchr(sz, *p, len) )
return p - c_str();
}
size_t i;
for(i = nStart; i < this->length(); ++i)
{
- if (!wxMemchr(sz, *(c_str() + i), len))
+ if (!wxTmemchr(sz, *(c_str() + i), len))
break;
}
for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
{
- if ( !wxMemchr(sz, *p,len) )
+ if ( !wxTmemchr(sz, *p,len) )
return p - c_str();
}
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;
const wxChar* s2, size_t l2)
{
if( l1 == l2 )
- return wxMemcmp(s1, s2, l1);
+ return wxTmemcmp(s1, s2, l1);
else if( l1 < l2 )
{
- int ret = wxMemcmp(s1, s2, l1);
+ int ret = wxTmemcmp(s1, s2, l1);
return ret == 0 ? -1 : ret;
}
- else if( l1 > l2 )
+ else
{
- int ret = wxMemcmp(s1, s2, l2);
+ int ret = wxTmemcmp(s1, s2, l2);
return ret == 0 ? +1 : ret;
}
-
- wxFAIL; // must never get there
- return 0; // quiet compilers
}
int STRINGCLASS::compare(const wxStringBase& str) const
// wxString class core
// ===========================================================================
-// ---------------------------------------------------------------------------
-// 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(char* szBuffer, 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);
-
- //Invalid conversion?
- if( nLen == (size_t)-1 )
- {
- szBuffer[0] = '\0';
- return 0;
- }
-
- //Increase the actual length (+1 for current null character)
- nActualLength += nLen + 1;
-
- //If this is true it means buffer overflow
- wxASSERT( nActualLength <= wxString::WorstEncodingCase(nStringLen, conv) + 1 );
-
- //Convert the current (sub)string
- 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"));
- szBuffer[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( wchar_t* szBuffer, 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);
-
- //Invalid conversion?
- if( nLen == (size_t)-1 )
- {
- szBuffer[0] = '\0';
- return 0;
- }
-
- //Increase the actual length (+1 for current null character)
- nActualLength += nLen + 1;
-
- //If this is true it means buffer overflow
- wxASSERT(nActualLength <= nStringLen + 1);
-
- //Convert the current (sub)string
- 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"));
- szBuffer[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
// ---------------------------------------------------------------------------
nLen = 0;
}
+
// anything to do?
if ( (nLen != 0) && (nLen != (size_t)-1) )
{
- //When converting mb->wc it never inflates to more characters than the length
- wxStringBufferLength internalBuffer(*this, nLen + 1);
+ //Convert string
+ size_t nRealSize;
+ wxWCharBuffer theBuffer = conv.cMB2WC(psz, nLen, &nRealSize);
- //Do the actual conversion & Set the length of the buffer
- internalBuffer.SetLength(
- wxWcstr(internalBuffer, psz, nLen, conv)
- );
+ //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
{
- //Create the buffer
- wxCharBuffer buffer( wxString::WorstEncodingCase(length(), conv) + 1);
-
- //Do the actual conversion (will return a blank string on error)
- wxMbstr(buffer.data(), (*this).c_str(), length(), conv);
-
- return buffer;
+ size_t dwOutSize;
+ return conv.cWC2MB(c_str(), length(), &dwOutSize);
}
#else // ANSI
// anything to do?
if ( (nLen != 0) && (nLen != (size_t)-1) )
{
- //Create a wxStringBufferLength which will access the internal
- //C char pointer in non-stl mode
- wxStringBufferLength internalBuffer(*this, wxString::WorstEncodingCase(nLen, conv) + 1);
+ //Convert string
+ size_t nRealSize;
+ wxCharBuffer theBuffer = conv.cWC2MB(pwz, nLen, &nRealSize);
- //Do the actual conversion & Set the length of the buffer
- internalBuffer.SetLength(
- wxMbstr(internalBuffer, pwz, nLen, conv)
- );
+ //Copy
+ if (nRealSize)
+ assign( theBuffer.data() , nRealSize - 1 );
}
}
//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);
-
- //Do the actual conversion (will return a blank string on error)
- wxWcstr(buffer.data(), (*this).c_str(), length(), conv);
-
- return buffer;
+ size_t dwOutSize;
+ return conv.cMB2WC(c_str(), length(), &dwOutSize);
}
#endif // wxUSE_WCHAR_T
if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
wxFAIL_MSG( _T("out of memory in wxString::operator+") );
}
- s = str;
+ s += str;
s += psz;
return s;
if(wxTolower(s1[i]) != wxTolower(s2[i]))
break;
}
- return i == l1 ? 0 : s1[i] < s2[i] ? -1 : 1;
+ return i == l1 ? 0 : wxTolower(s1[i]) < wxTolower(s2[i]) ? -1 : 1;
}
else if( l1 < l2 )
{
if(wxTolower(s1[i]) != wxTolower(s2[i]))
break;
}
- return i == l1 ? -1 : s1[i] < s2[i] ? -1 : 1;
+ return i == l1 ? -1 : wxTolower(s1[i]) < wxTolower(s2[i]) ? -1 : 1;
}
- else if( l1 > l2 )
+ else
{
for(i = 0; i < l2; ++i)
{
if(wxTolower(s1[i]) != wxTolower(s2[i]))
break;
}
- return i == l2 ? 1 : s1[i] < s2[i] ? -1 : 1;
+ return i == l2 ? 1 : wxTolower(s1[i]) < wxTolower(s2[i]) ? -1 : 1;
}
-
- wxFAIL; // must never get there
- return 0; // quiet compilers
}
int wxString::CmpNoCase(const wxString& s) 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 ? wxT('_') : *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
// extract string of length nCount starting at nFirst
wxString wxString::Mid(size_t nFirst, size_t nCount) const
{
- size_t nLen = length();
+ size_t nLen = length();
- // default value of nCount is npos and means "till the end"
- if ( nCount == npos )
- {
- nCount = nLen - nFirst;
- }
+ // default value of nCount is npos and means "till the end"
+ if ( nCount == npos )
+ {
+ nCount = nLen - nFirst;
+ }
- // out-of-bounds requests return sensible things
- if ( nFirst + nCount > nLen )
- {
- nCount = nLen - nFirst;
- }
+ // out-of-bounds requests return sensible things
+ if ( nFirst + nCount > nLen )
+ {
+ nCount = nLen - nFirst;
+ }
- if ( nFirst > nLen )
- {
- // AllocCopy() will return empty string
- nCount = 0;
- }
+ if ( nFirst > nLen )
+ {
+ // AllocCopy() will return empty string
+ return wxEmptyString;
+ }
- wxString dest(*this, nFirst, nCount);
- if ( dest.length() != nCount ) {
- wxFAIL_MSG( _T("out of memory in wxString::Mid") );
- }
+ wxString dest(*this, nFirst, nCount);
+ if ( dest.length() != nCount )
+ {
+ wxFAIL_MSG( _T("out of memory in wxString::Mid") );
+ }
- return dest;
+ return dest;
}
// check that the string starts with prefix and return the rest of the string
}
// 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 string that was replaced
+ dwPos += uiNewLen;
- // stop now?
- if ( !bReplaceAll ) {
- strTemp += pCurrent; // copy the rest
- break; // exit the loop
- }
- }
- }
+ //increase replace count
+ ++uiCount;
- // only done if there were replacements, otherwise would have returned above
- swap(strTemp);
+ // stop now?
+ if ( !bReplaceAll )
+ break; // exit the loop
+ }
+ }
- return uiCount;
+ return uiCount;
}
bool wxString::IsAscii() const
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)))
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;
+
+ if ( !buf )
{
- wxStringBuffer tmp(*this, size + 1);
- wxChar* buf = tmp;
+ // out of memory
+ return -1;
+ }
- if ( !buf )
- {
- // out of memory
- return -1;
- }
+ // 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);
- // wxVsnprintf() may modify the original arg pointer, so pass it
- // only a copy
- va_list argptrcopy;
- wxVaCopy(argptrcopy, argptr);
- 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
break;
}
+#ifdef EOVERFLOW
+ // if the error is not due to not having enough space (it could be e.g.
+ // EILSEQ), break too -- we'd just eat all available memory uselessly
+ if ( errno != EOVERFLOW )
+ {
+ // no sense in continuing
+ break;
+ }
+#endif // EOVERFLOW
+
// still not enough, double it again
size *= 2;
}
#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)
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)
END_SORT();
}
-typedef int (wxC_CALLING_CONV * wxStringCompareFn)(const void *first, const void *second);
+extern "C"
+{
+ typedef int (wxC_CALLING_CONV * wxStringCompareFn)(const void *first,
+ const void *second);
+}
void wxArrayString::Sort(CompareFunction2 compareFunction)
{
projects / wxWidgets.git / blobdiff