src/common/string.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        string.cpp
   3 // Purpose:     wxString class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "string.h"
  14 #endif
  15
  16 /*
  17  * About ref counting:
  18  *  1) all empty strings use g_strEmpty, nRefs = -1 (set in Init())
  19  *  2) AllocBuffer() sets nRefs to 1, Lock() increments it by one
  20  *  3) Unlock() decrements nRefs and frees memory if it goes to 0
  21  */
  22
  23 // ===========================================================================
  24 // headers, declarations, constants
  25 // ===========================================================================
  26
  27 // For compilers that support precompilation, includes "wx.h".
  28 #include "wx/wxprec.h"
  29
  30 #ifdef __BORLANDC__
  31 #pragma hdrstop
  32 #endif
  33
  34 #ifndef WX_PRECOMP
  35 #include "wx/defs.h"
  36 #include "wx/string.h"
  37 #include <wx/intl.h>
  38 #endif
  39
  40 #include <ctype.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43
  44 #ifdef  WXSTRING_IS_WXOBJECT
  45   IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
  46 #endif  //WXSTRING_IS_WXOBJECT
  47
  48 // allocating extra space for each string consumes more memory but speeds up
  49 // the concatenation operations (nLen is the current string's length)
  50 // NB: EXTRA_ALLOC must be >= 0!
  51 #define EXTRA_ALLOC       (19 - nLen % 16)
  52
  53 // ---------------------------------------------------------------------------
  54 // static class variables definition
  55 // ---------------------------------------------------------------------------
  56
  57 #ifdef  STD_STRING_COMPATIBILITY
  58   const size_t wxString::npos = STRING_MAXLEN;
  59 #endif
  60
  61 // ----------------------------------------------------------------------------
  62 // static data
  63 // ----------------------------------------------------------------------------
  64
  65 // for an empty string, GetStringData() will return this address
  66 static int g_strEmpty[] = { -1,     // ref count (locked)
  67                              0,     // current length
  68                              0,     // allocated memory
  69                              0 };   // string data
  70 // empty C style string: points to 'string data' byte of g_strEmpty
  71 extern const char *g_szNul = (const char *)(&g_strEmpty[3]);
  72
  73 // ----------------------------------------------------------------------------
  74 // global functions
  75 // ----------------------------------------------------------------------------
  76
  77 #ifdef  STD_STRING_COMPATIBILITY
  78
  79 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
  80 // iostream ones.
  81 //
  82 // ATTN: you can _not_ use both of these in the same program!
  83 #if 0 // def  _MSC_VER
  84   #include  <iostream>
  85   #define   NAMESPACE   std::
  86 #else
  87   #include  <iostream.h>
  88   #define   NAMESPACE
  89 #endif  //Visual C++
  90
  91 NAMESPACE istream& operator>>(NAMESPACE istream& is, wxString& WXUNUSED(str))
  92 {
  93 #if 0
  94   int w = is.width(0);
  95   if ( is.ipfx(0) ) {
  96     NAMESPACE streambuf *sb = is.rdbuf();
  97     str.erase();
  98     while ( true ) {
  99       int ch = sb->sbumpc ();
 100       if ( ch == EOF ) {
 101         is.setstate(NAMESPACE ios::eofbit);
 102         break;
 103       }
 104       else if ( isspace(ch) ) {
 105         sb->sungetc();
 106         break;
 107       }
 108
 109       str += ch;
 110       if ( --w == 1 )
 111         break;
 112     }
 113   }
 114
 115   is.isfx();
 116   if ( str.length() == 0 )
 117     is.setstate(NAMESPACE ios::failbit);
 118 #endif
 119   return is;
 120 }
 121
 122 #endif  //std::string compatibility
 123
 124 // ----------------------------------------------------------------------------
 125 // private classes
 126 // ----------------------------------------------------------------------------
 127
 128 // this small class is used to gather statistics for performance tuning
 129 //#define WXSTRING_STATISTICS
 130 #ifdef  WXSTRING_STATISTICS
 131   class Averager
 132   {
 133   public:
 134     Averager(const char *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
 135    ~Averager()
 136    { printf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
 137
 138     void Add(size_t n) { m_nTotal += n; m_nCount++; }
 139
 140   private:
 141     size_t m_nCount, m_nTotal;
 142     const char *m_sz;
 143   } g_averageLength("allocation size"),
 144     g_averageSummandLength("summand length"),
 145     g_averageConcatHit("hit probability in concat"),
 146     g_averageInitialLength("initial string length");
 147
 148   #define STATISTICS_ADD(av, val) g_average##av.Add(val)
 149 #else
 150   #define STATISTICS_ADD(av, val)
 151 #endif // WXSTRING_STATISTICS
 152
 153 // ===========================================================================
 154 // wxString class core
 155 // ===========================================================================
 156
 157 // ---------------------------------------------------------------------------
 158 // construction
 159 // ---------------------------------------------------------------------------
 160
 161 // constructs string of <nLength> copies of character <ch>
 162 wxString::wxString(char ch, size_t nLength)
 163 {
 164   Init();
 165
 166   if ( nLength > 0 ) {
 167     AllocBuffer(nLength);
 168
 169     wxASSERT( sizeof(char) == 1 );  // can't use memset if not
 170
 171     memset(m_pchData, ch, nLength);
 172   }
 173 }
 174
 175 // takes nLength elements of psz starting at nPos
 176 void wxString::InitWith(const char *psz, size_t nPos, size_t nLength)
 177 {
 178   Init();
 179
 180   wxASSERT( nPos <= Strlen(psz) );
 181
 182   if ( nLength == STRING_MAXLEN )
 183     nLength = Strlen(psz + nPos);
 184
 185   STATISTICS_ADD(InitialLength, nLength);
 186
 187   if ( nLength > 0 ) {
 188     // trailing '\0' is written in AllocBuffer()
 189     AllocBuffer(nLength);
 190     memcpy(m_pchData, psz + nPos, nLength*sizeof(char));
 191   }
 192 }
 193
 194 // the same as previous constructor, but for compilers using unsigned char
 195 wxString::wxString(const unsigned char* psz, size_t nLength)
 196 {
 197   InitWith((const char *)psz, 0, nLength);
 198 }
 199
 200 #ifdef  STD_STRING_COMPATIBILITY
 201
 202 // poor man's iterators are "void *" pointers
 203 wxString::wxString(const void *pStart, const void *pEnd)
 204 {
 205   InitWith((const char *)pStart, 0,
 206            (const char *)pEnd - (const char *)pStart);
 207 }
 208
 209 #endif  //std::string compatibility
 210
 211 // from wide string
 212 wxString::wxString(const wchar_t *pwz)
 213 {
 214   // first get necessary size
 215   size_t nLen = wcstombs((char *) NULL, pwz, 0);
 216
 217   // empty?
 218   if ( nLen != 0 ) {
 219     AllocBuffer(nLen);
 220     wcstombs(m_pchData, pwz, nLen);
 221   }
 222   else {
 223     Init();
 224   }
 225 }
 226
 227 // ---------------------------------------------------------------------------
 228 // memory allocation
 229 // ---------------------------------------------------------------------------
 230
 231 // allocates memory needed to store a C string of length nLen
 232 void wxString::AllocBuffer(size_t nLen)
 233 {
 234   wxASSERT( nLen >  0         );    //
 235   wxASSERT( nLen <= INT_MAX-1 );    // max size (enough room for 1 extra)
 236
 237   STATISTICS_ADD(Length, nLen);
 238
 239   // allocate memory:
 240   // 1) one extra character for '\0' termination
 241   // 2) sizeof(wxStringData) for housekeeping info
 242   wxStringData* pData = (wxStringData*)
 243     malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(char));
 244   pData->nRefs        = 1;
 245   pData->nDataLength  = nLen;
 246   pData->nAllocLength = nLen + EXTRA_ALLOC;
 247   m_pchData           = pData->data();  // data starts after wxStringData
 248   m_pchData[nLen]     = '\0';
 249 }
 250
 251 // must be called before changing this string
 252 void wxString::CopyBeforeWrite()
 253 {
 254   wxStringData* pData = GetStringData();
 255
 256   if ( pData->IsShared() ) {
 257     pData->Unlock();                // memory not freed because shared
 258     size_t nLen = pData->nDataLength;
 259     AllocBuffer(nLen);
 260     memcpy(m_pchData, pData->data(), nLen*sizeof(char));
 261   }
 262
 263   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner
 264 }
 265
 266 // must be called before replacing contents of this string
 267 void wxString::AllocBeforeWrite(size_t nLen)
 268 {
 269   wxASSERT( nLen != 0 );  // doesn't make any sense
 270
 271   // must not share string and must have enough space
 272   wxStringData* pData = GetStringData();
 273   if ( pData->IsShared() || (nLen > pData->nAllocLength) ) {
 274     // can't work with old buffer, get new one
 275     pData->Unlock();
 276     AllocBuffer(nLen);
 277   }
 278
 279   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner
 280 }
 281
 282 // allocate enough memory for nLen characters
 283 void wxString::Alloc(size_t nLen)
 284 {
 285   wxStringData *pData = GetStringData();
 286   if ( pData->nAllocLength <= nLen ) {
 287     if ( pData->IsEmpty() ) {
 288       nLen += EXTRA_ALLOC;
 289
 290       wxStringData* pData = (wxStringData*)
 291         malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(char));
 292       pData->nRefs = 1;
 293       pData->nDataLength = 0;
 294       pData->nAllocLength = nLen;
 295       m_pchData = pData->data();  // data starts after wxStringData
 296       m_pchData[0u] = '\0';
 297     }
 298     else if ( pData->IsShared() ) {
 299       pData->Unlock();                // memory not freed because shared
 300       size_t nOldLen = pData->nDataLength;
 301       AllocBuffer(nLen);
 302       memcpy(m_pchData, pData->data(), nOldLen*sizeof(char));
 303     }
 304     else {
 305       nLen += EXTRA_ALLOC;
 306
 307       wxStringData *p = (wxStringData *)
 308         realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(char));
 309
 310       if ( p == NULL ) {
 311         // @@@ what to do on memory error?
 312         return;
 313       }
 314
 315       // it's not important if the pointer changed or not (the check for this
 316       // is not faster than assigning to m_pchData in all cases)
 317       p->nAllocLength = nLen;
 318       m_pchData = p->data();
 319     }
 320   }
 321   //else: we've already got enough
 322 }
 323
 324 // shrink to minimal size (releasing extra memory)
 325 void wxString::Shrink()
 326 {
 327   wxStringData *pData = GetStringData();
 328
 329   // this variable is unused in release build, so avoid the compiler warning by
 330   // just not declaring it
 331 #ifdef __WXDEBUG__
 332   void *p =
 333 #endif
 334   realloc(pData, sizeof(wxStringData) + (pData->nDataLength + 1)*sizeof(char));
 335
 336   wxASSERT( p != NULL );  // can't free memory?
 337   wxASSERT( p == pData ); // we're decrementing the size - block shouldn't move!
 338 }
 339
 340 // get the pointer to writable buffer of (at least) nLen bytes
 341 char *wxString::GetWriteBuf(size_t nLen)
 342 {
 343   AllocBeforeWrite(nLen);
 344
 345   wxASSERT( GetStringData()->nRefs == 1 );
 346   GetStringData()->Validate(FALSE);
 347
 348   return m_pchData;
 349 }
 350
 351 // put string back in a reasonable state after GetWriteBuf
 352 void wxString::UngetWriteBuf()
 353 {
 354   GetStringData()->nDataLength = strlen(m_pchData);
 355   GetStringData()->Validate(TRUE);
 356 }
 357
 358 // ---------------------------------------------------------------------------
 359 // data access
 360 // ---------------------------------------------------------------------------
 361
 362 // all functions are inline in string.h
 363
 364 // ---------------------------------------------------------------------------
 365 // assignment operators
 366 // ---------------------------------------------------------------------------
 367
 368 // helper function: does real copy
 369 void wxString::AssignCopy(size_t nSrcLen, const char *pszSrcData)
 370 {
 371   if ( nSrcLen == 0 ) {
 372     Reinit();
 373   }
 374   else {
 375     AllocBeforeWrite(nSrcLen);
 376     memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(char));
 377     GetStringData()->nDataLength = nSrcLen;
 378     m_pchData[nSrcLen] = '\0';
 379   }
 380 }
 381
 382 // assigns one string to another
 383 wxString& wxString::operator=(const wxString& stringSrc)
 384 {
 385   wxASSERT( stringSrc.GetStringData()->IsValid() );
 386
 387   // don't copy string over itself
 388   if ( m_pchData != stringSrc.m_pchData ) {
 389     if ( stringSrc.GetStringData()->IsEmpty() ) {
 390       Reinit();
 391     }
 392     else {
 393       // adjust references
 394       GetStringData()->Unlock();
 395       m_pchData = stringSrc.m_pchData;
 396       GetStringData()->Lock();
 397     }
 398   }
 399
 400   return *this;
 401 }
 402
 403 // assigns a single character
 404 wxString& wxString::operator=(char ch)
 405 {
 406   AssignCopy(1, &ch);
 407   return *this;
 408 }
 409
 410 // assigns C string
 411 wxString& wxString::operator=(const char *psz)
 412 {
 413   AssignCopy(Strlen(psz), psz);
 414   return *this;
 415 }
 416
 417 // same as 'signed char' variant
 418 wxString& wxString::operator=(const unsigned char* psz)
 419 {
 420   *this = (const char *)psz;
 421   return *this;
 422 }
 423
 424 wxString& wxString::operator=(const wchar_t *pwz)
 425 {
 426   wxString str(pwz);
 427   *this = str;
 428   return *this;
 429 }
 430
 431 // ---------------------------------------------------------------------------
 432 // string concatenation
 433 // ---------------------------------------------------------------------------
 434
 435 // add something to this string
 436 void wxString::ConcatSelf(int nSrcLen, const char *pszSrcData)
 437 {
 438   STATISTICS_ADD(SummandLength, nSrcLen);
 439
 440   // concatenating an empty string is a NOP, but it happens quite rarely,
 441   // so we don't waste our time checking for it
 442   // if ( nSrcLen > 0 )
 443   wxStringData *pData = GetStringData();
 444   size_t nLen = pData->nDataLength;
 445   size_t nNewLen = nLen + nSrcLen;
 446
 447   // alloc new buffer if current is too small
 448   if ( pData->IsShared() ) {
 449     STATISTICS_ADD(ConcatHit, 0);
 450
 451     // we have to allocate another buffer
 452     wxStringData* pOldData = GetStringData();
 453     AllocBuffer(nNewLen);
 454     memcpy(m_pchData, pOldData->data(), nLen*sizeof(char));
 455     pOldData->Unlock();
 456   }
 457   else if ( nNewLen > pData->nAllocLength ) {
 458     STATISTICS_ADD(ConcatHit, 0);
 459
 460     // we have to grow the buffer
 461     Alloc(nNewLen);
 462   }
 463   else {
 464     STATISTICS_ADD(ConcatHit, 1);
 465
 466     // the buffer is already big enough
 467   }
 468
 469   // should be enough space
 470   wxASSERT( nNewLen <= GetStringData()->nAllocLength );
 471
 472   // fast concatenation - all is done in our buffer
 473   memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(char));
 474
 475   m_pchData[nNewLen] = '\0';              // put terminating '\0'
 476   GetStringData()->nDataLength = nNewLen; // and fix the length
 477 }
 478
 479 /*
 480  * concatenation functions come in 5 flavours:
 481  *  string + string
 482  *  char   + string      and      string + char
 483  *  C str  + string      and      string + C str
 484  */
 485
 486 wxString operator+(const wxString& string1, const wxString& string2)
 487 {
 488   wxASSERT( string1.GetStringData()->IsValid() );
 489   wxASSERT( string2.GetStringData()->IsValid() );
 490
 491   wxString s = string1;
 492   s += string2;
 493
 494   return s;
 495 }
 496
 497 wxString operator+(const wxString& string, char ch)
 498 {
 499   wxASSERT( string.GetStringData()->IsValid() );
 500
 501   wxString s = string;
 502   s += ch;
 503
 504   return s;
 505 }
 506
 507 wxString operator+(char ch, const wxString& string)
 508 {
 509   wxASSERT( string.GetStringData()->IsValid() );
 510
 511   wxString s = ch;
 512   s += string;
 513
 514   return s;
 515 }
 516
 517 wxString operator+(const wxString& string, const char *psz)
 518 {
 519   wxASSERT( string.GetStringData()->IsValid() );
 520
 521   wxString s;
 522   s.Alloc(Strlen(psz) + string.Len());
 523   s = string;
 524   s += psz;
 525
 526   return s;
 527 }
 528
 529 wxString operator+(const char *psz, const wxString& string)
 530 {
 531   wxASSERT( string.GetStringData()->IsValid() );
 532
 533   wxString s;
 534   s.Alloc(Strlen(psz) + string.Len());
 535   s = psz;
 536   s += string;
 537
 538   return s;
 539 }
 540
 541 // ===========================================================================
 542 // other common string functions
 543 // ===========================================================================
 544
 545 // ---------------------------------------------------------------------------
 546 // simple sub-string extraction
 547 // ---------------------------------------------------------------------------
 548
 549 // helper function: clone the data attached to this string
 550 void wxString::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const
 551 {
 552   if ( nCopyLen == 0 ) {
 553     dest.Init();
 554   }
 555   else {
 556     dest.AllocBuffer(nCopyLen);
 557     memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(char));
 558   }
 559 }
 560
 561 // extract string of length nCount starting at nFirst
 562 // default value of nCount is 0 and means "till the end"
 563 wxString wxString::Mid(size_t nFirst, size_t nCount) const
 564 {
 565   // out-of-bounds requests return sensible things
 566   if ( nCount == 0 )
 567     nCount = GetStringData()->nDataLength - nFirst;
 568
 569   if ( nFirst + nCount > (size_t)GetStringData()->nDataLength )
 570     nCount = GetStringData()->nDataLength - nFirst;
 571   if ( nFirst > (size_t)GetStringData()->nDataLength )
 572     nCount = 0;
 573
 574   wxString dest;
 575   AllocCopy(dest, nCount, nFirst);
 576   return dest;
 577 }
 578
 579 // extract nCount last (rightmost) characters
 580 wxString wxString::Right(size_t nCount) const
 581 {
 582   if ( nCount > (size_t)GetStringData()->nDataLength )
 583     nCount = GetStringData()->nDataLength;
 584
 585   wxString dest;
 586   AllocCopy(dest, nCount, GetStringData()->nDataLength - nCount);
 587   return dest;
 588 }
 589
 590 // get all characters after the last occurence of ch
 591 // (returns the whole string if ch not found)
 592 wxString wxString::Right(char ch) const
 593 {
 594   wxString str;
 595   int iPos = Find(ch, TRUE);
 596   if ( iPos == NOT_FOUND )
 597     str = *this;
 598   else
 599     str = c_str() + iPos + 1;
 600
 601   return str;
 602 }
 603
 604 // extract nCount first (leftmost) characters
 605 wxString wxString::Left(size_t nCount) const
 606 {
 607   if ( nCount > (size_t)GetStringData()->nDataLength )
 608     nCount = GetStringData()->nDataLength;
 609
 610   wxString dest;
 611   AllocCopy(dest, nCount, 0);
 612   return dest;
 613 }
 614
 615 // get all characters before the first occurence of ch
 616 // (returns the whole string if ch not found)
 617 wxString wxString::Left(char ch) const
 618 {
 619   wxString str;
 620   for ( const char *pc = m_pchData; *pc != '\0' && *pc != ch; pc++ )
 621     str += *pc;
 622
 623   return str;
 624 }
 625
 626 /// get all characters before the last occurence of ch
 627 /// (returns empty string if ch not found)
 628 wxString wxString::Before(char ch) const
 629 {
 630   wxString str;
 631   int iPos = Find(ch, TRUE);
 632   if ( iPos != NOT_FOUND && iPos != 0 )
 633     str = wxString(c_str(), iPos);
 634
 635   return str;
 636 }
 637
 638 /// get all characters after the first occurence of ch
 639 /// (returns empty string if ch not found)
 640 wxString wxString::After(char ch) const
 641 {
 642   wxString str;
 643   int iPos = Find(ch);
 644   if ( iPos != NOT_FOUND )
 645     str = c_str() + iPos + 1;
 646
 647   return str;
 648 }
 649
 650 // replace first (or all) occurences of some substring with another one
 651 size_t wxString::Replace(const char *szOld, const char *szNew, bool bReplaceAll)
 652 {
 653   size_t uiCount = 0;   // count of replacements made
 654
 655   size_t uiOldLen = Strlen(szOld);
 656
 657   wxString strTemp;
 658   const char *pCurrent = m_pchData;
 659   const char *pSubstr;
 660   while ( *pCurrent != '\0' ) {
 661     pSubstr = strstr(pCurrent, szOld);
 662     if ( pSubstr == NULL ) {
 663       // strTemp is unused if no replacements were made, so avoid the copy
 664       if ( uiCount == 0 )
 665         return 0;
 666
 667       strTemp += pCurrent;    // copy the rest
 668       break;                  // exit the loop
 669     }
 670     else {
 671       // take chars before match
 672       strTemp.ConcatSelf(pSubstr - pCurrent, pCurrent);
 673       strTemp += szNew;
 674       pCurrent = pSubstr + uiOldLen;  // restart after match
 675
 676       uiCount++;
 677
 678       // stop now?
 679       if ( !bReplaceAll ) {
 680         strTemp += pCurrent;    // copy the rest
 681         break;                  // exit the loop
 682       }
 683     }
 684   }
 685
 686   // only done if there were replacements, otherwise would have returned above
 687   *this = strTemp;
 688
 689   return uiCount;
 690 }
 691
 692 bool wxString::IsAscii() const
 693 {
 694   const char *s = (const char*) *this;
 695   while(*s){
 696     if(!isascii(*s)) return(FALSE);
 697     s++;
 698   }
 699   return(TRUE);
 700 }
 701
 702 bool wxString::IsWord() const
 703 {
 704   const char *s = (const char*) *this;
 705   while(*s){
 706     if(!isalpha(*s)) return(FALSE);
 707     s++;
 708   }
 709   return(TRUE);
 710 }
 711
 712 bool wxString::IsNumber() const
 713 {
 714   const char *s = (const char*) *this;
 715   while(*s){
 716     if(!isdigit(*s)) return(FALSE);
 717     s++;
 718   }
 719   return(TRUE);
 720 }
 721
 722 wxString wxString::Strip(stripType w) const
 723 {
 724     wxString s = *this;
 725     if ( w & leading ) s.Trim(FALSE);
 726     if ( w & trailing ) s.Trim(TRUE);
 727     return s;
 728 }
 729
 730 // ---------------------------------------------------------------------------
 731 // case conversion
 732 // ---------------------------------------------------------------------------
 733
 734 wxString& wxString::MakeUpper()
 735 {
 736   CopyBeforeWrite();
 737
 738   for ( char *p = m_pchData; *p; p++ )
 739     *p = (char)toupper(*p);
 740
 741   return *this;
 742 }
 743
 744 wxString& wxString::MakeLower()
 745 {
 746   CopyBeforeWrite();
 747
 748   for ( char *p = m_pchData; *p; p++ )
 749     *p = (char)tolower(*p);
 750
 751   return *this;
 752 }
 753
 754 // ---------------------------------------------------------------------------
 755 // trimming and padding
 756 // ---------------------------------------------------------------------------
 757
 758 // trims spaces (in the sense of isspace) from left or right side
 759 wxString& wxString::Trim(bool bFromRight)
 760 {
 761   CopyBeforeWrite();
 762
 763   if ( bFromRight )
 764   {
 765     // find last non-space character
 766     char *psz = m_pchData + GetStringData()->nDataLength - 1;
 767     while ( isspace(*psz) && (psz >= m_pchData) )
 768       psz--;
 769
 770     // truncate at trailing space start
 771     *++psz = '\0';
 772     GetStringData()->nDataLength = psz - m_pchData;
 773   }
 774   else
 775   {
 776     // find first non-space character
 777     const char *psz = m_pchData;
 778     while ( isspace(*psz) )
 779       psz++;
 780
 781     // fix up data and length
 782     int nDataLength = GetStringData()->nDataLength - (psz - m_pchData);
 783     memmove(m_pchData, psz, (nDataLength + 1)*sizeof(char));
 784     GetStringData()->nDataLength = nDataLength;
 785   }
 786
 787   return *this;
 788 }
 789
 790 // adds nCount characters chPad to the string from either side
 791 wxString& wxString::Pad(size_t nCount, char chPad, bool bFromRight)
 792 {
 793   wxString s(chPad, nCount);
 794
 795   if ( bFromRight )
 796     *this += s;
 797   else
 798   {
 799     s += *this;
 800     *this = s;
 801   }
 802
 803   return *this;
 804 }
 805
 806 // truncate the string
 807 wxString& wxString::Truncate(size_t uiLen)
 808 {
 809   *(m_pchData + uiLen) = '\0';
 810   GetStringData()->nDataLength = uiLen;
 811
 812   return *this;
 813 }
 814
 815 // ---------------------------------------------------------------------------
 816 // finding (return NOT_FOUND if not found and index otherwise)
 817 // ---------------------------------------------------------------------------
 818
 819 // find a character
 820 int wxString::Find(char ch, bool bFromEnd) const
 821 {
 822   const char *psz = bFromEnd ? strrchr(m_pchData, ch) : strchr(m_pchData, ch);
 823
 824   return (psz == NULL) ? NOT_FOUND : psz - m_pchData;
 825 }
 826
 827 // find a sub-string (like strstr)
 828 int wxString::Find(const char *pszSub) const
 829 {
 830   const char *psz = strstr(m_pchData, pszSub);
 831
 832   return (psz == NULL) ? NOT_FOUND : psz - m_pchData;
 833 }
 834
 835 // ---------------------------------------------------------------------------
 836 // formatted output
 837 // ---------------------------------------------------------------------------
 838 int wxString::Printf(const char *pszFormat, ...)
 839 {
 840   va_list argptr;
 841   va_start(argptr, pszFormat);
 842
 843   int iLen = PrintfV(pszFormat, argptr);
 844
 845   va_end(argptr);
 846
 847   return iLen;
 848 }
 849
 850 int wxString::PrintfV(const char* pszFormat, va_list argptr)
 851 {
 852   static char s_szScratch[1024];
 853
 854   int iLen = vsprintf(s_szScratch, pszFormat, argptr);
 855   AllocBeforeWrite(iLen);
 856   strcpy(m_pchData, s_szScratch);
 857
 858   return iLen;
 859 }
 860
 861 // ----------------------------------------------------------------------------
 862 // misc other operations
 863 // ----------------------------------------------------------------------------
 864 bool wxString::Matches(const char *pszMask) const
 865 {
 866   // check char by char
 867   const char *pszTxt;
 868   for ( pszTxt = c_str(); *pszMask != '\0'; pszMask++, pszTxt++ ) {
 869     switch ( *pszMask ) {
 870       case '?':
 871         if ( *pszTxt == '\0' )
 872           return FALSE;
 873
 874         pszTxt++;
 875         pszMask++;
 876         break;
 877
 878       case '*':
 879         {
 880           // ignore special chars immediately following this one
 881           while ( *pszMask == '*' || *pszMask == '?' )
 882             pszMask++;
 883
 884           // if there is nothing more, match
 885           if ( *pszMask == '\0' )
 886             return TRUE;
 887
 888           // are there any other metacharacters in the mask?
 889           size_t uiLenMask;
 890           const char *pEndMask = strpbrk(pszMask, "*?");
 891
 892           if ( pEndMask != NULL ) {
 893             // we have to match the string between two metachars
 894             uiLenMask = pEndMask - pszMask;
 895           }
 896           else {
 897             // we have to match the remainder of the string
 898             uiLenMask = strlen(pszMask);
 899           }
 900
 901           wxString strToMatch(pszMask, uiLenMask);
 902           const char* pMatch = strstr(pszTxt, strToMatch);
 903           if ( pMatch == NULL )
 904             return FALSE;
 905
 906           // -1 to compensate "++" in the loop
 907           pszTxt = pMatch + uiLenMask - 1;
 908           pszMask += uiLenMask - 1;
 909         }
 910         break;
 911
 912       default:
 913         if ( *pszMask != *pszTxt )
 914           return FALSE;
 915         break;
 916     }
 917   }
 918
 919   // match only if nothing left
 920   return *pszTxt == '\0';
 921 }
 922
 923 // ---------------------------------------------------------------------------
 924 // standard C++ library string functions
 925 // ---------------------------------------------------------------------------
 926 #ifdef  STD_STRING_COMPATIBILITY
 927
 928 wxString& wxString::insert(size_t nPos, const wxString& str)
 929 {
 930   wxASSERT( str.GetStringData()->IsValid() );
 931   wxASSERT( nPos <= Len() );
 932
 933   if ( !str.IsEmpty() ) {
 934     wxString strTmp;
 935     char *pc = strTmp.GetWriteBuf(Len() + str.Len());
 936     strncpy(pc, c_str(), nPos);
 937     strcpy(pc + nPos, str);
 938     strcpy(pc + nPos + str.Len(), c_str() + nPos);
 939     strTmp.UngetWriteBuf();
 940     *this = strTmp;
 941   }
 942
 943   return *this;
 944 }
 945
 946 size_t wxString::find(const wxString& str, size_t nStart) const
 947 {
 948   wxASSERT( str.GetStringData()->IsValid() );
 949   wxASSERT( nStart <= Len() );
 950
 951   const char *p = strstr(c_str() + nStart, str);
 952
 953   return p == NULL ? npos : p - c_str();
 954 }
 955
 956 // VC++ 1.5 can't cope with the default argument in the header.
 957 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
 958 size_t wxString::find(const char* sz, size_t nStart, size_t n) const
 959 {
 960   return find(wxString(sz, n == npos ? 0 : n), nStart);
 961 }
 962 #endif
 963
 964 size_t wxString::find(char ch, size_t nStart) const
 965 {
 966   wxASSERT( nStart <= Len() );
 967
 968   const char *p = strchr(c_str() + nStart, ch);
 969
 970   return p == NULL ? npos : p - c_str();
 971 }
 972
 973 size_t wxString::rfind(const wxString& str, size_t nStart) const
 974 {
 975   wxASSERT( str.GetStringData()->IsValid() );
 976   wxASSERT( nStart <= Len() );
 977
 978   // # could be quicker than that
 979   const char *p = c_str() + (nStart == npos ? Len() : nStart);
 980   while ( p >= c_str() + str.Len() ) {
 981     if ( strncmp(p - str.Len(), str, str.Len()) == 0 )
 982       return p - str.Len() - c_str();
 983     p--;
 984   }
 985
 986   return npos;
 987 }
 988
 989 // VC++ 1.5 can't cope with the default argument in the header.
 990 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
 991 size_t wxString::rfind(const char* sz, size_t nStart, size_t n) const
 992 {
 993   return rfind(wxString(sz, n == npos ? 0 : n), nStart);
 994 }
 995
 996 size_t wxString::rfind(char ch, size_t nStart) const
 997 {
 998   wxASSERT( nStart <= Len() );
 999
1000   const char *p = strrchr(c_str() + nStart, ch);
1001
1002   return p == NULL ? npos : p - c_str();
1003 }
1004 #endif
1005
1006 wxString wxString::substr(size_t nStart, size_t nLen) const
1007 {
1008   // npos means 'take all'
1009   if ( nLen == npos )
1010     nLen = 0;
1011
1012   wxASSERT( nStart + nLen <= Len() );
1013
1014   return wxString(c_str() + nStart, nLen == npos ? 0 : nLen);
1015 }
1016
1017 wxString& wxString::erase(size_t nStart, size_t nLen)
1018 {
1019   wxString strTmp(c_str(), nStart);
1020   if ( nLen != npos ) {
1021     wxASSERT( nStart + nLen <= Len() );
1022
1023     strTmp.append(c_str() + nStart + nLen);
1024   }
1025
1026   *this = strTmp;
1027   return *this;
1028 }
1029
1030 wxString& wxString::replace(size_t nStart, size_t nLen, const char *sz)
1031 {
1032   wxASSERT( nStart + nLen <= Strlen(sz) );
1033
1034   wxString strTmp;
1035   if ( nStart != 0 )
1036     strTmp.append(c_str(), nStart);
1037   strTmp += sz;
1038   strTmp.append(c_str() + nStart + nLen);
1039
1040   *this = strTmp;
1041   return *this;
1042 }
1043
1044 wxString& wxString::replace(size_t nStart, size_t nLen, size_t nCount, char ch)
1045 {
1046   return replace(nStart, nLen, wxString(ch, nCount));
1047 }
1048
1049 wxString& wxString::replace(size_t nStart, size_t nLen,
1050                             const wxString& str, size_t nStart2, size_t nLen2)
1051 {
1052   return replace(nStart, nLen, str.substr(nStart2, nLen2));
1053 }
1054
1055 wxString& wxString::replace(size_t nStart, size_t nLen,
1056                         const char* sz, size_t nCount)
1057 {
1058   return replace(nStart, nLen, wxString(sz, nCount));
1059 }
1060
1061 #endif  //std::string compatibility
1062
1063 // ============================================================================
1064 // ArrayString
1065 // ============================================================================
1066
1067 // size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
1068 #define   ARRAY_MAXSIZE_INCREMENT       4096
1069 #ifndef   ARRAY_DEFAULT_INITIAL_SIZE    // also defined in dynarray.h
1070   #define   ARRAY_DEFAULT_INITIAL_SIZE    (16)
1071 #endif
1072
1073 #define   STRING(p)   ((wxString *)(&(p)))
1074
1075 // ctor
1076 wxArrayString::wxArrayString()
1077 {
1078   m_nSize  =
1079   m_nCount = 0;
1080   m_pItems = (char **) NULL;
1081 }
1082
1083 // copy ctor
1084 wxArrayString::wxArrayString(const wxArrayString& src)
1085 {
1086   m_nSize  =
1087   m_nCount = 0;
1088   m_pItems = (char **) NULL;
1089
1090   *this = src;
1091 }
1092
1093 // assignment operator
1094 wxArrayString& wxArrayString::operator=(const wxArrayString& src)
1095 {
1096   if ( m_nSize > 0 )
1097     Clear();
1098
1099   if ( src.m_nCount > ARRAY_DEFAULT_INITIAL_SIZE )
1100     Alloc(src.m_nCount);
1101
1102   // we can't just copy the pointers here because otherwise we would share
1103   // the strings with another array
1104   for ( size_t n = 0; n < src.m_nCount; n++ )
1105     Add(src[n]);
1106
1107   if ( m_nCount != 0 )
1108     memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(char *));
1109
1110   return *this;
1111 }
1112
1113 // grow the array
1114 void wxArrayString::Grow()
1115 {
1116   // only do it if no more place
1117   if( m_nCount == m_nSize ) {
1118     if( m_nSize == 0 ) {
1119       // was empty, alloc some memory
1120       m_nSize = ARRAY_DEFAULT_INITIAL_SIZE;
1121       m_pItems = new char *[m_nSize];
1122     }
1123     else {
1124       // otherwise when it's called for the first time, nIncrement would be 0
1125       // and the array would never be expanded
1126       wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
1127
1128       // add 50% but not too much
1129       size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
1130                           ? ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;
1131       if ( nIncrement > ARRAY_MAXSIZE_INCREMENT )
1132         nIncrement = ARRAY_MAXSIZE_INCREMENT;
1133       m_nSize += nIncrement;
1134       char **pNew = new char *[m_nSize];
1135
1136       // copy data to new location
1137       memcpy(pNew, m_pItems, m_nCount*sizeof(char *));
1138
1139       // delete old memory (but do not release the strings!)
1140       wxDELETEA(m_pItems);
1141
1142       m_pItems = pNew;
1143     }
1144   }
1145 }
1146
1147 void wxArrayString::Free()
1148 {
1149   for ( size_t n = 0; n < m_nCount; n++ ) {
1150     STRING(m_pItems[n])->GetStringData()->Unlock();
1151   }
1152 }
1153
1154 // deletes all the strings from the list
1155 void wxArrayString::Empty()
1156 {
1157   Free();
1158
1159   m_nCount = 0;
1160 }
1161
1162 // as Empty, but also frees memory
1163 void wxArrayString::Clear()
1164 {
1165   Free();
1166
1167   m_nSize  =
1168   m_nCount = 0;
1169
1170   wxDELETEA(m_pItems);
1171 }
1172
1173 // dtor
1174 wxArrayString::~wxArrayString()
1175 {
1176   Free();
1177
1178   wxDELETEA(m_pItems);
1179 }
1180
1181 // pre-allocates memory (frees the previous data!)
1182 void wxArrayString::Alloc(size_t nSize)
1183 {
1184   wxASSERT( nSize > 0 );
1185
1186   // only if old buffer was not big enough
1187   if ( nSize > m_nSize ) {
1188     Free();
1189     wxDELETEA(m_pItems);
1190     m_pItems = new char *[nSize];
1191     m_nSize  = nSize;
1192   }
1193
1194   m_nCount = 0;
1195 }
1196
1197 // searches the array for an item (forward or backwards)
1198 int wxArrayString::Index(const char *sz, bool bCase, bool bFromEnd) const
1199 {
1200   if ( bFromEnd ) {
1201     if ( m_nCount > 0 ) {
1202       size_t ui = m_nCount;
1203       do {
1204         if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) )
1205           return ui;
1206       }
1207       while ( ui != 0 );
1208     }
1209   }
1210   else {
1211     for( size_t ui = 0; ui < m_nCount; ui++ ) {
1212       if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) )
1213         return ui;
1214     }
1215   }
1216
1217   return NOT_FOUND;
1218 }
1219
1220 // add item at the end
1221 void wxArrayString::Add(const wxString& str)
1222 {
1223   wxASSERT( str.GetStringData()->IsValid() );
1224
1225   Grow();
1226
1227   // the string data must not be deleted!
1228   str.GetStringData()->Lock();
1229   m_pItems[m_nCount++] = (char *)str.c_str();
1230 }
1231
1232 // add item at the given position
1233 void wxArrayString::Insert(const wxString& str, size_t nIndex)
1234 {
1235   wxASSERT( str.GetStringData()->IsValid() );
1236
1237   wxCHECK_RET( nIndex <= m_nCount, ("bad index in wxArrayString::Insert") );
1238
1239   Grow();
1240
1241   memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex],
1242           (m_nCount - nIndex)*sizeof(char *));
1243
1244   str.GetStringData()->Lock();
1245   m_pItems[nIndex] = (char *)str.c_str();
1246
1247   m_nCount++;
1248 }
1249
1250 // removes item from array (by index)
1251 void wxArrayString::Remove(size_t nIndex)
1252 {
1253   wxCHECK_RET( nIndex <= m_nCount, _("bad index in wxArrayString::Remove") );
1254
1255   // release our lock
1256   Item(nIndex).GetStringData()->Unlock();
1257
1258   memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],
1259           (m_nCount - nIndex - 1)*sizeof(char *));
1260   m_nCount--;
1261 }
1262
1263 // removes item from array (by value)
1264 void wxArrayString::Remove(const char *sz)
1265 {
1266   int iIndex = Index(sz);
1267
1268   wxCHECK_RET( iIndex != NOT_FOUND,
1269                _("removing inexistent element in wxArrayString::Remove") );
1270
1271   Remove(iIndex);
1272 }
1273
1274 // sort array elements using passed comparaison function
1275
1276 void wxArrayString::Sort(bool WXUNUSED(bCase), bool WXUNUSED(bReverse) )
1277 {
1278   //@@@@ TO DO
1279   //qsort(m_pItems, m_nCount, sizeof(char *), fCmp);
1280 }