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  * About ref counting:
  15  *  1) all empty strings use g_strEmpty, nRefs = -1 (set in Init())
  16  *  2) AllocBuffer() sets nRefs to 1, Lock() increments it by one
  17  *  3) Unlock() decrements nRefs and frees memory if it goes to 0
  18  */
  19
  20 // ===========================================================================
  21 // headers, declarations, constants
  22 // ===========================================================================
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/string.h"
  33 #endif
  34
  35 #include <ctype.h>
  36
  37 #ifndef __WXWINCE__
  38     #include <errno.h>
  39 #endif
  40
  41 #include <string.h>
  42 #include <stdlib.h>
  43
  44 #ifdef __SALFORDC__
  45     #include <clib.h>
  46 #endif
  47
  48
  49 // string handling functions used by wxString:
  50 #if wxUSE_UNICODE_UTF8
  51     #define wxStringMemcpy   memcpy
  52     #define wxStringMemcmp   memcmp
  53     #define wxStringMemchr   memchr
  54     #define wxStringStrlen   strlen
  55 #else
  56     #define wxStringMemcpy   wxTmemcpy
  57     #define wxStringMemcmp   wxTmemcmp
  58     #define wxStringMemchr   wxTmemchr
  59     #define wxStringStrlen   wxStrlen
  60 #endif
  61
  62
  63 // ---------------------------------------------------------------------------
  64 // static class variables definition
  65 // ---------------------------------------------------------------------------
  66
  67 //According to STL _must_ be a -1 size_t
  68 const size_t wxString::npos = (size_t) -1;
  69
  70 // ----------------------------------------------------------------------------
  71 // global functions
  72 // ----------------------------------------------------------------------------
  73
  74 #if wxUSE_STD_IOSTREAM
  75
  76 #include <iostream>
  77
  78 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
  79 {
  80 // FIXME-UTF8: always, not only if wxUSE_UNICODE
  81 #if wxUSE_UNICODE && !defined(__BORLANDC__)
  82     return os << str.AsWChar();
  83 #else
  84     return os << str.AsChar();
  85 #endif
  86 }
  87
  88 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
  89 {
  90     return os << str.c_str();
  91 }
  92
  93 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCharBuffer& str)
  94 {
  95     return os << str.data();
  96 }
  97
  98 #ifndef __BORLANDC__
  99 wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
 100 {
 101     return os << str.data();
 102 }
 103 #endif
 104
 105 #endif // wxUSE_STD_IOSTREAM
 106
 107 // ===========================================================================
 108 // wxString class core
 109 // ===========================================================================
 110
 111 // ---------------------------------------------------------------------------
 112 // construction and conversion
 113 // ---------------------------------------------------------------------------
 114
 115 #if wxUSE_UNICODE
 116 /* static */
 117 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 118                                                const wxMBConv& conv)
 119 {
 120     // anything to do?
 121     if ( !psz || nLength == 0 )
 122         return SubstrBufFromMB();
 123
 124     if ( nLength == npos )
 125         nLength = wxNO_LEN;
 126
 127     size_t wcLen;
 128     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
 129     if ( !wcLen )
 130         return SubstrBufFromMB();
 131     else
 132         return SubstrBufFromMB(wcBuf, wcLen);
 133 }
 134 #else
 135 /* static */
 136 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
 137                                                const wxMBConv& conv)
 138 {
 139     // anything to do?
 140     if ( !pwz || nLength == 0 )
 141         return SubstrBufFromWC();
 142
 143     if ( nLength == npos )
 144         nLength = wxNO_LEN;
 145
 146     size_t mbLen;
 147     wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
 148     if ( !mbLen )
 149         return SubstrBufFromWC();
 150     else
 151         return SubstrBufFromWC(mbBuf, mbLen);
 152 }
 153 #endif
 154
 155
 156 #if wxUSE_UNICODE
 157
 158 //Convert wxString in Unicode mode to a multi-byte string
 159 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 160 {
 161     return conv.cWC2MB(c_str(), length() + 1 /* size, not length */, NULL);
 162 }
 163
 164 #else // ANSI
 165
 166 #if wxUSE_WCHAR_T
 167
 168 //Converts this string to a wide character string if unicode
 169 //mode is not enabled and wxUSE_WCHAR_T is enabled
 170 const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const
 171 {
 172     return conv.cMB2WC(c_str(), length() + 1 /* size, not length */, NULL);
 173 }
 174
 175 #endif // wxUSE_WCHAR_T
 176
 177 #endif // Unicode/ANSI
 178
 179 // shrink to minimal size (releasing extra memory)
 180 bool wxString::Shrink()
 181 {
 182   wxString tmp(begin(), end());
 183   swap(tmp);
 184   return tmp.length() == length();
 185 }
 186
 187 // deprecated compatibility code:
 188 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 189 wxChar *wxString::GetWriteBuf(size_t nLen)
 190 {
 191     return DoGetWriteBuf(nLen);
 192 }
 193
 194 void wxString::UngetWriteBuf()
 195 {
 196     DoUngetWriteBuf();
 197 }
 198
 199 void wxString::UngetWriteBuf(size_t nLen)
 200 {
 201     DoUngetWriteBuf(nLen);
 202 }
 203 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 204
 205
 206 // ---------------------------------------------------------------------------
 207 // data access
 208 // ---------------------------------------------------------------------------
 209
 210 // all functions are inline in string.h
 211
 212 // ---------------------------------------------------------------------------
 213 // concatenation operators
 214 // ---------------------------------------------------------------------------
 215
 216 /*
 217  * concatenation functions come in 5 flavours:
 218  *  string + string
 219  *  char   + string      and      string + char
 220  *  C str  + string      and      string + C str
 221  */
 222
 223 wxString operator+(const wxString& str1, const wxString& str2)
 224 {
 225 #if !wxUSE_STL_BASED_WXSTRING
 226     wxASSERT( str1.IsValid() );
 227     wxASSERT( str2.IsValid() );
 228 #endif
 229
 230     wxString s = str1;
 231     s += str2;
 232
 233     return s;
 234 }
 235
 236 wxString operator+(const wxString& str, wxUniChar ch)
 237 {
 238 #if !wxUSE_STL_BASED_WXSTRING
 239     wxASSERT( str.IsValid() );
 240 #endif
 241
 242     wxString s = str;
 243     s += ch;
 244
 245     return s;
 246 }
 247
 248 wxString operator+(wxUniChar ch, const wxString& str)
 249 {
 250 #if !wxUSE_STL_BASED_WXSTRING
 251     wxASSERT( str.IsValid() );
 252 #endif
 253
 254     wxString s = ch;
 255     s += str;
 256
 257     return s;
 258 }
 259
 260 wxString operator+(const wxString& str, const char *psz)
 261 {
 262 #if !wxUSE_STL_BASED_WXSTRING
 263     wxASSERT( str.IsValid() );
 264 #endif
 265
 266     wxString s;
 267     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 268         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 269     }
 270     s += str;
 271     s += psz;
 272
 273     return s;
 274 }
 275
 276 wxString operator+(const wxString& str, const wchar_t *pwz)
 277 {
 278 #if !wxUSE_STL_BASED_WXSTRING
 279     wxASSERT( str.IsValid() );
 280 #endif
 281
 282     wxString s;
 283     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 284         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 285     }
 286     s += str;
 287     s += pwz;
 288
 289     return s;
 290 }
 291
 292 wxString operator+(const char *psz, const wxString& str)
 293 {
 294 #if !wxUSE_STL_BASED_WXSTRING
 295     wxASSERT( str.IsValid() );
 296 #endif
 297
 298     wxString s;
 299     if ( !s.Alloc(strlen(psz) + str.length()) ) {
 300         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 301     }
 302     s = psz;
 303     s += str;
 304
 305     return s;
 306 }
 307
 308 wxString operator+(const wchar_t *pwz, const wxString& str)
 309 {
 310 #if !wxUSE_STL_BASED_WXSTRING
 311     wxASSERT( str.IsValid() );
 312 #endif
 313
 314     wxString s;
 315     if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
 316         wxFAIL_MSG( _T("out of memory in wxString::operator+") );
 317     }
 318     s = pwz;
 319     s += str;
 320
 321     return s;
 322 }
 323
 324 // ---------------------------------------------------------------------------
 325 // string comparison
 326 // ---------------------------------------------------------------------------
 327
 328 #ifdef HAVE_STD_STRING_COMPARE
 329
 330 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
 331 //     UTF-8 encoded strings too, thanks to UTF-8's design which allows us to
 332 //     sort strings in characters code point order by sorting the byte sequence
 333 //     in byte values order (i.e. what strcmp() and memcmp() do).
 334
 335 int wxString::compare(const wxString& str) const
 336 {
 337     return m_impl.compare(str.m_impl);
 338 }
 339
 340 int wxString::compare(size_t nStart, size_t nLen,
 341                       const wxString& str) const
 342 {
 343     size_t pos, len;
 344     PosLenToImpl(nStart, nLen, &pos, &len);
 345     return m_impl.compare(pos, len, str.m_impl);
 346 }
 347
 348 int wxString::compare(size_t nStart, size_t nLen,
 349                       const wxString& str,
 350                       size_t nStart2, size_t nLen2) const
 351 {
 352     size_t pos, len;
 353     PosLenToImpl(nStart, nLen, &pos, &len);
 354
 355     size_t pos2, len2;
 356     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 357
 358     return m_impl.compare(pos, len, str.m_impl, pos2, len2);
 359 }
 360
 361 int wxString::compare(const char* sz) const
 362 {
 363     return m_impl.compare(ImplStr(sz));
 364 }
 365
 366 int wxString::compare(const wchar_t* sz) const
 367 {
 368     return m_impl.compare(ImplStr(sz));
 369 }
 370
 371 int wxString::compare(size_t nStart, size_t nLen,
 372                       const char* sz, size_t nCount) const
 373 {
 374     size_t pos, len;
 375     PosLenToImpl(nStart, nLen, &pos, &len);
 376
 377     SubstrBufFromMB str(ImplStr(sz, nCount));
 378
 379     return m_impl.compare(pos, len, str.data, str.len);
 380 }
 381
 382 int wxString::compare(size_t nStart, size_t nLen,
 383                       const wchar_t* sz, size_t nCount) const
 384 {
 385     size_t pos, len;
 386     PosLenToImpl(nStart, nLen, &pos, &len);
 387
 388     SubstrBufFromWC str(ImplStr(sz, nCount));
 389
 390     return m_impl.compare(pos, len, str.data, str.len);
 391 }
 392
 393 #else // !HAVE_STD_STRING_COMPARE
 394
 395 static inline int wxDoCmp(const wxStringCharType* s1, size_t l1,
 396                           const wxStringCharType* s2, size_t l2)
 397 {
 398     if( l1 == l2 )
 399         return wxStringMemcmp(s1, s2, l1);
 400     else if( l1 < l2 )
 401     {
 402         int ret = wxStringMemcmp(s1, s2, l1);
 403         return ret == 0 ? -1 : ret;
 404     }
 405     else
 406     {
 407         int ret = wxStringMemcmp(s1, s2, l2);
 408         return ret == 0 ? +1 : ret;
 409     }
 410 }
 411
 412 int wxString::compare(const wxString& str) const
 413 {
 414     return ::wxDoCmp(m_impl.data(), m_impl.length(),
 415                      str.m_impl.data(), str.m_impl.length());
 416 }
 417
 418 int wxString::compare(size_t nStart, size_t nLen,
 419                       const wxString& str) const
 420 {
 421     wxASSERT(nStart <= length());
 422     size_type strLen = length() - nStart;
 423     nLen = strLen < nLen ? strLen : nLen;
 424
 425     size_t pos, len;
 426     PosLenToImpl(nStart, nLen, &pos, &len);
 427
 428     return ::wxDoCmp(m_impl.data() + pos,  len,
 429                      str.m_impl.data(), str.m_impl.length());
 430 }
 431
 432 int wxString::compare(size_t nStart, size_t nLen,
 433                       const wxString& str,
 434                       size_t nStart2, size_t nLen2) const
 435 {
 436     wxASSERT(nStart <= length());
 437     wxASSERT(nStart2 <= str.length());
 438     size_type strLen  =     length() - nStart,
 439               strLen2 = str.length() - nStart2;
 440     nLen  = strLen  < nLen  ? strLen  : nLen;
 441     nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
 442
 443     size_t pos, len;
 444     PosLenToImpl(nStart, nLen, &pos, &len);
 445     size_t pos2, len2;
 446     str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
 447
 448     return ::wxDoCmp(m_impl.data() + pos, len,
 449                      str.m_impl.data() + pos2, len2);
 450 }
 451
 452 int wxString::compare(const char* sz) const
 453 {
 454     SubstrBufFromMB str(ImplStr(sz, npos));
 455     if ( str.len == npos )
 456         str.len = wxStringStrlen(str.data);
 457     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 458 }
 459
 460 int wxString::compare(const wchar_t* sz) const
 461 {
 462     SubstrBufFromWC str(ImplStr(sz, npos));
 463     if ( str.len == npos )
 464         str.len = wxStringStrlen(str.data);
 465     return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
 466 }
 467
 468 int wxString::compare(size_t nStart, size_t nLen,
 469                       const char* sz, size_t nCount) const
 470 {
 471     wxASSERT(nStart <= length());
 472     size_type strLen = length() - nStart;
 473     nLen = strLen < nLen ? strLen : nLen;
 474
 475     size_t pos, len;
 476     PosLenToImpl(nStart, nLen, &pos, &len);
 477
 478     SubstrBufFromMB str(ImplStr(sz, nCount));
 479     if ( str.len == npos )
 480         str.len = wxStringStrlen(str.data);
 481
 482     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 483 }
 484
 485 int wxString::compare(size_t nStart, size_t nLen,
 486                       const wchar_t* sz, size_t nCount) const
 487 {
 488     wxASSERT(nStart <= length());
 489     size_type strLen = length() - nStart;
 490     nLen = strLen < nLen ? strLen : nLen;
 491
 492     size_t pos, len;
 493     PosLenToImpl(nStart, nLen, &pos, &len);
 494
 495     SubstrBufFromWC str(ImplStr(sz, nCount));
 496     if ( str.len == npos )
 497         str.len = wxStringStrlen(str.data);
 498
 499     return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
 500 }
 501
 502 #endif // HAVE_STD_STRING_COMPARE/!HAVE_STD_STRING_COMPARE
 503
 504
 505 // ---------------------------------------------------------------------------
 506 // find_{first,last}_[not]_of functions
 507 // ---------------------------------------------------------------------------
 508
 509 #if !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
 510
 511 // NB: All these functions are implemented  with the argument being wxChar*,
 512 //     i.e. widechar string in any Unicode build, even though native string
 513 //     representation is char* in the UTF-8 build. This is because we couldn't
 514 //     use memchr() to determine if a character is in a set encoded as UTF-8.
 515
 516 size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
 517 {
 518     return find_first_of(sz, nStart, wxStrlen(sz));
 519 }
 520
 521 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
 522 {
 523     return find_first_not_of(sz, nStart, wxStrlen(sz));
 524 }
 525
 526 size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
 527 {
 528     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 529
 530     size_t idx = nStart;
 531     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 532     {
 533         if ( wxTmemchr(sz, *i, n) )
 534             return idx;
 535     }
 536
 537     return npos;
 538 }
 539
 540 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
 541 {
 542     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 543
 544     size_t idx = nStart;
 545     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 546     {
 547         if ( !wxTmemchr(sz, *i, n) )
 548             return idx;
 549     }
 550
 551     return npos;
 552 }
 553
 554
 555 size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
 556 {
 557     return find_last_of(sz, nStart, wxStrlen(sz));
 558 }
 559
 560 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
 561 {
 562     return find_last_not_of(sz, nStart, wxStrlen(sz));
 563 }
 564
 565 size_t wxString::find_last_of(const wxChar* sz, size_t nStart, size_t n) const
 566 {
 567     size_t len = length();
 568
 569     if ( nStart == npos )
 570     {
 571         nStart = len - 1;
 572     }
 573     else
 574     {
 575         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 576     }
 577
 578     size_t idx = nStart;
 579     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 580           i != rend(); --idx, ++i )
 581     {
 582         if ( wxTmemchr(sz, *i, n) )
 583             return idx;
 584     }
 585
 586     return npos;
 587 }
 588
 589 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const
 590 {
 591     size_t len = length();
 592
 593     if ( nStart == npos )
 594     {
 595         nStart = len - 1;
 596     }
 597     else
 598     {
 599         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 600     }
 601
 602     size_t idx = nStart;
 603     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 604           i != rend(); --idx, ++i )
 605     {
 606         if ( !wxTmemchr(sz, *i, n) )
 607             return idx;
 608     }
 609
 610     return npos;
 611 }
 612
 613 size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
 614 {
 615     wxASSERT_MSG( nStart <= length(),  _T("invalid index") );
 616
 617     size_t idx = nStart;
 618     for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
 619     {
 620         if ( *i != ch )
 621             return idx;
 622     }
 623
 624     return npos;
 625 }
 626
 627 size_t wxString::find_last_not_of(wxUniChar ch, size_t nStart) const
 628 {
 629     size_t len = length();
 630
 631     if ( nStart == npos )
 632     {
 633         nStart = len - 1;
 634     }
 635     else
 636     {
 637         wxASSERT_MSG( nStart <= len, _T("invalid index") );
 638     }
 639
 640     size_t idx = nStart;
 641     for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
 642           i != rend(); --idx, ++i )
 643     {
 644         if ( *i != ch )
 645             return idx;
 646     }
 647
 648     return npos;
 649 }
 650
 651 // the functions above were implemented for wchar_t* arguments in Unicode
 652 // build and char* in ANSI build; below are implementations for the other
 653 // version:
 654 #if wxUSE_UNICODE
 655     #define wxOtherCharType char
 656     #define STRCONV         (const wxChar*)wxConvLibc.cMB2WC
 657 #else
 658     #define wxOtherCharType wchar_t
 659     #define STRCONV         (const wxChar*)wxConvLibc.cWC2MB
 660 #endif
 661
 662 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart) const
 663     { return find_first_of(STRCONV(sz), nStart); }
 664
 665 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart,
 666                                size_t n) const
 667     { return find_first_of(STRCONV(sz, n, NULL), nStart, n); }
 668 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart) const
 669     { return find_last_of(STRCONV(sz), nStart); }
 670 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart,
 671                               size_t n) const
 672     { return find_last_of(STRCONV(sz, n, NULL), nStart, n); }
 673 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart) const
 674     { return find_first_not_of(STRCONV(sz), nStart); }
 675 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart,
 676                                    size_t n) const
 677     { return find_first_not_of(STRCONV(sz, n, NULL), nStart, n); }
 678 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart) const
 679     { return find_last_not_of(STRCONV(sz), nStart); }
 680 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart,
 681                                   size_t n) const
 682     { return find_last_not_of(STRCONV(sz, n, NULL), nStart, n); }
 683
 684 #undef wxOtherCharType
 685 #undef STRCONV
 686
 687 #endif // !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
 688
 689 // ===========================================================================
 690 // other common string functions
 691 // ===========================================================================
 692
 693 int wxString::CmpNoCase(const wxString& s) const
 694 {
 695     // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
 696
 697     size_t idx = 0;
 698     const_iterator i1 = begin();
 699     const_iterator end1 = end();
 700     const_iterator i2 = s.begin();
 701     const_iterator end2 = s.end();
 702
 703     for ( ; i1 != end1 && i2 != end2; ++idx, ++i1, ++i2 )
 704     {
 705         wxUniChar lower1 = (wxChar)wxTolower(*i1);
 706         wxUniChar lower2 = (wxChar)wxTolower(*i2);
 707         if ( lower1 != lower2 )
 708             return lower1 < lower2 ? -1 : 1;
 709     }
 710
 711     size_t len1 = length();
 712     size_t len2 = s.length();
 713
 714     if ( len1 < len2 )
 715         return -1;
 716     else if ( len1 > len2 )
 717         return 1;
 718     return 0;
 719 }
 720
 721
 722 #if wxUSE_UNICODE
 723
 724 #ifdef __MWERKS__
 725 #ifndef __SCHAR_MAX__
 726 #define __SCHAR_MAX__ 127
 727 #endif
 728 #endif
 729
 730 wxString wxString::FromAscii(const char *ascii)
 731 {
 732     if (!ascii)
 733        return wxEmptyString;
 734
 735     size_t len = strlen( ascii );
 736     wxString res;
 737
 738     if ( len )
 739     {
 740         wxStringBuffer buf(res, len);
 741
 742         wchar_t *dest = buf;
 743
 744         for ( ;; )
 745         {
 746            if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' )
 747                break;
 748         }
 749     }
 750
 751     return res;
 752 }
 753
 754 wxString wxString::FromAscii(const char ascii)
 755 {
 756     // What do we do with '\0' ?
 757
 758     wxString res;
 759     res += (wchar_t)(unsigned char) ascii;
 760
 761     return res;
 762 }
 763
 764 const wxCharBuffer wxString::ToAscii() const
 765 {
 766     // this will allocate enough space for the terminating NUL too
 767     wxCharBuffer buffer(length());
 768
 769
 770     char *dest = buffer.data();
 771
 772     const wchar_t *pwc = c_str();
 773     for ( ;; )
 774     {
 775         *dest++ = (char)(*pwc > SCHAR_MAX ? wxT('_') : *pwc);
 776
 777         // the output string can't have embedded NULs anyhow, so we can safely
 778         // stop at first of them even if we do have any
 779         if ( !*pwc++ )
 780             break;
 781     }
 782
 783     return buffer;
 784 }
 785
 786 #endif // Unicode
 787
 788 // extract string of length nCount starting at nFirst
 789 wxString wxString::Mid(size_t nFirst, size_t nCount) const
 790 {
 791     size_t nLen = length();
 792
 793     // default value of nCount is npos and means "till the end"
 794     if ( nCount == npos )
 795     {
 796         nCount = nLen - nFirst;
 797     }
 798
 799     // out-of-bounds requests return sensible things
 800     if ( nFirst + nCount > nLen )
 801     {
 802         nCount = nLen - nFirst;
 803     }
 804
 805     if ( nFirst > nLen )
 806     {
 807         // AllocCopy() will return empty string
 808         return wxEmptyString;
 809     }
 810
 811     wxString dest(*this, nFirst, nCount);
 812     if ( dest.length() != nCount )
 813     {
 814         wxFAIL_MSG( _T("out of memory in wxString::Mid") );
 815     }
 816
 817     return dest;
 818 }
 819
 820 // check that the string starts with prefix and return the rest of the string
 821 // in the provided pointer if it is not NULL, otherwise return false
 822 bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
 823 {
 824     wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
 825
 826     // first check if the beginning of the string matches the prefix: note
 827     // that we don't have to check that we don't run out of this string as
 828     // when we reach the terminating NUL, either prefix string ends too (and
 829     // then it's ok) or we break out of the loop because there is no match
 830     const wxChar *p = c_str();
 831     while ( *prefix )
 832     {
 833         if ( *prefix++ != *p++ )
 834         {
 835             // no match
 836             return false;
 837         }
 838     }
 839
 840     if ( rest )
 841     {
 842         // put the rest of the string into provided pointer
 843         *rest = p;
 844     }
 845
 846     return true;
 847 }
 848
 849
 850 // check that the string ends with suffix and return the rest of it in the
 851 // provided pointer if it is not NULL, otherwise return false
 852 bool wxString::EndsWith(const wxChar *suffix, wxString *rest) const
 853 {
 854     wxASSERT_MSG( suffix, _T("invalid parameter in wxString::EndssWith") );
 855
 856     int start = length() - wxStrlen(suffix);
 857     if ( start < 0 || wxStrcmp(wx_str() + start, suffix) != 0 )
 858         return false;
 859
 860     if ( rest )
 861     {
 862         // put the rest of the string into provided pointer
 863         rest->assign(*this, 0, start);
 864     }
 865
 866     return true;
 867 }
 868
 869
 870 // extract nCount last (rightmost) characters
 871 wxString wxString::Right(size_t nCount) const
 872 {
 873   if ( nCount > length() )
 874     nCount = length();
 875
 876   wxString dest(*this, length() - nCount, nCount);
 877   if ( dest.length() != nCount ) {
 878     wxFAIL_MSG( _T("out of memory in wxString::Right") );
 879   }
 880   return dest;
 881 }
 882
 883 // get all characters after the last occurence of ch
 884 // (returns the whole string if ch not found)
 885 wxString wxString::AfterLast(wxUniChar ch) const
 886 {
 887   wxString str;
 888   int iPos = Find(ch, true);
 889   if ( iPos == wxNOT_FOUND )
 890     str = *this;
 891   else
 892     str = wx_str() + iPos + 1;
 893
 894   return str;
 895 }
 896
 897 // extract nCount first (leftmost) characters
 898 wxString wxString::Left(size_t nCount) const
 899 {
 900   if ( nCount > length() )
 901     nCount = length();
 902
 903   wxString dest(*this, 0, nCount);
 904   if ( dest.length() != nCount ) {
 905     wxFAIL_MSG( _T("out of memory in wxString::Left") );
 906   }
 907   return dest;
 908 }
 909
 910 // get all characters before the first occurence of ch
 911 // (returns the whole string if ch not found)
 912 wxString wxString::BeforeFirst(wxUniChar ch) const
 913 {
 914   int iPos = Find(ch);
 915   if ( iPos == wxNOT_FOUND ) iPos = length();
 916   return wxString(*this, 0, iPos);
 917 }
 918
 919 /// get all characters before the last occurence of ch
 920 /// (returns empty string if ch not found)
 921 wxString wxString::BeforeLast(wxUniChar ch) const
 922 {
 923   wxString str;
 924   int iPos = Find(ch, true);
 925   if ( iPos != wxNOT_FOUND && iPos != 0 )
 926     str = wxString(c_str(), iPos);
 927
 928   return str;
 929 }
 930
 931 /// get all characters after the first occurence of ch
 932 /// (returns empty string if ch not found)
 933 wxString wxString::AfterFirst(wxUniChar ch) const
 934 {
 935   wxString str;
 936   int iPos = Find(ch);
 937   if ( iPos != wxNOT_FOUND )
 938     str = wx_str() + iPos + 1;
 939
 940   return str;
 941 }
 942
 943 // replace first (or all) occurences of some substring with another one
 944 size_t wxString::Replace(const wxString& strOld,
 945                          const wxString& strNew, bool bReplaceAll)
 946 {
 947     // if we tried to replace an empty string we'd enter an infinite loop below
 948     wxCHECK_MSG( !strOld.empty(), 0,
 949                  _T("wxString::Replace(): invalid parameter") );
 950
 951     size_t uiCount = 0;   // count of replacements made
 952
 953     size_t uiOldLen = strOld.length();
 954     size_t uiNewLen = strNew.length();
 955
 956     size_t dwPos = 0;
 957
 958     while ( (*this)[dwPos] != wxT('\0') )
 959     {
 960         //DO NOT USE STRSTR HERE
 961         //this string can contain embedded null characters,
 962         //so strstr will function incorrectly
 963         dwPos = find(strOld, dwPos);
 964         if ( dwPos == npos )
 965             break;                  // exit the loop
 966         else
 967         {
 968             //replace this occurance of the old string with the new one
 969             replace(dwPos, uiOldLen, strNew, uiNewLen);
 970
 971             //move up pos past the string that was replaced
 972             dwPos += uiNewLen;
 973
 974             //increase replace count
 975             ++uiCount;
 976
 977             // stop now?
 978             if ( !bReplaceAll )
 979                 break;                  // exit the loop
 980         }
 981     }
 982
 983     return uiCount;
 984 }
 985
 986 bool wxString::IsAscii() const
 987 {
 988   const wxChar *s = (const wxChar*) *this;
 989   while(*s){
 990     if(!isascii(*s)) return(false);
 991     s++;
 992   }
 993   return(true);
 994 }
 995
 996 bool wxString::IsWord() const
 997 {
 998   const wxChar *s = (const wxChar*) *this;
 999   while(*s){
1000     if(!wxIsalpha(*s)) return(false);
1001     s++;
1002   }
1003   return(true);
1004 }
1005
1006 bool wxString::IsNumber() const
1007 {
1008   const wxChar *s = (const wxChar*) *this;
1009   if (wxStrlen(s))
1010      if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++;
1011   while(*s){
1012     if(!wxIsdigit(*s)) return(false);
1013     s++;
1014   }
1015   return(true);
1016 }
1017
1018 wxString wxString::Strip(stripType w) const
1019 {
1020     wxString s = *this;
1021     if ( w & leading ) s.Trim(false);
1022     if ( w & trailing ) s.Trim(true);
1023     return s;
1024 }
1025
1026 // ---------------------------------------------------------------------------
1027 // case conversion
1028 // ---------------------------------------------------------------------------
1029
1030 wxString& wxString::MakeUpper()
1031 {
1032   for ( iterator it = begin(), en = end(); it != en; ++it )
1033     *it = (wxChar)wxToupper(*it);
1034
1035   return *this;
1036 }
1037
1038 wxString& wxString::MakeLower()
1039 {
1040   for ( iterator it = begin(), en = end(); it != en; ++it )
1041     *it = (wxChar)wxTolower(*it);
1042
1043   return *this;
1044 }
1045
1046 // ---------------------------------------------------------------------------
1047 // trimming and padding
1048 // ---------------------------------------------------------------------------
1049
1050 // some compilers (VC++ 6.0 not to name them) return true for a call to
1051 // isspace('ê') in the C locale which seems to be broken to me, but we have to
1052 // live with this by checking that the character is a 7 bit one - even if this
1053 // may fail to detect some spaces (I don't know if Unicode doesn't have
1054 // space-like symbols somewhere except in the first 128 chars), it is arguably
1055 // still better than trimming away accented letters
1056 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
1057
1058 // trims spaces (in the sense of isspace) from left or right side
1059 wxString& wxString::Trim(bool bFromRight)
1060 {
1061     // first check if we're going to modify the string at all
1062     if ( !empty() &&
1063          (
1064           (bFromRight && wxSafeIsspace(GetChar(length() - 1))) ||
1065           (!bFromRight && wxSafeIsspace(GetChar(0u)))
1066          )
1067        )
1068     {
1069         if ( bFromRight )
1070         {
1071             // find last non-space character
1072             reverse_iterator psz = rbegin();
1073             while ( (psz != rend()) && wxSafeIsspace(*psz) )
1074                 psz++;
1075
1076             // truncate at trailing space start
1077             erase(psz.base(), end());
1078         }
1079         else
1080         {
1081             // find first non-space character
1082             iterator psz = begin();
1083             while ( (psz != end()) && wxSafeIsspace(*psz) )
1084                 psz++;
1085
1086             // fix up data and length
1087             erase(begin(), psz);
1088         }
1089     }
1090
1091     return *this;
1092 }
1093
1094 // adds nCount characters chPad to the string from either side
1095 wxString& wxString::Pad(size_t nCount, wxUniChar chPad, bool bFromRight)
1096 {
1097     wxString s(chPad, nCount);
1098
1099     if ( bFromRight )
1100         *this += s;
1101     else
1102     {
1103         s += *this;
1104         swap(s);
1105     }
1106
1107     return *this;
1108 }
1109
1110 // truncate the string
1111 wxString& wxString::Truncate(size_t uiLen)
1112 {
1113     if ( uiLen < length() )
1114     {
1115         erase(begin() + uiLen, end());
1116     }
1117     //else: nothing to do, string is already short enough
1118
1119     return *this;
1120 }
1121
1122 // ---------------------------------------------------------------------------
1123 // finding (return wxNOT_FOUND if not found and index otherwise)
1124 // ---------------------------------------------------------------------------
1125
1126 // find a character
1127 int wxString::Find(wxUniChar ch, bool bFromEnd) const
1128 {
1129     size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);
1130
1131     return (idx == npos) ? wxNOT_FOUND : (int)idx;
1132 }
1133
1134 // ----------------------------------------------------------------------------
1135 // conversion to numbers
1136 // ----------------------------------------------------------------------------
1137
1138 // the implementation of all the functions below is exactly the same so factor
1139 // it out
1140
1141 template <typename T, typename F>
1142 bool wxStringToIntType(const wxChar *start,
1143                        T *val,
1144                        int base,
1145                        F func)
1146 {
1147     wxCHECK_MSG( val, false, _T("NULL output pointer") );
1148     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1149
1150 #ifndef __WXWINCE__
1151     errno = 0;
1152 #endif
1153
1154     wxChar *end;
1155     *val = (*func)(start, &end, base);
1156
1157     // return true only if scan was stopped by the terminating NUL and if the
1158     // string was not empty to start with and no under/overflow occurred
1159     return !*end && (end != start)
1160 #ifndef __WXWINCE__
1161         && (errno != ERANGE)
1162 #endif
1163     ;
1164 }
1165
1166 bool wxString::ToLong(long *val, int base) const
1167 {
1168     return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtol);
1169 }
1170
1171 bool wxString::ToULong(unsigned long *val, int base) const
1172 {
1173     return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoul);
1174 }
1175
1176 bool wxString::ToLongLong(wxLongLong_t *val, int base) const
1177 {
1178 #ifdef wxHAS_STRTOLL
1179     return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll);
1180 #else
1181     // TODO: implement this ourselves
1182     wxUnusedVar(val);
1183     wxUnusedVar(base);
1184     return false;
1185 #endif // wxHAS_STRTOLL
1186 }
1187
1188 bool wxString::ToULongLong(wxULongLong_t *val, int base) const
1189 {
1190 #ifdef wxHAS_STRTOLL
1191     return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull);
1192 #else
1193     // TODO: implement this ourselves
1194     wxUnusedVar(val);
1195     wxUnusedVar(base);
1196     return false;
1197 #endif
1198 }
1199
1200 bool wxString::ToDouble(double *val) const
1201 {
1202     wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") );
1203
1204 #ifndef __WXWINCE__
1205     errno = 0;
1206 #endif
1207
1208     const wxChar *start = c_str();
1209     wxChar *end;
1210     *val = wxStrtod(start, &end);
1211
1212     // return true only if scan was stopped by the terminating NUL and if the
1213     // string was not empty to start with and no under/overflow occurred
1214     return !*end && (end != start)
1215 #ifndef __WXWINCE__
1216         && (errno != ERANGE)
1217 #endif
1218     ;
1219 }
1220
1221 // ---------------------------------------------------------------------------
1222 // formatted output
1223 // ---------------------------------------------------------------------------
1224
1225 /* static */
1226 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1227 wxString wxStringPrintfMixinBase::DoFormat(const wxChar *format, ...)
1228 #else
1229 wxString wxString::DoFormat(const wxChar *format, ...)
1230 #endif
1231 {
1232     va_list argptr;
1233     va_start(argptr, format);
1234
1235     wxString s;
1236     s.PrintfV(format, argptr);
1237
1238     va_end(argptr);
1239
1240     return s;
1241 }
1242
1243 /* static */
1244 wxString wxString::FormatV(const wxString& format, va_list argptr)
1245 {
1246     wxString s;
1247     s.PrintfV(format, argptr);
1248     return s;
1249 }
1250
1251 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1252 int wxStringPrintfMixinBase::DoPrintf(const wxChar *format, ...)
1253 #else
1254 int wxString::DoPrintf(const wxChar *format, ...)
1255 #endif
1256 {
1257     va_list argptr;
1258     va_start(argptr, format);
1259
1260 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1261     // get a pointer to the wxString instance; we have to use dynamic_cast<>
1262     // because it's the only cast that works safely for downcasting when
1263     // multiple inheritance is used:
1264     wxString *str = static_cast<wxString*>(this);
1265 #else
1266     wxString *str = this;
1267 #endif
1268
1269     int iLen = str->PrintfV(format, argptr);
1270
1271     va_end(argptr);
1272
1273     return iLen;
1274 }
1275
1276 int wxString::PrintfV(const wxString& format, va_list argptr)
1277 {
1278     int size = 1024;
1279
1280     for ( ;; )
1281     {
1282         wxStringBuffer tmp(*this, size + 1);
1283         wxChar *buf = tmp;
1284
1285         if ( !buf )
1286         {
1287             // out of memory
1288             return -1;
1289         }
1290
1291         // wxVsnprintf() may modify the original arg pointer, so pass it
1292         // only a copy
1293         va_list argptrcopy;
1294         wxVaCopy(argptrcopy, argptr);
1295         int len = wxVsnprintf(buf, size, format, argptrcopy);
1296         va_end(argptrcopy);
1297
1298         // some implementations of vsnprintf() don't NUL terminate
1299         // the string if there is not enough space for it so
1300         // always do it manually
1301         buf[size] = _T('\0');
1302
1303         // vsnprintf() may return either -1 (traditional Unix behaviour) or the
1304         // total number of characters which would have been written if the
1305         // buffer were large enough (newer standards such as Unix98)
1306         if ( len < 0 )
1307         {
1308 #if wxUSE_WXVSNPRINTF
1309             // we know that our own implementation of wxVsnprintf() returns -1
1310             // only for a format error - thus there's something wrong with
1311             // the user's format string
1312             return -1;
1313 #else // assume that system version only returns error if not enough space
1314             // still not enough, as we don't know how much we need, double the
1315             // current size of the buffer
1316             size *= 2;
1317 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
1318         }
1319         else if ( len >= size )
1320         {
1321 #if wxUSE_WXVSNPRINTF
1322             // we know that our own implementation of wxVsnprintf() returns
1323             // size+1 when there's not enough space but that's not the size
1324             // of the required buffer!
1325             size *= 2;      // so we just double the current size of the buffer
1326 #else
1327             // some vsnprintf() implementations NUL-terminate the buffer and
1328             // some don't in len == size case, to be safe always add 1
1329             size = len + 1;
1330 #endif
1331         }
1332         else // ok, there was enough space
1333         {
1334             break;
1335         }
1336     }
1337
1338     // we could have overshot
1339     Shrink();
1340
1341     return length();
1342 }
1343
1344 // ----------------------------------------------------------------------------
1345 // misc other operations
1346 // ----------------------------------------------------------------------------
1347
1348 // returns true if the string matches the pattern which may contain '*' and
1349 // '?' metacharacters (as usual, '?' matches any character and '*' any number
1350 // of them)
1351 bool wxString::Matches(const wxString& mask) const
1352 {
1353     // I disable this code as it doesn't seem to be faster (in fact, it seems
1354     // to be much slower) than the old, hand-written code below and using it
1355     // here requires always linking with libregex even if the user code doesn't
1356     // use it
1357 #if 0 // wxUSE_REGEX
1358     // first translate the shell-like mask into a regex
1359     wxString pattern;
1360     pattern.reserve(wxStrlen(pszMask));
1361
1362     pattern += _T('^');
1363     while ( *pszMask )
1364     {
1365         switch ( *pszMask )
1366         {
1367             case _T('?'):
1368                 pattern += _T('.');
1369                 break;
1370
1371             case _T('*'):
1372                 pattern += _T(".*");
1373                 break;
1374
1375             case _T('^'):
1376             case _T('.'):
1377             case _T('$'):
1378             case _T('('):
1379             case _T(')'):
1380             case _T('|'):
1381             case _T('+'):
1382             case _T('\\'):
1383                 // these characters are special in a RE, quote them
1384                 // (however note that we don't quote '[' and ']' to allow
1385                 // using them for Unix shell like matching)
1386                 pattern += _T('\\');
1387                 // fall through
1388
1389             default:
1390                 pattern += *pszMask;
1391         }
1392
1393         pszMask++;
1394     }
1395     pattern += _T('$');
1396
1397     // and now use it
1398     return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
1399 #else // !wxUSE_REGEX
1400   // TODO: this is, of course, awfully inefficient...
1401
1402   // FIXME-UTF8: implement using iterators, remove #if
1403 #if wxUSE_UNICODE_UTF8
1404   wxWCharBuffer maskBuf = mask.wc_str();
1405   wxWCharBuffer txtBuf = wc_str();
1406   const wxChar *pszMask = maskBuf.data();
1407   const wxChar *pszTxt = txtBuf.data();
1408 #else
1409   const wxChar *pszMask = mask.wx_str();
1410   // the char currently being checked
1411   const wxChar *pszTxt = wx_str();
1412 #endif
1413
1414   // the last location where '*' matched
1415   const wxChar *pszLastStarInText = NULL;
1416   const wxChar *pszLastStarInMask = NULL;
1417
1418 match:
1419   for ( ; *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
1420     switch ( *pszMask ) {
1421       case wxT('?'):
1422         if ( *pszTxt == wxT('\0') )
1423           return false;
1424
1425         // pszTxt and pszMask will be incremented in the loop statement
1426
1427         break;
1428
1429       case wxT('*'):
1430         {
1431           // remember where we started to be able to backtrack later
1432           pszLastStarInText = pszTxt;
1433           pszLastStarInMask = pszMask;
1434
1435           // ignore special chars immediately following this one
1436           // (should this be an error?)
1437           while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
1438             pszMask++;
1439
1440           // if there is nothing more, match
1441           if ( *pszMask == wxT('\0') )
1442             return true;
1443
1444           // are there any other metacharacters in the mask?
1445           size_t uiLenMask;
1446           const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
1447
1448           if ( pEndMask != NULL ) {
1449             // we have to match the string between two metachars
1450             uiLenMask = pEndMask - pszMask;
1451           }
1452           else {
1453             // we have to match the remainder of the string
1454             uiLenMask = wxStrlen(pszMask);
1455           }
1456
1457           wxString strToMatch(pszMask, uiLenMask);
1458           const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
1459           if ( pMatch == NULL )
1460             return false;
1461
1462           // -1 to compensate "++" in the loop
1463           pszTxt = pMatch + uiLenMask - 1;
1464           pszMask += uiLenMask - 1;
1465         }
1466         break;
1467
1468       default:
1469         if ( *pszMask != *pszTxt )
1470           return false;
1471         break;
1472     }
1473   }
1474
1475   // match only if nothing left
1476   if ( *pszTxt == wxT('\0') )
1477     return true;
1478
1479   // if we failed to match, backtrack if we can
1480   if ( pszLastStarInText ) {
1481     pszTxt = pszLastStarInText + 1;
1482     pszMask = pszLastStarInMask;
1483
1484     pszLastStarInText = NULL;
1485
1486     // don't bother resetting pszLastStarInMask, it's unnecessary
1487
1488     goto match;
1489   }
1490
1491   return false;
1492 #endif // wxUSE_REGEX/!wxUSE_REGEX
1493 }
1494
1495 // Count the number of chars
1496 int wxString::Freq(wxUniChar ch) const
1497 {
1498     int count = 0;
1499     for ( const_iterator i = begin(); i != end(); ++i )
1500     {
1501         if ( *i == ch )
1502             count ++;
1503     }
1504     return count;
1505 }
1506
1507 // convert to upper case, return the copy of the string
1508 wxString wxString::Upper() const
1509 { wxString s(*this); return s.MakeUpper(); }
1510
1511 // convert to lower case, return the copy of the string
1512 wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }
1513