#include "wx/defs.h"
#include "wx/string.h"
#include "wx/intl.h"
-#if wxUSE_THREADS
- #include <wx/thread.h>
-#endif
+ #include "wx/thread.h"
#endif
+#include "wx/regex.h" // for wxString::Matches()
+
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <clib.h>
#endif
-#if wxUSE_WCSRTOMBS
- #include <wchar.h> // for wcsrtombs(), see comments where it's used
-#endif // GNU
-
#ifdef WXSTRING_IS_WXOBJECT
IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
#endif //WXSTRING_IS_WXOBJECT
+#if wxUSE_UNICODE
+#undef wxUSE_EXPERIMENTAL_PRINTF
+#define wxUSE_EXPERIMENTAL_PRINTF 1
+#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!
// 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
+
#ifdef wxSTD_STRING_COMPATIBILITY
const size_t wxString::npos = wxSTRING_MAXLEN;
#endif // wxSTD_STRING_COMPATIBILITY
{
wxStringData data;
wxChar dummy;
-} g_strEmpty = { {-1, 0, 0}, _T('\0') };
+} g_strEmpty = { {-1, 0, 0}, wxT('\0') };
// empty C style string: points to 'string data' byte of g_strEmpty
-extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
+extern const wxChar WXDLLEXPORT *wxEmptyString = &g_strEmpty.dummy;
// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------
+#if !defined(__WXSW__) && wxUSE_UNICODE
+ #ifdef wxUSE_EXPERIMENTAL_PRINTF
+ #undef wxUSE_EXPERIMENTAL_PRINTF
+ #endif
+ #define wxUSE_EXPERIMENTAL_PRINTF 1
+#endif
+
// we want to find out if the current platform supports vsnprintf()-like
// function: for Unix this is done with configure, for Windows we test the
// compiler explicitly.
+//
+// FIXME currently, this is only for ANSI (!Unicode) strings, so we call this
+// function wxVsnprintfA (A for ANSI), should also find one for Unicode
+// strings in Unicode build
#ifdef __WXMSW__
- #ifdef __VISUALC__
- #define wxVsnprintf _vsnprintf
+ #if defined(__VISUALC__) || (defined(__MINGW32__) && wxUSE_NORLANDER_HEADERS)
+ #define wxVsnprintfA _vsnprintf
#endif
+#elif defined(__WXMAC__)
+ #define wxVsnprintfA vsnprintf
#else // !Windows
#ifdef HAVE_VSNPRINTF
- #define wxVsnprintf vsnprintf
+ #define wxVsnprintfA vsnprintf
#endif
#endif // Windows/!Windows
-#ifndef wxVsnprintf
+#ifndef wxVsnprintfA
// in this case we'll use vsprintf() (which is ANSI and thus should be
// always available), but it's unsafe because it doesn't check for buffer
// size - so give a warning
- #define wxVsnprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr)
+ #define wxVsnprintfA(buf, len, format, arg) vsprintf(buf, format, arg)
#if defined(__VISUALC__)
#pragma message("Using sprintf() because no snprintf()-like function defined")
- #elif defined(__GNUG__) && !defined(__UNIX__)
+ #elif defined(__GNUG__)
#warning "Using sprintf() because no snprintf()-like function defined"
- #elif defined(__MWERKS__)
- #warning "Using sprintf() because no snprintf()-like function defined"
#endif //compiler
#endif // no vsnprintf
// global functions
// ----------------------------------------------------------------------------
-#ifdef wxSTD_STRING_COMPATIBILITY
+#if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
// MS Visual C++ version 5.0 provides the new STL headers as well as the old
// iostream ones.
//
// ATTN: you can _not_ use both of these in the same program!
-istream& operator>>(istream& is, wxString& WXUNUSED(str))
+wxSTD istream& operator>>(wxSTD istream& is, wxString& WXUNUSED(str))
{
#if 0
int w = is.width(0);
return is;
}
+wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
+{
+ os << str.c_str();
+ return os;
+}
+
#endif //std::string compatibility
+extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
+ const wxChar *format, va_list argptr)
+{
+#if wxUSE_UNICODE
+ // FIXME should use wvsnprintf() or whatever if it's available
+ wxString s;
+ int iLen = s.PrintfV(format, argptr);
+ if ( iLen != -1 )
+ {
+ wxStrncpy(buf, s.c_str(), len);
+ buf[len-1] = wxT('\0');
+ }
+
+ return iLen;
+#else // ANSI
+ // vsnprintf() will not terminate the string with '\0' if there is not
+ // enough place, but we want the string to always be NUL terminated
+ int rc = wxVsnprintfA(buf, len - 1, format, argptr);
+ if ( rc == -1 )
+ {
+ buf[len] = 0;
+ }
+
+ return rc;
+#endif // Unicode/ANSI
+}
+
+extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
+ const wxChar *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int iLen = wxVsnprintf(buf, len, format, argptr);
+
+ va_end(argptr);
+
+ return iLen;
+}
+
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
{
Init();
- wxASSERT( nPos <= wxStrlen(psz) );
+ // if the length is not given, assume the string to be NUL terminated
+ if ( nLength == wxSTRING_MAXLEN ) {
+ wxASSERT_MSG( nPos <= wxStrlen(psz), _T("index out of bounds") );
- if ( nLength == wxSTRING_MAXLEN )
nLength = wxStrlen(psz + nPos);
+ }
STATISTICS_ADD(InitialLength, nLength);
size_t nLen = psz ? conv.MB2WC((wchar_t *) NULL, psz, 0) : 0;
// nLength is number of *Unicode* characters here!
- if (nLen > nLength)
+ if ((nLen != (size_t)-1) && (nLen > nLength))
nLen = nLength;
// empty?
- if ( nLen != 0 ) {
+ if ( (nLen != 0) && (nLen != (size_t)-1) ) {
AllocBuffer(nLen);
conv.MB2WC(m_pchData, psz, nLen);
}
}
}
-#else
+#else // ANSI
+#if wxUSE_WCHAR_T
// from wide string
-wxString::wxString(const wchar_t *pwz)
+wxString::wxString(const wchar_t *pwz, wxMBConv& conv)
{
// first get necessary size
- size_t nLen = pwz ? wxWC2MB((char *) NULL, pwz, 0) : 0;
+ size_t nLen = pwz ? conv.WC2MB((char *) NULL, pwz, 0) : 0;
// empty?
- if ( nLen != 0 ) {
+ if ( (nLen != 0) && (nLen != (size_t)-1) ) {
AllocBuffer(nLen);
- wxWC2MB(m_pchData, pwz, nLen);
+ conv.WC2MB(m_pchData, pwz, nLen);
}
else {
Init();
}
}
+#endif // wxUSE_WCHAR_T
-#endif
+#endif // Unicode/ANSI
// ---------------------------------------------------------------------------
// memory allocation
// allocates memory needed to store a C string of length nLen
void wxString::AllocBuffer(size_t nLen)
{
- wxASSERT( nLen > 0 ); //
- wxASSERT( nLen <= INT_MAX-1 ); // max size (enough room for 1 extra)
+ // allocating 0 sized buffer doesn't make sense, all empty strings should
+ // reuse g_strEmpty
+ wxASSERT( nLen > 0 );
+
+ // make sure that we don't overflow
+ wxASSERT( nLen < (INT_MAX / sizeof(wxChar)) -
+ (sizeof(wxStringData) + EXTRA_ALLOC + 1) );
STATISTICS_ADD(Length, nLen);
pData->nDataLength = nLen;
pData->nAllocLength = nLen + EXTRA_ALLOC;
m_pchData = pData->data(); // data starts after wxStringData
- m_pchData[nLen] = _T('\0');
+ m_pchData[nLen] = wxT('\0');
}
// must be called before changing this string
// must not share string and must have enough space
wxStringData* pData = GetStringData();
- if ( pData->IsShared() || (nLen > pData->nAllocLength) ) {
+ if ( pData->IsShared() || pData->IsEmpty() ) {
// can't work with old buffer, get new one
pData->Unlock();
AllocBuffer(nLen);
}
else {
- // update the string length
+ if ( nLen > pData->nAllocLength ) {
+ // realloc the buffer instead of calling malloc() again, this is more
+ // efficient
+ STATISTICS_ADD(Length, nLen);
+
+ nLen += EXTRA_ALLOC;
+
+ wxStringData *pDataOld = pData;
+ pData = (wxStringData*)
+ realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
+ if ( !pData ) {
+ // out of memory
+ free(pDataOld);
+
+ // FIXME we're going to crash...
+ return;
+ }
+
+ pData->nAllocLength = nLen;
+ m_pchData = pData->data();
+ }
+
+ // now we have enough space, just update the string length
pData->nDataLength = nLen;
}
pData->nDataLength = 0;
pData->nAllocLength = nLen;
m_pchData = pData->data(); // data starts after wxStringData
- m_pchData[0u] = _T('\0');
+ m_pchData[0u] = wxT('\0');
}
else if ( pData->IsShared() ) {
pData->Unlock(); // memory not freed because shared
else {
nLen += EXTRA_ALLOC;
+ wxStringData *pDataOld = pData;
wxStringData *p = (wxStringData *)
realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
if ( p == NULL ) {
- // @@@ what to do on memory error?
+ // don't leak memory
+ free(pDataOld);
+
+ // FIXME what to do on memory error?
return;
}
{
wxStringData *pData = GetStringData();
- // this variable is unused in release build, so avoid the compiler warning by
- // just not declaring it
-#ifdef __WXDEBUG__
- void *p =
-#endif
- realloc(pData, sizeof(wxStringData) + (pData->nDataLength + 1)*sizeof(wxChar));
+ size_t nLen = pData->nDataLength;
+ void *p = realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
- wxASSERT( p != NULL ); // can't free memory?
- wxASSERT( p == pData ); // we're decrementing the size - block shouldn't move!
+ wxASSERT_MSG( p != NULL, _T("can't free memory?") );
+
+ if ( p != pData )
+ {
+ // contrary to what one might believe, some realloc() implementation do
+ // move the memory block even when its size is reduced
+ pData = (wxStringData *)p;
+
+ m_pchData = pData->data();
+ }
+
+ pData->nAllocLength = nLen;
}
// get the pointer to writable buffer of (at least) nLen bytes
GetStringData()->Validate(TRUE);
}
+void wxString::UngetWriteBuf(size_t nLen)
+{
+ GetStringData()->nDataLength = nLen;
+ GetStringData()->Validate(TRUE);
+}
+
// ---------------------------------------------------------------------------
// data access
// ---------------------------------------------------------------------------
AllocBeforeWrite(nSrcLen);
memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
GetStringData()->nDataLength = nSrcLen;
- m_pchData[nSrcLen] = _T('\0');
+ m_pchData[nSrcLen] = wxT('\0');
}
}
return *this;
}
+
// assigns C string
wxString& wxString::operator=(const wxChar *psz)
{
return *this;
}
+#if wxUSE_WCHAR_T
wxString& wxString::operator=(const wchar_t *pwz)
{
wxString str(pwz);
*this = str;
return *this;
}
+#endif
#endif
// fast concatenation - all is done in our buffer
memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(wxChar));
- m_pchData[nNewLen] = _T('\0'); // put terminating '\0'
+ m_pchData[nNewLen] = wxT('\0'); // put terminating '\0'
GetStringData()->nDataLength = nNewLen; // and fix the length
}
//else: the string to append was empty
return dest;
}
+// check that the tring starts with prefix and return the rest of the string
+// 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") );
+
+ // first check if the beginning of the string matches the prefix: note
+ // that we don't have to check that we don't run out of this string as
+ // when we reach the terminating NUL, either prefix string ends too (and
+ // then it's ok) or we break out of the loop because there is no match
+ const wxChar *p = c_str();
+ while ( *prefix )
+ {
+ if ( *prefix++ != *p++ )
+ {
+ // no match
+ return FALSE;
+ }
+ }
+
+ if ( rest )
+ {
+ // put the rest of the string into provided pointer
+ *rest = p;
+ }
+
+ return TRUE;
+}
+
// extract nCount last (rightmost) characters
wxString wxString::Right(size_t nCount) const
{
wxString wxString::BeforeFirst(wxChar ch) const
{
wxString str;
- for ( const wxChar *pc = m_pchData; *pc != _T('\0') && *pc != ch; pc++ )
+ for ( const wxChar *pc = m_pchData; *pc != wxT('\0') && *pc != ch; pc++ )
str += *pc;
return str;
wxString strTemp;
const wxChar *pCurrent = m_pchData;
const wxChar *pSubstr;
- while ( *pCurrent != _T('\0') ) {
+ while ( *pCurrent != wxT('\0') ) {
pSubstr = wxStrstr(pCurrent, szOld);
if ( pSubstr == NULL ) {
// strTemp is unused if no replacements were made, so avoid the copy
bool wxString::IsNumber() const
{
const wxChar *s = (const wxChar*) *this;
+ if (wxStrlen(s))
+ if ((s[0] == '-') || (s[0] == '+')) s++;
while(*s){
if(!wxIsdigit(*s)) return(FALSE);
s++;
// trimming and padding
// ---------------------------------------------------------------------------
+// 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
+// space-like symbols somewhere except in the first 128 chars), it is arguably
+// still better than trimming away accented letters
+inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
+
// trims spaces (in the sense of isspace) from left or right side
wxString& wxString::Trim(bool bFromRight)
{
// first check if we're going to modify the string at all
- if ( !IsEmpty() &&
- (
- (bFromRight && wxIsspace(GetChar(Len() - 1))) ||
- (!bFromRight && wxIsspace(GetChar(0u)))
+ if ( !IsEmpty() &&
+ (
+ (bFromRight && wxSafeIsspace(GetChar(Len() - 1))) ||
+ (!bFromRight && wxSafeIsspace(GetChar(0u)))
)
)
{
{
// find last non-space character
wxChar *psz = m_pchData + GetStringData()->nDataLength - 1;
- while ( wxIsspace(*psz) && (psz >= m_pchData) )
+ while ( wxSafeIsspace(*psz) && (psz >= m_pchData) )
psz--;
// truncate at trailing space start
- *++psz = _T('\0');
+ *++psz = wxT('\0');
GetStringData()->nDataLength = psz - m_pchData;
}
else
{
// find first non-space character
const wxChar *psz = m_pchData;
- while ( wxIsspace(*psz) )
+ while ( wxSafeIsspace(*psz) )
psz++;
// fix up data and length
if ( uiLen < Len() ) {
CopyBeforeWrite();
- *(m_pchData + uiLen) = _T('\0');
+ *(m_pchData + uiLen) = wxT('\0');
GetStringData()->nDataLength = uiLen;
}
//else: nothing to do, string is already short enough
return (psz == NULL) ? wxNOT_FOUND : psz - (const wxChar*) m_pchData;
}
-// ---------------------------------------------------------------------------
-// stream-like operators
-// ---------------------------------------------------------------------------
-wxString& wxString::operator<<(int i)
+// ----------------------------------------------------------------------------
+// conversion to numbers
+// ----------------------------------------------------------------------------
+
+bool wxString::ToLong(long *val, int base) const
{
- wxString res;
- res.Printf(_T("%d"), i);
+ wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToLong") );
+
+ const wxChar *start = c_str();
+ wxChar *end;
+ *val = wxStrtol(start, &end, base);
- return (*this) << res;
+ // 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);
}
-wxString& wxString::operator<<(float f)
+bool wxString::ToULong(unsigned long *val, int base) const
{
- wxString res;
- res.Printf(_T("%f"), f);
+ wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToULong") );
- return (*this) << res;
+ 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
+ // string was not empty to start with
+ return !*end && (end != start);
}
-wxString& wxString::operator<<(double d)
+bool wxString::ToDouble(double *val) const
{
- wxString res;
- res.Printf(_T("%g"), d);
+ wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToDouble") );
+
+ const wxChar *start = c_str();
+ wxChar *end;
+ *val = wxStrtod(start, &end);
- return (*this) << res;
+ // 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);
}
// ---------------------------------------------------------------------------
// formatted output
// ---------------------------------------------------------------------------
+
+/* static */
+wxString wxString::Format(const wxChar *pszFormat, ...)
+{
+ va_list argptr;
+ va_start(argptr, pszFormat);
+
+ wxString s;
+ s.PrintfV(pszFormat, argptr);
+
+ va_end(argptr);
+
+ return s;
+}
+
+/* static */
+wxString wxString::FormatV(const wxChar *pszFormat, va_list argptr)
+{
+ wxString s;
+ s.PrintfV(pszFormat, argptr);
+ return s;
+}
+
int wxString::Printf(const wxChar *pszFormat, ...)
{
va_list argptr;
int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
{
- // static buffer to avoid dynamic memory allocation each time
- static char s_szScratch[1024];
-#if wxUSE_THREADS
- // protect the static buffer
- static wxCriticalSection critsect;
- wxCriticalSectionLocker lock(critsect);
-#endif
+#if wxUSE_EXPERIMENTAL_PRINTF
+ // the new implementation
-#if 1 // the new implementation
+ // buffer to avoid dynamic memory allocation each time for small strings
+ char szScratch[1024];
Reinit();
for (size_t n = 0; pszFormat[n]; n++)
- if (pszFormat[n] == _T('%')) {
+ if (pszFormat[n] == wxT('%')) {
static char s_szFlags[256] = "%";
size_t flagofs = 1;
bool adj_left = FALSE, in_prec = FALSE,
- prec_dot = FALSE, done = FALSE;
+ prec_dot = FALSE, done = FALSE;
int ilen = 0;
size_t min_width = 0, max_width = wxSTRING_MAXLEN;
do {
#define CHECK_PREC if (in_prec && !prec_dot) { s_szFlags[flagofs++] = '.'; prec_dot = TRUE; }
- switch (pszFormat[++n]) {
- case _T('\0'):
- done = TRUE;
- break;
- case _T('%'):
- *this += _T('%');
- done = TRUE;
- break;
- case _T('#'):
- case _T('0'):
- case _T(' '):
- case _T('+'):
- case _T('\''):
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('-'):
- CHECK_PREC
- adj_left = TRUE;
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('.'):
- CHECK_PREC
- in_prec = TRUE;
- prec_dot = FALSE;
- max_width = 0;
- // dot will be auto-added to s_szFlags if non-negative number follows
- break;
- case _T('h'):
- ilen = -1;
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('l'):
- ilen = 1;
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('q'):
- case _T('L'):
- ilen = 2;
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('Z'):
- ilen = 3;
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- break;
- case _T('*'):
- {
- int len = va_arg(argptr, int);
- if (in_prec) {
- if (len<0) break;
- CHECK_PREC
- max_width = len;
- } else {
- if (len<0) {
- adj_left = !adj_left;
- s_szFlags[flagofs++] = '-';
- len = -len;
- }
- min_width = len;
- }
- flagofs += ::sprintf(s_szFlags+flagofs,"%d",len);
- }
- break;
- case _T('1'): case _T('2'): case _T('3'):
- case _T('4'): case _T('5'): case _T('6'):
- case _T('7'): case _T('8'): case _T('9'):
- {
- int len = 0;
- CHECK_PREC
- while ((pszFormat[n]>=_T('0')) && (pszFormat[n]<=_T('9'))) {
- s_szFlags[flagofs++] = pszFormat[n];
- len = len*10 + (pszFormat[n] - _T('0'));
- n++;
- }
- if (in_prec) max_width = len;
- else min_width = len;
- n--; // the main loop pre-increments n again
- }
- break;
- case _T('d'):
- case _T('i'):
- case _T('o'):
- case _T('u'):
- case _T('x'):
- case _T('X'):
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- s_szFlags[flagofs] = '\0';
- if (ilen == 0 ) {
- int val = va_arg(argptr, int);
- ::sprintf(s_szScratch, s_szFlags, val);
- }
- else if (ilen == -1) {
- short int val = va_arg(argptr, short int);
- ::sprintf(s_szScratch, s_szFlags, val);
- }
- else if (ilen == 1) {
- long int val = va_arg(argptr, long int);
- ::sprintf(s_szScratch, s_szFlags, val);
- }
- else if (ilen == 2) {
+ switch (pszFormat[++n]) {
+ case wxT('\0'):
+ done = TRUE;
+ break;
+ case wxT('%'):
+ *this += wxT('%');
+ done = TRUE;
+ break;
+ case wxT('#'):
+ case wxT('0'):
+ case wxT(' '):
+ case wxT('+'):
+ case wxT('\''):
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('-'):
+ CHECK_PREC
+ adj_left = TRUE;
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('.'):
+ CHECK_PREC
+ in_prec = TRUE;
+ prec_dot = FALSE;
+ max_width = 0;
+ // dot will be auto-added to s_szFlags if non-negative number follows
+ break;
+ case wxT('h'):
+ ilen = -1;
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('l'):
+ ilen = 1;
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('q'):
+ case wxT('L'):
+ ilen = 2;
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('Z'):
+ ilen = 3;
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ break;
+ case wxT('*'):
+ {
+ int len = va_arg(argptr, int);
+ if (in_prec) {
+ if (len<0) break;
+ CHECK_PREC
+ max_width = len;
+ } else {
+ if (len<0) {
+ adj_left = !adj_left;
+ s_szFlags[flagofs++] = '-';
+ len = -len;
+ }
+ min_width = len;
+ }
+ flagofs += ::sprintf(s_szFlags+flagofs,"%d",len);
+ }
+ break;
+ case wxT('1'): case wxT('2'): case wxT('3'):
+ case wxT('4'): case wxT('5'): case wxT('6'):
+ case wxT('7'): case wxT('8'): case wxT('9'):
+ {
+ int len = 0;
+ CHECK_PREC
+ while ((pszFormat[n]>=wxT('0')) && (pszFormat[n]<=wxT('9'))) {
+ s_szFlags[flagofs++] = pszFormat[n];
+ len = len*10 + (pszFormat[n] - wxT('0'));
+ n++;
+ }
+ if (in_prec) max_width = len;
+ else min_width = len;
+ n--; // the main loop pre-increments n again
+ }
+ break;
+ case wxT('d'):
+ case wxT('i'):
+ case wxT('o'):
+ case wxT('u'):
+ case wxT('x'):
+ case wxT('X'):
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ s_szFlags[flagofs] = '\0';
+ if (ilen == 0 ) {
+ int val = va_arg(argptr, int);
+ ::sprintf(szScratch, s_szFlags, val);
+ }
+ else if (ilen == -1) {
+ short int val = va_arg(argptr, short int);
+ ::sprintf(szScratch, s_szFlags, val);
+ }
+ else if (ilen == 1) {
+ long int val = va_arg(argptr, long int);
+ ::sprintf(szScratch, s_szFlags, val);
+ }
+ else if (ilen == 2) {
#if SIZEOF_LONG_LONG
- long long int val = va_arg(argptr, long long int);
- ::sprintf(s_szScratch, s_szFlags, val);
+ long long int val = va_arg(argptr, long long int);
+ ::sprintf(szScratch, s_szFlags, val);
#else
- long int val = va_arg(argptr, long int);
- ::sprintf(s_szScratch, s_szFlags, val);
+ long int val = va_arg(argptr, long int);
+ ::sprintf(szScratch, s_szFlags, val);
#endif
- }
- else if (ilen == 3) {
- size_t val = va_arg(argptr, size_t);
- ::sprintf(s_szScratch, s_szFlags, val);
- }
- *this += wxString(s_szScratch);
- done = TRUE;
- break;
- case _T('e'):
- case _T('E'):
- case _T('f'):
- case _T('g'):
- case _T('G'):
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- s_szFlags[flagofs] = '\0';
- if (ilen == 2) {
- long double val = va_arg(argptr, long double);
- ::sprintf(s_szScratch, s_szFlags, val);
- } else {
- double val = va_arg(argptr, double);
- ::sprintf(s_szScratch, s_szFlags, val);
- }
- *this += wxString(s_szScratch);
- done = TRUE;
- break;
- case _T('p'):
- {
- void *val = va_arg(argptr, void *);
- CHECK_PREC
- s_szFlags[flagofs++] = pszFormat[n];
- s_szFlags[flagofs] = '\0';
- ::sprintf(s_szScratch, s_szFlags, val);
- *this += wxString(s_szScratch);
- done = TRUE;
- }
- break;
- case _T('c'):
- {
- wxChar val = va_arg(argptr, int);
- // we don't need to honor padding here, do we?
- *this += val;
- done = TRUE;
- }
- break;
- case _T('s'):
- if (ilen == -1) {
- // wx extension: we'll let %hs mean non-Unicode strings
- char *val = va_arg(argptr, char *);
+ }
+ else if (ilen == 3) {
+ size_t val = va_arg(argptr, size_t);
+ ::sprintf(szScratch, s_szFlags, val);
+ }
+ *this += wxString(szScratch);
+ done = TRUE;
+ break;
+ case wxT('e'):
+ case wxT('E'):
+ case wxT('f'):
+ case wxT('g'):
+ case wxT('G'):
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ s_szFlags[flagofs] = '\0';
+ if (ilen == 2) {
+ long double val = va_arg(argptr, long double);
+ ::sprintf(szScratch, s_szFlags, val);
+ } else {
+ double val = va_arg(argptr, double);
+ ::sprintf(szScratch, s_szFlags, val);
+ }
+ *this += wxString(szScratch);
+ done = TRUE;
+ break;
+ case wxT('p'):
+ {
+ void *val = va_arg(argptr, void *);
+ CHECK_PREC
+ s_szFlags[flagofs++] = pszFormat[n];
+ s_szFlags[flagofs] = '\0';
+ ::sprintf(szScratch, s_szFlags, val);
+ *this += wxString(szScratch);
+ done = TRUE;
+ }
+ break;
+ case wxT('c'):
+ {
+ wxChar val = va_arg(argptr, int);
+ // we don't need to honor padding here, do we?
+ *this += val;
+ done = TRUE;
+ }
+ break;
+ case wxT('s'):
+ if (ilen == -1) {
+ // wx extension: we'll let %hs mean non-Unicode strings
+ char *val = va_arg(argptr, char *);
#if wxUSE_UNICODE
- // ASCII->Unicode constructor handles max_width right
- wxString s(val, wxConv_libc, max_width);
+ // ASCII->Unicode constructor handles max_width right
+ wxString s(val, wxConvLibc, max_width);
#else
- size_t len = wxSTRING_MAXLEN;
- if (val) {
- for (len = 0; val[len] && (len<max_width); len++);
- } else val = _T("(null)");
- wxString s(val, len);
+ size_t len = wxSTRING_MAXLEN;
+ if (val) {
+ for (len = 0; val[len] && (len<max_width); len++);
+ } else val = wxT("(null)");
+ wxString s(val, len);
#endif
- if (s.Len() < min_width)
- s.Pad(min_width - s.Len(), _T(' '), adj_left);
- *this += s;
- } else {
- wxChar *val = va_arg(argptr, wxChar *);
- size_t len = wxSTRING_MAXLEN;
- if (val) {
- for (len = 0; val[len] && (len<max_width); len++);
- } else val = _T("(null)");
- wxString s(val, len);
- if (s.Len() < min_width)
- s.Pad(min_width - s.Len(), _T(' '), adj_left);
- *this += s;
- done = TRUE;
- }
- break;
- case _T('n'):
- if (ilen == 0) {
- int *val = va_arg(argptr, int *);
- *val = Len();
- }
- else if (ilen == -1) {
- short int *val = va_arg(argptr, short int *);
- *val = Len();
- }
- else if (ilen >= 1) {
- long int *val = va_arg(argptr, long int *);
- *val = Len();
- }
- done = TRUE;
- break;
- default:
- if (wxIsalpha(pszFormat[n]))
- // probably some flag not taken care of here yet
- s_szFlags[flagofs++] = pszFormat[n];
- else {
- // bad format
- *this += _T('%'); // just to pass the glibc tst-printf.c
- n--;
- done = TRUE;
- }
- break;
- }
+ if (s.Len() < min_width)
+ s.Pad(min_width - s.Len(), wxT(' '), adj_left);
+ *this += s;
+ } else {
+ wxChar *val = va_arg(argptr, wxChar *);
+ size_t len = wxSTRING_MAXLEN;
+ if (val) {
+ for (len = 0; val[len] && (len<max_width); len++);
+ } else val = wxT("(null)");
+ wxString s(val, len);
+ if (s.Len() < min_width)
+ s.Pad(min_width - s.Len(), wxT(' '), adj_left);
+ *this += s;
+ }
+ done = TRUE;
+ break;
+ case wxT('n'):
+ if (ilen == 0) {
+ int *val = va_arg(argptr, int *);
+ *val = Len();
+ }
+ else if (ilen == -1) {
+ short int *val = va_arg(argptr, short int *);
+ *val = Len();
+ }
+ else if (ilen >= 1) {
+ long int *val = va_arg(argptr, long int *);
+ *val = Len();
+ }
+ done = TRUE;
+ break;
+ default:
+ if (wxIsalpha(pszFormat[n]))
+ // probably some flag not taken care of here yet
+ s_szFlags[flagofs++] = pszFormat[n];
+ else {
+ // bad format
+ *this += wxT('%'); // just to pass the glibc tst-printf.c
+ n--;
+ done = TRUE;
+ }
+ break;
+ }
#undef CHECK_PREC
} while (!done);
} else *this += pszFormat[n];
#else
- // NB: wxVsnprintf() may return either less than the buffer size or -1 if there
- // is not enough place depending on implementation
- int iLen = wxVsnprintf(s_szScratch, WXSIZEOF(s_szScratch), pszFormat, argptr);
- char *buffer;
- if ( iLen < (int)WXSIZEOF(s_szScratch) ) {
- buffer = s_szScratch;
+ // buffer to avoid dynamic memory allocation each time for small strings
+ char szScratch[1024];
+
+ // NB: wxVsnprintf() may return either less than the buffer size or -1 if
+ // there is not enough place depending on implementation
+ int iLen = wxVsnprintfA(szScratch, WXSIZEOF(szScratch), (char *)pszFormat, argptr);
+ if ( iLen != -1 ) {
+ // the whole string is in szScratch
+ *this = szScratch;
}
else {
- int size = WXSIZEOF(s_szScratch) * 2;
- buffer = (char *)malloc(size);
- while ( buffer != NULL ) {
- iLen = wxVsnprintf(buffer, WXSIZEOF(s_szScratch), pszFormat, argptr);
- if ( iLen < size ) {
+ bool outOfMemory = FALSE;
+ int size = 2*WXSIZEOF(szScratch);
+ while ( !outOfMemory ) {
+ char *buf = GetWriteBuf(size);
+ if ( buf )
+ iLen = wxVsnprintfA(buf, size, pszFormat, argptr);
+ else
+ outOfMemory = TRUE;
+
+ UngetWriteBuf();
+
+ if ( iLen != -1 ) {
// ok, there was enough space
break;
}
// still not enough, double it again
- buffer = (char *)realloc(buffer, size *= 2);
+ size *= 2;
}
- if ( !buffer ) {
+ if ( outOfMemory ) {
// out of memory
return -1;
}
}
-
- wxString s(buffer);
- *this = s;
-
- if ( buffer != s_szScratch )
- free(buffer);
-#endif
+#endif // wxUSE_EXPERIMENTAL_PRINTF/!wxUSE_EXPERIMENTAL_PRINTF
return Len();
}
// ----------------------------------------------------------------------------
// misc other operations
// ----------------------------------------------------------------------------
+
+// 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
{
- // check char by char
- const wxChar *pszTxt;
- for ( pszTxt = c_str(); *pszMask != _T('\0'); pszMask++, pszTxt++ ) {
+#if wxUSE_REGEX
+ // first translate the shell-like mask into a regex
+ wxString pattern;
+ pattern.reserve(wxStrlen(pszMask));
+
+ pattern += _T('^');
+ while ( *pszMask )
+ {
+ switch ( *pszMask )
+ {
+ case _T('?'):
+ pattern += _T('.');
+ break;
+
+ case _T('*'):
+ pattern += _T(".*");
+ break;
+
+ case _T('^'):
+ case _T('.'):
+ case _T('$'):
+ case _T('('):
+ case _T(')'):
+ case _T('|'):
+ case _T('+'):
+ case _T('\\'):
+ // these characters are special in a RE, quote them
+ // (however note that we don't quote '[' and ']' to allow
+ // using them for Unix shell like matching)
+ pattern += _T('\\');
+ // fall through
+
+ default:
+ pattern += *pszMask;
+ }
+
+ pszMask++;
+ }
+ pattern += _T('$');
+
+ // and now use it
+ return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
+#else // !wxUSE_REGEX
+ // TODO: this is, of course, awfully inefficient...
+
+ // the char currently being checked
+ const wxChar *pszTxt = c_str();
+
+ // the last location where '*' matched
+ const wxChar *pszLastStarInText = NULL;
+ const wxChar *pszLastStarInMask = NULL;
+
+match:
+ for ( ; *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
switch ( *pszMask ) {
- case _T('?'):
- if ( *pszTxt == _T('\0') )
+ case wxT('?'):
+ if ( *pszTxt == wxT('\0') )
return FALSE;
- pszTxt++;
- pszMask++;
+ // pszTxt and pszMask will be incremented in the loop statement
+
break;
- case _T('*'):
+ case wxT('*'):
{
+ // remember where we started to be able to backtrack later
+ pszLastStarInText = pszTxt;
+ pszLastStarInMask = pszMask;
+
// ignore special chars immediately following this one
- while ( *pszMask == _T('*') || *pszMask == _T('?') )
+ // (should this be an error?)
+ while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
pszMask++;
// if there is nothing more, match
- if ( *pszMask == _T('\0') )
+ if ( *pszMask == wxT('\0') )
return TRUE;
// are there any other metacharacters in the mask?
size_t uiLenMask;
- const wxChar *pEndMask = wxStrpbrk(pszMask, _T("*?"));
+ const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
if ( pEndMask != NULL ) {
// we have to match the string between two metachars
}
// match only if nothing left
- return *pszTxt == _T('\0');
+ if ( *pszTxt == wxT('\0') )
+ return TRUE;
+
+ // if we failed to match, backtrack if we can
+ if ( pszLastStarInText ) {
+ pszTxt = pszLastStarInText + 1;
+ pszMask = pszLastStarInMask;
+
+ pszLastStarInText = NULL;
+
+ // don't bother resetting pszLastStarInMask, it's unnecessary
+
+ goto match;
+ }
+
+ return FALSE;
+#endif // wxUSE_REGEX/!wxUSE_REGEX
}
// Count the number of chars
// ---------------------------------------------------------------------------
// standard C++ library string functions
// ---------------------------------------------------------------------------
+
#ifdef wxSTD_STRING_COMPATIBILITY
+void wxString::resize(size_t nSize, wxChar ch)
+{
+ size_t len = length();
+
+ if ( nSize < len )
+ {
+ Truncate(nSize);
+ }
+ else if ( nSize > len )
+ {
+ *this += wxString(ch, nSize - len);
+ }
+ //else: we have exactly the specified length, nothing to do
+}
+
+void wxString::swap(wxString& str)
+{
+ // this is slightly less efficient than fiddling with m_pchData directly,
+ // but it is still quite efficient as we don't copy the string here because
+ // ref count always stays positive
+ wxString tmp = str;
+ str = *this;
+ *this = str;
+}
+
wxString& wxString::insert(size_t nPos, const wxString& str)
{
wxASSERT( str.GetStringData()->IsValid() );
#if !defined(__VISUALC__) || defined(__WIN32__)
size_t wxString::find(const wxChar* sz, size_t nStart, size_t n) const
{
- return find(wxString(sz, n == npos ? 0 : n), nStart);
+ return find(wxString(sz, n), nStart);
}
#endif // VC++ 1.5
wxASSERT( str.GetStringData()->IsValid() );
wxASSERT( nStart <= Len() );
- // # could be quicker than that
+ // TODO could be made much quicker than that
const wxChar *p = c_str() + (nStart == npos ? Len() : nStart);
while ( p >= c_str() + str.Len() ) {
if ( wxStrncmp(p - str.Len(), str, str.Len()) == 0 )
#if !defined(__VISUALC__) || defined(__WIN32__)
size_t wxString::rfind(const wxChar* sz, size_t nStart, size_t n) const
{
- return rfind(wxString(sz, n == npos ? 0 : n), nStart);
+ return rfind(wxString(sz, n == npos ? 0 : n), nStart);
}
size_t wxString::rfind(wxChar ch, size_t nStart) const
{
- wxASSERT( nStart <= Len() );
+ if ( nStart == npos )
+ {
+ nStart = Len();
+ }
+ else
+ {
+ wxASSERT( nStart <= Len() );
+ }
- const wxChar *p = wxStrrchr(c_str() + nStart, ch);
+ const wxChar *p = wxStrrchr(c_str(), ch);
- return p == NULL ? npos : p - c_str();
+ if ( p == NULL )
+ return npos;
+
+ size_t result = p - c_str();
+ return ( result > nStart ) ? npos : result;
}
#endif // VC++ 1.5
-wxString wxString::substr(size_t nStart, size_t nLen) const
+size_t wxString::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
+ return npos;
+}
+
+size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
+{
+ if ( nStart == npos )
+ {
+ nStart = Len();
+ }
+ else
+ {
+ wxASSERT( nStart <= Len() );
+ }
+
+ for ( const wxChar *p = c_str() + length() - 1; p >= c_str(); p-- )
+ {
+ if ( wxStrchr(sz, *p) )
+ return p - c_str();
+ }
+
+ return npos;
+}
+
+size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
+{
+ if ( nStart == npos )
+ {
+ nStart = Len();
+ }
+ else
+ {
+ wxASSERT( nStart <= Len() );
+ }
+
+ size_t nAccept = wxStrspn(c_str() + nStart, sz);
+ if ( nAccept >= length() - nStart )
+ return npos;
+ else
+ return nAccept;
+}
+
+size_t wxString::find_first_not_of(wxChar ch, size_t nStart) const
+{
+ wxASSERT( nStart <= Len() );
+
+ for ( const wxChar *p = c_str() + nStart; *p; p++ )
+ {
+ if ( *p != ch )
+ return p - c_str();
+ }
+
+ return npos;
+}
+
+size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
+{
+ if ( nStart == npos )
+ {
+ nStart = Len();
+ }
+ else
+ {
+ wxASSERT( nStart <= Len() );
+ }
+
+ for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
+ {
+ if ( !wxStrchr(sz, *p) )
+ return p - c_str();
+ }
+
+ return npos;
+}
+
+size_t wxString::find_last_not_of(wxChar ch, size_t nStart) const
{
- // npos means 'take all'
- if ( nLen == npos )
- nLen = 0;
+ if ( nStart == npos )
+ {
+ nStart = Len();
+ }
+ else
+ {
+ wxASSERT( nStart <= Len() );
+ }
- wxASSERT( nStart + nLen <= Len() );
+ for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
+ {
+ if ( *p != ch )
+ return p - c_str();
+ }
- return wxString(c_str() + nStart, nLen == npos ? 0 : nLen);
+ return npos;
}
wxString& wxString::erase(size_t nStart, size_t nLen)
wxString& wxString::replace(size_t nStart, size_t nLen, const wxChar *sz)
{
- wxASSERT( nStart + nLen <= wxStrlen(sz) );
+ wxASSERT_MSG( nStart + nLen <= Len(),
+ _T("index out of bounds in wxString::replace") );
wxString strTmp;
+ strTmp.Alloc(Len()); // micro optimisation to avoid multiple mem allocs
+
if ( nStart != 0 )
strTmp.append(c_str(), nStart);
- strTmp += sz;
- strTmp.append(c_str() + nStart + nLen);
+ strTmp << sz << c_str() + nStart + nLen;
*this = strTmp;
return *this;
#define STRING(p) ((wxString *)(&(p)))
// ctor
-wxArrayString::wxArrayString()
+wxArrayString::wxArrayString(bool autoSort)
{
m_nSize =
m_nCount = 0;
m_pItems = (wxChar **) NULL;
+ m_autoSort = autoSort;
}
// copy ctor
m_nSize =
m_nCount = 0;
m_pItems = (wxChar **) NULL;
+ m_autoSort = src.m_autoSort;
*this = src;
}
if ( m_nSize > 0 )
Clear();
+ Copy(src);
+
+ m_autoSort = src.m_autoSort;
+
+ return *this;
+}
+
+void wxArrayString::Copy(const wxArrayString& src)
+{
if ( src.m_nCount > ARRAY_DEFAULT_INITIAL_SIZE )
Alloc(src.m_nCount);
- // we can't just copy the pointers here because otherwise we would share
- // the strings with another array
for ( size_t n = 0; n < src.m_nCount; n++ )
Add(src[n]);
-
- if ( m_nCount != 0 )
- memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(wxChar *));
-
- return *this;
}
// grow the array
void wxArrayString::Grow()
{
// only do it if no more place
- if( m_nCount == m_nSize ) {
- if( m_nSize == 0 ) {
+ if ( m_nCount == m_nSize ) {
+ // if ARRAY_DEFAULT_INITIAL_SIZE were set to 0, the initially empty would
+ // be never resized!
+ #if ARRAY_DEFAULT_INITIAL_SIZE == 0
+ #error "ARRAY_DEFAULT_INITIAL_SIZE must be > 0!"
+ #endif
+
+ if ( m_nSize == 0 ) {
// was empty, alloc some memory
m_nSize = ARRAY_DEFAULT_INITIAL_SIZE;
m_pItems = new wxChar *[m_nSize];
else {
// otherwise when it's called for the first time, nIncrement would be 0
// and the array would never be expanded
- wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
-
// add 50% but not too much
size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
? ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;
// only do it if we have some memory to free
if( m_nCount < m_nSize ) {
// allocates exactly as much memory as we need
- wxChar **pNew = new wxChar *[m_nCount];
+ wxChar **pNew = new wxChar *[m_nCount];
// copy data to new location
memcpy(pNew, m_pItems, m_nCount*sizeof(wxChar *));
// searches the array for an item (forward or backwards)
int wxArrayString::Index(const wxChar *sz, bool bCase, bool bFromEnd) const
{
- if ( bFromEnd ) {
- if ( m_nCount > 0 ) {
- size_t ui = m_nCount;
- do {
- if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) )
- return ui;
- }
- while ( ui != 0 );
+ if ( m_autoSort ) {
+ // use binary search in the sorted array
+ wxASSERT_MSG( bCase && !bFromEnd,
+ wxT("search parameters ignored for auto sorted array") );
+
+ size_t i,
+ lo = 0,
+ hi = m_nCount;
+ int res;
+ while ( lo < hi ) {
+ i = (lo + hi)/2;
+
+ res = wxStrcmp(sz, m_pItems[i]);
+ if ( res < 0 )
+ hi = i;
+ else if ( res > 0 )
+ lo = i + 1;
+ else
+ return i;
}
+
+ return wxNOT_FOUND;
}
else {
- for( size_t ui = 0; ui < m_nCount; ui++ ) {
- if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) )
- return ui;
+ // use linear search in unsorted array
+ if ( bFromEnd ) {
+ if ( m_nCount > 0 ) {
+ size_t ui = m_nCount;
+ do {
+ if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) )
+ return ui;
+ }
+ while ( ui != 0 );
+ }
+ }
+ else {
+ for( size_t ui = 0; ui < m_nCount; ui++ ) {
+ if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) )
+ return ui;
+ }
}
}
}
// add item at the end
-void wxArrayString::Add(const wxString& str)
-{
- wxASSERT( str.GetStringData()->IsValid() );
+size_t wxArrayString::Add(const wxString& str)
+{
+ if ( m_autoSort ) {
+ // insert the string at the correct position to keep the array sorted
+ size_t i,
+ lo = 0,
+ hi = m_nCount;
+ int res;
+ while ( lo < hi ) {
+ i = (lo + hi)/2;
+
+ res = wxStrcmp(str, m_pItems[i]);
+ if ( res < 0 )
+ hi = i;
+ else if ( res > 0 )
+ lo = i + 1;
+ else {
+ lo = hi = i;
+ break;
+ }
+ }
- Grow();
+ wxASSERT_MSG( lo == hi, wxT("binary search broken") );
- // the string data must not be deleted!
- str.GetStringData()->Lock();
- m_pItems[m_nCount++] = (wxChar *)str.c_str();
+ Insert(str, lo);
+
+ return (size_t)lo;
+ }
+ else {
+ wxASSERT( str.GetStringData()->IsValid() );
+
+ Grow();
+
+ // the string data must not be deleted!
+ str.GetStringData()->Lock();
+
+ // just append
+ m_pItems[m_nCount] = (wxChar *)str.c_str(); // const_cast
+
+ return m_nCount++;
+ }
}
// add item at the given position
{
wxASSERT( str.GetStringData()->IsValid() );
- wxCHECK_RET( nIndex <= m_nCount, _("bad index in wxArrayString::Insert") );
+ wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArrayString::Insert") );
Grow();
m_nCount++;
}
+// expand the array
+void wxArrayString::SetCount(size_t count)
+{
+ Alloc(count);
+
+ wxString s;
+ while ( m_nCount < count )
+ m_pItems[m_nCount++] = (wxChar *)s.c_str();
+}
+
// removes item from array (by index)
void wxArrayString::Remove(size_t nIndex)
{
- wxCHECK_RET( nIndex <= m_nCount, _("bad index in wxArrayString::Remove") );
+ wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArrayString::Remove") );
// release our lock
Item(nIndex).GetStringData()->Unlock();
int iIndex = Index(sz);
wxCHECK_RET( iIndex != wxNOT_FOUND,
- _("removing inexistent element in wxArrayString::Remove") );
+ wxT("removing inexistent element in wxArrayString::Remove") );
Remove(iIndex);
}
static bool gs_sortAscending = TRUE;
// function which is called by quick sort
-static int wxStringCompareFunction(const void *first, const void *second)
+static int LINKAGEMODE wxStringCompareFunction(const void *first, const void *second)
{
wxString *strFirst = (wxString *)first;
wxString *strSecond = (wxString *)second;
DoSort();
+ // reset it to NULL so that Sort(bool) will work the next time
+ gs_compareFunction = NULL;
+
END_SORT();
}
void wxArrayString::DoSort()
{
+ wxCHECK_RET( !m_autoSort, wxT("can't use this method with sorted arrays") );
+
// just sort the pointers using qsort() - of course it only works because
// wxString() *is* a pointer to its data
qsort(m_pItems, m_nCount, sizeof(wxChar *), wxStringCompareFunction);
}
-// ============================================================================
-// MBConv
-// ============================================================================
-
-WXDLLEXPORT_DATA(wxMBConv *) wxConv_current = &wxConv_libc;
-
-// ----------------------------------------------------------------------------
-// standard libc conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv) wxConv_libc;
-
-size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+bool wxArrayString::operator==(const wxArrayString& a) const
{
- return wxWC2MB(buf, psz, n);
-}
+ if ( m_nCount != a.m_nCount )
+ return FALSE;
-// ----------------------------------------------------------------------------
-// standard file conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_file) wxConv_file;
-
-// just use the libc conversion for now
-size_t wxMBConv_file::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv_file::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// standard gdk conversion
-// ----------------------------------------------------------------------------
-
-#if defined(__WXGTK__) && (GTK_MINOR_VERSION > 0)
-WXDLLEXPORT_DATA(wxMBConv_gdk) wxConv_gdk;
-
-#include <gdk/gdk.h>
-
-size_t wxMBConv_gdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- if (buf) {
- return gdk_mbstowcs((GdkWChar *)buf, psz, n);
- } else {
- GdkWChar *nbuf = new GdkWChar[n=strlen(psz)];
- size_t len = gdk_mbstowcs(nbuf, psz, n);
- delete [] nbuf;
- return len;
- }
-}
-
-size_t wxMBConv_gdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- char *mbstr = gdk_wcstombs((GdkWChar *)psz);
- size_t len = mbstr ? strlen(mbstr) : 0;
- if (buf) {
- if (len > n) len = n;
- memcpy(buf, psz, len);
- if (len < n) buf[len] = 0;
- }
- return len;
-}
-#endif // GTK > 1.0
-
-// ----------------------------------------------------------------------------
-// UTF-7
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_UTF7) wxConv_UTF7;
-
-// TODO: write actual implementations of UTF-7 here
-size_t wxMBConv_UTF7::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- return 0;
-}
-
-size_t wxMBConv_UTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- return 0;
-}
-
-// ----------------------------------------------------------------------------
-// UTF-8
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_UTF8) wxConv_UTF8;
-
-// TODO: write actual implementations of UTF-8 here
-size_t wxMBConv_UTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv_UTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// specified character set
-// ----------------------------------------------------------------------------
-
-class wxCharacterSet
-{
-public:
- wxArrayString names;
- wchar_t *data;
-};
-
-#ifndef WX_PRECOMP
- #include "wx/dynarray.h"
- #include "wx/filefn.h"
- #include "wx/textfile.h"
- #include "wx/tokenzr.h"
- #include "wx/utils.h"
-#endif
-
-WX_DECLARE_OBJARRAY(wxCharacterSet, wxCSArray);
-#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(wxCSArray);
-
-static wxCSArray wxCharsets;
-
-static void wxLoadCharacterSets(void)
-{
- static bool already_loaded = FALSE;
-
- if (already_loaded) return;
-
-#if defined(__UNIX__)
- // search through files in /usr/share/i18n/charmaps
- wxString fname;
- for (fname = ::wxFindFirstFile(_T("/usr/share/i18n/charmaps/*"));
- !fname.IsEmpty();
- fname = ::wxFindNextFile()) {
- wxTextFile cmap(fname);
- if (cmap.Open()) {
- wxCharacterSet *cset = new wxCharacterSet;
- wxString comchar,escchar;
- bool in_charset = FALSE;
-
- // wxFprintf(stderr,_T("Loaded: %s\n"),fname.c_str());
-
- wxString line;
- for (line = cmap.GetFirstLine();
- !cmap.Eof();
- line = cmap.GetNextLine()) {
- // wxFprintf(stderr,_T("line contents: %s\n"),line.c_str());
- wxStringTokenizer token(line);
- wxString cmd = token.GetNextToken();
- if (cmd == comchar) {
- if (token.GetNextToken() == _T("alias")) {
- wxStringTokenizer names(token.GetNextToken(),_T("/"));
- wxString name;
- while (!(name = names.GetNextToken()).IsEmpty())
- cset->names.Add(name);
- }
- }
- else if (cmd == _T("<code_set_name>"))
- cset->names.Add(token.GetNextToken());
- else if (cmd == _T("<comment_char>"))
- comchar = token.GetNextToken();
- else if (cmd == _T("<escape_char>"))
- escchar = token.GetNextToken();
- else if (cmd == _T("<mb_cur_min>")) {
- delete cset;
- cset = (wxCharacterSet *) NULL;
- break; // we don't support multibyte charsets ourselves (yet)
- }
- else if (cmd == _T("CHARMAP")) {
- cset->data = (wchar_t *)calloc(256, sizeof(wchar_t));
- in_charset = TRUE;
- }
- else if (cmd == _T("END")) {
- if (token.GetNextToken() == _T("CHARMAP"))
- in_charset = FALSE;
- }
- else if (in_charset) {
- // format: <NUL> /x00 <U0000> NULL (NUL)
- // <A> /x41 <U0041> LATIN CAPITAL LETTER A
- wxString hex = token.GetNextToken();
- // skip whitespace (why doesn't wxStringTokenizer do this?)
- while (wxIsEmpty(hex) && token.HasMoreTokens()) hex = token.GetNextToken();
- wxString uni = token.GetNextToken();
- // skip whitespace again
- while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
-
- if ((hex.GetChar(0) == escchar) && (hex.GetChar(1) == _T('x')) &&
- (uni.Left(2) == _T("<U"))) {
- hex.MakeUpper(); uni.MakeUpper();
- int pos = ::wxHexToDec(hex.Mid(2,2));
- if (pos>=0) {
- unsigned long uni1 = ::wxHexToDec(uni.Mid(2,2));
- unsigned long uni2 = ::wxHexToDec(uni.Mid(4,2));
- cset->data[pos] = (uni1 << 16) | uni2;
- // wxFprintf(stderr,_T("char %02x mapped to %04x (%c)\n"),pos,cset->data[pos],cset->data[pos]);
- }
- }
- }
- }
- if (cset) {
- cset->names.Shrink();
- wxCharsets.Add(cset);
- }
- }
- }
-#endif
- wxCharsets.Shrink();
- already_loaded = TRUE;
-}
-
-static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)
-{
- if (!charset) return (wxCharacterSet *)NULL;
- wxLoadCharacterSets();
- for (size_t n=0; n<wxCharsets.GetCount(); n++)
- if (wxCharsets[n].names.Index(charset) != wxNOT_FOUND)
- return &(wxCharsets[n]);
- return (wxCharacterSet *)NULL;
-}
-
-WXDLLEXPORT_DATA(wxCSConv) wxConv_local((const wxChar *)NULL);
-
-wxCSConv::wxCSConv(const wxChar *charset)
-{
- m_name = (wxChar *) NULL;
- m_cset = (wxCharacterSet *) NULL;
- m_deferred = TRUE;
- SetName(charset);
-}
-
-wxCSConv::~wxCSConv()
-{
- if (m_name) free(m_name);
-}
-
-void wxCSConv::SetName(const wxChar *charset)
-{
- if (charset) {
-#ifdef __UNIX__
- // first, convert the character set name to standard form
- wxString codeset;
- if (wxString(charset,3).CmpNoCase(_T("ISO")) == 0) {
- // make sure it's represented in the standard form: ISO_8859-1
- codeset = _T("ISO_");
- charset += 3;
- if ((*charset == _T('-')) || (*charset == _T('_'))) charset++;
- if (wxStrlen(charset)>4) {
- if (wxString(charset,4) == _T("8859")) {
- codeset << _T("8859-");
- if (*charset == _T('-')) charset++;
- }
- }
- }
- codeset << charset;
- codeset.MakeUpper();
- m_name = wxStrdup(codeset.c_str());
- m_deferred = TRUE;
-#endif
- }
-}
-
-void wxCSConv::LoadNow()
-{
-// wxPrintf(_T("Conversion request\n"));
- if (m_deferred) {
- if (!m_name) {
-#ifdef __UNIX__
- wxChar *lang = wxGetenv(_T("LANG"));
- wxChar *dot = lang ? wxStrchr(lang, _T('.')) : (wxChar *)NULL;
- if (dot) SetName(dot+1);
-#endif
- }
- m_cset = wxFindCharacterSet(m_name);
- m_deferred = FALSE;
- }
-}
-
-size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- ((wxCSConv *)this)->LoadNow(); // discard constness
- if (buf) {
- if (m_cset) {
- for (size_t c=0; c<=n; c++)
- buf[c] = m_cset->data[psz[c]];
- } else {
- // latin-1 (direct)
- for (size_t c=0; c<=n; c++)
- buf[c] = psz[c];
+ for ( size_t n = 0; n < m_nCount; n++ )
+ {
+ if ( Item(n) != a[n] )
+ return FALSE;
}
- }
- return n;
-}
-size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- ((wxCSConv *)this)->LoadNow(); // discard constness
- if (buf) {
- if (m_cset) {
- for (size_t c=0; c<=n; c++) {
- size_t n;
- for (n=0; (n<256) && (m_cset->data[n] != psz[c]); n++);
- buf[c] = (n>0xff) ? '?' : n;
- }
- } else {
- // latin-1 (direct)
- for (size_t c=0; c<=n; c++)
- buf[c] = (psz[c]>0xff) ? '?' : psz[c];
- }
- }
- return n;
+ return TRUE;
}
projects / wxWidgets.git / blobdiff