src/common/string.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/string.cpp
   3 // Purpose:     wxString class
   4 // Author:      Vadim Zeitlin, Ryan Norton
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 //              (c) 2004 Ryan Norton <wxprojects@comcast.net>
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ===========================================================================
  14 // headers, declarations, constants
  15 // ===========================================================================
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21     #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/string.h"
  26     #include "wx/wxcrtvararg.h"
  27 #endif
  28
  29 #include <ctype.h>
  30
  31 #ifndef __WXWINCE__
  32     #include <errno.h>
  33 #endif
  34
  35 #include <string.h>
  36 #include <stdlib.h>
  37
  38 #include "wx/hashmap.h"
  39 #include "wx/vector.h"
  40 #include "wx/xlocale.h"
  41
  42 // string handling functions used by wxString:
  43 #if wxUSE_UNICODE_UTF8
  44     #define wxStringMemcpy   memcpy
  45     #define wxStringMemcmp   memcmp
  46     #define wxStringMemchr   memchr
  47     #define wxStringStrlen   strlen
  48 #else
  49     #define wxStringMemcpy   wxTmemcpy
  50     #define wxStringMemcmp   wxTmemcmp
  51     #define wxStringMemchr   wxTmemchr
  52     #define wxStringStrlen   wxStrlen
  53 #endif
  54
  55 // ----------------------------------------------------------------------------
  56 // global variables
  57 // ----------------------------------------------------------------------------
  58
  59 namespace wxPrivate
  60 {
  61
  62 static UntypedBufferData s_untypedNullData(NULL);
  63
  64 UntypedBufferData * const untypedNullDataPtr = &s_untypedNullData;
  65
  66 } // namespace wxPrivate
  67
  68 // ---------------------------------------------------------------------------
  69 // static class variables definition
  70 // ---------------------------------------------------------------------------
  71
  72 //According to STL _must_ be a -1 size_t
  73 const size_t wxString::npos = (size_t) -1;
  74
  75 #if wxUSE_STRING_POS_CACHE
  76
  77 #ifdef wxHAS_COMPILER_TLS
  78
  79 wxTLS_TYPE(wxString::Cache) wxString::ms_cache;
  80
  81 #else // !wxHAS_COMPILER_TLS
  82
  83 struct wxStrCacheInitializer
  84 {
  85     wxStrCacheInitializer()
  86     {
  87         // calling this function triggers s_cache initialization in it, and
  88         // from now on it becomes safe to call from multiple threads
  89         wxString::GetCache();
  90     }
  91 };
  92
  93 /*
  94 wxString::Cache& wxString::GetCache()
  95 {
  96     static wxTLS_TYPE(Cache) s_cache;
  97
  98     return wxTLS_VALUE(s_cache);
  99 }
 100 */
 101
 102 static wxStrCacheInitializer gs_stringCacheInit;
 103
 104 #endif // wxHAS_COMPILER_TLS/!wxHAS_COMPILER_TLS
 105
 106 // gdb seems to be unable to display thread-local variables correctly, at least
 107 // not my 6.4.98 version under amd64, so provide this debugging helper to do it
 108 #if wxDEBUG_LEVEL >= 2
 109
 110 struct wxStrCacheDumper
 111 {
 112     static void ShowAll()
 113     {
 114         puts("*** wxString cache dump:");
 115         for ( unsigned n = 0; n < wxString::Cache::SIZE; n++ )
 116         {
 117             const wxString::Cache::Element&
 118                 c = wxString::GetCacheBegin()[n];
 119
 120             printf("\t%u%s\t%p: pos=(%lu, %lu), len=%ld\n",
 121                    n,
 122                    n == wxString::LastUsedCacheElement() ? " [*]" : "",
 123                    c.str,
 124                    (unsigned long)c.pos,
 125                    (unsigned long)c.impl,
 126                    (long)c.len);
 127         }
 128     }
 129 };
 130
 131 void wxDumpStrCache() { wxStrCacheDumper::ShowAll(); }
 132
 133 #endif // wxDEBUG_LEVEL >= 2
 134
 135 #ifdef wxPROFILE_STRING_CACHE
 136
 137 wxString::CacheStats wxString::ms_cacheStats;
 138
 139 struct wxStrCacheStatsDumper
 140 {
 141     ~wxStrCacheStatsDumper()
 142     {
 143         const wxString::CacheStats& stats = wxString::ms_cacheStats;
 144
 145         if ( stats.postot )
 146         {
 147             puts("*** wxString cache statistics:");
 148             printf("\tTotal non-trivial calls to PosToImpl(): %u\n",
 149                    stats.postot);
 150             printf("\tHits %u (of which %u not used) or %.2f%%\n",
 151                    stats.poshits,
 152                    stats.mishits,
 153                    100.*float(stats.poshits - stats.mishits)/stats.postot);
 154             printf("\tAverage position requested: %.2f\n",
 155                    float(stats.sumpos) / stats.postot);
 156             printf("\tAverage offset after cached hint: %.2f\n",
 157                    float(stats.sumofs) / stats.postot);
 158         }
 159
 160         if ( stats.lentot )
 161         {
 162             printf("\tNumber of calls to length(): %u, hits=%.2f%%\n",
 163                    stats.lentot, 100.*float(stats.lenhits)/stats.lentot);
 164         }
 165     }
 166 };
 167
 168 static wxStrCacheStatsDumper s_showCacheStats;
 169
 170 #endif // wxPROFILE_STRING_CACHE
 171
 172 #endif // wxUSE_STRING_POS_CACHE
 173
 174 // ----------------------------------------------------------------------------
 175 // global functions
 176 // ----------------------------------------------------------------------------
 177
 178 #if wxUSE_STD_IOSTREAM
 179
 180 #include <iostream>
 181
 182 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
 183 {
 184 #if wxUSE_UNICODE && !wxUSE_UNICODE_UTF8
 185     const wxCharBuffer buf(str.AsCharBuf());
 186     if ( !buf )
 187         os.clear(wxSTD ios_base::failbit);
 188     else
 189         os << buf.data();
 190
 191     return os;
 192 #else
 193     return os << str.AsInternal();
 194 #endif
 195 }
 196
 197 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
 198 {
 199     return os << str.c_str();
 200 }
 201
 202 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCharBuffer& str)
 203 {
 204     return os << str.data();
 205 }
 206
 207 #ifndef __BORLANDC__
 208 wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
 209 {
 210     return os << str.data();
 211 }
 212 #endif
 213
 214 #if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 215
 216 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxString& str)
 217 {
 218     return wos << str.wc_str();
 219 }
 220
 221 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxCStrData& str)
 222 {
 223     return wos << str.AsWChar();
 224 }
 225
 226 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxWCharBuffer& str)
 227 {
 228     return wos << str.data();
 229 }
 230
 231 #endif  // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
 232
 233 #endif // wxUSE_STD_IOSTREAM
 234
 235 // ===========================================================================
 236 // wxString class core
 237 // ===========================================================================
 238
 239 #if wxUSE_UNICODE_UTF8
 240
 241 void wxString::PosLenToImpl(size_t pos, size_t len,
 242                             size_t *implPos, size_t *implLen) const
 243 {
 244     if ( pos == npos )
 245     {
 246         *implPos = npos;
 247     }
 248     else // have valid start position
 249     {
 250         const const_iterator b = GetIterForNthChar(pos);
 251         *implPos = wxStringImpl::const_iterator(b.impl()) - m_impl.begin();
 252         if ( len == npos )
 253         {
 254             *implLen = npos;
 255         }
 256         else // have valid length too
 257         {
 258             // we need to handle the case of length specifying a substring
 259             // going beyond the end of the string, just as std::string does
 260             const const_iterator e(end());
 261             const_iterator i(b);
 262             while ( len && i <= e )
 263             {
 264                 ++i;
 265                 --len;
 266             }
 267
 268             *implLen = i.impl() - b.impl();
 269         }
 270     }
 271 }
 272
 273 #endif // wxUSE_UNICODE_UTF8
 274
 275 // ----------------------------------------------------------------------------
 276 // wxCStrData converted strings caching
 277 // ----------------------------------------------------------------------------
 278
 279 // FIXME-UTF8: temporarily disabled because it doesn't work with global
 280 //             string objects; re-enable after fixing this bug and benchmarking
 281 //             performance to see if using a hash is a good idea at all
 282 #if 0
 283
 284 // For backward compatibility reasons, it must be possible to assign the value
 285 // returned by wxString::c_str() to a char* or wchar_t* variable and work with
 286 // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick,
 287 // because the memory would be freed immediately, but it has to be valid as long
 288 // as the string is not modified, so that code like this still works:
 289 //
 290 // const wxChar *s = str.c_str();
 291 // while ( s ) { ... }
 292
 293 // FIXME-UTF8: not thread safe!
 294 // FIXME-UTF8: we currently clear the cached conversion only when the string is
 295 //             destroyed, but we should do it when the string is modified, to
 296 //             keep memory usage down
 297 // FIXME-UTF8: we do the conversion every time As[W]Char() is called, but if we
 298 //             invalidated the cache on every change, we could keep the previous
 299 //             conversion
 300 // FIXME-UTF8: add tracing of usage of these two methods - new code is supposed
 301 //             to use mb_str() or wc_str() instead of (const [w]char*)c_str()
 302
 303 template<typename T>
 304 static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
 305 {
 306     typename T::iterator i = hash.find(wxConstCast(s, wxString));
 307     if ( i != hash.end() )
 308     {
 309         free(i->second);
 310         hash.erase(i);
 311     }
 312 }
 313
 314 #if wxUSE_UNICODE
 315 // NB: non-STL implementation doesn't compile with "const wxString*" key type,
 316 //     so we have to use wxString* here and const-cast when used
 317 WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual,
 318                     wxStringCharConversionCache);
 319 static wxStringCharConversionCache gs_stringsCharCache;
 320
 321 const char* wxCStrData::AsChar() const
 322 {
 323     // remove previously cache value, if any (see FIXMEs above):
 324     DeleteStringFromConversionCache(gs_stringsCharCache, m_str);
 325
 326     // convert the string and keep it:
 327     const char *s = gs_stringsCharCache[wxConstCast(m_str, wxString)] =
 328         m_str->mb_str().release();
 329
 330     return s + m_offset;
 331 }
 332 #endif // wxUSE_UNICODE
 333
 334 #if !wxUSE_UNICODE_WCHAR
 335 WX_DECLARE_HASH_MAP(wxString*, wchar_t*, wxPointerHash, wxPointerEqual,
 336                     wxStringWCharConversionCache);
 337 static wxStringWCharConversionCache gs_stringsWCharCache;
 338
 339 const wchar_t* wxCStrData::AsWChar() const
 340 {
 341     // remove previously cache value, if any (see FIXMEs above):
 342     DeleteStringFromConversionCache(gs_stringsWCharCache, m_str);
 343
 344     // convert the string and keep it:
 345     const wchar_t *s = gs_stringsWCharCache[wxConstCast(m_str, wxString)] =
 346         m_str->wc_str().release();
 347
 348     return s + m_offset;
 349 }
 350 #endif // !wxUSE_UNICODE_WCHAR
 351
 352 wxString::~wxString()
 353 {
 354 #if wxUSE_UNICODE
 355     // FIXME-UTF8: do this only if locale is not UTF8 if wxUSE_UNICODE_UTF8
 356     DeleteStringFromConversionCache(gs_stringsCharCache, this);
 357 #endif
 358 #if !wxUSE_UNICODE_WCHAR
 359     DeleteStringFromConversionCache(gs_stringsWCharCache, this);
 360 #endif
 361 }
 362 #endif
 363
 364 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 365 const char* wxCStrData::AsChar() const
 366 {
 367 #if wxUSE_UNICODE_UTF8
 368     if ( wxLocaleIsUtf8 )
 369         return AsInternal();
 370 #endif
 371     // under non-UTF8 locales, we have to convert the internal UTF-8
 372     // representation using wxConvLibc and cache the result
 373
 374     wxString *str = wxConstCast(m_str, wxString);
 375
 376     // convert the string:
 377     //
 378     // FIXME-UTF8: we'd like to do the conversion in the existing buffer (if we
 379     //             have it) but it's unfortunately not obvious to implement
 380     //             because we don't know how big buffer do we need for the
 381     //             given string length (in case of multibyte encodings, e.g.
 382     //             ISO-2022-JP or UTF-8 when internal representation is wchar_t)
 383     //
 384     //             One idea would be to store more than just m_convertedToChar
 385     //             in wxString: then we could record the length of the string
 386     //             which was converted the last time and try to reuse the same
 387     //             buffer if the current length is not greater than it (this
 388     //             could still fail because string could have been modified in
 389     //             place but it would work most of the time, so we'd do it and
 390     //             only allocate the new buffer if in-place conversion returned
 391     //             an error). We could also store a bit saying if the string
 392     //             was modified since the last conversion (and update it in all
 393     //             operation modifying the string, of course) to avoid unneeded
 394     //             consequential conversions. But both of these ideas require
 395     //             adding more fields to wxString and require profiling results
 396     //             to be sure that we really gain enough from them to justify
 397     //             doing it.
 398     wxCharBuffer buf(str->mb_str());
 399
 400     // if it failed, return empty string and not NULL to avoid crashes in code
 401     // written with either wxWidgets 2 wxString or std::string behaviour in
 402     // mind: neither of them ever returns NULL and so we shouldn't neither
 403     if ( !buf )
 404         return "";
 405
 406     if ( str->m_convertedToChar &&
 407          strlen(buf) == strlen(str->m_convertedToChar) )
 408     {
 409         // keep the same buffer for as long as possible, so that several calls
 410         // to c_str() in a row still work:
 411         strcpy(str->m_convertedToChar, buf);
 412     }
 413     else
 414     {
 415         str->m_convertedToChar = buf.release();
 416     }
 417
 418     // and keep it:
 419     return str->m_convertedToChar + m_offset;
 420 }
 421 #endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 422
 423 #if !wxUSE_UNICODE_WCHAR
 424 const wchar_t* wxCStrData::AsWChar() const
 425 {
 426     wxString *str = wxConstCast(m_str, wxString);
 427
 428     // convert the string:
 429     wxWCharBuffer buf(str->wc_str());
 430
 431     // notice that here, unlike above in AsChar(), conversion can't fail as our
 432     // internal UTF-8 is always well-formed -- or the string was corrupted and
 433     // all bets are off anyhow
 434
 435     // FIXME-UTF8: do the conversion in-place in the existing buffer
 436     if ( str->m_convertedToWChar &&
 437          wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
 438     {
 439         // keep the same buffer for as long as possible, so that several calls
 440         // to c_str() in a row still work:
 441         memcpy(str->m_convertedToWChar, buf, sizeof(wchar_t) * wxWcslen(buf));
 442     }
 443     else
 444     {
 445         str->m_convertedToWChar = buf.release();
 446     }
 447
 448     // and keep it:
 449     return str->m_convertedToWChar + m_offset;
 450 }
 451 #endif // !wxUSE_UNICODE_WCHAR
 452
 453 // ===========================================================================
 454 // wxString class core
 455 // ===========================================================================
 456
 457 // ---------------------------------------------------------------------------
 458 // construction and conversion
 459 // ---------------------------------------------------------------------------
 460
 461 #if wxUSE_UNICODE_WCHAR
 462 /* static */
 463 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 464                                                const wxMBConv& conv)
 465 {
 466     // anything to do?
 467     if ( !psz || nLength == 0 )
 468         return SubstrBufFromMB(L"", 0);
 469
 470     if ( nLength == npos )
 471         nLength = wxNO_LEN;
 472
 473     size_t wcLen;
 474     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
 475     if ( !wcLen )
 476         return SubstrBufFromMB(_T(""), 0);
 477     else
 478         return SubstrBufFromMB(wcBuf, wcLen);
 479 }
 480 #endif // wxUSE_UNICODE_WCHAR
 481
 482 #if wxUSE_UNICODE_UTF8
 483 /* static */
 484 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 485                                                const wxMBConv& conv)
 486 {
 487     // anything to do?
 488     if ( !psz || nLength == 0 )
 489         return SubstrBufFromMB("", 0);
 490
 491     // if psz is already in UTF-8, we don't have to do the roundtrip to
 492     // wchar_t* and back:
 493     if ( conv.IsUTF8() )
 494     {
 495         // we need to validate the input because UTF8 iterators assume valid
 496         // UTF-8 sequence and psz may be invalid:
 497         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
 498         {
 499             // we must pass the real string length to SubstrBufFromMB ctor
 500             if ( nLength == npos )
 501                 nLength = psz ? strlen(psz) : 0;
 502             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
 503         }
 504         // else: do the roundtrip through wchar_t*
 505     }
 506
 507     if ( nLength == npos )
 508         nLength = wxNO_LEN;
 509
 510     // first convert to wide string:
 511     size_t wcLen;
 512     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
 513     if ( !wcLen )
 514         return SubstrBufFromMB("", 0);
 515
 516     // and then to UTF-8:
 517     SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
 518     // widechar -> UTF-8 conversion isn't supposed to ever fail:
 519     wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
 520
 521     return buf;
 522 }
 523 #endif // wxUSE_UNICODE_UTF8
 524
 525 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
 526 /* static */
 527 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
 528                                                const wxMBConv& conv)
 529 {
 530     // anything to do?
 531     if ( !pwz || nLength == 0 )
 532         return SubstrBufFromWC("", 0);
 533
 534     if ( nLength == npos )
 535         nLength = wxNO_LEN;
 536
 537     size_t mbLen;
 538     wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
 539     if ( !mbLen )
 540         return SubstrBufFromWC("", 0);
 541     else
 542         return SubstrBufFromWC(mbBuf, mbLen);
 543 }
 544 #endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
 545
 546
 547 #if wxUSE_UNICODE_WCHAR
 548
 549 //Convert wxString in Unicode mode to a multi-byte string
 550 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 551 {
 552     return conv.cWC2MB(wx_str(), length() + 1 /* size, not length */, NULL);
 553 }
 554
 555 #elif wxUSE_UNICODE_UTF8
 556
 557 const wxWCharBuffer wxString::wc_str() const
 558 {
 559     return wxMBConvStrictUTF8().cMB2WC
 560                                 (
 561                                     m_impl.c_str(),
 562                                     m_impl.length() + 1, // size, not length
 563                                     NULL
 564                                 );
 565 }
 566
 567 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 568 {
 569     if ( conv.IsUTF8() )
 570         return wxCharBuffer::CreateNonOwned(m_impl.c_str());
 571
 572     // FIXME-UTF8: use wc_str() here once we have buffers with length
 573
 574     size_t wcLen;
 575     wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC
 576                                              (
 577                                                 m_impl.c_str(),
 578                                                 m_impl.length() + 1, // size
 579                                                 &wcLen
 580                                              ));
 581     if ( !wcLen )
 582         return wxCharBuffer("");
 583
 584     return conv.cWC2MB(wcBuf, wcLen+1, NULL);
 585 }
 586
 587 #else // ANSI
 588
 589 //Converts this string to a wide character string if unicode
 590 //mode is not enabled and wxUSE_WCHAR_T is enabled
 591 const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const
 592 {
 593     return conv.cMB2WC(wx_str(), length() + 1 /* size, not length */, NULL);
 594 }
 595
 596 #endif // Unicode/ANSI
 597
 598 // shrink to minimal size (releasing extra memory)
 599 bool wxString::Shrink()
 600 {
 601   wxString tmp(begin(), end());
 602   swap(tmp);
 603   return tmp.length() == length();
 604 }
 605
 606 // deprecated compatibility code:
 607 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 608 wxStringCharType *wxString::GetWriteBuf(size_t nLen)
 609 {
 610     return DoGetWriteBuf(nLen);
 611 }
 612
 613 void wxString::UngetWriteBuf()
 614 {
 615     DoUngetWriteBuf();
 616 }
 617
 618 void wxString::UngetWriteBuf(size_t nLen)
 619 {
 620     DoUngetWriteBuf(nLen);
 621 }
 622 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 623
 624
 625 // ---------------------------------------------------------------------------
 626 // data access
 627 // ---------------------------------------------------------------------------
 628
 629 // all functions are inline in string.h
 630
 631 // ---------------------------------------------------------------------------
 632 // concatenation operators
 633 // ---------------------------------------------------------------------------
 634
 635 /*
 636  * concatenation functions come in 5 flavours:
 637  *  string + string
 638  *  char   + string      and      string + char
 639  *  C str  + string      and      string + C str
 640  */
 641
 642 wxString operator+(const wxString& str1, const wxString& str2)
 643 {
 644 #if !wxUSE_STL_BASED_WXSTRING
 645     wxASSERT( str1.IsValid() );
 646     wxASSERT( str2.IsValid() );
 647 #endif
 648
 649     wxString s = str1;
 650     s += str2;
 651
 652     return s;
 653 }
 654
 655 wxString operator+(const wxString& str, wxUniChar ch)
 656 {
 657 #if !wxUSE_STL_BASED_WXSTRING
 658     wxASSERT( str.IsValid() );
 659 #endif
 660
 661     wxString s = str;
 662     s += ch;
 663
 664     return s;
 665 }
 666
 667 wxString operator+(wxUniChar ch, const wxString& str)
 668 {
 669 #if !wxUSE_STL_BASED_WXSTRING
 670     wxASSERT( str.IsValid() );
 671 #endif
 672
 673     wxString s = ch;
 674     s += str;
 675
 676     return s;
 677 }
 678
 679 wxString operator+(const wxString& str, const char *psz)
 680 {
 681 #if !wxUSE_STL_BASED_WXSTRING
 682     wxASSERT( str.IsValid() );
 683 #endif
 684
 685     wxString s;
 686     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 687         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 688     }
 689     s += str;
 690     s += psz;
 691
 692     return s;
 693 }
 694
 695 wxString operator+(const wxString& str, const wchar_t *pwz)
 696 {
 697 #if !wxUSE_STL_BASED_WXSTRING
 698     wxASSERT( str.IsValid() );
 699 #endif
 700
 701     wxString s;
 702     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 703         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 704     }
 705     s += str;
 706     s += pwz;
 707
 708     return s;
 709 }
 710
 711 wxString operator+(const char *psz, const wxString& str)
 712 {
 713 #if !wxUSE_STL_BASED_WXSTRING
 714     wxASSERT( str.IsValid() );
 715 #endif
 716
 717     wxString s;
 718     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 719         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 720     }
 721     s = psz;
 722     s += str;
 723
 724     return s;
 725 }
 726
 727 wxString operator+(const wchar_t *pwz, const wxString& str)
 728 {
 729 #if !wxUSE_STL_BASED_WXSTRING
 730     wxASSERT( str.IsValid() );
 731 #endif
 732
 733     wxString s;
 734     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 735         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 736     }
 737     s = pwz;
 738     s += str;
 739
 740     return s;
 741 }
 742
 743 // ---------------------------------------------------------------------------
 744 // string comparison
 745 // ---------------------------------------------------------------------------
 746
 747 bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const
 748 {
 749     return (length() == 1) && (compareWithCase ? GetChar(0u) == c
 750                                : wxToupper(GetChar(0u)) == wxToupper(c));
 751 }
 752
 753 #ifdef HAVE_STD_STRING_COMPARE
 754
 755 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
 756 //     UTF-8 encoded strings too, thanks to UTF-8's design which allows us to
 757 //     sort strings in characters code point order by sorting the byte sequence
 758 //     in byte values order (i.e. what strcmp() and memcmp() do).
 759
 760 int wxString::compare(const wxString& str) const
 761 {
 762     return m_impl.compare(str.m_impl);
 763 }
 764
 765 int wxString::compare(size_t nStart, size_t nLen,
 766                       const wxString& str) const
 767 {
 768     size_t pos, len;
 769     PosLenToImpl(nStart, nLen, &pos, &len);
 770     return m_impl.compare(pos, len, str.m_impl);
 771 }
 772
 773 int wxString::compare(size_t nStart, size_t nLen,
 774                       const wxString& str,
 775                       size_t nStart2, size_t nLen2) const
 776 {
 777     size_t pos, len;
 778     PosLenToImpl(nStart, nLen, &pos, &len);
 779
 780     size_t pos2, len2;
 781     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 782
 783     return m_impl.compare(pos, len, str.m_impl, pos2, len2);
 784 }
 785
 786 int wxString::compare(const char* sz) const
 787 {
 788     return m_impl.compare(ImplStr(sz));
 789 }
 790
 791 int wxString::compare(const wchar_t* sz) const
 792 {
 793     return m_impl.compare(ImplStr(sz));
 794 }
 795
 796 int wxString::compare(size_t nStart, size_t nLen,
 797                       const char* sz, size_t nCount) const
 798 {
 799     size_t pos, len;
 800     PosLenToImpl(nStart, nLen, &pos, &len);
 801
 802     SubstrBufFromMB str(ImplStr(sz, nCount));
 803
 804     return m_impl.compare(pos, len, str.data, str.len);
 805 }
 806
 807 int wxString::compare(size_t nStart, size_t nLen,
 808                       const wchar_t* sz, size_t nCount) const
 809 {
 810     size_t pos, len;
 811     PosLenToImpl(nStart, nLen, &pos, &len);
 812
 813     SubstrBufFromWC str(ImplStr(sz, nCount));
 814
 815     return m_impl.compare(pos, len, str.data, str.len);
 816 }
 817
 818 #else // !HAVE_STD_STRING_COMPARE
 819
 820 static inline int wxDoCmp(const wxStringCharType* s1, size_t l1,
 821                           const wxStringCharType* s2, size_t l2)
 822 {
 823     if( l1 == l2 )
 824         return wxStringMemcmp(s1, s2, l1);
 825     else if( l1 < l2 )
 826     {
 827         int ret = wxStringMemcmp(s1, s2, l1);
 828         return ret == 0 ? -1 : ret;
 829     }
 830     else
 831     {
 832         int ret = wxStringMemcmp(s1, s2, l2);
 833         return ret == 0 ? +1 : ret;
 834     }
 835 }
 836
 837 int wxString::compare(const wxString& str) const
 838 {
 839     return ::wxDoCmp(m_impl.data(), m_impl.length(),
 840                      str.m_impl.data(), str.m_impl.length());
 841 }
 842
 843 int wxString::compare(size_t nStart, size_t nLen,
 844                       const wxString& str) const
 845 {
 846     wxASSERT(nStart <= length());
 847     size_type strLen = length() - nStart;
 848     nLen = strLen < nLen ? strLen : nLen;
 849
 850     size_t pos, len;
 851     PosLenToImpl(nStart, nLen, &pos, &len);
 852
 853     return ::wxDoCmp(m_impl.data() + pos,  len,
 854                      str.m_impl.data(), str.m_impl.length());
 855 }
 856
 857 int wxString::compare(size_t nStart, size_t nLen,
 858                       const wxString& str,
 859                       size_t nStart2, size_t nLen2) const
 860 {
 861     wxASSERT(nStart <= length());
 862     wxASSERT(nStart2 <= str.length());
 863     size_type strLen  =     length() - nStart,
 864               strLen2 = str.length() - nStart2;
 865     nLen  = strLen  < nLen  ? strLen  : nLen;
 866     nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
 867
 868     size_t pos, len;
 869     PosLenToImpl(nStart, nLen, &pos, &len);
 870     size_t pos2, len2;
 871     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 872
 873     return ::wxDoCmp(m_impl.data() + pos, len,
 874                      str.m_impl.data() + pos2, len2);
 875 }
 876
 877 int wxString::compare(const char* sz) const
 878 {
 879     SubstrBufFromMB str(ImplStr(sz, npos));
 880     if ( str.len == npos )
 881         str.len = wxStringStrlen(str.data);
 882     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 883 }
 884
 885 int wxString::compare(const wchar_t* sz) const
 886 {
 887     SubstrBufFromWC str(ImplStr(sz, npos));
 888     if ( str.len == npos )
 889         str.len = wxStringStrlen(str.data);
 890     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 891 }
 892
 893 int wxString::compare(size_t nStart, size_t nLen,
 894                       const char* sz, size_t nCount) const
 895 {
 896     wxASSERT(nStart <= length());
 897     size_type strLen = length() - nStart;
 898     nLen = strLen < nLen ? strLen : nLen;
 899
 900     size_t pos, len;
 901     PosLenToImpl(nStart, nLen, &pos, &len);
 902
 903     SubstrBufFromMB str(ImplStr(sz, nCount));
 904     if ( str.len == npos )
 905         str.len = wxStringStrlen(str.data);
 906
 907     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 908 }
 909
 910 int wxString::compare(size_t nStart, size_t nLen,
 911                       const wchar_t* sz, size_t nCount) const
 912 {
 913     wxASSERT(nStart <= length());
 914     size_type strLen = length() - nStart;
 915     nLen = strLen < nLen ? strLen : nLen;
 916
 917     size_t pos, len;
 918     PosLenToImpl(nStart, nLen, &pos, &len);
 919
 920     SubstrBufFromWC str(ImplStr(sz, nCount));
 921     if ( str.len == npos )
 922         str.len = wxStringStrlen(str.data);
 923
 924     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 925 }
 926
 927 #endif // HAVE_STD_STRING_COMPARE/!HAVE_STD_STRING_COMPARE
 928
 929
 930 // ---------------------------------------------------------------------------
 931 // find_{first,last}_[not]_of functions
 932 // ---------------------------------------------------------------------------
 933
 934 #if !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
 935
 936 // NB: All these functions are implemented  with the argument being wxChar*,
 937 //     i.e. widechar string in any Unicode build, even though native string
 938 //     representation is char* in the UTF-8 build. This is because we couldn't
 939 //     use memchr() to determine if a character is in a set encoded as UTF-8.
 940
 941 size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
 942 {
 943     return find_first_of(sz, nStart, wxStrlen(sz));
 944 }
 945
 946 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
 947 {
 948     return find_first_not_of(sz, nStart, wxStrlen(sz));
 949 }
 950
 951 size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
 952 {
 953     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 954
 955     size_t idx = nStart;
 956     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 957     {
 958         if ( wxTmemchr(sz, *i, n) )
 959             return idx;
 960     }
 961
 962     return npos;
 963 }
 964
 965 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
 966 {
 967     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 968
 969     size_t idx = nStart;
 970     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 971     {
 972         if ( !wxTmemchr(sz, *i, n) )
 973             return idx;
 974     }
 975
 976     return npos;
 977 }
 978
 979
 980 size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
 981 {
 982     return find_last_of(sz, nStart, wxStrlen(sz));
 983 }
 984
 985 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
 986 {
 987     return find_last_not_of(sz, nStart, wxStrlen(sz));
 988 }
 989
 990 size_t wxString::find_last_of(const wxChar* sz, size_t nStart, size_t n) const
 991 {
 992     size_t len = length();
 993
 994     if ( nStart == npos )
 995     {
 996         nStart = len - 1;
 997     }
 998     else
 999     {
1000         wxASSERT_MSG( nStart <= len, _T("invalid index") );
1001     }
1002
1003     size_t idx = nStart;
1004     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1005           i != rend(); --idx, ++i )
1006     {
1007         if ( wxTmemchr(sz, *i, n) )
1008             return idx;
1009     }
1010
1011     return npos;
1012 }
1013
1014 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const
1015 {
1016     size_t len = length();
1017
1018     if ( nStart == npos )
1019     {
1020         nStart = len - 1;
1021     }
1022     else
1023     {
1024         wxASSERT_MSG( nStart <= len, _T("invalid index") );
1025     }
1026
1027     size_t idx = nStart;
1028     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1029           i != rend(); --idx, ++i )
1030     {
1031         if ( !wxTmemchr(sz, *i, n) )
1032             return idx;
1033     }
1034
1035     return npos;
1036 }
1037
1038 size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
1039 {
1040     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
1041
1042     size_t idx = nStart;
1043     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
1044     {
1045         if ( *i != ch )
1046             return idx;
1047     }
1048
1049     return npos;
1050 }
1051
1052 size_t wxString::find_last_not_of(wxUniChar ch, size_t nStart) const
1053 {
1054     size_t len = length();
1055
1056     if ( nStart == npos )
1057     {
1058         nStart = len - 1;
1059     }
1060     else
1061     {
1062         wxASSERT_MSG( nStart <= len, _T("invalid index") );
1063     }
1064
1065     size_t idx = nStart;
1066     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1067           i != rend(); --idx, ++i )
1068     {
1069         if ( *i != ch )
1070             return idx;
1071     }
1072
1073     return npos;
1074 }
1075
1076 // the functions above were implemented for wchar_t* arguments in Unicode
1077 // build and char* in ANSI build; below are implementations for the other
1078 // version:
1079 #if wxUSE_UNICODE
1080     #define wxOtherCharType char
1081     #define STRCONV         (const wxChar*)wxConvLibc.cMB2WC
1082 #else
1083     #define wxOtherCharType wchar_t
1084     #define STRCONV         (const wxChar*)wxConvLibc.cWC2MB
1085 #endif
1086
1087 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart) const
1088     { return find_first_of(STRCONV(sz), nStart); }
1089
1090 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart,
1091                                size_t n) const
1092     { return find_first_of(STRCONV(sz, n, NULL), nStart, n); }
1093 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart) const
1094     { return find_last_of(STRCONV(sz), nStart); }
1095 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart,
1096                               size_t n) const
1097     { return find_last_of(STRCONV(sz, n, NULL), nStart, n); }
1098 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart) const
1099     { return find_first_not_of(STRCONV(sz), nStart); }
1100 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart,
1101                                    size_t n) const
1102     { return find_first_not_of(STRCONV(sz, n, NULL), nStart, n); }
1103 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart) const
1104     { return find_last_not_of(STRCONV(sz), nStart); }
1105 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart,
1106                                   size_t n) const
1107     { return find_last_not_of(STRCONV(sz, n, NULL), nStart, n); }
1108
1109 #undef wxOtherCharType
1110 #undef STRCONV
1111
1112 #endif // !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
1113
1114 // ===========================================================================
1115 // other common string functions
1116 // ===========================================================================
1117
1118 int wxString::CmpNoCase(const wxString& s) const
1119 {
1120 #if wxUSE_UNICODE_UTF8
1121     // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
1122
1123     const_iterator i1 = begin();
1124     const_iterator end1 = end();
1125     const_iterator i2 = s.begin();
1126     const_iterator end2 = s.end();
1127
1128     for ( ; i1 != end1 && i2 != end2; ++i1, ++i2 )
1129     {
1130         wxUniChar lower1 = (wxChar)wxTolower(*i1);
1131         wxUniChar lower2 = (wxChar)wxTolower(*i2);
1132         if ( lower1 != lower2 )
1133             return lower1 < lower2 ? -1 : 1;
1134     }
1135
1136     size_t len1 = length();
1137     size_t len2 = s.length();
1138
1139     if ( len1 < len2 )
1140         return -1;
1141     else if ( len1 > len2 )
1142         return 1;
1143     return 0;
1144 #else // wxUSE_UNICODE_WCHAR or ANSI
1145     return wxStricmp(m_impl.c_str(), s.m_impl.c_str());
1146 #endif
1147 }
1148
1149
1150 #if wxUSE_UNICODE
1151
1152 #ifdef __MWERKS__
1153 #ifndef __SCHAR_MAX__
1154 #define __SCHAR_MAX__ 127
1155 #endif
1156 #endif
1157
1158 wxString wxString::FromAscii(const char *ascii, size_t len)
1159 {
1160     if (!ascii || len == 0)
1161        return wxEmptyString;
1162
1163     wxString res;
1164
1165     {
1166         wxStringInternalBuffer buf(res, len);
1167         wxStringCharType *dest = buf;
1168
1169         for ( ; len > 0; --len )
1170         {
1171             unsigned char c = (unsigned char)*ascii++;
1172             wxASSERT_MSG( c < 0x80,
1173                           _T("Non-ASCII value passed to FromAscii().") );
1174
1175             *dest++ = (wchar_t)c;
1176         }
1177     }
1178
1179     return res;
1180 }
1181
1182 wxString wxString::FromAscii(const char *ascii)
1183 {
1184     return FromAscii(ascii, wxStrlen(ascii));
1185 }
1186
1187 wxString wxString::FromAscii(char ascii)
1188 {
1189     // What do we do with '\0' ?
1190
1191     unsigned char c = (unsigned char)ascii;
1192
1193     wxASSERT_MSG( c < 0x80, _T("Non-ASCII value passed to FromAscii().") );
1194
1195     // NB: the cast to wchar_t causes interpretation of 'ascii' as Latin1 value
1196     return wxString(wxUniChar((wchar_t)c));
1197 }
1198
1199 const wxCharBuffer wxString::ToAscii() const
1200 {
1201     // this will allocate enough space for the terminating NUL too
1202     wxCharBuffer buffer(length());
1203     char *dest = buffer.data();
1204
1205     for ( const_iterator i = begin(); i != end(); ++i )
1206     {
1207         wxUniChar c(*i);
1208         // FIXME-UTF8: unify substituted char ('_') with wxUniChar ('?')
1209         *dest++ = c.IsAscii() ? (char)c : '_';
1210
1211         // the output string can't have embedded NULs anyhow, so we can safely
1212         // stop at first of them even if we do have any
1213         if ( !c )
1214             break;
1215     }
1216
1217     return buffer;
1218 }
1219
1220 #endif // wxUSE_UNICODE
1221
1222 // extract string of length nCount starting at nFirst
1223 wxString wxString::Mid(size_t nFirst, size_t nCount) const
1224 {
1225     size_t nLen = length();
1226
1227     // default value of nCount is npos and means "till the end"
1228     if ( nCount == npos )
1229     {
1230         nCount = nLen - nFirst;
1231     }
1232
1233     // out-of-bounds requests return sensible things
1234     if ( nFirst + nCount > nLen )
1235     {
1236         nCount = nLen - nFirst;
1237     }
1238
1239     if ( nFirst > nLen )
1240     {
1241         // AllocCopy() will return empty string
1242         return wxEmptyString;
1243     }
1244
1245     wxString dest(*this, nFirst, nCount);
1246     if ( dest.length() != nCount )
1247     {
1248         wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1249     }
1250
1251     return dest;
1252 }
1253
1254 // check that the string starts with prefix and return the rest of the string
1255 // in the provided pointer if it is not NULL, otherwise return false
1256 bool wxString::StartsWith(const wxString& prefix, wxString *rest) const
1257 {
1258     if ( compare(0, prefix.length(), prefix) != 0 )
1259         return false;
1260
1261     if ( rest )
1262     {
1263         // put the rest of the string into provided pointer
1264         rest->assign(*this, prefix.length(), npos);
1265     }
1266
1267     return true;
1268 }
1269
1270
1271 // check that the string ends with suffix and return the rest of it in the
1272 // provided pointer if it is not NULL, otherwise return false
1273 bool wxString::EndsWith(const wxString& suffix, wxString *rest) const
1274 {
1275     int start = length() - suffix.length();
1276
1277     if ( start < 0 || compare(start, npos, suffix) != 0 )
1278         return false;
1279
1280     if ( rest )
1281     {
1282         // put the rest of the string into provided pointer
1283         rest->assign(*this, 0, start);
1284     }
1285
1286     return true;
1287 }
1288
1289
1290 // extract nCount last (rightmost) characters
1291 wxString wxString::Right(size_t nCount) const
1292 {
1293   if ( nCount > length() )
1294     nCount = length();
1295
1296   wxString dest(*this, length() - nCount, nCount);
1297   if ( dest.length() != nCount ) {
1298     wxFAIL_MSG( _T("out of memory in wxString::Right") );
1299   }
1300   return dest;
1301 }
1302
1303 // get all characters after the last occurrence of ch
1304 // (returns the whole string if ch not found)
1305 wxString wxString::AfterLast(wxUniChar ch) const
1306 {
1307   wxString str;
1308   int iPos = Find(ch, true);
1309   if ( iPos == wxNOT_FOUND )
1310     str = *this;
1311   else
1312     str.assign(*this, iPos + 1, npos);
1313
1314   return str;
1315 }
1316
1317 // extract nCount first (leftmost) characters
1318 wxString wxString::Left(size_t nCount) const
1319 {
1320   if ( nCount > length() )
1321     nCount = length();
1322
1323   wxString dest(*this, 0, nCount);
1324   if ( dest.length() != nCount ) {
1325     wxFAIL_MSG( _T("out of memory in wxString::Left") );
1326   }
1327   return dest;
1328 }
1329
1330 // get all characters before the first occurrence of ch
1331 // (returns the whole string if ch not found)
1332 wxString wxString::BeforeFirst(wxUniChar ch) const
1333 {
1334   int iPos = Find(ch);
1335   if ( iPos == wxNOT_FOUND )
1336       iPos = length();
1337   return wxString(*this, 0, iPos);
1338 }
1339
1340 /// get all characters before the last occurrence of ch
1341 /// (returns empty string if ch not found)
1342 wxString wxString::BeforeLast(wxUniChar ch) const
1343 {
1344   wxString str;
1345   int iPos = Find(ch, true);
1346   if ( iPos != wxNOT_FOUND && iPos != 0 )
1347     str = wxString(c_str(), iPos);
1348
1349   return str;
1350 }
1351
1352 /// get all characters after the first occurrence of ch
1353 /// (returns empty string if ch not found)
1354 wxString wxString::AfterFirst(wxUniChar ch) const
1355 {
1356   wxString str;
1357   int iPos = Find(ch);
1358   if ( iPos != wxNOT_FOUND )
1359       str.assign(*this, iPos + 1, npos);
1360
1361   return str;
1362 }
1363
1364 // replace first (or all) occurrences of some substring with another one
1365 size_t wxString::Replace(const wxString& strOld,
1366                          const wxString& strNew, bool bReplaceAll)
1367 {
1368     // if we tried to replace an empty string we'd enter an infinite loop below
1369     wxCHECK_MSG( !strOld.empty(), 0,
1370                  _T("wxString::Replace(): invalid parameter") );
1371
1372     wxSTRING_INVALIDATE_CACHE();
1373
1374     size_t uiCount = 0;   // count of replacements made
1375
1376     // optimize the special common case: replacement of one character by
1377     // another one (in UTF-8 case we can only do this for ASCII characters)
1378     //
1379     // benchmarks show that this special version is around 3 times faster
1380     // (depending on the proportion of matching characters and UTF-8/wchar_t
1381     // build)
1382     if ( strOld.m_impl.length() == 1 && strNew.m_impl.length() == 1 )
1383     {
1384         const wxStringCharType chOld = strOld.m_impl[0],
1385                                chNew = strNew.m_impl[0];
1386
1387         // this loop is the simplified version of the one below
1388         for ( size_t pos = 0; ; )
1389         {
1390             pos = m_impl.find(chOld, pos);
1391             if ( pos == npos )
1392                 break;
1393
1394             m_impl[pos++] = chNew;
1395
1396             uiCount++;
1397
1398             if ( !bReplaceAll )
1399                 break;
1400         }
1401     }
1402     else if ( !bReplaceAll)
1403     {
1404         size_t pos = m_impl.find(strOld, 0);
1405         if ( pos != npos )
1406         {
1407             m_impl.replace(pos, strOld.m_impl.length(), strNew.m_impl);
1408             uiCount = 1;
1409         }
1410     }
1411     else // replace all occurrences
1412     {
1413         const size_t uiOldLen = strOld.m_impl.length();
1414         const size_t uiNewLen = strNew.m_impl.length();
1415
1416         // first scan the string to find all positions at which the replacement
1417         // should be made
1418         wxVector<size_t> replacePositions;
1419
1420         size_t pos;
1421         for ( pos = m_impl.find(strOld.m_impl, 0);
1422               pos != npos;
1423               pos = m_impl.find(strOld.m_impl, pos + uiOldLen))
1424         {
1425             replacePositions.push_back(pos);
1426             ++uiCount;
1427         }
1428
1429         if ( !uiCount )
1430             return 0;
1431
1432         // allocate enough memory for the whole new string
1433         wxString tmp;
1434         tmp.m_impl.reserve(m_impl.length() + uiCount*(uiNewLen - uiOldLen));
1435
1436         // copy this string to tmp doing replacements on the fly
1437         size_t replNum = 0;
1438         for ( pos = 0; replNum < uiCount; replNum++ )
1439         {
1440             const size_t nextReplPos = replacePositions[replNum];
1441
1442             if ( pos != nextReplPos )
1443             {
1444                 tmp.m_impl.append(m_impl, pos, nextReplPos - pos);
1445             }
1446
1447             tmp.m_impl.append(strNew.m_impl);
1448             pos = nextReplPos + uiOldLen;
1449         }
1450
1451         if ( pos != m_impl.length() )
1452         {
1453             // append the rest of the string unchanged
1454             tmp.m_impl.append(m_impl, pos, m_impl.length() - pos);
1455         }
1456
1457         swap(tmp);
1458     }
1459
1460     return uiCount;
1461 }
1462
1463 bool wxString::IsAscii() const
1464 {
1465     for ( const_iterator i = begin(); i != end(); ++i )
1466     {
1467         if ( !(*i).IsAscii() )
1468             return false;
1469     }
1470
1471     return true;
1472 }
1473
1474 bool wxString::IsWord() const
1475 {
1476     for ( const_iterator i = begin(); i != end(); ++i )
1477     {
1478         if ( !wxIsalpha(*i) )
1479             return false;
1480     }
1481
1482     return true;
1483 }
1484
1485 bool wxString::IsNumber() const
1486 {
1487     if ( empty() )
1488         return true;
1489
1490     const_iterator i = begin();
1491
1492     if ( *i == _T('-') || *i == _T('+') )
1493         ++i;
1494
1495     for ( ; i != end(); ++i )
1496     {
1497         if ( !wxIsdigit(*i) )
1498             return false;
1499     }
1500
1501     return true;
1502 }
1503
1504 wxString wxString::Strip(stripType w) const
1505 {
1506     wxString s = *this;
1507     if ( w & leading ) s.Trim(false);
1508     if ( w & trailing ) s.Trim(true);
1509     return s;
1510 }
1511
1512 // ---------------------------------------------------------------------------
1513 // case conversion
1514 // ---------------------------------------------------------------------------
1515
1516 wxString& wxString::MakeUpper()
1517 {
1518   for ( iterator it = begin(), en = end(); it != en; ++it )
1519     *it = (wxChar)wxToupper(*it);
1520
1521   return *this;
1522 }
1523
1524 wxString& wxString::MakeLower()
1525 {
1526   for ( iterator it = begin(), en = end(); it != en; ++it )
1527     *it = (wxChar)wxTolower(*it);
1528
1529   return *this;
1530 }
1531
1532 wxString& wxString::MakeCapitalized()
1533 {
1534     const iterator en = end();
1535     iterator it = begin();
1536     if ( it != en )
1537     {
1538         *it = (wxChar)wxToupper(*it);
1539         for ( ++it; it != en; ++it )
1540             *it = (wxChar)wxTolower(*it);
1541     }
1542
1543     return *this;
1544 }
1545
1546 // ---------------------------------------------------------------------------
1547 // trimming and padding
1548 // ---------------------------------------------------------------------------
1549
1550 // some compilers (VC++ 6.0 not to name them) return true for a call to
1551 // isspace('\xEA') in the C locale which seems to be broken to me, but we have
1552 // to live with this by checking that the character is a 7 bit one - even if
1553 // this may fail to detect some spaces (I don't know if Unicode doesn't have
1554 // space-like symbols somewhere except in the first 128 chars), it is arguably
1555 // still better than trimming away accented letters
1556 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
1557
1558 // trims spaces (in the sense of isspace) from left or right side
1559 wxString& wxString::Trim(bool bFromRight)
1560 {
1561     // first check if we're going to modify the string at all
1562     if ( !empty() &&
1563          (
1564           (bFromRight && wxSafeIsspace(GetChar(length() - 1))) ||
1565           (!bFromRight && wxSafeIsspace(GetChar(0u)))
1566          )
1567        )
1568     {
1569         if ( bFromRight )
1570         {
1571             // find last non-space character
1572             reverse_iterator psz = rbegin();
1573             while ( (psz != rend()) && wxSafeIsspace(*psz) )
1574                 ++psz;
1575
1576             // truncate at trailing space start
1577             erase(psz.base(), end());
1578         }
1579         else
1580         {
1581             // find first non-space character
1582             iterator psz = begin();
1583             while ( (psz != end()) && wxSafeIsspace(*psz) )
1584                 ++psz;
1585
1586             // fix up data and length
1587             erase(begin(), psz);
1588         }
1589     }
1590
1591     return *this;
1592 }
1593
1594 // adds nCount characters chPad to the string from either side
1595 wxString& wxString::Pad(size_t nCount, wxUniChar chPad, bool bFromRight)
1596 {
1597     wxString s(chPad, nCount);
1598
1599     if ( bFromRight )
1600         *this += s;
1601     else
1602     {
1603         s += *this;
1604         swap(s);
1605     }
1606
1607     return *this;
1608 }
1609
1610 // truncate the string
1611 wxString& wxString::Truncate(size_t uiLen)
1612 {
1613     if ( uiLen < length() )
1614     {
1615         erase(begin() + uiLen, end());
1616     }
1617     //else: nothing to do, string is already short enough
1618
1619     return *this;
1620 }
1621
1622 // ---------------------------------------------------------------------------
1623 // finding (return wxNOT_FOUND if not found and index otherwise)
1624 // ---------------------------------------------------------------------------
1625
1626 // find a character
1627 int wxString::Find(wxUniChar ch, bool bFromEnd) const
1628 {
1629     size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);
1630
1631     return (idx == npos) ? wxNOT_FOUND : (int)idx;
1632 }
1633
1634 // ----------------------------------------------------------------------------
1635 // conversion to numbers
1636 // ----------------------------------------------------------------------------
1637
1638 // The implementation of all the functions below is exactly the same so factor
1639 // it out. Note that number extraction works correctly on UTF-8 strings, so
1640 // we can use wxStringCharType and wx_str() for maximum efficiency.
1641
1642 #ifndef __WXWINCE__
1643     #define DO_IF_NOT_WINCE(x) x
1644 #else
1645     #define DO_IF_NOT_WINCE(x)
1646 #endif
1647
1648 #define WX_STRING_TO_X_TYPE_START                                           \
1649     wxCHECK_MSG( pVal, false, _T("NULL output pointer") );                  \
1650     DO_IF_NOT_WINCE( errno = 0; )                                           \
1651     const wxStringCharType *start = wx_str();                               \
1652     wxStringCharType *end;
1653
1654 #define WX_STRING_TO_X_TYPE_END                                             \
1655     /* return true only if scan was stopped by the terminating NUL and */   \
1656     /* if the string was not empty to start with and no under/overflow */   \
1657     /* occurred: */                                                         \
1658     if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) )         \
1659         return false;                                                       \
1660     *pVal = val;                                                            \
1661     return true;
1662
1663 bool wxString::ToLong(long *pVal, int base) const
1664 {
1665     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1666
1667     WX_STRING_TO_X_TYPE_START
1668     long val = wxStrtol(start, &end, base);
1669     WX_STRING_TO_X_TYPE_END
1670 }
1671
1672 bool wxString::ToULong(unsigned long *pVal, int base) const
1673 {
1674     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1675
1676     WX_STRING_TO_X_TYPE_START
1677     unsigned long val = wxStrtoul(start, &end, base);
1678     WX_STRING_TO_X_TYPE_END
1679 }
1680
1681 bool wxString::ToLongLong(wxLongLong_t *pVal, int base) const
1682 {
1683     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1684
1685     WX_STRING_TO_X_TYPE_START
1686     wxLongLong_t val = wxStrtoll(start, &end, base);
1687     WX_STRING_TO_X_TYPE_END
1688 }
1689
1690 bool wxString::ToULongLong(wxULongLong_t *pVal, int base) const
1691 {
1692     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1693
1694     WX_STRING_TO_X_TYPE_START
1695     wxULongLong_t val = wxStrtoull(start, &end, base);
1696     WX_STRING_TO_X_TYPE_END
1697 }
1698
1699 bool wxString::ToDouble(double *pVal) const
1700 {
1701     WX_STRING_TO_X_TYPE_START
1702     double val = wxStrtod(start, &end);
1703     WX_STRING_TO_X_TYPE_END
1704 }
1705
1706 #if wxUSE_XLOCALE
1707
1708 bool wxString::ToCLong(long *pVal, int base) const
1709 {
1710     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1711
1712     WX_STRING_TO_X_TYPE_START
1713 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1714     long val = wxStrtol_lA(start, &end, base, wxCLocale);
1715 #else
1716     long val = wxStrtol_l(start, &end, base, wxCLocale);
1717 #endif
1718     WX_STRING_TO_X_TYPE_END
1719 }
1720
1721 bool wxString::ToCULong(unsigned long *pVal, int base) const
1722 {
1723     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1724
1725     WX_STRING_TO_X_TYPE_START
1726 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1727     unsigned long val = wxStrtoul_lA(start, &end, base, wxCLocale);
1728 #else
1729     unsigned long val = wxStrtoul_l(start, &end, base, wxCLocale);
1730 #endif
1731     WX_STRING_TO_X_TYPE_END
1732 }
1733
1734 bool wxString::ToCDouble(double *pVal) const
1735 {
1736     WX_STRING_TO_X_TYPE_START
1737 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1738     double val = wxStrtod_lA(start, &end, wxCLocale);
1739 #else
1740     double val = wxStrtod_l(start, &end, wxCLocale);
1741 #endif
1742     WX_STRING_TO_X_TYPE_END
1743 }
1744
1745 #endif  // wxUSE_XLOCALE
1746
1747 // ---------------------------------------------------------------------------
1748 // formatted output
1749 // ---------------------------------------------------------------------------
1750
1751 #if !wxUSE_UTF8_LOCALE_ONLY
1752 /* static */
1753 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1754 wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...)
1755 #else
1756 wxString wxString::DoFormatWchar(const wxChar *format, ...)
1757 #endif
1758 {
1759     va_list argptr;
1760     va_start(argptr, format);
1761
1762     wxString s;
1763     s.PrintfV(format, argptr);
1764
1765     va_end(argptr);
1766
1767     return s;
1768 }
1769 #endif // !wxUSE_UTF8_LOCALE_ONLY
1770
1771 #if wxUSE_UNICODE_UTF8
1772 /* static */
1773 wxString wxString::DoFormatUtf8(const char *format, ...)
1774 {
1775     va_list argptr;
1776     va_start(argptr, format);
1777
1778     wxString s;
1779     s.PrintfV(format, argptr);
1780
1781     va_end(argptr);
1782
1783     return s;
1784 }
1785 #endif // wxUSE_UNICODE_UTF8
1786
1787 /* static */
1788 wxString wxString::FormatV(const wxString& format, va_list argptr)
1789 {
1790     wxString s;
1791     s.PrintfV(format, argptr);
1792     return s;
1793 }
1794
1795 #if !wxUSE_UTF8_LOCALE_ONLY
1796 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1797 int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...)
1798 #else
1799 int wxString::DoPrintfWchar(const wxChar *format, ...)
1800 #endif
1801 {
1802     va_list argptr;
1803     va_start(argptr, format);
1804
1805 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1806     // get a pointer to the wxString instance; we have to use dynamic_cast<>
1807     // because it's the only cast that works safely for downcasting when
1808     // multiple inheritance is used:
1809     wxString *str = static_cast<wxString*>(this);
1810 #else
1811     wxString *str = this;
1812 #endif
1813
1814     int iLen = str->PrintfV(format, argptr);
1815
1816     va_end(argptr);
1817
1818     return iLen;
1819 }
1820 #endif // !wxUSE_UTF8_LOCALE_ONLY
1821
1822 #if wxUSE_UNICODE_UTF8
1823 int wxString::DoPrintfUtf8(const char *format, ...)
1824 {
1825     va_list argptr;
1826     va_start(argptr, format);
1827
1828     int iLen = PrintfV(format, argptr);
1829
1830     va_end(argptr);
1831
1832     return iLen;
1833 }
1834 #endif // wxUSE_UNICODE_UTF8
1835
1836 /*
1837     Uses wxVsnprintf and places the result into the this string.
1838
1839     In ANSI build, wxVsnprintf is effectively vsnprintf but in Unicode build
1840     it is vswprintf.  Due to a discrepancy between vsnprintf and vswprintf in
1841     the ISO C99 (and thus SUSv3) standard the return value for the case of
1842     an undersized buffer is inconsistent.  For conforming vsnprintf
1843     implementations the function must return the number of characters that
1844     would have been printed had the buffer been large enough.  For conforming
1845     vswprintf implementations the function must return a negative number
1846     and set errno.
1847
1848     What vswprintf sets errno to is undefined but Darwin seems to set it to
1849     EOVERFLOW.  The only expected errno are EILSEQ and EINVAL.  Both of
1850     those are defined in the standard and backed up by several conformance
1851     statements.  Note that ENOMEM mentioned in the manual page does not
1852     apply to swprintf, only wprintf and fwprintf.
1853
1854     Official manual page:
1855     http://www.opengroup.org/onlinepubs/009695399/functions/swprintf.html
1856
1857     Some conformance statements (AIX, Solaris):
1858     http://www.opengroup.org/csq/view.mhtml?RID=ibm%2FSD1%2F3
1859     http://www.theopengroup.org/csq/view.mhtml?norationale=1&noreferences=1&RID=Fujitsu%2FSE2%2F10
1860
1861     Since EILSEQ and EINVAL are rather common but EOVERFLOW is not and since
1862     EILSEQ and EINVAL are specifically defined to mean the error is other than
1863     an undersized buffer and no other errno are defined we treat those two
1864     as meaning hard errors and everything else gets the old behavior which
1865     is to keep looping and increasing buffer size until the function succeeds.
1866
1867     In practice it's impossible to determine before compilation which behavior
1868     may be used.  The vswprintf function may have vsnprintf-like behavior or
1869     vice-versa.  Behavior detected on one release can theoretically change
1870     with an updated release.  Not to mention that configure testing for it
1871     would require the test to be run on the host system, not the build system
1872     which makes cross compilation difficult. Therefore, we make no assumptions
1873     about behavior and try our best to handle every known case, including the
1874     case where wxVsnprintf returns a negative number and fails to set errno.
1875
1876     There is yet one more non-standard implementation and that is our own.
1877     Fortunately, that can be detected at compile-time.
1878
1879     On top of all that, ISO C99 explicitly defines snprintf to write a null
1880     character to the last position of the specified buffer.  That would be at
1881     at the given buffer size minus 1.  It is supposed to do this even if it
1882     turns out that the buffer is sized too small.
1883
1884     Darwin (tested on 10.5) follows the C99 behavior exactly.
1885
1886     Glibc 2.6 almost follows the C99 behavior except vswprintf never sets
1887     errno even when it fails.  However, it only seems to ever fail due
1888     to an undersized buffer.
1889 */
1890 #if wxUSE_UNICODE_UTF8
1891 template<typename BufferType>
1892 #else
1893 // we only need one version in non-UTF8 builds and at least two Windows
1894 // compilers have problems with this function template, so use just one
1895 // normal function here
1896 #endif
1897 static int DoStringPrintfV(wxString& str,
1898                            const wxString& format, va_list argptr)
1899 {
1900     int size = 1024;
1901
1902     for ( ;; )
1903     {
1904 #if wxUSE_UNICODE_UTF8
1905         BufferType tmp(str, size + 1);
1906         typename BufferType::CharType *buf = tmp;
1907 #else
1908         wxStringBuffer tmp(str, size + 1);
1909         wxChar *buf = tmp;
1910 #endif
1911
1912         if ( !buf )
1913         {
1914             // out of memory
1915
1916             // in UTF-8 build, leaving uninitialized junk in the buffer
1917             // could result in invalid non-empty UTF-8 string, so just
1918             // reset the string to empty on failure:
1919             buf[0] = '\0';
1920             return -1;
1921         }
1922
1923         // wxVsnprintf() may modify the original arg pointer, so pass it
1924         // only a copy
1925         va_list argptrcopy;
1926         wxVaCopy(argptrcopy, argptr);
1927
1928 #ifndef __WXWINCE__
1929         // Set errno to 0 to make it determinate if wxVsnprintf fails to set it.
1930         errno = 0;
1931 #endif
1932         int len = wxVsnprintf(buf, size, format, argptrcopy);
1933         va_end(argptrcopy);
1934
1935         // some implementations of vsnprintf() don't NUL terminate
1936         // the string if there is not enough space for it so
1937         // always do it manually
1938         // FIXME: This really seems to be the wrong and would be an off-by-one
1939         // bug except the code above allocates an extra character.
1940         buf[size] = _T('\0');
1941
1942         // vsnprintf() may return either -1 (traditional Unix behaviour) or the
1943         // total number of characters which would have been written if the
1944         // buffer were large enough (newer standards such as Unix98)
1945         if ( len < 0 )
1946         {
1947             // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or
1948             //     wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF
1949             //     is true if *both* of them use our own implementation,
1950             //     otherwise we can't be sure
1951 #if wxUSE_WXVSNPRINTF
1952             // we know that our own implementation of wxVsnprintf() returns -1
1953             // only for a format error - thus there's something wrong with
1954             // the user's format string
1955             buf[0] = '\0';
1956             return -1;
1957 #else // possibly using system version
1958             // assume it only returns error if there is not enough space, but
1959             // as we don't know how much we need, double the current size of
1960             // the buffer
1961 #ifndef __WXWINCE__
1962             if( (errno == EILSEQ) || (errno == EINVAL) )
1963             // If errno was set to one of the two well-known hard errors
1964             // then fail immediately to avoid an infinite loop.
1965                 return -1;
1966             else
1967 #endif // __WXWINCE__
1968             // still not enough, as we don't know how much we need, double the
1969             // current size of the buffer
1970                 size *= 2;
1971 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
1972         }
1973         else if ( len >= size )
1974         {
1975 #if wxUSE_WXVSNPRINTF
1976             // we know that our own implementation of wxVsnprintf() returns
1977             // size+1 when there's not enough space but that's not the size
1978             // of the required buffer!
1979             size *= 2;      // so we just double the current size of the buffer
1980 #else
1981             // some vsnprintf() implementations NUL-terminate the buffer and
1982             // some don't in len == size case, to be safe always add 1
1983             // FIXME: I don't quite understand this comment.  The vsnprintf
1984             // function is specifically defined to return the number of
1985             // characters printed not including the null terminator.
1986             // So OF COURSE you need to add 1 to get the right buffer size.
1987             // The following line is definitely correct, no question.
1988             size = len + 1;
1989 #endif
1990         }
1991         else // ok, there was enough space
1992         {
1993             break;
1994         }
1995     }
1996
1997     // we could have overshot
1998     str.Shrink();
1999
2000     return str.length();
2001 }
2002
2003 int wxString::PrintfV(const wxString& format, va_list argptr)
2004 {
2005 #if wxUSE_UNICODE_UTF8
2006     #if wxUSE_STL_BASED_WXSTRING
2007         typedef wxStringTypeBuffer<char> Utf8Buffer;
2008     #else
2009         typedef wxStringInternalBuffer Utf8Buffer;
2010     #endif
2011 #endif
2012
2013 #if wxUSE_UTF8_LOCALE_ONLY
2014     return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
2015 #else
2016     #if wxUSE_UNICODE_UTF8
2017     if ( wxLocaleIsUtf8 )
2018         return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
2019     else
2020         // wxChar* version
2021         return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);
2022     #else
2023         return DoStringPrintfV(*this, format, argptr);
2024     #endif // UTF8/WCHAR
2025 #endif
2026 }
2027
2028 // ----------------------------------------------------------------------------
2029 // misc other operations
2030 // ----------------------------------------------------------------------------
2031
2032 // returns true if the string matches the pattern which may contain '*' and
2033 // '?' metacharacters (as usual, '?' matches any character and '*' any number
2034 // of them)
2035 bool wxString::Matches(const wxString& mask) const
2036 {
2037     // I disable this code as it doesn't seem to be faster (in fact, it seems
2038     // to be much slower) than the old, hand-written code below and using it
2039     // here requires always linking with libregex even if the user code doesn't
2040     // use it
2041 #if 0 // wxUSE_REGEX
2042     // first translate the shell-like mask into a regex
2043     wxString pattern;
2044     pattern.reserve(wxStrlen(pszMask));
2045
2046     pattern += _T('^');
2047     while ( *pszMask )
2048     {
2049         switch ( *pszMask )
2050         {
2051             case _T('?'):
2052                 pattern += _T('.');
2053                 break;
2054
2055             case _T('*'):
2056                 pattern += _T(".*");
2057                 break;
2058
2059             case _T('^'):
2060             case _T('.'):
2061             case _T('$'):
2062             case _T('('):
2063             case _T(')'):
2064             case _T('|'):
2065             case _T('+'):
2066             case _T('\\'):
2067                 // these characters are special in a RE, quote them
2068                 // (however note that we don't quote '[' and ']' to allow
2069                 // using them for Unix shell like matching)
2070                 pattern += _T('\\');
2071                 // fall through
2072
2073             default:
2074                 pattern += *pszMask;
2075         }
2076
2077         pszMask++;
2078     }
2079     pattern += _T('$');
2080
2081     // and now use it
2082     return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
2083 #else // !wxUSE_REGEX
2084   // TODO: this is, of course, awfully inefficient...
2085
2086   // FIXME-UTF8: implement using iterators, remove #if
2087 #if wxUSE_UNICODE_UTF8
2088   wxWCharBuffer maskBuf = mask.wc_str();
2089   wxWCharBuffer txtBuf = wc_str();
2090   const wxChar *pszMask = maskBuf.data();
2091   const wxChar *pszTxt = txtBuf.data();
2092 #else
2093   const wxChar *pszMask = mask.wx_str();
2094   // the char currently being checked
2095   const wxChar *pszTxt = wx_str();
2096 #endif
2097
2098   // the last location where '*' matched
2099   const wxChar *pszLastStarInText = NULL;
2100   const wxChar *pszLastStarInMask = NULL;
2101
2102 match:
2103   for ( ; *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
2104     switch ( *pszMask ) {
2105       case wxT('?'):
2106         if ( *pszTxt == wxT('\0') )
2107           return false;
2108
2109         // pszTxt and pszMask will be incremented in the loop statement
2110
2111         break;
2112
2113       case wxT('*'):
2114         {
2115           // remember where we started to be able to backtrack later
2116           pszLastStarInText = pszTxt;
2117           pszLastStarInMask = pszMask;
2118
2119           // ignore special chars immediately following this one
2120           // (should this be an error?)
2121           while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
2122             pszMask++;
2123
2124           // if there is nothing more, match
2125           if ( *pszMask == wxT('\0') )
2126             return true;
2127
2128           // are there any other metacharacters in the mask?
2129           size_t uiLenMask;
2130           const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
2131
2132           if ( pEndMask != NULL ) {
2133             // we have to match the string between two metachars
2134             uiLenMask = pEndMask - pszMask;
2135           }
2136           else {
2137             // we have to match the remainder of the string
2138             uiLenMask = wxStrlen(pszMask);
2139           }
2140
2141           wxString strToMatch(pszMask, uiLenMask);
2142           const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
2143           if ( pMatch == NULL )
2144             return false;
2145
2146           // -1 to compensate "++" in the loop
2147           pszTxt = pMatch + uiLenMask - 1;
2148           pszMask += uiLenMask - 1;
2149         }
2150         break;
2151
2152       default:
2153         if ( *pszMask != *pszTxt )
2154           return false;
2155         break;
2156     }
2157   }
2158
2159   // match only if nothing left
2160   if ( *pszTxt == wxT('\0') )
2161     return true;
2162
2163   // if we failed to match, backtrack if we can
2164   if ( pszLastStarInText ) {
2165     pszTxt = pszLastStarInText + 1;
2166     pszMask = pszLastStarInMask;
2167
2168     pszLastStarInText = NULL;
2169
2170     // don't bother resetting pszLastStarInMask, it's unnecessary
2171
2172     goto match;
2173   }
2174
2175   return false;
2176 #endif // wxUSE_REGEX/!wxUSE_REGEX
2177 }
2178
2179 // Count the number of chars
2180 int wxString::Freq(wxUniChar ch) const
2181 {
2182     int count = 0;
2183     for ( const_iterator i = begin(); i != end(); ++i )
2184     {
2185         if ( *i == ch )
2186             count ++;
2187     }
2188     return count;
2189 }
2190