#include "wx/string.h"
#include "wx/intl.h"
#if wxUSE_THREADS
- #include <wx/thread.h>
+ #include "wx/thread.h"
#endif
#endif
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!
{
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.
#elif defined(__GNUG__) && !defined(__UNIX__)
#warning "Using sprintf() because no snprintf()-like function defined"
#elif defined(__MWERKS__)
- #warning "Using sprintf() because no snprintf()-like function defined"
+ #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.
return is;
}
+ostream& operator<<(ostream& os, const wxString& str)
+{
+ os << str.c_str();
+ return os;
+}
+
#endif //std::string compatibility
// ----------------------------------------------------------------------------
}
}
-#else
+#else // ANSI
#if wxUSE_WCHAR_T
// from wide string
Init();
}
}
-#endif
+#endif // wxUSE_WCHAR_T
-#endif
+#endif // Unicode/ANSI
// ---------------------------------------------------------------------------
// memory allocation
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
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
AllocBeforeWrite(nSrcLen);
memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
GetStringData()->nDataLength = nSrcLen;
- m_pchData[nSrcLen] = _T('\0');
+ m_pchData[nSrcLen] = wxT('\0');
}
}
// 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
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
wxString& wxString::Trim(bool bFromRight)
{
// first check if we're going to modify the string at all
- if ( !IsEmpty() &&
- (
+ if ( !IsEmpty() &&
+ (
(bFromRight && wxIsspace(GetChar(Len() - 1))) ||
(!bFromRight && wxIsspace(GetChar(0u)))
)
psz--;
// truncate at trailing space start
- *++psz = _T('\0');
+ *++psz = wxT('\0');
GetStringData()->nDataLength = psz - m_pchData;
}
else
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
wxString& wxString::operator<<(int i)
{
wxString res;
- res.Printf(_T("%d"), i);
+ res.Printf(wxT("%d"), i);
return (*this) << res;
}
wxString& wxString::operator<<(float f)
{
wxString res;
- res.Printf(_T("%f"), f);
+ res.Printf(wxT("%f"), f);
return (*this) << res;
}
wxString& wxString::operator<<(double d)
{
wxString res;
- res.Printf(_T("%g"), d);
+ res.Printf(wxT("%g"), d);
return (*this) << res;
}
int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
{
// static buffer to avoid dynamic memory allocation each time
- static char s_szScratch[1024];
+ char s_szScratch[1024]; // using static buffer causes internal compiler err
+#if 0
#if wxUSE_THREADS
// protect the static buffer
static wxCriticalSection critsect;
wxCriticalSectionLocker lock(critsect);
#endif
+#endif
-#if 1 // the new implementation
+#if wxUSE_EXPERIMENTAL_PRINTF
+// the new implementation
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(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) {
#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(s_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(s_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(s_szScratch, s_szFlags, val);
+ }
+ *this += wxString(s_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(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 wxT('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 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, wxConvLibc, 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];
// ----------------------------------------------------------------------------
// 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++ ) {
+ for ( pszTxt = c_str(); *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
switch ( *pszMask ) {
- case _T('?'):
- if ( *pszTxt == _T('\0') )
+ case wxT('?'):
+ if ( *pszTxt == wxT('\0') )
return FALSE;
- pszTxt++;
- pszMask++;
+ // pszText and pszMask will be incremented in the loop statement
+
break;
- case _T('*'):
+ case wxT('*'):
{
// ignore special chars immediately following this one
- while ( *pszMask == _T('*') || *pszMask == _T('?') )
+ 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');
+ return *pszTxt == wxT('\0');
}
// Count the number of chars
#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);
+
+ 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]);
-
+ // the strings with another array because strings are ref counted
+#if 0
if ( m_nCount != 0 )
memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(wxChar *));
+#endif // 0
- return *this;
+ for ( size_t n = 0; n < src.m_nCount; n++ )
+ Add(src[n]);
+
+ // if the other array is auto sorted too, we're already sorted, but
+ // otherwise we should rearrange the items
+ if ( m_autoSort && !src.m_autoSort )
+ Sort();
}
// grow the array
else {
// otherwise when it's called for the first time, nIncrement would be 0
// and the array would never be expanded
+#if defined(__VISAGECPP__) && defined(__WXDEBUG__)
+ int array_size = ARRAY_DEFAULT_INITIAL_SIZE;
+ wxASSERT( array_size != 0 );
+#else
wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
+#endif
// add 50% but not too much
size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
// 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();
// 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;
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 *) wxConvCurrent = &wxConvLibc;
-#if !wxUSE_WCHAR_T
-WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;
-#endif
-
-#if wxUSE_WCHAR_T
-
-// ----------------------------------------------------------------------------
-// standard libc conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv) wxConvLibc;
-
-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
-{
- return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// standard file conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConvFile) wxConvFile;
-
-// just use the libc conversion for now
-size_t wxMBConvFile::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConvFile::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// standard gdk conversion
-// ----------------------------------------------------------------------------
-
-#ifdef __WXGTK12__
-WXDLLEXPORT_DATA(wxMBConvGdk) wxConvGdk;
-
-#include <gdk/gdk.h>
-
-size_t wxMBConvGdk::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 wxMBConvGdk::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(wxMBConvUTF7) wxConvUTF7;
-
-#if 0
-static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz"
- "0123456789'(),-./:?";
-static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}";
-static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz"
- "0123456789+/";
-#endif
-
-// TODO: write actual implementations of UTF-7 here
-size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
- const char * WXUNUSED(psz),
- size_t WXUNUSED(n)) const
-{
- return 0;
-}
-
-size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
- const wchar_t * WXUNUSED(psz),
- size_t WXUNUSED(n)) const
-{
- return 0;
-}
-
-// ----------------------------------------------------------------------------
-// UTF-8
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConvUTF8) wxConvUTF8;
-
-static unsigned long utf8_max[]={0x7f,0x7ff,0xffff,0x1fffff,0x3ffffff,0x7fffffff,0xffffffff};
-
-size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
- size_t len = 0;
-
- while (*psz && ((!buf) || (len<n))) {
- unsigned char cc=*psz++, fc=cc;
- unsigned cnt;
- for (cnt=0; fc&0x80; cnt++) fc<<=1;
- if (!cnt) {
- // plain ASCII char
- if (buf) *buf++=cc;
- len++;
- } else {
- cnt--;
- if (!cnt) {
- // invalid UTF-8 sequence
- return (size_t)-1;
- } else {
- unsigned ocnt=cnt-1;
- unsigned long res=cc&(0x3f>>cnt);
- while (cnt--) {
- cc = *psz++;
- if ((cc&0xC0)!=0x80) {
- // invalid UTF-8 sequence
- return (size_t)-1;
- }
- res=(res<<6)|(cc&0x3f);
- }
- if (res<=utf8_max[ocnt]) {
- // illegal UTF-8 encoding
- return (size_t)-1;
- }
- if (buf) *buf++=res;
- len++;
- }
- }
- }
- if (buf && (len<n)) *buf = 0;
- return len;
-}
-
-size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
- size_t len = 0;
-
- while (*psz && ((!buf) || (len<n))) {
- unsigned long cc=(*psz++)&0x7fffffff;
- unsigned cnt;
- for (cnt=0; cc>utf8_max[cnt]; cnt++);
- if (!cnt) {
- // plain ASCII char
- if (buf) *buf++=cc;
- len++;
- } else {
- len+=cnt+1;
- if (buf) {
- *buf++=(-128>>cnt)|((cc>>(cnt*6))&(0x3f>>cnt));
- while (cnt--)
- *buf++=0x80|((cc>>(cnt*6))&0x3f);
- }
- }
- }
- if (buf && (len<n)) *buf = 0;
- return len;
-}
-
-// ----------------------------------------------------------------------------
-// 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;
-
- already_loaded = TRUE;
-#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"))
- cset->names.Add(token.GetNextToken());
- }
- 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.Len() > 2) && (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();
-}
-
-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) wxConvLocal((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[(unsigned char)(psz[c])];
- } else {
- // latin-1 (direct)
- for (size_t c=0; c<n; c++)
- buf[c] = (unsigned char)(psz[c]);
- }
- return n;
- }
- return strlen(psz);
-}
-
-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 wcslen(psz);
-}
-
-#endif//wxUSE_WCHAR_T
-
-#if wxUSE_WCHAR_T
-const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
- {
- if (psz) {
- size_t nLen = MB2WC((wchar_t *) NULL, psz, 0);
- wxWCharBuffer buf(nLen);
- MB2WC(WCSTRINGCAST buf, psz, nLen);
- return buf;
- } else return wxWCharBuffer((wchar_t *) NULL);
- }
-
-const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *psz) const
- {
- if (psz) {
- size_t nLen = WC2MB((char *) NULL, psz, 0);
- wxCharBuffer buf(nLen);
- WC2MB(MBSTRINGCAST buf, psz, nLen);
- return buf;
- } else return wxCharBuffer((char *) NULL);
- }
-
-#endif//wxUSE_WCHAR_T
-
projects / wxWidgets.git / blobdiff