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