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