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 #ifdef __SALFORDC__
  39     #include <clib.h>
  40 #endif
  41
  42 #include "wx/hashmap.h"
  43
  44 // string handling functions used by wxString:
  45 #if wxUSE_UNICODE_UTF8
  46     #define wxStringMemcpy   memcpy
  47     #define wxStringMemcmp   memcmp
  48     #define wxStringMemchr   memchr
  49     #define wxStringStrlen   strlen
  50 #else
  51     #define wxStringMemcpy   wxTmemcpy
  52     #define wxStringMemcmp   wxTmemcmp
  53     #define wxStringMemchr   wxTmemchr
  54     #define wxStringStrlen   wxStrlen
  55 #endif
  56
  57
  58 // ---------------------------------------------------------------------------
  59 // static class variables definition
  60 // ---------------------------------------------------------------------------
  61
  62 //According to STL _must_ be a -1 size_t
  63 const size_t wxString::npos = (size_t) -1;
  64
  65 // ----------------------------------------------------------------------------
  66 // global functions
  67 // ----------------------------------------------------------------------------
  68
  69 #if wxUSE_STD_IOSTREAM
  70
  71 #include <iostream>
  72
  73 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
  74 {
  75 // FIXME-UTF8: always, not only if wxUSE_UNICODE
  76 #if wxUSE_UNICODE && !defined(__BORLANDC__)
  77     return os << (const wchar_t*)str.AsWCharBuf();
  78 #else
  79     return os << (const char*)str.AsCharBuf();
  80 #endif
  81 }
  82
  83 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
  84 {
  85     return os << str.c_str();
  86 }
  87
  88 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCharBuffer& str)
  89 {
  90     return os << str.data();
  91 }
  92
  93 #ifndef __BORLANDC__
  94 wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
  95 {
  96     return os << str.data();
  97 }
  98 #endif
  99
 100 #endif // wxUSE_STD_IOSTREAM
 101
 102 // ===========================================================================
 103 // wxString class core
 104 // ===========================================================================
 105
 106 #if wxUSE_UNICODE_UTF8
 107
 108 void wxString::PosLenToImpl(size_t pos, size_t len,
 109                             size_t *implPos, size_t *implLen) const
 110 {
 111     if ( pos == npos )
 112         *implPos = npos;
 113     else
 114     {
 115         const_iterator i = begin() + pos;
 116         *implPos = wxStringImpl::const_iterator(i.impl()) - m_impl.begin();
 117         if ( len == npos )
 118             *implLen = npos;
 119         else
 120         {
 121             // too large length is interpreted as "to the end of the string"
 122             // FIXME-UTF8: verify this is the case in std::string, assert
 123             // otherwise
 124             if ( pos + len > length() )
 125                 len = length() - pos;
 126
 127             *implLen = (i + len).impl() - i.impl();
 128         }
 129     }
 130 }
 131
 132 #endif // wxUSE_UNICODE_UTF8
 133
 134 // ----------------------------------------------------------------------------
 135 // wxCStrData converted strings caching
 136 // ----------------------------------------------------------------------------
 137
 138 // FIXME-UTF8: temporarily disabled because it doesn't work with global
 139 //             string objects; re-enable after fixing this bug and benchmarking
 140 //             performance to see if using a hash is a good idea at all
 141 #if 0
 142
 143 // For backward compatibility reasons, it must be possible to assign the value
 144 // returned by wxString::c_str() to a char* or wchar_t* variable and work with
 145 // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick,
 146 // because the memory would be freed immediately, but it has to be valid as long
 147 // as the string is not modified, so that code like this still works:
 148 //
 149 // const wxChar *s = str.c_str();
 150 // while ( s ) { ... }
 151
 152 // FIXME-UTF8: not thread safe!
 153 // FIXME-UTF8: we currently clear the cached conversion only when the string is
 154 //             destroyed, but we should do it when the string is modified, to
 155 //             keep memory usage down
 156 // FIXME-UTF8: we do the conversion every time As[W]Char() is called, but if we
 157 //             invalidated the cache on every change, we could keep the previous
 158 //             conversion
 159 // FIXME-UTF8: add tracing of usage of these two methods - new code is supposed
 160 //             to use mb_str() or wc_str() instead of (const [w]char*)c_str()
 161
 162 template<typename T>
 163 static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
 164 {
 165     typename T::iterator i = hash.find(wxConstCast(s, wxString));
 166     if ( i != hash.end() )
 167     {
 168         free(i->second);
 169         hash.erase(i);
 170     }
 171 }
 172
 173 #if wxUSE_UNICODE
 174 // NB: non-STL implementation doesn't compile with "const wxString*" key type,
 175 //     so we have to use wxString* here and const-cast when used
 176 WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual,
 177                     wxStringCharConversionCache);
 178 static wxStringCharConversionCache gs_stringsCharCache;
 179
 180 const char* wxCStrData::AsChar() const
 181 {
 182     // remove previously cache value, if any (see FIXMEs above):
 183     DeleteStringFromConversionCache(gs_stringsCharCache, m_str);
 184
 185     // convert the string and keep it:
 186     const char *s = gs_stringsCharCache[wxConstCast(m_str, wxString)] =
 187         m_str->mb_str().release();
 188
 189     return s + m_offset;
 190 }
 191 #endif // wxUSE_UNICODE
 192
 193 #if !wxUSE_UNICODE_WCHAR
 194 WX_DECLARE_HASH_MAP(wxString*, wchar_t*, wxPointerHash, wxPointerEqual,
 195                     wxStringWCharConversionCache);
 196 static wxStringWCharConversionCache gs_stringsWCharCache;
 197
 198 const wchar_t* wxCStrData::AsWChar() const
 199 {
 200     // remove previously cache value, if any (see FIXMEs above):
 201     DeleteStringFromConversionCache(gs_stringsWCharCache, m_str);
 202
 203     // convert the string and keep it:
 204     const wchar_t *s = gs_stringsWCharCache[wxConstCast(m_str, wxString)] =
 205         m_str->wc_str().release();
 206
 207     return s + m_offset;
 208 }
 209 #endif // !wxUSE_UNICODE_WCHAR
 210
 211 wxString::~wxString()
 212 {
 213 #if wxUSE_UNICODE
 214     // FIXME-UTF8: do this only if locale is not UTF8 if wxUSE_UNICODE_UTF8
 215     DeleteStringFromConversionCache(gs_stringsCharCache, this);
 216 #endif
 217 #if !wxUSE_UNICODE_WCHAR
 218     DeleteStringFromConversionCache(gs_stringsWCharCache, this);
 219 #endif
 220 }
 221 #endif
 222
 223 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 224 const char* wxCStrData::AsChar() const
 225 {
 226 #if wxUSE_UNICODE_UTF8
 227     if ( wxLocaleIsUtf8 )
 228         return AsInternal();
 229 #endif
 230     // under non-UTF8 locales, we have to convert the internal UTF-8
 231     // representation using wxConvLibc and cache the result
 232
 233     wxString *str = wxConstCast(m_str, wxString);
 234
 235     // convert the string:
 236     wxCharBuffer buf(str->mb_str());
 237
 238     // FIXME-UTF8: do the conversion in-place in the existing buffer
 239     if ( str->m_convertedToChar &&
 240          strlen(buf) == strlen(str->m_convertedToChar) )
 241     {
 242         // keep the same buffer for as long as possible, so that several calls
 243         // to c_str() in a row still work:
 244         strcpy(str->m_convertedToChar, buf);
 245     }
 246     else
 247     {
 248         str->m_convertedToChar = buf.release();
 249     }
 250
 251     // and keep it:
 252     return str->m_convertedToChar + m_offset;
 253 }
 254 #endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 255
 256 #if !wxUSE_UNICODE_WCHAR
 257 const wchar_t* wxCStrData::AsWChar() const
 258 {
 259     wxString *str = wxConstCast(m_str, wxString);
 260
 261     // convert the string:
 262     wxWCharBuffer buf(str->wc_str());
 263
 264     // FIXME-UTF8: do the conversion in-place in the existing buffer
 265     if ( str->m_convertedToWChar &&
 266          wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
 267     {
 268         // keep the same buffer for as long as possible, so that several calls
 269         // to c_str() in a row still work:
 270         memcpy(str->m_convertedToWChar, buf, sizeof(wchar_t) * wxWcslen(buf));
 271     }
 272     else
 273     {
 274         str->m_convertedToWChar = buf.release();
 275     }
 276
 277     // and keep it:
 278     return str->m_convertedToWChar + m_offset;
 279 }
 280 #endif // !wxUSE_UNICODE_WCHAR
 281
 282 // ===========================================================================
 283 // wxString class core
 284 // ===========================================================================
 285
 286 // ---------------------------------------------------------------------------
 287 // construction and conversion
 288 // ---------------------------------------------------------------------------
 289
 290 #if wxUSE_UNICODE_WCHAR
 291 /* static */
 292 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 293                                                const wxMBConv& conv)
 294 {
 295     // anything to do?
 296     if ( !psz || nLength == 0 )
 297         return SubstrBufFromMB(L"", 0);
 298
 299     if ( nLength == npos )
 300         nLength = wxNO_LEN;
 301
 302     size_t wcLen;
 303     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
 304     if ( !wcLen )
 305         return SubstrBufFromMB(_T(""), 0);
 306     else
 307         return SubstrBufFromMB(wcBuf, wcLen);
 308 }
 309 #endif // wxUSE_UNICODE_WCHAR
 310
 311 #if wxUSE_UNICODE_UTF8
 312 /* static */
 313 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 314                                                const wxMBConv& conv)
 315 {
 316     // anything to do?
 317     if ( !psz || nLength == 0 )
 318         return SubstrBufFromMB("", 0);
 319
 320     // if psz is already in UTF-8, we don't have to do the roundtrip to
 321     // wchar_t* and back:
 322     if ( conv.IsUTF8() )
 323     {
 324         // we need to validate the input because UTF8 iterators assume valid
 325         // UTF-8 sequence and psz may be invalid:
 326         if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
 327         {
 328             return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
 329         }
 330         // else: do the roundtrip through wchar_t*
 331     }
 332
 333     if ( nLength == npos )
 334         nLength = wxNO_LEN;
 335
 336     // first convert to wide string:
 337     size_t wcLen;
 338     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
 339     if ( !wcLen )
 340         return SubstrBufFromMB("", 0);
 341
 342     // and then to UTF-8:
 343     SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
 344     // widechar -> UTF-8 conversion isn't supposed to ever fail:
 345     wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
 346
 347     return buf;
 348 }
 349 #endif // wxUSE_UNICODE_UTF8
 350
 351 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
 352 /* static */
 353 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
 354                                                const wxMBConv& conv)
 355 {
 356     // anything to do?
 357     if ( !pwz || nLength == 0 )
 358         return SubstrBufFromWC("", 0);
 359
 360     if ( nLength == npos )
 361         nLength = wxNO_LEN;
 362
 363     size_t mbLen;
 364     wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
 365     if ( !mbLen )
 366         return SubstrBufFromWC("", 0);
 367     else
 368         return SubstrBufFromWC(mbBuf, mbLen);
 369 }
 370 #endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
 371
 372
 373 #if wxUSE_UNICODE_WCHAR
 374
 375 //Convert wxString in Unicode mode to a multi-byte string
 376 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 377 {
 378     return conv.cWC2MB(wx_str(), length() + 1 /* size, not length */, NULL);
 379 }
 380
 381 #elif wxUSE_UNICODE_UTF8
 382
 383 const wxWCharBuffer wxString::wc_str() const
 384 {
 385     return wxMBConvStrictUTF8().cMB2WC
 386                                 (
 387                                     m_impl.c_str(),
 388                                     m_impl.length() + 1, // size, not length
 389                                     NULL
 390                                 );
 391 }
 392
 393 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 394 {
 395     if ( conv.IsUTF8() )
 396         return wxCharBuffer::CreateNonOwned(m_impl.c_str());
 397
 398     // FIXME-UTF8: use wc_str() here once we have buffers with length
 399
 400     size_t wcLen;
 401     wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC
 402                                              (
 403                                                 m_impl.c_str(),
 404                                                 m_impl.length() + 1, // size
 405                                                 &wcLen
 406                                              ));
 407     if ( !wcLen )
 408         return wxCharBuffer("");
 409
 410     return conv.cWC2MB(wcBuf, wcLen, NULL);
 411 }
 412
 413 #else // ANSI
 414
 415 //Converts this string to a wide character string if unicode
 416 //mode is not enabled and wxUSE_WCHAR_T is enabled
 417 const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const
 418 {
 419     return conv.cMB2WC(wx_str(), length() + 1 /* size, not length */, NULL);
 420 }
 421
 422 #endif // Unicode/ANSI
 423
 424 // shrink to minimal size (releasing extra memory)
 425 bool wxString::Shrink()
 426 {
 427   wxString tmp(begin(), end());
 428   swap(tmp);
 429   return tmp.length() == length();
 430 }
 431
 432 // deprecated compatibility code:
 433 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 434 wxStringCharType *wxString::GetWriteBuf(size_t nLen)
 435 {
 436     return DoGetWriteBuf(nLen);
 437 }
 438
 439 void wxString::UngetWriteBuf()
 440 {
 441     DoUngetWriteBuf();
 442 }
 443
 444 void wxString::UngetWriteBuf(size_t nLen)
 445 {
 446     DoUngetWriteBuf(nLen);
 447 }
 448 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 449
 450
 451 // ---------------------------------------------------------------------------
 452 // data access
 453 // ---------------------------------------------------------------------------
 454
 455 // all functions are inline in string.h
 456
 457 // ---------------------------------------------------------------------------
 458 // concatenation operators
 459 // ---------------------------------------------------------------------------
 460
 461 /*
 462  * concatenation functions come in 5 flavours:
 463  *  string + string
 464  *  char   + string      and      string + char
 465  *  C str  + string      and      string + C str
 466  */
 467
 468 wxString operator+(const wxString& str1, const wxString& str2)
 469 {
 470 #if !wxUSE_STL_BASED_WXSTRING
 471     wxASSERT( str1.IsValid() );
 472     wxASSERT( str2.IsValid() );
 473 #endif
 474
 475     wxString s = str1;
 476     s += str2;
 477
 478     return s;
 479 }
 480
 481 wxString operator+(const wxString& str, wxUniChar ch)
 482 {
 483 #if !wxUSE_STL_BASED_WXSTRING
 484     wxASSERT( str.IsValid() );
 485 #endif
 486
 487     wxString s = str;
 488     s += ch;
 489
 490     return s;
 491 }
 492
 493 wxString operator+(wxUniChar ch, const wxString& str)
 494 {
 495 #if !wxUSE_STL_BASED_WXSTRING
 496     wxASSERT( str.IsValid() );
 497 #endif
 498
 499     wxString s = ch;
 500     s += str;
 501
 502     return s;
 503 }
 504
 505 wxString operator+(const wxString& str, const char *psz)
 506 {
 507 #if !wxUSE_STL_BASED_WXSTRING
 508     wxASSERT( str.IsValid() );
 509 #endif
 510
 511     wxString s;
 512     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 513         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 514     }
 515     s += str;
 516     s += psz;
 517
 518     return s;
 519 }
 520
 521 wxString operator+(const wxString& str, const wchar_t *pwz)
 522 {
 523 #if !wxUSE_STL_BASED_WXSTRING
 524     wxASSERT( str.IsValid() );
 525 #endif
 526
 527     wxString s;
 528     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 529         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 530     }
 531     s += str;
 532     s += pwz;
 533
 534     return s;
 535 }
 536
 537 wxString operator+(const char *psz, const wxString& str)
 538 {
 539 #if !wxUSE_STL_BASED_WXSTRING
 540     wxASSERT( str.IsValid() );
 541 #endif
 542
 543     wxString s;
 544     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 545         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 546     }
 547     s = psz;
 548     s += str;
 549
 550     return s;
 551 }
 552
 553 wxString operator+(const wchar_t *pwz, const wxString& str)
 554 {
 555 #if !wxUSE_STL_BASED_WXSTRING
 556     wxASSERT( str.IsValid() );
 557 #endif
 558
 559     wxString s;
 560     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 561         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 562     }
 563     s = pwz;
 564     s += str;
 565
 566     return s;
 567 }
 568
 569 // ---------------------------------------------------------------------------
 570 // string comparison
 571 // ---------------------------------------------------------------------------
 572
 573 bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const
 574 {
 575     return (length() == 1) && (compareWithCase ? GetChar(0u) == c
 576                                : wxToupper(GetChar(0u)) == wxToupper(c));
 577 }
 578
 579 #ifdef HAVE_STD_STRING_COMPARE
 580
 581 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
 582 //     UTF-8 encoded strings too, thanks to UTF-8's design which allows us to
 583 //     sort strings in characters code point order by sorting the byte sequence
 584 //     in byte values order (i.e. what strcmp() and memcmp() do).
 585
 586 int wxString::compare(const wxString& str) const
 587 {
 588     return m_impl.compare(str.m_impl);
 589 }
 590
 591 int wxString::compare(size_t nStart, size_t nLen,
 592                       const wxString& str) const
 593 {
 594     size_t pos, len;
 595     PosLenToImpl(nStart, nLen, &pos, &len);
 596     return m_impl.compare(pos, len, str.m_impl);
 597 }
 598
 599 int wxString::compare(size_t nStart, size_t nLen,
 600                       const wxString& str,
 601                       size_t nStart2, size_t nLen2) const
 602 {
 603     size_t pos, len;
 604     PosLenToImpl(nStart, nLen, &pos, &len);
 605
 606     size_t pos2, len2;
 607     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 608
 609     return m_impl.compare(pos, len, str.m_impl, pos2, len2);
 610 }
 611
 612 int wxString::compare(const char* sz) const
 613 {
 614     return m_impl.compare(ImplStr(sz));
 615 }
 616
 617 int wxString::compare(const wchar_t* sz) const
 618 {
 619     return m_impl.compare(ImplStr(sz));
 620 }
 621
 622 int wxString::compare(size_t nStart, size_t nLen,
 623                       const char* sz, size_t nCount) const
 624 {
 625     size_t pos, len;
 626     PosLenToImpl(nStart, nLen, &pos, &len);
 627
 628     SubstrBufFromMB str(ImplStr(sz, nCount));
 629
 630     return m_impl.compare(pos, len, str.data, str.len);
 631 }
 632
 633 int wxString::compare(size_t nStart, size_t nLen,
 634                       const wchar_t* sz, size_t nCount) const
 635 {
 636     size_t pos, len;
 637     PosLenToImpl(nStart, nLen, &pos, &len);
 638
 639     SubstrBufFromWC str(ImplStr(sz, nCount));
 640
 641     return m_impl.compare(pos, len, str.data, str.len);
 642 }
 643
 644 #else // !HAVE_STD_STRING_COMPARE
 645
 646 static inline int wxDoCmp(const wxStringCharType* s1, size_t l1,
 647                           const wxStringCharType* s2, size_t l2)
 648 {
 649     if( l1 == l2 )
 650         return wxStringMemcmp(s1, s2, l1);
 651     else if( l1 < l2 )
 652     {
 653         int ret = wxStringMemcmp(s1, s2, l1);
 654         return ret == 0 ? -1 : ret;
 655     }
 656     else
 657     {
 658         int ret = wxStringMemcmp(s1, s2, l2);
 659         return ret == 0 ? +1 : ret;
 660     }
 661 }
 662
 663 int wxString::compare(const wxString& str) const
 664 {
 665     return ::wxDoCmp(m_impl.data(), m_impl.length(),
 666                      str.m_impl.data(), str.m_impl.length());
 667 }
 668
 669 int wxString::compare(size_t nStart, size_t nLen,
 670                       const wxString& str) const
 671 {
 672     wxASSERT(nStart <= length());
 673     size_type strLen = length() - nStart;
 674     nLen = strLen < nLen ? strLen : nLen;
 675
 676     size_t pos, len;
 677     PosLenToImpl(nStart, nLen, &pos, &len);
 678
 679     return ::wxDoCmp(m_impl.data() + pos,  len,
 680                      str.m_impl.data(), str.m_impl.length());
 681 }
 682
 683 int wxString::compare(size_t nStart, size_t nLen,
 684                       const wxString& str,
 685                       size_t nStart2, size_t nLen2) const
 686 {
 687     wxASSERT(nStart <= length());
 688     wxASSERT(nStart2 <= str.length());
 689     size_type strLen  =     length() - nStart,
 690               strLen2 = str.length() - nStart2;
 691     nLen  = strLen  < nLen  ? strLen  : nLen;
 692     nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
 693
 694     size_t pos, len;
 695     PosLenToImpl(nStart, nLen, &pos, &len);
 696     size_t pos2, len2;
 697     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 698
 699     return ::wxDoCmp(m_impl.data() + pos, len,
 700                      str.m_impl.data() + pos2, len2);
 701 }
 702
 703 int wxString::compare(const char* sz) const
 704 {
 705     SubstrBufFromMB str(ImplStr(sz, npos));
 706     if ( str.len == npos )
 707         str.len = wxStringStrlen(str.data);
 708     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 709 }
 710
 711 int wxString::compare(const wchar_t* sz) const
 712 {
 713     SubstrBufFromWC str(ImplStr(sz, npos));
 714     if ( str.len == npos )
 715         str.len = wxStringStrlen(str.data);
 716     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 717 }
 718
 719 int wxString::compare(size_t nStart, size_t nLen,
 720                       const char* sz, size_t nCount) const
 721 {
 722     wxASSERT(nStart <= length());
 723     size_type strLen = length() - nStart;
 724     nLen = strLen < nLen ? strLen : nLen;
 725
 726     size_t pos, len;
 727     PosLenToImpl(nStart, nLen, &pos, &len);
 728
 729     SubstrBufFromMB str(ImplStr(sz, nCount));
 730     if ( str.len == npos )
 731         str.len = wxStringStrlen(str.data);
 732
 733     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 734 }
 735
 736 int wxString::compare(size_t nStart, size_t nLen,
 737                       const wchar_t* sz, size_t nCount) const
 738 {
 739     wxASSERT(nStart <= length());
 740     size_type strLen = length() - nStart;
 741     nLen = strLen < nLen ? strLen : nLen;
 742
 743     size_t pos, len;
 744     PosLenToImpl(nStart, nLen, &pos, &len);
 745
 746     SubstrBufFromWC str(ImplStr(sz, nCount));
 747     if ( str.len == npos )
 748         str.len = wxStringStrlen(str.data);
 749
 750     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 751 }
 752
 753 #endif // HAVE_STD_STRING_COMPARE/!HAVE_STD_STRING_COMPARE
 754
 755
 756 // ---------------------------------------------------------------------------
 757 // find_{first,last}_[not]_of functions
 758 // ---------------------------------------------------------------------------
 759
 760 #if !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
 761
 762 // NB: All these functions are implemented  with the argument being wxChar*,
 763 //     i.e. widechar string in any Unicode build, even though native string
 764 //     representation is char* in the UTF-8 build. This is because we couldn't
 765 //     use memchr() to determine if a character is in a set encoded as UTF-8.
 766
 767 size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
 768 {
 769     return find_first_of(sz, nStart, wxStrlen(sz));
 770 }
 771
 772 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
 773 {
 774     return find_first_not_of(sz, nStart, wxStrlen(sz));
 775 }
 776
 777 size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
 778 {
 779     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 780
 781     size_t idx = nStart;
 782     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 783     {
 784         if ( wxTmemchr(sz, *i, n) )
 785             return idx;
 786     }
 787
 788     return npos;
 789 }
 790
 791 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
 792 {
 793     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 794
 795     size_t idx = nStart;
 796     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 797     {
 798         if ( !wxTmemchr(sz, *i, n) )
 799             return idx;
 800     }
 801
 802     return npos;
 803 }
 804
 805
 806 size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
 807 {
 808     return find_last_of(sz, nStart, wxStrlen(sz));
 809 }
 810
 811 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
 812 {
 813     return find_last_not_of(sz, nStart, wxStrlen(sz));
 814 }
 815
 816 size_t wxString::find_last_of(const wxChar* sz, size_t nStart, size_t n) const
 817 {
 818     size_t len = length();
 819
 820     if ( nStart == npos )
 821     {
 822         nStart = len - 1;
 823     }
 824     else
 825     {
 826         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 827     }
 828
 829     size_t idx = nStart;
 830     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 831           i != rend(); --idx, ++i )
 832     {
 833         if ( wxTmemchr(sz, *i, n) )
 834             return idx;
 835     }
 836
 837     return npos;
 838 }
 839
 840 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const
 841 {
 842     size_t len = length();
 843
 844     if ( nStart == npos )
 845     {
 846         nStart = len - 1;
 847     }
 848     else
 849     {
 850         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 851     }
 852
 853     size_t idx = nStart;
 854     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 855           i != rend(); --idx, ++i )
 856     {
 857         if ( !wxTmemchr(sz, *i, n) )
 858             return idx;
 859     }
 860
 861     return npos;
 862 }
 863
 864 size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
 865 {
 866     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 867
 868     size_t idx = nStart;
 869     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 870     {
 871         if ( *i != ch )
 872             return idx;
 873     }
 874
 875     return npos;
 876 }
 877
 878 size_t wxString::find_last_not_of(wxUniChar ch, size_t nStart) const
 879 {
 880     size_t len = length();
 881
 882     if ( nStart == npos )
 883     {
 884         nStart = len - 1;
 885     }
 886     else
 887     {
 888         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 889     }
 890
 891     size_t idx = nStart;
 892     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 893           i != rend(); --idx, ++i )
 894     {
 895         if ( *i != ch )
 896             return idx;
 897     }
 898
 899     return npos;
 900 }
 901
 902 // the functions above were implemented for wchar_t* arguments in Unicode
 903 // build and char* in ANSI build; below are implementations for the other
 904 // version:
 905 #if wxUSE_UNICODE
 906     #define wxOtherCharType char
 907     #define STRCONV         (const wxChar*)wxConvLibc.cMB2WC
 908 #else
 909     #define wxOtherCharType wchar_t
 910     #define STRCONV         (const wxChar*)wxConvLibc.cWC2MB
 911 #endif
 912
 913 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart) const
 914     { return find_first_of(STRCONV(sz), nStart); }
 915
 916 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart,
 917                                size_t n) const
 918     { return find_first_of(STRCONV(sz, n, NULL), nStart, n); }
 919 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart) const
 920     { return find_last_of(STRCONV(sz), nStart); }
 921 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart,
 922                               size_t n) const
 923     { return find_last_of(STRCONV(sz, n, NULL), nStart, n); }
 924 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart) const
 925     { return find_first_not_of(STRCONV(sz), nStart); }
 926 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart,
 927                                    size_t n) const
 928     { return find_first_not_of(STRCONV(sz, n, NULL), nStart, n); }
 929 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart) const
 930     { return find_last_not_of(STRCONV(sz), nStart); }
 931 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart,
 932                                   size_t n) const
 933     { return find_last_not_of(STRCONV(sz, n, NULL), nStart, n); }
 934
 935 #undef wxOtherCharType
 936 #undef STRCONV
 937
 938 #endif // !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
 939
 940 // ===========================================================================
 941 // other common string functions
 942 // ===========================================================================
 943
 944 int wxString::CmpNoCase(const wxString& s) const
 945 {
 946     // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
 947
 948     size_t idx = 0;
 949     const_iterator i1 = begin();
 950     const_iterator end1 = end();
 951     const_iterator i2 = s.begin();
 952     const_iterator end2 = s.end();
 953
 954     for ( ; i1 != end1 && i2 != end2; ++idx, ++i1, ++i2 )
 955     {
 956         wxUniChar lower1 = (wxChar)wxTolower(*i1);
 957         wxUniChar lower2 = (wxChar)wxTolower(*i2);
 958         if ( lower1 != lower2 )
 959             return lower1 < lower2 ? -1 : 1;
 960     }
 961
 962     size_t len1 = length();
 963     size_t len2 = s.length();
 964
 965     if ( len1 < len2 )
 966         return -1;
 967     else if ( len1 > len2 )
 968         return 1;
 969     return 0;
 970 }
 971
 972
 973 #if wxUSE_UNICODE
 974
 975 #ifdef __MWERKS__
 976 #ifndef __SCHAR_MAX__
 977 #define __SCHAR_MAX__ 127
 978 #endif
 979 #endif
 980
 981 wxString wxString::FromAscii(const char *ascii, size_t len)
 982 {
 983     if (!ascii || len == 0)
 984        return wxEmptyString;
 985
 986     wxString res;
 987
 988     {
 989         wxStringInternalBuffer buf(res, len);
 990         wxStringCharType *dest = buf;
 991
 992         for ( ; len > 0; --len )
 993         {
 994             unsigned char c = (unsigned char)*ascii++;
 995             wxASSERT_MSG( c < 0x80,
 996                           _T("Non-ASCII value passed to FromAscii().") );
 997
 998             *dest++ = (wchar_t)c;
 999         }
1000     }
1001
1002     return res;
1003 }
1004
1005 wxString wxString::FromAscii(const char *ascii)
1006 {
1007     return FromAscii(ascii, wxStrlen(ascii));
1008 }
1009
1010 wxString wxString::FromAscii(const char ascii)
1011 {
1012     // What do we do with '\0' ?
1013
1014     unsigned char c = (unsigned char)ascii;
1015
1016     wxASSERT_MSG( c < 0x80, _T("Non-ASCII value passed to FromAscii().") );
1017
1018     // NB: the cast to wchar_t causes interpretation of 'ascii' as Latin1 value
1019     return wxString(wxUniChar((wchar_t)c));
1020 }
1021
1022 const wxCharBuffer wxString::ToAscii() const
1023 {
1024     // this will allocate enough space for the terminating NUL too
1025     wxCharBuffer buffer(length());
1026     char *dest = buffer.data();
1027
1028     for ( const_iterator i = begin(); i != end(); ++i )
1029     {
1030         wxUniChar c(*i);
1031         // FIXME-UTF8: unify substituted char ('_') with wxUniChar ('?')
1032         *dest++ = c.IsAscii() ? (char)c : '_';
1033
1034         // the output string can't have embedded NULs anyhow, so we can safely
1035         // stop at first of them even if we do have any
1036         if ( !c )
1037             break;
1038     }
1039
1040     return buffer;
1041 }
1042
1043 #endif // wxUSE_UNICODE
1044
1045 // extract string of length nCount starting at nFirst
1046 wxString wxString::Mid(size_t nFirst, size_t nCount) const
1047 {
1048     size_t nLen = length();
1049
1050     // default value of nCount is npos and means "till the end"
1051     if ( nCount == npos )
1052     {
1053         nCount = nLen - nFirst;
1054     }
1055
1056     // out-of-bounds requests return sensible things
1057     if ( nFirst + nCount > nLen )
1058     {
1059         nCount = nLen - nFirst;
1060     }
1061
1062     if ( nFirst > nLen )
1063     {
1064         // AllocCopy() will return empty string
1065         return wxEmptyString;
1066     }
1067
1068     wxString dest(*this, nFirst, nCount);
1069     if ( dest.length() != nCount )
1070     {
1071         wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1072     }
1073
1074     return dest;
1075 }
1076
1077 // check that the string starts with prefix and return the rest of the string
1078 // in the provided pointer if it is not NULL, otherwise return false
1079 bool wxString::StartsWith(const wxString& prefix, wxString *rest) const
1080 {
1081     if ( compare(0, prefix.length(), prefix) != 0 )
1082         return false;
1083
1084     if ( rest )
1085     {
1086         // put the rest of the string into provided pointer
1087         rest->assign(*this, prefix.length(), npos);
1088     }
1089
1090     return true;
1091 }
1092
1093
1094 // check that the string ends with suffix and return the rest of it in the
1095 // provided pointer if it is not NULL, otherwise return false
1096 bool wxString::EndsWith(const wxString& suffix, wxString *rest) const
1097 {
1098     int start = length() - suffix.length();
1099
1100     if ( start < 0 || compare(start, npos, suffix) != 0 )
1101         return false;
1102
1103     if ( rest )
1104     {
1105         // put the rest of the string into provided pointer
1106         rest->assign(*this, 0, start);
1107     }
1108
1109     return true;
1110 }
1111
1112
1113 // extract nCount last (rightmost) characters
1114 wxString wxString::Right(size_t nCount) const
1115 {
1116   if ( nCount > length() )
1117     nCount = length();
1118
1119   wxString dest(*this, length() - nCount, nCount);
1120   if ( dest.length() != nCount ) {
1121     wxFAIL_MSG( _T("out of memory in wxString::Right") );
1122   }
1123   return dest;
1124 }
1125
1126 // get all characters after the last occurence of ch
1127 // (returns the whole string if ch not found)
1128 wxString wxString::AfterLast(wxUniChar ch) const
1129 {
1130   wxString str;
1131   int iPos = Find(ch, true);
1132   if ( iPos == wxNOT_FOUND )
1133     str = *this;
1134   else
1135     str = wx_str() + iPos + 1;
1136
1137   return str;
1138 }
1139
1140 // extract nCount first (leftmost) characters
1141 wxString wxString::Left(size_t nCount) const
1142 {
1143   if ( nCount > length() )
1144     nCount = length();
1145
1146   wxString dest(*this, 0, nCount);
1147   if ( dest.length() != nCount ) {
1148     wxFAIL_MSG( _T("out of memory in wxString::Left") );
1149   }
1150   return dest;
1151 }
1152
1153 // get all characters before the first occurence of ch
1154 // (returns the whole string if ch not found)
1155 wxString wxString::BeforeFirst(wxUniChar ch) const
1156 {
1157   int iPos = Find(ch);
1158   if ( iPos == wxNOT_FOUND ) iPos = length();
1159   return wxString(*this, 0, iPos);
1160 }
1161
1162 /// get all characters before the last occurence of ch
1163 /// (returns empty string if ch not found)
1164 wxString wxString::BeforeLast(wxUniChar ch) const
1165 {
1166   wxString str;
1167   int iPos = Find(ch, true);
1168   if ( iPos != wxNOT_FOUND && iPos != 0 )
1169     str = wxString(c_str(), iPos);
1170
1171   return str;
1172 }
1173
1174 /// get all characters after the first occurence of ch
1175 /// (returns empty string if ch not found)
1176 wxString wxString::AfterFirst(wxUniChar ch) const
1177 {
1178   wxString str;
1179   int iPos = Find(ch);
1180   if ( iPos != wxNOT_FOUND )
1181     str = wx_str() + iPos + 1;
1182
1183   return str;
1184 }
1185
1186 // replace first (or all) occurences of some substring with another one
1187 size_t wxString::Replace(const wxString& strOld,
1188                          const wxString& strNew, bool bReplaceAll)
1189 {
1190     // if we tried to replace an empty string we'd enter an infinite loop below
1191     wxCHECK_MSG( !strOld.empty(), 0,
1192                  _T("wxString::Replace(): invalid parameter") );
1193
1194     size_t uiCount = 0;   // count of replacements made
1195
1196     size_t uiOldLen = strOld.length();
1197     size_t uiNewLen = strNew.length();
1198
1199     size_t dwPos = 0;
1200
1201     while ( (*this)[dwPos] != wxT('\0') )
1202     {
1203         //DO NOT USE STRSTR HERE
1204         //this string can contain embedded null characters,
1205         //so strstr will function incorrectly
1206         dwPos = find(strOld, dwPos);
1207         if ( dwPos == npos )
1208             break;                  // exit the loop
1209         else
1210         {
1211             //replace this occurance of the old string with the new one
1212             replace(dwPos, uiOldLen, strNew, uiNewLen);
1213
1214             //move up pos past the string that was replaced
1215             dwPos += uiNewLen;
1216
1217             //increase replace count
1218             ++uiCount;
1219
1220             // stop now?
1221             if ( !bReplaceAll )
1222                 break;                  // exit the loop
1223         }
1224     }
1225
1226     return uiCount;
1227 }
1228
1229 bool wxString::IsAscii() const
1230 {
1231     for ( const_iterator i = begin(); i != end(); ++i )
1232     {
1233         if ( !(*i).IsAscii() )
1234             return false;
1235     }
1236
1237     return true;
1238 }
1239
1240 bool wxString::IsWord() const
1241 {
1242     for ( const_iterator i = begin(); i != end(); ++i )
1243     {
1244         if ( !wxIsalpha(*i) )
1245             return false;
1246     }
1247
1248     return true;
1249 }
1250
1251 bool wxString::IsNumber() const
1252 {
1253     if ( empty() )
1254         return true;
1255
1256     const_iterator i = begin();
1257
1258     if ( *i == _T('-') || *i == _T('+') )
1259         ++i;
1260
1261     for ( ; i != end(); ++i )
1262     {
1263         if ( !wxIsdigit(*i) )
1264             return false;
1265     }
1266
1267     return true;
1268 }
1269
1270 wxString wxString::Strip(stripType w) const
1271 {
1272     wxString s = *this;
1273     if ( w & leading ) s.Trim(false);
1274     if ( w & trailing ) s.Trim(true);
1275     return s;
1276 }
1277
1278 // ---------------------------------------------------------------------------
1279 // case conversion
1280 // ---------------------------------------------------------------------------
1281
1282 wxString& wxString::MakeUpper()
1283 {
1284   for ( iterator it = begin(), en = end(); it != en; ++it )
1285     *it = (wxChar)wxToupper(*it);
1286
1287   return *this;
1288 }
1289
1290 wxString& wxString::MakeLower()
1291 {
1292   for ( iterator it = begin(), en = end(); it != en; ++it )
1293     *it = (wxChar)wxTolower(*it);
1294
1295   return *this;
1296 }
1297
1298 // ---------------------------------------------------------------------------
1299 // trimming and padding
1300 // ---------------------------------------------------------------------------
1301
1302 // some compilers (VC++ 6.0 not to name them) return true for a call to
1303 // isspace('ê') in the C locale which seems to be broken to me, but we have to
1304 // live with this by checking that the character is a 7 bit one - even if this
1305 // may fail to detect some spaces (I don't know if Unicode doesn't have
1306 // space-like symbols somewhere except in the first 128 chars), it is arguably
1307 // still better than trimming away accented letters
1308 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
1309
1310 // trims spaces (in the sense of isspace) from left or right side
1311 wxString& wxString::Trim(bool bFromRight)
1312 {
1313     // first check if we're going to modify the string at all
1314     if ( !empty() &&
1315          (
1316           (bFromRight && wxSafeIsspace(GetChar(length() - 1))) ||
1317           (!bFromRight && wxSafeIsspace(GetChar(0u)))
1318          )
1319        )
1320     {
1321         if ( bFromRight )
1322         {
1323             // find last non-space character
1324             reverse_iterator psz = rbegin();
1325             while ( (psz != rend()) && wxSafeIsspace(*psz) )
1326                 psz++;
1327
1328             // truncate at trailing space start
1329             erase(psz.base(), end());
1330         }
1331         else
1332         {
1333             // find first non-space character
1334             iterator psz = begin();
1335             while ( (psz != end()) && wxSafeIsspace(*psz) )
1336                 psz++;
1337
1338             // fix up data and length
1339             erase(begin(), psz);
1340         }
1341     }
1342
1343     return *this;
1344 }
1345
1346 // adds nCount characters chPad to the string from either side
1347 wxString& wxString::Pad(size_t nCount, wxUniChar chPad, bool bFromRight)
1348 {
1349     wxString s(chPad, nCount);
1350
1351     if ( bFromRight )
1352         *this += s;
1353     else
1354     {
1355         s += *this;
1356         swap(s);
1357     }
1358
1359     return *this;
1360 }
1361
1362 // truncate the string
1363 wxString& wxString::Truncate(size_t uiLen)
1364 {
1365     if ( uiLen < length() )
1366     {
1367         erase(begin() + uiLen, end());
1368     }
1369     //else: nothing to do, string is already short enough
1370
1371     return *this;
1372 }
1373
1374 // ---------------------------------------------------------------------------
1375 // finding (return wxNOT_FOUND if not found and index otherwise)
1376 // ---------------------------------------------------------------------------
1377
1378 // find a character
1379 int wxString::Find(wxUniChar ch, bool bFromEnd) const
1380 {
1381     size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);
1382
1383     return (idx == npos) ? wxNOT_FOUND : (int)idx;
1384 }
1385
1386 // ----------------------------------------------------------------------------
1387 // conversion to numbers
1388 // ----------------------------------------------------------------------------
1389
1390 // The implementation of all the functions below is exactly the same so factor
1391 // it out. Note that number extraction works correctly on UTF-8 strings, so
1392 // we can use wxStringCharType and wx_str() for maximum efficiency.
1393
1394 #ifndef __WXWINCE__
1395     #define DO_IF_NOT_WINCE(x) x
1396 #else
1397     #define DO_IF_NOT_WINCE(x)
1398 #endif
1399
1400 #define WX_STRING_TO_INT_TYPE(val, base, func)                              \
1401     wxCHECK_MSG( val, false, _T("NULL output pointer") );                   \
1402     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );  \
1403                                                                             \
1404     DO_IF_NOT_WINCE( errno = 0; )                                           \
1405                                                                             \
1406     const wxStringCharType *start = wx_str();                               \
1407     wxStringCharType *end;                                                  \
1408     *val = func(start, &end, base);                                         \
1409                                                                             \
1410     /* return true only if scan was stopped by the terminating NUL and */   \
1411     /* if the string was not empty to start with and no under/overflow */   \
1412     /* occurred: */                                                         \
1413     return !*end && (end != start)                                          \
1414         DO_IF_NOT_WINCE( && (errno != ERANGE) )
1415
1416 bool wxString::ToLong(long *val, int base) const
1417 {
1418     WX_STRING_TO_INT_TYPE(val, base, wxStrtol);
1419 }
1420
1421 bool wxString::ToULong(unsigned long *val, int base) const
1422 {
1423     WX_STRING_TO_INT_TYPE(val, base, wxStrtoul);
1424 }
1425
1426 bool wxString::ToLongLong(wxLongLong_t *val, int base) const
1427 {
1428     WX_STRING_TO_INT_TYPE(val, base, wxStrtoll);
1429 }
1430
1431 bool wxString::ToULongLong(wxULongLong_t *val, int base) const
1432 {
1433     WX_STRING_TO_INT_TYPE(val, base, wxStrtoull);
1434 }
1435
1436 bool wxString::ToDouble(double *val) const
1437 {
1438     wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") );
1439
1440 #ifndef __WXWINCE__
1441     errno = 0;
1442 #endif
1443
1444     const wxChar *start = c_str();
1445     wxChar *end;
1446     *val = wxStrtod(start, &end);
1447
1448     // return true only if scan was stopped by the terminating NUL and if the
1449     // string was not empty to start with and no under/overflow occurred
1450     return !*end && (end != start)
1451 #ifndef __WXWINCE__
1452         && (errno != ERANGE)
1453 #endif
1454     ;
1455 }
1456
1457 // ---------------------------------------------------------------------------
1458 // formatted output
1459 // ---------------------------------------------------------------------------
1460
1461 #if !wxUSE_UTF8_LOCALE_ONLY
1462 /* static */
1463 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1464 wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...)
1465 #else
1466 wxString wxString::DoFormatWchar(const wxChar *format, ...)
1467 #endif
1468 {
1469     va_list argptr;
1470     va_start(argptr, format);
1471
1472     wxString s;
1473     s.PrintfV(format, argptr);
1474
1475     va_end(argptr);
1476
1477     return s;
1478 }
1479 #endif // !wxUSE_UTF8_LOCALE_ONLY
1480
1481 #if wxUSE_UNICODE_UTF8
1482 /* static */
1483 wxString wxString::DoFormatUtf8(const char *format, ...)
1484 {
1485     va_list argptr;
1486     va_start(argptr, format);
1487
1488     wxString s;
1489     s.PrintfV(format, argptr);
1490
1491     va_end(argptr);
1492
1493     return s;
1494 }
1495 #endif // wxUSE_UNICODE_UTF8
1496
1497 /* static */
1498 wxString wxString::FormatV(const wxString& format, va_list argptr)
1499 {
1500     wxString s;
1501     s.PrintfV(format, argptr);
1502     return s;
1503 }
1504
1505 #if !wxUSE_UTF8_LOCALE_ONLY
1506 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1507 int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...)
1508 #else
1509 int wxString::DoPrintfWchar(const wxChar *format, ...)
1510 #endif
1511 {
1512     va_list argptr;
1513     va_start(argptr, format);
1514
1515 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1516     // get a pointer to the wxString instance; we have to use dynamic_cast<>
1517     // because it's the only cast that works safely for downcasting when
1518     // multiple inheritance is used:
1519     wxString *str = static_cast<wxString*>(this);
1520 #else
1521     wxString *str = this;
1522 #endif
1523
1524     int iLen = str->PrintfV(format, argptr);
1525
1526     va_end(argptr);
1527
1528     return iLen;
1529 }
1530 #endif // !wxUSE_UTF8_LOCALE_ONLY
1531
1532 #if wxUSE_UNICODE_UTF8
1533 int wxString::DoPrintfUtf8(const char *format, ...)
1534 {
1535     va_list argptr;
1536     va_start(argptr, format);
1537
1538     int iLen = PrintfV(format, argptr);
1539
1540     va_end(argptr);
1541
1542     return iLen;
1543 }
1544 #endif // wxUSE_UNICODE_UTF8
1545
1546 #if wxUSE_UNICODE_UTF8
1547 template<typename BufferType>
1548 #else
1549 // we only need one version in non-UTF8 builds and at least two Windows
1550 // compilers have problems with this function template, so use just one
1551 // normal function here
1552 #endif
1553 static int DoStringPrintfV(wxString& str,
1554                            const wxString& format, va_list argptr)
1555 {
1556     int size = 1024;
1557
1558     for ( ;; )
1559     {
1560 #if wxUSE_UNICODE_UTF8
1561         BufferType tmp(str, size + 1);
1562         typename BufferType::CharType *buf = tmp;
1563 #else
1564         wxStringBuffer tmp(str, size + 1);
1565         wxChar *buf = tmp;
1566 #endif
1567
1568         if ( !buf )
1569         {
1570             // out of memory
1571
1572             // in UTF-8 build, leaving uninitialized junk in the buffer
1573             // could result in invalid non-empty UTF-8 string, so just
1574             // reset the string to empty on failure:
1575             buf[0] = '\0';
1576             return -1;
1577         }
1578
1579         // wxVsnprintf() may modify the original arg pointer, so pass it
1580         // only a copy
1581         va_list argptrcopy;
1582         wxVaCopy(argptrcopy, argptr);
1583         int len = wxVsnprintf(buf, size, format, argptrcopy);
1584         va_end(argptrcopy);
1585
1586         // some implementations of vsnprintf() don't NUL terminate
1587         // the string if there is not enough space for it so
1588         // always do it manually
1589         buf[size] = _T('\0');
1590
1591         // vsnprintf() may return either -1 (traditional Unix behaviour) or the
1592         // total number of characters which would have been written if the
1593         // buffer were large enough (newer standards such as Unix98)
1594         if ( len < 0 )
1595         {
1596             // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or
1597             //     wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF
1598             //     is true if *both* of them use our own implementation,
1599             //     otherwise we can't be sure
1600 #if wxUSE_WXVSNPRINTF
1601             // we know that our own implementation of wxVsnprintf() returns -1
1602             // only for a format error - thus there's something wrong with
1603             // the user's format string
1604             buf[0] = '\0';
1605             return -1;
1606 #else // possibly using system version
1607             // assume it only returns error if there is not enough space, but
1608             // as we don't know how much we need, double the current size of
1609             // the buffer
1610             size *= 2;
1611 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
1612         }
1613         else if ( len >= size )
1614         {
1615 #if wxUSE_WXVSNPRINTF
1616             // we know that our own implementation of wxVsnprintf() returns
1617             // size+1 when there's not enough space but that's not the size
1618             // of the required buffer!
1619             size *= 2;      // so we just double the current size of the buffer
1620 #else
1621             // some vsnprintf() implementations NUL-terminate the buffer and
1622             // some don't in len == size case, to be safe always add 1
1623             size = len + 1;
1624 #endif
1625         }
1626         else // ok, there was enough space
1627         {
1628             break;
1629         }
1630     }
1631
1632     // we could have overshot
1633     str.Shrink();
1634
1635     return str.length();
1636 }
1637
1638 int wxString::PrintfV(const wxString& format, va_list argptr)
1639 {
1640 #if wxUSE_UNICODE_UTF8
1641     #if wxUSE_STL_BASED_WXSTRING
1642         typedef wxStringTypeBuffer<char> Utf8Buffer;
1643     #else
1644         typedef wxStringInternalBuffer Utf8Buffer;
1645     #endif
1646 #endif
1647
1648 #if wxUSE_UTF8_LOCALE_ONLY
1649     return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
1650 #else
1651     #if wxUSE_UNICODE_UTF8
1652     if ( wxLocaleIsUtf8 )
1653         return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
1654     else
1655         // wxChar* version
1656         return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);
1657     #else
1658         return DoStringPrintfV(*this, format, argptr);
1659     #endif // UTF8/WCHAR
1660 #endif
1661 }
1662
1663 // ----------------------------------------------------------------------------
1664 // misc other operations
1665 // ----------------------------------------------------------------------------
1666
1667 // returns true if the string matches the pattern which may contain '*' and
1668 // '?' metacharacters (as usual, '?' matches any character and '*' any number
1669 // of them)
1670 bool wxString::Matches(const wxString& mask) const
1671 {
1672     // I disable this code as it doesn't seem to be faster (in fact, it seems
1673     // to be much slower) than the old, hand-written code below and using it
1674     // here requires always linking with libregex even if the user code doesn't
1675     // use it
1676 #if 0 // wxUSE_REGEX
1677     // first translate the shell-like mask into a regex
1678     wxString pattern;
1679     pattern.reserve(wxStrlen(pszMask));
1680
1681     pattern += _T('^');
1682     while ( *pszMask )
1683     {
1684         switch ( *pszMask )
1685         {
1686             case _T('?'):
1687                 pattern += _T('.');
1688                 break;
1689
1690             case _T('*'):
1691                 pattern += _T(".*");
1692                 break;
1693
1694             case _T('^'):
1695             case _T('.'):
1696             case _T('$'):
1697             case _T('('):
1698             case _T(')'):
1699             case _T('|'):
1700             case _T('+'):
1701             case _T('\\'):
1702                 // these characters are special in a RE, quote them
1703                 // (however note that we don't quote '[' and ']' to allow
1704                 // using them for Unix shell like matching)
1705                 pattern += _T('\\');
1706                 // fall through
1707
1708             default:
1709                 pattern += *pszMask;
1710         }
1711
1712         pszMask++;
1713     }
1714     pattern += _T('$');
1715
1716     // and now use it
1717     return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
1718 #else // !wxUSE_REGEX
1719   // TODO: this is, of course, awfully inefficient...
1720
1721   // FIXME-UTF8: implement using iterators, remove #if
1722 #if wxUSE_UNICODE_UTF8
1723   wxWCharBuffer maskBuf = mask.wc_str();
1724   wxWCharBuffer txtBuf = wc_str();
1725   const wxChar *pszMask = maskBuf.data();
1726   const wxChar *pszTxt = txtBuf.data();
1727 #else
1728   const wxChar *pszMask = mask.wx_str();
1729   // the char currently being checked
1730   const wxChar *pszTxt = wx_str();
1731 #endif
1732
1733   // the last location where '*' matched
1734   const wxChar *pszLastStarInText = NULL;
1735   const wxChar *pszLastStarInMask = NULL;
1736
1737 match:
1738   for ( ; *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
1739     switch ( *pszMask ) {
1740       case wxT('?'):
1741         if ( *pszTxt == wxT('\0') )
1742           return false;
1743
1744         // pszTxt and pszMask will be incremented in the loop statement
1745
1746         break;
1747
1748       case wxT('*'):
1749         {
1750           // remember where we started to be able to backtrack later
1751           pszLastStarInText = pszTxt;
1752           pszLastStarInMask = pszMask;
1753
1754           // ignore special chars immediately following this one
1755           // (should this be an error?)
1756           while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
1757             pszMask++;
1758
1759           // if there is nothing more, match
1760           if ( *pszMask == wxT('\0') )
1761             return true;
1762
1763           // are there any other metacharacters in the mask?
1764           size_t uiLenMask;
1765           const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
1766
1767           if ( pEndMask != NULL ) {
1768             // we have to match the string between two metachars
1769             uiLenMask = pEndMask - pszMask;
1770           }
1771           else {
1772             // we have to match the remainder of the string
1773             uiLenMask = wxStrlen(pszMask);
1774           }
1775
1776           wxString strToMatch(pszMask, uiLenMask);
1777           const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
1778           if ( pMatch == NULL )
1779             return false;
1780
1781           // -1 to compensate "++" in the loop
1782           pszTxt = pMatch + uiLenMask - 1;
1783           pszMask += uiLenMask - 1;
1784         }
1785         break;
1786
1787       default:
1788         if ( *pszMask != *pszTxt )
1789           return false;
1790         break;
1791     }
1792   }
1793
1794   // match only if nothing left
1795   if ( *pszTxt == wxT('\0') )
1796     return true;
1797
1798   // if we failed to match, backtrack if we can
1799   if ( pszLastStarInText ) {
1800     pszTxt = pszLastStarInText + 1;
1801     pszMask = pszLastStarInMask;
1802
1803     pszLastStarInText = NULL;
1804
1805     // don't bother resetting pszLastStarInMask, it's unnecessary
1806
1807     goto match;
1808   }
1809
1810   return false;
1811 #endif // wxUSE_REGEX/!wxUSE_REGEX
1812 }
1813
1814 // Count the number of chars
1815 int wxString::Freq(wxUniChar ch) const
1816 {
1817     int count = 0;
1818     for ( const_iterator i = begin(); i != end(); ++i )
1819     {
1820         if ( *i == ch )
1821             count ++;
1822     }
1823     return count;
1824 }
1825
1826 // convert to upper case, return the copy of the string
1827 wxString wxString::Upper() const
1828 { wxString s(*this); return s.MakeUpper(); }
1829
1830 // convert to lower case, return the copy of the string
1831 wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }
1832
1833 // ----------------------------------------------------------------------------
1834 // wxUTF8StringBuffer
1835 // ----------------------------------------------------------------------------
1836
1837 #if wxUSE_UNICODE_WCHAR
1838 wxUTF8StringBuffer::~wxUTF8StringBuffer()
1839 {
1840     wxMBConvStrictUTF8 conv;
1841     size_t wlen = conv.ToWChar(NULL, 0, m_buf);
1842     wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );
1843
1844     wxStringInternalBuffer wbuf(m_str, wlen);
1845     conv.ToWChar(wbuf, wlen, m_buf);
1846 }
1847
1848 wxUTF8StringBufferLength::~wxUTF8StringBufferLength()
1849 {
1850     wxCHECK_RET(m_lenSet, "length not set");
1851
1852     wxMBConvStrictUTF8 conv;
1853     size_t wlen = conv.ToWChar(NULL, 0, m_buf, m_len);
1854     wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );
1855
1856     wxStringInternalBufferLength wbuf(m_str, wlen);
1857     conv.ToWChar(wbuf, wlen, m_buf, m_len);
1858     wbuf.SetLength(wlen);
1859 }
1860 #endif // wxUSE_UNICODE_WCHAR