src/common/stringimpl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/stringimpl.cpp
   3 // Purpose:     wxString class
   4 // Author:      Vadim Zeitlin, Ryan Norton
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 //              (c) 2004 Ryan Norton <wxprojects@comcast.net>
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 /*
  14  * About ref counting:
  15  *  1) all empty strings use g_strEmpty, nRefs = -1 (set in Init())
  16  *  2) AllocBuffer() sets nRefs to 1, Lock() increments it by one
  17  *  3) Unlock() decrements nRefs and frees memory if it goes to 0
  18  */
  19
  20 // ===========================================================================
  21 // headers, declarations, constants
  22 // ===========================================================================
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/stringimpl.h"
  33 #endif
  34
  35 #include <ctype.h>
  36
  37 #ifndef __WXWINCE__
  38     #include <errno.h>
  39 #endif
  40
  41 #include <string.h>
  42 #include <stdlib.h>
  43
  44 #ifdef __SALFORDC__
  45     #include <clib.h>
  46 #endif
  47
  48 // 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 // string handling functions used by wxString:
  55 #if wxUSE_UNICODE_UTF8
  56     #define wxStringMemcpy   memcpy
  57     #define wxStringMemcmp   memcmp
  58     #define wxStringMemchr   memchr
  59 #else
  60     #define wxStringMemcpy   wxTmemcpy
  61     #define wxStringMemcmp   wxTmemcmp
  62     #define wxStringMemchr   wxTmemchr
  63 #endif
  64
  65
  66 // ---------------------------------------------------------------------------
  67 // static class variables definition
  68 // ---------------------------------------------------------------------------
  69
  70 #if !wxUSE_STL_BASED_WXSTRING
  71 //According to STL _must_ be a -1 size_t
  72 const size_t wxStringImpl::npos = (size_t) -1;
  73 #endif
  74
  75 // ----------------------------------------------------------------------------
  76 // static data
  77 // ----------------------------------------------------------------------------
  78
  79 #if wxUSE_STL_BASED_WXSTRING
  80
  81 // FIXME-UTF8: get rid of this, have only one wxEmptyString
  82 #if wxUSE_UNICODE_UTF8
  83 extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = "";
  84 #endif
  85 extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = _T("");
  86
  87 #else
  88
  89 // for an empty string, GetStringData() will return this address: this
  90 // structure has the same layout as wxStringData and it's data() method will
  91 // return the empty string (dummy pointer)
  92 static const struct
  93 {
  94   wxStringData data;
  95   wxStringCharType dummy;
  96 } g_strEmpty = { {-1, 0, 0}, wxT('\0') };
  97
  98 // empty C style string: points to 'string data' byte of g_strEmpty
  99 #if wxUSE_UNICODE_UTF8
 100 // FIXME-UTF8: get rid of this, have only one wxEmptyString
 101 extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyStringImpl = &g_strEmpty.dummy;
 102 extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = _T("");
 103 #else
 104 extern const wxStringCharType WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy;
 105 #endif
 106
 107 #endif
 108
 109
 110 #if !wxUSE_STL_BASED_WXSTRING
 111
 112 // ----------------------------------------------------------------------------
 113 // private classes
 114 // ----------------------------------------------------------------------------
 115
 116 // this small class is used to gather statistics for performance tuning
 117 //#define WXSTRING_STATISTICS
 118 #ifdef  WXSTRING_STATISTICS
 119   class Averager
 120   {
 121   public:
 122     Averager(const wxStringCharType *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
 123    ~Averager()
 124    { wxPrintf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
 125
 126     void Add(size_t n) { m_nTotal += n; m_nCount++; }
 127
 128   private:
 129     size_t m_nCount, m_nTotal;
 130     const wxStringCharType *m_sz;
 131   } g_averageLength("allocation size"),
 132     g_averageSummandLength("summand length"),
 133     g_averageConcatHit("hit probability in concat"),
 134     g_averageInitialLength("initial string length");
 135
 136   #define STATISTICS_ADD(av, val) g_average##av.Add(val)
 137 #else
 138   #define STATISTICS_ADD(av, val)
 139 #endif // WXSTRING_STATISTICS
 140
 141 // ===========================================================================
 142 // wxStringData class deallocation
 143 // ===========================================================================
 144
 145 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
 146 #  pragma message (__FILE__ ": building with Multithreaded non DLL runtime has a performance impact on wxString!")
 147 void wxStringData::Free()
 148 {
 149     free(this);
 150 }
 151 #endif
 152
 153 // ===========================================================================
 154 // wxStringImpl
 155 // ===========================================================================
 156
 157 // takes nLength elements of psz starting at nPos
 158 void wxStringImpl::InitWith(const wxStringCharType *psz,
 159                             size_t nPos, size_t nLength)
 160 {
 161   Init();
 162
 163   // if the length is not given, assume the string to be NUL terminated
 164   if ( nLength == npos ) {
 165     wxASSERT_MSG( nPos <= Strsize(psz), _T("index out of bounds") );
 166
 167     nLength = Strsize(psz + nPos);
 168   }
 169
 170   STATISTICS_ADD(InitialLength, nLength);
 171
 172   if ( nLength > 0 ) {
 173     // trailing '\0' is written in AllocBuffer()
 174     if ( !AllocBuffer(nLength) ) {
 175       wxFAIL_MSG( _T("out of memory in wxStringImpl::InitWith") );
 176       return;
 177     }
 178     wxStringMemcpy(m_pchData, psz + nPos, nLength);
 179   }
 180 }
 181
 182 wxStringImpl::wxStringImpl(const_iterator first, const_iterator last)
 183 {
 184   if ( last >= first )
 185   {
 186     InitWith(first, 0, last - first);
 187   }
 188   else
 189   {
 190     wxFAIL_MSG( _T("first must be before last") );
 191     Init();
 192   }
 193 }
 194
 195 wxStringImpl::wxStringImpl(size_type n, wxStringCharType ch)
 196 {
 197   Init();
 198   append(n, ch);
 199 }
 200
 201 // ---------------------------------------------------------------------------
 202 // memory allocation
 203 // ---------------------------------------------------------------------------
 204
 205 // allocates memory needed to store a C string of length nLen
 206 bool wxStringImpl::AllocBuffer(size_t nLen)
 207 {
 208   // allocating 0 sized buffer doesn't make sense, all empty strings should
 209   // reuse g_strEmpty
 210   wxASSERT( nLen >  0 );
 211
 212   // make sure that we don't overflow
 213   wxASSERT( nLen < (INT_MAX / sizeof(wxStringCharType)) -
 214                    (sizeof(wxStringData) + EXTRA_ALLOC + 1) );
 215
 216   STATISTICS_ADD(Length, nLen);
 217
 218   // allocate memory:
 219   // 1) one extra character for '\0' termination
 220   // 2) sizeof(wxStringData) for housekeeping info
 221   wxStringData* pData = (wxStringData*)
 222     malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(wxStringCharType));
 223
 224   if ( pData == NULL ) {
 225     // allocation failures are handled by the caller
 226     return false;
 227   }
 228
 229   pData->nRefs        = 1;
 230   pData->nDataLength  = nLen;
 231   pData->nAllocLength = nLen + EXTRA_ALLOC;
 232   m_pchData           = pData->data();  // data starts after wxStringData
 233   m_pchData[nLen]     = wxT('\0');
 234   return true;
 235 }
 236
 237 // must be called before changing this string
 238 bool wxStringImpl::CopyBeforeWrite()
 239 {
 240   wxStringData* pData = GetStringData();
 241
 242   if ( pData->IsShared() ) {
 243     pData->Unlock();                // memory not freed because shared
 244     size_t nLen = pData->nDataLength;
 245     if ( !AllocBuffer(nLen) ) {
 246       // allocation failures are handled by the caller
 247       return false;
 248     }
 249     wxStringMemcpy(m_pchData, pData->data(), nLen);
 250   }
 251
 252   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner
 253
 254   return true;
 255 }
 256
 257 // must be called before replacing contents of this string
 258 bool wxStringImpl::AllocBeforeWrite(size_t nLen)
 259 {
 260   wxASSERT( nLen != 0 );  // doesn't make any sense
 261
 262   // must not share string and must have enough space
 263   wxStringData* pData = GetStringData();
 264   if ( pData->IsShared() || pData->IsEmpty() ) {
 265     // can't work with old buffer, get new one
 266     pData->Unlock();
 267     if ( !AllocBuffer(nLen) ) {
 268       // allocation failures are handled by the caller
 269       return false;
 270     }
 271   }
 272   else {
 273     if ( nLen > pData->nAllocLength ) {
 274       // realloc the buffer instead of calling malloc() again, this is more
 275       // efficient
 276       STATISTICS_ADD(Length, nLen);
 277
 278       nLen += EXTRA_ALLOC;
 279
 280       pData = (wxStringData*)
 281           realloc(pData,
 282                   sizeof(wxStringData) + (nLen + 1)*sizeof(wxStringCharType));
 283
 284       if ( pData == NULL ) {
 285         // allocation failures are handled by the caller
 286         // keep previous data since reallocation failed
 287         return false;
 288       }
 289
 290       pData->nAllocLength = nLen;
 291       m_pchData = pData->data();
 292     }
 293   }
 294
 295   wxASSERT( !GetStringData()->IsShared() );  // we must be the only owner
 296
 297   // it doesn't really matter what the string length is as it's going to be
 298   // overwritten later but, for extra safety, set it to 0 for now as we may
 299   // have some junk in m_pchData
 300   GetStringData()->nDataLength = 0;
 301
 302   return true;
 303 }
 304
 305 wxStringImpl& wxStringImpl::append(size_t n, wxStringCharType ch)
 306 {
 307     size_type len = length();
 308
 309     if ( !Alloc(len + n) || !CopyBeforeWrite() ) {
 310       wxFAIL_MSG( _T("out of memory in wxStringImpl::append") );
 311       return *this;
 312     }
 313     GetStringData()->nDataLength = len + n;
 314     m_pchData[len + n] = '\0';
 315     for ( size_t i = 0; i < n; ++i )
 316         m_pchData[len + i] = ch;
 317     return *this;
 318 }
 319
 320 void wxStringImpl::resize(size_t nSize, wxStringCharType ch)
 321 {
 322     size_t len = length();
 323
 324     if ( nSize < len )
 325     {
 326         erase(begin() + nSize, end());
 327     }
 328     else if ( nSize > len )
 329     {
 330         append(nSize - len, ch);
 331     }
 332     //else: we have exactly the specified length, nothing to do
 333 }
 334
 335 // allocate enough memory for nLen characters
 336 bool wxStringImpl::Alloc(size_t nLen)
 337 {
 338   wxStringData *pData = GetStringData();
 339   if ( pData->nAllocLength <= nLen ) {
 340     if ( pData->IsEmpty() ) {
 341       nLen += EXTRA_ALLOC;
 342
 343       pData = (wxStringData *)
 344              malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(wxStringCharType));
 345
 346       if ( pData == NULL ) {
 347         // allocation failure handled by caller
 348         return false;
 349       }
 350
 351       pData->nRefs = 1;
 352       pData->nDataLength = 0;
 353       pData->nAllocLength = nLen;
 354       m_pchData = pData->data();  // data starts after wxStringData
 355       m_pchData[0u] = wxT('\0');
 356     }
 357     else if ( pData->IsShared() ) {
 358       pData->Unlock();                // memory not freed because shared
 359       size_t nOldLen = pData->nDataLength;
 360       if ( !AllocBuffer(nLen) ) {
 361         // allocation failure handled by caller
 362         return false;
 363       }
 364       // +1 to copy the terminator, too
 365       memcpy(m_pchData, pData->data(), (nOldLen+1)*sizeof(wxStringCharType));
 366       GetStringData()->nDataLength = nOldLen;
 367     }
 368     else {
 369       nLen += EXTRA_ALLOC;
 370
 371       pData = (wxStringData *)
 372         realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxStringCharType));
 373
 374       if ( pData == NULL ) {
 375         // allocation failure handled by caller
 376         // keep previous data since reallocation failed
 377         return false;
 378       }
 379
 380       // it's not important if the pointer changed or not (the check for this
 381       // is not faster than assigning to m_pchData in all cases)
 382       pData->nAllocLength = nLen;
 383       m_pchData = pData->data();
 384     }
 385   }
 386   //else: we've already got enough
 387   return true;
 388 }
 389
 390 wxStringImpl::iterator wxStringImpl::begin()
 391 {
 392     if (length() > 0)
 393         CopyBeforeWrite();
 394     return m_pchData;
 395 }
 396
 397 wxStringImpl::iterator wxStringImpl::end()
 398 {
 399     if (length() > 0)
 400         CopyBeforeWrite();
 401     return m_pchData + length();
 402 }
 403
 404 wxStringImpl::iterator wxStringImpl::erase(iterator it)
 405 {
 406     size_type idx = it - begin();
 407     erase(idx, 1);
 408     return begin() + idx;
 409 }
 410
 411 wxStringImpl& wxStringImpl::erase(size_t nStart, size_t nLen)
 412 {
 413     wxASSERT(nStart <= length());
 414     size_t strLen = length() - nStart;
 415     // delete nLen or up to the end of the string characters
 416     nLen = strLen < nLen ? strLen : nLen;
 417     wxStringImpl strTmp(c_str(), nStart);
 418     strTmp.append(c_str() + nStart + nLen, length() - nStart - nLen);
 419
 420     swap(strTmp);
 421     return *this;
 422 }
 423
 424 wxStringImpl& wxStringImpl::insert(size_t nPos,
 425                                    const wxStringCharType *sz, size_t n)
 426 {
 427     wxASSERT( nPos <= length() );
 428
 429     if ( n == npos ) n = Strsize(sz);
 430     if ( n == 0 ) return *this;
 431
 432     if ( !Alloc(length() + n) || !CopyBeforeWrite() ) {
 433         wxFAIL_MSG( _T("out of memory in wxStringImpl::insert") );
 434         return *this;
 435     }
 436
 437     memmove(m_pchData + nPos + n, m_pchData + nPos,
 438             (length() - nPos) * sizeof(wxStringCharType));
 439     memcpy(m_pchData + nPos, sz, n * sizeof(wxStringCharType));
 440     GetStringData()->nDataLength = length() + n;
 441     m_pchData[length()] = '\0';
 442
 443     return *this;
 444 }
 445
 446 void wxStringImpl::swap(wxStringImpl& str)
 447 {
 448     wxStringCharType* tmp = str.m_pchData;
 449     str.m_pchData = m_pchData;
 450     m_pchData = tmp;
 451 }
 452
 453 size_t wxStringImpl::find(const wxStringImpl& str, size_t nStart) const
 454 {
 455     // deal with the special case of empty string first
 456     const size_t nLen = length();
 457     const size_t nLenOther = str.length();
 458
 459     if ( !nLenOther )
 460     {
 461         // empty string is a substring of anything
 462         return 0;
 463     }
 464
 465     if ( !nLen )
 466     {
 467         // the other string is non empty so can't be our substring
 468         return npos;
 469     }
 470
 471     wxASSERT( str.GetStringData()->IsValid() );
 472     wxASSERT( nStart <= nLen );
 473
 474     const wxStringCharType * const other = str.c_str();
 475
 476     // anchor
 477     const wxStringCharType* p =
 478         (const wxStringCharType*)wxStringMemchr(c_str() + nStart,
 479                                                 *other,
 480                                                 nLen - nStart);
 481
 482     if ( !p )
 483         return npos;
 484
 485     while ( p - c_str() + nLenOther <= nLen &&
 486             wxStringMemcmp(p, other, nLenOther) )
 487     {
 488         p++;
 489
 490         // anchor again
 491         p = (const wxStringCharType*)
 492                 wxStringMemchr(p, *other, nLen - (p - c_str()));
 493
 494         if ( !p )
 495             return npos;
 496     }
 497
 498     return p - c_str() + nLenOther <= nLen ? p - c_str() : npos;
 499 }
 500
 501 size_t wxStringImpl::find(const wxStringCharType* sz,
 502                           size_t nStart, size_t n) const
 503 {
 504     return find(wxStringImpl(sz, n), nStart);
 505 }
 506
 507 size_t wxStringImpl::find(wxStringCharType ch, size_t nStart) const
 508 {
 509     wxASSERT( nStart <= length() );
 510
 511     const wxStringCharType *p = (const wxStringCharType*)
 512         wxStringMemchr(c_str() + nStart, ch, length() - nStart);
 513
 514     return p == NULL ? npos : p - c_str();
 515 }
 516
 517 size_t wxStringImpl::rfind(const wxStringImpl& str, size_t nStart) const
 518 {
 519     wxASSERT( str.GetStringData()->IsValid() );
 520     wxASSERT( nStart == npos || nStart <= length() );
 521
 522     if ( length() >= str.length() )
 523     {
 524         // avoids a corner case later
 525         if ( length() == 0 && str.length() == 0 )
 526             return 0;
 527
 528         // "top" is the point where search starts from
 529         size_t top = length() - str.length();
 530
 531         if ( nStart == npos )
 532             nStart = length() - 1;
 533         if ( nStart < top )
 534             top = nStart;
 535
 536         const wxStringCharType *cursor = c_str() + top;
 537         do
 538         {
 539             if ( wxStringMemcmp(cursor, str.c_str(), str.length()) == 0 )
 540             {
 541                 return cursor - c_str();
 542             }
 543         } while ( cursor-- > c_str() );
 544     }
 545
 546     return npos;
 547 }
 548
 549 size_t wxStringImpl::rfind(const wxStringCharType* sz,
 550                            size_t nStart, size_t n) const
 551 {
 552     return rfind(wxStringImpl(sz, n), nStart);
 553 }
 554
 555 size_t wxStringImpl::rfind(wxStringCharType ch, size_t nStart) const
 556 {
 557     if ( nStart == npos )
 558     {
 559         nStart = length();
 560     }
 561     else
 562     {
 563         wxASSERT( nStart <= length() );
 564     }
 565
 566     const wxStringCharType *actual;
 567     for ( actual = c_str() + ( nStart == npos ? length() : nStart + 1 );
 568           actual > c_str(); --actual )
 569     {
 570         if ( *(actual - 1) == ch )
 571             return (actual - 1) - c_str();
 572     }
 573
 574     return npos;
 575 }
 576
 577 wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
 578                                     const wxStringCharType *sz)
 579 {
 580   wxASSERT_MSG( nStart <= length(),
 581                 _T("index out of bounds in wxStringImpl::replace") );
 582   size_t strLen = length() - nStart;
 583   nLen = strLen < nLen ? strLen : nLen;
 584
 585   wxStringImpl strTmp;
 586   strTmp.reserve(length()); // micro optimisation to avoid multiple mem allocs
 587
 588   //This is kind of inefficient, but its pretty good considering...
 589   //we don't want to use character access operators here because on STL
 590   //it will freeze the reference count of strTmp, which means a deep copy
 591   //at the end when swap is called
 592   //
 593   //Also, we can't use append with the full character pointer and must
 594   //do it manually because this string can contain null characters
 595   for(size_t i1 = 0; i1 < nStart; ++i1)
 596       strTmp.append(1, this->c_str()[i1]);
 597
 598   //its safe to do the full version here because
 599   //sz must be a normal c string
 600   strTmp.append(sz);
 601
 602   for(size_t i2 = nStart + nLen; i2 < length(); ++i2)
 603       strTmp.append(1, this->c_str()[i2]);
 604
 605   swap(strTmp);
 606   return *this;
 607 }
 608
 609 wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
 610                                     size_t nCount, wxStringCharType ch)
 611 {
 612   return replace(nStart, nLen, wxStringImpl(nCount, ch).c_str());
 613 }
 614
 615 wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
 616                                     const wxStringImpl& str,
 617                                     size_t nStart2, size_t nLen2)
 618 {
 619   return replace(nStart, nLen, str.substr(nStart2, nLen2));
 620 }
 621
 622 wxStringImpl& wxStringImpl::replace(size_t nStart, size_t nLen,
 623                                     const wxStringCharType* sz, size_t nCount)
 624 {
 625   return replace(nStart, nLen, wxStringImpl(sz, nCount).c_str());
 626 }
 627
 628 wxStringImpl wxStringImpl::substr(size_t nStart, size_t nLen) const
 629 {
 630   if ( nLen == npos )
 631     nLen = length() - nStart;
 632   return wxStringImpl(*this, nStart, nLen);
 633 }
 634
 635 // assigns one string to another
 636 wxStringImpl& wxStringImpl::operator=(const wxStringImpl& stringSrc)
 637 {
 638   wxASSERT( stringSrc.GetStringData()->IsValid() );
 639
 640   // don't copy string over itself
 641   if ( m_pchData != stringSrc.m_pchData ) {
 642     if ( stringSrc.GetStringData()->IsEmpty() ) {
 643       Reinit();
 644     }
 645     else {
 646       // adjust references
 647       GetStringData()->Unlock();
 648       m_pchData = stringSrc.m_pchData;
 649       GetStringData()->Lock();
 650     }
 651   }
 652
 653   return *this;
 654 }
 655
 656 // assigns a single character
 657 wxStringImpl& wxStringImpl::operator=(wxStringCharType ch)
 658 {
 659   wxStringCharType c(ch);
 660   if ( !AssignCopy(1, &c) ) {
 661     wxFAIL_MSG( _T("out of memory in wxStringImpl::operator=(wxStringCharType)") );
 662   }
 663   return *this;
 664 }
 665
 666 // assigns C string
 667 wxStringImpl& wxStringImpl::operator=(const wxStringCharType *psz)
 668 {
 669   if ( !AssignCopy(Strsize(psz), psz) ) {
 670     wxFAIL_MSG( _T("out of memory in wxStringImpl::operator=(const wxStringCharType *)") );
 671   }
 672   return *this;
 673 }
 674
 675 // helper function: does real copy
 676 bool wxStringImpl::AssignCopy(size_t nSrcLen,
 677                               const wxStringCharType *pszSrcData)
 678 {
 679   if ( nSrcLen == 0 ) {
 680     Reinit();
 681   }
 682   else {
 683     if ( !AllocBeforeWrite(nSrcLen) ) {
 684       // allocation failure handled by caller
 685       return false;
 686     }
 687     memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxStringCharType));
 688     GetStringData()->nDataLength = nSrcLen;
 689     m_pchData[nSrcLen] = wxT('\0');
 690   }
 691   return true;
 692 }
 693
 694 // ---------------------------------------------------------------------------
 695 // string concatenation
 696 // ---------------------------------------------------------------------------
 697
 698 // add something to this string
 699 bool wxStringImpl::ConcatSelf(size_t nSrcLen,
 700                               const wxStringCharType *pszSrcData,
 701                               size_t nMaxLen)
 702 {
 703   STATISTICS_ADD(SummandLength, nSrcLen);
 704
 705   nSrcLen = nSrcLen < nMaxLen ? nSrcLen : nMaxLen;
 706
 707   // concatenating an empty string is a NOP
 708   if ( nSrcLen > 0 ) {
 709     wxStringData *pData = GetStringData();
 710     size_t nLen = pData->nDataLength;
 711     size_t nNewLen = nLen + nSrcLen;
 712
 713     // alloc new buffer if current is too small
 714     if ( pData->IsShared() ) {
 715       STATISTICS_ADD(ConcatHit, 0);
 716
 717       // we have to allocate another buffer
 718       wxStringData* pOldData = GetStringData();
 719       if ( !AllocBuffer(nNewLen) ) {
 720           // allocation failure handled by caller
 721           return false;
 722       }
 723       memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxStringCharType));
 724       pOldData->Unlock();
 725     }
 726     else if ( nNewLen > pData->nAllocLength ) {
 727       STATISTICS_ADD(ConcatHit, 0);
 728
 729       reserve(nNewLen);
 730       // we have to grow the buffer
 731       if ( capacity() < nNewLen ) {
 732           // allocation failure handled by caller
 733           return false;
 734       }
 735     }
 736     else {
 737       STATISTICS_ADD(ConcatHit, 1);
 738
 739       // the buffer is already big enough
 740     }
 741
 742     // should be enough space
 743     wxASSERT( nNewLen <= GetStringData()->nAllocLength );
 744
 745     // fast concatenation - all is done in our buffer
 746     memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(wxStringCharType));
 747
 748     m_pchData[nNewLen] = wxT('\0');          // put terminating '\0'
 749     GetStringData()->nDataLength = nNewLen; // and fix the length
 750   }
 751   //else: the string to append was empty
 752   return true;
 753 }
 754
 755 #if !wxUSE_UNICODE_UTF8
 756 // get the pointer to writable buffer of (at least) nLen bytes
 757 wxChar *wxStringImpl::DoGetWriteBuf(size_t nLen)
 758 {
 759   if ( !AllocBeforeWrite(nLen) ) {
 760     // allocation failure handled by caller
 761     return NULL;
 762   }
 763
 764   wxASSERT( GetStringData()->nRefs == 1 );
 765   GetStringData()->Validate(false);
 766
 767   return m_pchData;
 768 }
 769
 770 // put string back in a reasonable state after GetWriteBuf
 771 void wxStringImpl::DoUngetWriteBuf()
 772 {
 773   DoUngetWriteBuf(Strsize(m_pchData));
 774 }
 775
 776 void wxStringImpl::DoUngetWriteBuf(size_t nLen)
 777 {
 778   wxStringData * const pData = GetStringData();
 779
 780   wxASSERT_MSG( nLen < pData->nAllocLength, _T("buffer overrun") );
 781
 782   // the strings we store are always NUL-terminated
 783   pData->data()[nLen] = _T('\0');
 784   pData->nDataLength = nLen;
 785   pData->Validate(true);
 786 }
 787 #endif // !wxUSE_UNICODE_UTF8
 788
 789 #endif // !wxUSE_STL_BASED_WXSTRING