]> git.saurik.com Git - wxWidgets.git/blame - src/common/string.cpp
added wxStringStream classes
[wxWidgets.git] / src / common / string.cpp
CommitLineData
c801d85f
KB
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>
65571936 9// Licence: wxWindows licence
c801d85f
KB
10/////////////////////////////////////////////////////////////////////////////
11
14f355c2 12#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
30b21f9a 13 #pragma implementation "string.h"
c801d85f
KB
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__
30b21f9a 31 #pragma hdrstop
c801d85f
KB
32#endif
33
34#ifndef WX_PRECOMP
3c024cc2
VZ
35 #include "wx/defs.h"
36 #include "wx/string.h"
37 #include "wx/intl.h"
3096bd2f 38 #include "wx/thread.h"
6b769f3d 39#endif
c801d85f
KB
40
41#include <ctype.h>
42#include <string.h>
43#include <stdlib.h>
44
ce3ed50d 45#ifdef __SALFORDC__
30b21f9a 46 #include <clib.h>
ce3ed50d
JS
47#endif
48
3168a13f
VZ
49// allocating extra space for each string consumes more memory but speeds up
50// the concatenation operations (nLen is the current string's length)
77ca46e7
VZ
51// NB: EXTRA_ALLOC must be >= 0!
52#define EXTRA_ALLOC (19 - nLen % 16)
3168a13f 53
c801d85f
KB
54// ---------------------------------------------------------------------------
55// static class variables definition
56// ---------------------------------------------------------------------------
57
75ad8feb
DW
58#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
59// must define this static for VA or else you get multiply defined symbols
60// everywhere
61const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
62#endif // Visual Age
63
e87b7833
MB
64#if !wxUSE_STL
65 const size_t wxStringBase::npos = wxSTRING_MAXLEN;
66#endif
c801d85f 67
3168a13f
VZ
68// ----------------------------------------------------------------------------
69// static data
70// ----------------------------------------------------------------------------
c801d85f 71
e87b7833
MB
72#if wxUSE_STL
73
74extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = _T("");
75
76#else
77
3c024cc2
VZ
78// for an empty string, GetStringData() will return this address: this
79// structure has the same layout as wxStringData and it's data() method will
80// return the empty string (dummy pointer)
81static const struct
82{
83 wxStringData data;
2bb67b80 84 wxChar dummy;
223d09f6 85} g_strEmpty = { {-1, 0, 0}, wxT('\0') };
3c024cc2 86
c801d85f 87// empty C style string: points to 'string data' byte of g_strEmpty
fd242375 88extern const wxChar WXDLLIMPEXP_BASE *wxEmptyString = &g_strEmpty.dummy;
c801d85f 89
e87b7833
MB
90#endif
91
3168a13f 92// ----------------------------------------------------------------------------
c801d85f 93// global functions
3168a13f 94// ----------------------------------------------------------------------------
c801d85f 95
e87b7833 96#if wxUSE_STD_IOSTREAM
c801d85f
KB
97
98// MS Visual C++ version 5.0 provides the new STL headers as well as the old
99// iostream ones.
100//
101// ATTN: you can _not_ use both of these in the same program!
a38b83c3 102
6eaebb29
JS
103#include <iostream>
104
dd107c50 105wxSTD istream& operator>>(wxSTD istream& is, wxString& WXUNUSED(str))
c801d85f
KB
106{
107#if 0
108 int w = is.width(0);
109 if ( is.ipfx(0) ) {
3f4a0c5b 110 streambuf *sb = is.rdbuf();
c801d85f
KB
111 str.erase();
112 while ( true ) {
113 int ch = sb->sbumpc ();
114 if ( ch == EOF ) {
3f4a0c5b 115 is.setstate(ios::eofbit);
c801d85f
KB
116 break;
117 }
118 else if ( isspace(ch) ) {
119 sb->sungetc();
120 break;
121 }
dd1eaa89 122
c801d85f
KB
123 str += ch;
124 if ( --w == 1 )
125 break;
126 }
127 }
128
129 is.isfx();
130 if ( str.length() == 0 )
3f4a0c5b 131 is.setstate(ios::failbit);
c801d85f
KB
132#endif
133 return is;
134}
135
dd107c50 136wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
825ba8f0
SB
137{
138 os << str.c_str();
139 return os;
140}
141
e87b7833 142#endif // wxUSE_STD_IOSTREAM
c801d85f 143
3168a13f
VZ
144// ----------------------------------------------------------------------------
145// private classes
146// ----------------------------------------------------------------------------
147
148// this small class is used to gather statistics for performance tuning
149//#define WXSTRING_STATISTICS
150#ifdef WXSTRING_STATISTICS
151 class Averager
152 {
153 public:
f6f5941b 154 Averager(const wxChar *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
2c3b684c 155 ~Averager()
f6f5941b 156 { wxPrintf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
3168a13f 157
c86f1403 158 void Add(size_t n) { m_nTotal += n; m_nCount++; }
3168a13f
VZ
159
160 private:
c86f1403 161 size_t m_nCount, m_nTotal;
f6f5941b 162 const wxChar *m_sz;
3168a13f
VZ
163 } g_averageLength("allocation size"),
164 g_averageSummandLength("summand length"),
165 g_averageConcatHit("hit probability in concat"),
166 g_averageInitialLength("initial string length");
167
168 #define STATISTICS_ADD(av, val) g_average##av.Add(val)
169#else
170 #define STATISTICS_ADD(av, val)
171#endif // WXSTRING_STATISTICS
172
4cc6a9db
VZ
173#if !wxUSE_STL
174
ca5e07c7
GD
175// ===========================================================================
176// wxStringData class deallocation
177// ===========================================================================
178
8ecf21b7
GD
179#if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
180# pragma message (__FILE__ ": building with Multithreaded non DLL runtime has a performance impact on wxString!")
ca5e07c7
GD
181void wxStringData::Free()
182{
183 free(this);
184}
8ecf21b7 185#endif
ca5e07c7 186
c801d85f 187// ===========================================================================
e87b7833 188// wxStringBase
c801d85f
KB
189// ===========================================================================
190
c801d85f 191// takes nLength elements of psz starting at nPos
e87b7833 192void wxStringBase::InitWith(const wxChar *psz, size_t nPos, size_t nLength)
c801d85f
KB
193{
194 Init();
195
f6bcfd97 196 // if the length is not given, assume the string to be NUL terminated
e87b7833 197 if ( nLength == npos ) {
f6bcfd97 198 wxASSERT_MSG( nPos <= wxStrlen(psz), _T("index out of bounds") );
c801d85f 199
f6bcfd97
BP
200 nLength = wxStrlen(psz + nPos);
201 }
6c68273f 202
3168a13f
VZ
203 STATISTICS_ADD(InitialLength, nLength);
204
c801d85f
KB
205 if ( nLength > 0 ) {
206 // trailing '\0' is written in AllocBuffer()
b1801e0e 207 if ( !AllocBuffer(nLength) ) {
e87b7833 208 wxFAIL_MSG( _T("out of memory in wxStringBase::InitWith") );
b1801e0e
GD
209 return;
210 }
2bb67b80 211 memcpy(m_pchData, psz + nPos, nLength*sizeof(wxChar));
c801d85f
KB
212 }
213}
dd1eaa89 214
c801d85f 215// poor man's iterators are "void *" pointers
e87b7833 216wxStringBase::wxStringBase(const void *pStart, const void *pEnd)
c801d85f 217{
2bb67b80
OK
218 InitWith((const wxChar *)pStart, 0,
219 (const wxChar *)pEnd - (const wxChar *)pStart);
c801d85f
KB
220}
221
e87b7833 222wxStringBase::wxStringBase(size_type n, wxChar ch)
c801d85f 223{
e87b7833
MB
224 Init();
225 append(n, ch);
c801d85f 226}
2bb67b80 227
c801d85f
KB
228// ---------------------------------------------------------------------------
229// memory allocation
230// ---------------------------------------------------------------------------
231
232// allocates memory needed to store a C string of length nLen
e87b7833 233bool wxStringBase::AllocBuffer(size_t nLen)
c801d85f 234{
13111b2a
VZ
235 // allocating 0 sized buffer doesn't make sense, all empty strings should
236 // reuse g_strEmpty
237 wxASSERT( nLen > 0 );
238
239 // make sure that we don't overflow
240 wxASSERT( nLen < (INT_MAX / sizeof(wxChar)) -
241 (sizeof(wxStringData) + EXTRA_ALLOC + 1) );
c801d85f 242
3168a13f
VZ
243 STATISTICS_ADD(Length, nLen);
244
c801d85f
KB
245 // allocate memory:
246 // 1) one extra character for '\0' termination
247 // 2) sizeof(wxStringData) for housekeeping info
3168a13f 248 wxStringData* pData = (wxStringData*)
2bb67b80 249 malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(wxChar));
e015c2a3 250
b1801e0e
GD
251 if ( pData == NULL ) {
252 // allocation failures are handled by the caller
253 return FALSE;
254 }
e015c2a3 255
c801d85f 256 pData->nRefs = 1;
c801d85f 257 pData->nDataLength = nLen;
3168a13f 258 pData->nAllocLength = nLen + EXTRA_ALLOC;
c801d85f 259 m_pchData = pData->data(); // data starts after wxStringData
223d09f6 260 m_pchData[nLen] = wxT('\0');
b1801e0e 261 return TRUE;
c801d85f
KB
262}
263
c801d85f 264// must be called before changing this string
e87b7833 265bool wxStringBase::CopyBeforeWrite()
c801d85f
KB
266{
267 wxStringData* pData = GetStringData();
268
269 if ( pData->IsShared() ) {
270 pData->Unlock(); // memory not freed because shared
c86f1403 271 size_t nLen = pData->nDataLength;
b1801e0e
GD
272 if ( !AllocBuffer(nLen) ) {
273 // allocation failures are handled by the caller
274 return FALSE;
275 }
2bb67b80 276 memcpy(m_pchData, pData->data(), nLen*sizeof(wxChar));
c801d85f
KB
277 }
278
3bbb630a 279 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
b1801e0e
GD
280
281 return TRUE;
c801d85f
KB
282}
283
284// must be called before replacing contents of this string
e87b7833 285bool wxStringBase::AllocBeforeWrite(size_t nLen)
c801d85f
KB
286{
287 wxASSERT( nLen != 0 ); // doesn't make any sense
288
289 // must not share string and must have enough space
3168a13f 290 wxStringData* pData = GetStringData();
fbf0c83d 291 if ( pData->IsShared() || pData->IsEmpty() ) {
c801d85f
KB
292 // can't work with old buffer, get new one
293 pData->Unlock();
b1801e0e
GD
294 if ( !AllocBuffer(nLen) ) {
295 // allocation failures are handled by the caller
296 return FALSE;
297 }
c801d85f 298 }
471aebdd 299 else {
fbf0c83d
VZ
300 if ( nLen > pData->nAllocLength ) {
301 // realloc the buffer instead of calling malloc() again, this is more
302 // efficient
303 STATISTICS_ADD(Length, nLen);
304
305 nLen += EXTRA_ALLOC;
306
fbf0c83d
VZ
307 pData = (wxStringData*)
308 realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
e015c2a3 309
b1801e0e
GD
310 if ( pData == NULL ) {
311 // allocation failures are handled by the caller
312 // keep previous data since reallocation failed
313 return FALSE;
fbf0c83d
VZ
314 }
315
316 pData->nAllocLength = nLen;
317 m_pchData = pData->data();
318 }
319
320 // now we have enough space, just update the string length
471aebdd
VZ
321 pData->nDataLength = nLen;
322 }
c801d85f 323
f1da2f03 324 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
b1801e0e
GD
325
326 return TRUE;
c801d85f
KB
327}
328
e87b7833
MB
329wxStringBase& wxStringBase::append(size_t n, wxChar ch)
330{
331 size_type len = length();
332
333 if ( !CopyBeforeWrite() || !Alloc(len + n) ) {
334 wxFAIL_MSG( _T("out of memory in wxStringBase::append") );
335 }
336 GetStringData()->nDataLength = len + n;
337 m_pchData[len + n] = '\0';
338 for ( size_t i = 0; i < n; ++i )
339 m_pchData[len + i] = ch;
340 return *this;
341}
342
343void wxStringBase::resize(size_t nSize, wxChar ch)
344{
345 size_t len = length();
346
347 if ( nSize < len )
348 {
349 erase(begin() + nSize, end());
350 }
351 else if ( nSize > len )
352 {
353 append(nSize - len, ch);
354 }
355 //else: we have exactly the specified length, nothing to do
356}
357
dd1eaa89 358// allocate enough memory for nLen characters
e87b7833 359bool wxStringBase::Alloc(size_t nLen)
dd1eaa89
VZ
360{
361 wxStringData *pData = GetStringData();
362 if ( pData->nAllocLength <= nLen ) {
9fbd8b8d
VZ
363 if ( pData->IsEmpty() ) {
364 nLen += EXTRA_ALLOC;
365
366 wxStringData* pData = (wxStringData*)
b1801e0e
GD
367 malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
368
369 if ( pData == NULL ) {
370 // allocation failure handled by caller
371 return FALSE;
372 }
e015c2a3 373
9fbd8b8d
VZ
374 pData->nRefs = 1;
375 pData->nDataLength = 0;
376 pData->nAllocLength = nLen;
377 m_pchData = pData->data(); // data starts after wxStringData
223d09f6 378 m_pchData[0u] = wxT('\0');
9fbd8b8d 379 }
3168a13f
VZ
380 else if ( pData->IsShared() ) {
381 pData->Unlock(); // memory not freed because shared
c86f1403 382 size_t nOldLen = pData->nDataLength;
b1801e0e
GD
383 if ( !AllocBuffer(nLen) ) {
384 // allocation failure handled by caller
385 return FALSE;
386 }
2bb67b80 387 memcpy(m_pchData, pData->data(), nOldLen*sizeof(wxChar));
3168a13f 388 }
dd1eaa89 389 else {
3168a13f
VZ
390 nLen += EXTRA_ALLOC;
391
b1801e0e 392 pData = (wxStringData *)
2bb67b80 393 realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
3168a13f 394
b1801e0e
GD
395 if ( pData == NULL ) {
396 // allocation failure handled by caller
397 // keep previous data since reallocation failed
398 return FALSE;
dd1eaa89 399 }
3168a13f
VZ
400
401 // it's not important if the pointer changed or not (the check for this
402 // is not faster than assigning to m_pchData in all cases)
b1801e0e
GD
403 pData->nAllocLength = nLen;
404 m_pchData = pData->data();
dd1eaa89
VZ
405 }
406 }
407 //else: we've already got enough
b1801e0e 408 return TRUE;
dd1eaa89 409}
ac3c86ee
VS
410
411wxStringBase::iterator wxStringBase::begin()
412{
413 if (length() > 0)
414 CopyBeforeWrite();
415 return m_pchData;
416}
417
418wxStringBase::iterator wxStringBase::end()
419{
420 if (length() > 0)
421 CopyBeforeWrite();
422 return m_pchData + length();
423}
dd1eaa89 424
e87b7833 425wxStringBase::iterator wxStringBase::erase(iterator it)
dd1eaa89 426{
e87b7833
MB
427 size_type idx = it - begin();
428 erase(idx, 1);
429 return begin() + idx;
430}
3bbb630a 431
e87b7833
MB
432wxStringBase& wxStringBase::erase(size_t nStart, size_t nLen)
433{
434 wxASSERT(nStart <= length());
435 size_t strLen = length() - nStart;
436 // delete nLen or up to the end of the string characters
437 nLen = strLen < nLen ? strLen : nLen;
438 wxString strTmp(c_str(), nStart);
439 strTmp.append(c_str() + nStart + nLen, length() - nStart - nLen);
337a0010 440
e87b7833
MB
441 swap(strTmp);
442 return *this;
443}
337a0010 444
e87b7833
MB
445wxStringBase& wxStringBase::insert(size_t nPos, const wxChar *sz, size_t n)
446{
447 wxASSERT( nPos <= length() );
3bbb630a 448
e87b7833
MB
449 if ( n == npos ) n = wxStrlen(sz);
450 if ( n == 0 ) return *this;
451
452 if ( !CopyBeforeWrite() || !Alloc(length() + n) ) {
453 wxFAIL_MSG( _T("out of memory in wxStringBase::insert") );
337a0010 454 }
fbf0c83d 455
e87b7833
MB
456 memmove(m_pchData + nPos + n, m_pchData + nPos,
457 (length() - nPos) * sizeof(wxChar));
458 memcpy(m_pchData + nPos, sz, n * sizeof(wxChar));
459 GetStringData()->nDataLength = length() + n;
460 m_pchData[length()] = '\0';
b1801e0e 461
e87b7833 462 return *this;
dd1eaa89
VZ
463}
464
e87b7833 465void wxStringBase::swap(wxStringBase& str)
c801d85f 466{
e87b7833
MB
467 wxChar* tmp = str.m_pchData;
468 str.m_pchData = m_pchData;
469 m_pchData = tmp;
c801d85f
KB
470}
471
e87b7833 472size_t wxStringBase::find(const wxStringBase& str, size_t nStart) const
097c080b 473{
e87b7833
MB
474 wxASSERT( str.GetStringData()->IsValid() );
475 wxASSERT( nStart <= length() );
476
477 const wxChar *p = wxStrstr(c_str() + nStart, str.c_str());
478
479 return p == NULL ? npos : p - c_str();
097c080b
VZ
480}
481
e87b7833 482size_t wxStringBase::find(const wxChar* sz, size_t nStart, size_t n) const
8f06a017 483{
e87b7833 484 return find(wxStringBase(sz, n), nStart);
8f06a017
RD
485}
486
e87b7833
MB
487size_t wxStringBase::find(wxChar ch, size_t nStart) const
488{
489 wxASSERT( nStart <= length() );
c801d85f 490
e87b7833 491 const wxChar *p = wxStrchr(c_str() + nStart, ch);
c801d85f 492
e87b7833 493 return p == NULL ? npos : p - c_str();
c801d85f
KB
494}
495
e87b7833 496size_t wxStringBase::rfind(const wxStringBase& str, size_t nStart) const
c801d85f 497{
e2101186
MB
498 wxASSERT( str.GetStringData()->IsValid() );
499 wxASSERT( nStart == npos || nStart <= length() );
500
501 if ( length() >= str.length() )
502 {
503 // avoids a corner case later
504 if ( length() == 0 && str.length() == 0 )
505 return 0;
506
507 // "top" is the point where search starts from
508 size_t top = length() - str.length();
c801d85f 509
e2101186
MB
510 if ( nStart == npos )
511 nStart = length() - 1;
512 if ( nStart < top )
513 top = nStart;
514
515 const wxChar *cursor = c_str() + top;
516 do
517 {
518 if ( memcmp(cursor, str.c_str(),
519 str.length() * sizeof(wxChar)) == 0 )
520 {
521 return cursor - c_str();
522 }
78e6050b 523 } while ( cursor-- > c_str() );
e2101186
MB
524 }
525
526 return npos;
c801d85f
KB
527}
528
e87b7833 529size_t wxStringBase::rfind(const wxChar* sz, size_t nStart, size_t n) const
c801d85f 530{
e87b7833 531 return rfind(wxStringBase(sz, n), nStart);
c801d85f
KB
532}
533
e87b7833 534size_t wxStringBase::rfind(wxChar ch, size_t nStart) const
c801d85f 535{
e87b7833
MB
536 if ( nStart == npos )
537 {
538 nStart = length();
539 }
540 else
541 {
542 wxASSERT( nStart <= length() );
543 }
c801d85f 544
93c83507
MB
545 const wxChar *actual;
546 for ( actual = c_str() + ( nStart == npos ? length() : nStart + 1 );
547 actual > c_str(); --actual )
548 {
549 if ( *(actual - 1) == ch )
550 return (actual - 1) - c_str();
551 }
e87b7833 552
93c83507 553 return npos;
c801d85f
KB
554}
555
e87b7833 556size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart) const
c801d85f 557{
e87b7833
MB
558 const wxChar *start = c_str() + nStart;
559 const wxChar *firstOf = wxStrpbrk(start, sz);
560 if ( firstOf )
561 return firstOf - c_str();
562 else
563 return npos;
c801d85f 564}
e87b7833 565
e2101186
MB
566size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart,
567 size_t n) const
568{
569 return find_first_of(wxStringBase(sz, n), nStart);
570}
571
e87b7833
MB
572size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart) const
573{
574 if ( nStart == npos )
575 {
e2101186 576 nStart = length() - 1;
e87b7833
MB
577 }
578 else
579 {
65c75abe
VZ
580 wxASSERT_MSG( nStart <= length(),
581 _T("invalid index in find_last_of()") );
e87b7833
MB
582 }
583
e2101186 584 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833
MB
585 {
586 if ( wxStrchr(sz, *p) )
587 return p - c_str();
588 }
589
590 return npos;
591}
592
e2101186
MB
593size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart,
594 size_t n) const
595{
596 return find_last_of(wxStringBase(sz, n), nStart);
597}
598
e87b7833
MB
599size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart) const
600{
601 if ( nStart == npos )
602 {
603 nStart = length();
604 }
605 else
606 {
607 wxASSERT( nStart <= length() );
608 }
609
610 size_t nAccept = wxStrspn(c_str() + nStart, sz);
611 if ( nAccept >= length() - nStart )
612 return npos;
613 else
e2101186
MB
614 return nStart + nAccept;
615}
616
617size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart,
618 size_t n) const
619{
620 return find_first_not_of(wxStringBase(sz, n), nStart);
e87b7833
MB
621}
622
623size_t wxStringBase::find_first_not_of(wxChar ch, size_t nStart) const
624{
625 wxASSERT( nStart <= length() );
626
627 for ( const wxChar *p = c_str() + nStart; *p; p++ )
628 {
629 if ( *p != ch )
630 return p - c_str();
631 }
632
633 return npos;
634}
635
636size_t wxStringBase::find_last_not_of(const wxChar* sz, size_t nStart) const
637{
638 if ( nStart == npos )
639 {
e2101186 640 nStart = length() - 1;
e87b7833
MB
641 }
642 else
643 {
644 wxASSERT( nStart <= length() );
645 }
646
e2101186 647 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833
MB
648 {
649 if ( !wxStrchr(sz, *p) )
650 return p - c_str();
651 }
652
653 return npos;
654}
655
e2101186
MB
656size_t wxStringBase::find_last_not_of(const wxChar* sz, size_t nStart,
657 size_t n) const
658{
659 return find_last_not_of(wxStringBase(sz, n), nStart);
660}
661
e87b7833
MB
662size_t wxStringBase::find_last_not_of(wxChar ch, size_t nStart) const
663{
664 if ( nStart == npos )
665 {
e2101186 666 nStart = length() - 1;
e87b7833
MB
667 }
668 else
669 {
670 wxASSERT( nStart <= length() );
671 }
672
e2101186 673 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833
MB
674 {
675 if ( *p != ch )
676 return p - c_str();
677 }
678
679 return npos;
680}
681
682wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
683 const wxChar *sz)
684{
685 wxASSERT_MSG( nStart <= length(),
686 _T("index out of bounds in wxStringBase::replace") );
687 size_t strLen = length() - nStart;
688 nLen = strLen < nLen ? strLen : nLen;
689
690 wxStringBase strTmp;
691 strTmp.reserve(length()); // micro optimisation to avoid multiple mem allocs
692
693 if ( nStart != 0 )
694 strTmp.append(c_str(), nStart);
695 strTmp.append(sz);
696 strTmp.append(c_str() + nStart + nLen);
697
698 swap(strTmp);
699 return *this;
700}
701
702wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
703 size_t nCount, wxChar ch)
704{
705 return replace(nStart, nLen, wxStringBase(ch, nCount).c_str());
706}
707
708wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
709 const wxStringBase& str,
710 size_t nStart2, size_t nLen2)
711{
712 return replace(nStart, nLen, str.substr(nStart2, nLen2));
713}
714
715wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
716 const wxChar* sz, size_t nCount)
717{
718 return replace(nStart, nLen, wxStringBase(sz, nCount).c_str());
719}
720
721wxStringBase wxStringBase::substr(size_t nStart, size_t nLen) const
722{
723 if ( nLen == npos )
724 nLen = length() - nStart;
725 return wxStringBase(*this, nStart, nLen);
726}
727
728// assigns one string to another
729wxStringBase& wxStringBase::operator=(const wxStringBase& stringSrc)
730{
731 wxASSERT( stringSrc.GetStringData()->IsValid() );
732
733 // don't copy string over itself
734 if ( m_pchData != stringSrc.m_pchData ) {
735 if ( stringSrc.GetStringData()->IsEmpty() ) {
736 Reinit();
737 }
738 else {
739 // adjust references
740 GetStringData()->Unlock();
741 m_pchData = stringSrc.m_pchData;
742 GetStringData()->Lock();
743 }
744 }
745
746 return *this;
747}
748
749// assigns a single character
750wxStringBase& wxStringBase::operator=(wxChar ch)
751{
752 if ( !AssignCopy(1, &ch) ) {
753 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(wxChar)") );
754 }
755 return *this;
756}
757
758// assigns C string
759wxStringBase& wxStringBase::operator=(const wxChar *psz)
760{
761 if ( !AssignCopy(wxStrlen(psz), psz) ) {
762 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(const wxChar *)") );
763 }
764 return *this;
765}
766
767// helper function: does real copy
768bool wxStringBase::AssignCopy(size_t nSrcLen, const wxChar *pszSrcData)
769{
770 if ( nSrcLen == 0 ) {
771 Reinit();
772 }
773 else {
774 if ( !AllocBeforeWrite(nSrcLen) ) {
775 // allocation failure handled by caller
776 return FALSE;
777 }
778 memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
779 GetStringData()->nDataLength = nSrcLen;
780 m_pchData[nSrcLen] = wxT('\0');
781 }
782 return TRUE;
783}
784
785// ---------------------------------------------------------------------------
786// string concatenation
787// ---------------------------------------------------------------------------
c801d85f 788
c801d85f 789// add something to this string
e87b7833
MB
790bool wxStringBase::ConcatSelf(size_t nSrcLen, const wxChar *pszSrcData,
791 size_t nMaxLen)
c801d85f 792{
3168a13f 793 STATISTICS_ADD(SummandLength, nSrcLen);
c801d85f 794
e87b7833
MB
795 nSrcLen = nSrcLen < nMaxLen ? nSrcLen : nMaxLen;
796
05488905
VZ
797 // concatenating an empty string is a NOP
798 if ( nSrcLen > 0 ) {
799 wxStringData *pData = GetStringData();
800 size_t nLen = pData->nDataLength;
801 size_t nNewLen = nLen + nSrcLen;
c801d85f 802
05488905
VZ
803 // alloc new buffer if current is too small
804 if ( pData->IsShared() ) {
805 STATISTICS_ADD(ConcatHit, 0);
3168a13f 806
05488905
VZ
807 // we have to allocate another buffer
808 wxStringData* pOldData = GetStringData();
b1801e0e
GD
809 if ( !AllocBuffer(nNewLen) ) {
810 // allocation failure handled by caller
811 return FALSE;
812 }
2bb67b80 813 memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxChar));
05488905
VZ
814 pOldData->Unlock();
815 }
816 else if ( nNewLen > pData->nAllocLength ) {
817 STATISTICS_ADD(ConcatHit, 0);
3168a13f 818
e87b7833 819 reserve(nNewLen);
05488905 820 // we have to grow the buffer
e87b7833 821 if ( capacity() < nNewLen ) {
b1801e0e
GD
822 // allocation failure handled by caller
823 return FALSE;
824 }
05488905
VZ
825 }
826 else {
827 STATISTICS_ADD(ConcatHit, 1);
3168a13f 828
05488905
VZ
829 // the buffer is already big enough
830 }
3168a13f 831
05488905
VZ
832 // should be enough space
833 wxASSERT( nNewLen <= GetStringData()->nAllocLength );
3168a13f 834
05488905 835 // fast concatenation - all is done in our buffer
2bb67b80 836 memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(wxChar));
3168a13f 837
e87b7833
MB
838 m_pchData[nNewLen] = wxT('\0'); // put terminating '\0'
839 GetStringData()->nDataLength = nNewLen; // and fix the length
840 }
841 //else: the string to append was empty
842 return TRUE;
843}
844
845// ---------------------------------------------------------------------------
846// simple sub-string extraction
847// ---------------------------------------------------------------------------
848
849// helper function: clone the data attached to this string
850bool wxStringBase::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const
851{
852 if ( nCopyLen == 0 ) {
853 dest.Init();
854 }
855 else {
856 if ( !dest.AllocBuffer(nCopyLen) ) {
857 // allocation failure handled by caller
858 return FALSE;
859 }
860 memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(wxChar));
861 }
862 return TRUE;
863}
864
865#endif // !wxUSE_STL
866
867#if !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
868
869#if !wxUSE_STL
870 #define STRINGCLASS wxStringBase
871#else
872 #define STRINGCLASS wxString
873#endif
874
875static inline int wxDoCmp(const wxChar* s1, size_t l1,
876 const wxChar* s2, size_t l2)
877{
878 if( l1 == l2 )
879 return wxStrncmp(s1, s2, l1);
880 else if( l1 < l2 )
881 {
882 int ret = wxStrncmp(s1, s2, l1);
883 return ret == 0 ? -1 : ret;
884 }
885 else if( l1 > l2 )
886 {
887 int ret = wxStrncmp(s1, s2, l2);
888 return ret == 0 ? +1 : ret;
889 }
890
891 wxFAIL; // must never get there
892 return 0; // quiet compilers
893}
894
895#if wxUSE_STL
896
897int STRINGCLASS::compare(const wxStringBase& str) const
898{
899 return ::wxDoCmp(data(), length(), str.data(), str.length());
900}
901
902#endif
903
904int STRINGCLASS::compare(size_t nStart, size_t nLen,
905 const wxStringBase& str) const
906{
907 wxASSERT(nStart <= length());
908 size_type strLen = length() - nStart;
909 nLen = strLen < nLen ? strLen : nLen;
910 return ::wxDoCmp(data() + nStart, nLen, str.data(), str.length());
911}
912
913int STRINGCLASS::compare(size_t nStart, size_t nLen,
914 const wxStringBase& str,
915 size_t nStart2, size_t nLen2) const
916{
917 wxASSERT(nStart <= length());
918 wxASSERT(nStart2 <= str.length());
919 size_type strLen = length() - nStart,
920 strLen2 = str.length() - nStart2;
921 nLen = strLen < nLen ? strLen : nLen;
922 nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
923 return ::wxDoCmp(data() + nStart, nLen, str.data() + nStart2, nLen2);
924}
925
926#if wxUSE_STL
927
928int STRINGCLASS::compare(const wxChar* sz) const
929{
930 size_t nLen = wxStrlen(sz);
931 return ::wxDoCmp(data(), length(), sz, nLen);
932}
933
934#endif
935
936int STRINGCLASS::compare(size_t nStart, size_t nLen,
937 const wxChar* sz, size_t nCount) const
938{
939 wxASSERT(nStart <= length());
940 size_type strLen = length() - nStart;
941 nLen = strLen < nLen ? strLen : nLen;
942 if( nCount == npos )
943 nCount = wxStrlen(sz);
944
945 return ::wxDoCmp(data() + nStart, nLen, sz, nCount);
946}
947
948#undef STRINGCLASS
949
950#endif // !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
951
952// ===========================================================================
953// wxString class core
954// ===========================================================================
955
956// ---------------------------------------------------------------------------
957// construction
958// ---------------------------------------------------------------------------
959
960#if wxUSE_UNICODE
961
962// from multibyte string
963wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
964{
31444b6a
VS
965 // if nLength != npos, then we have to make a NULL-terminated copy
966 // of first nLength bytes of psz first because the input buffer to MB2WC
967 // must always be NULL-terminated:
968 wxCharBuffer inBuf((const char *)NULL);
969 if (nLength != npos)
970 {
b65ee6fd 971 wxASSERT( psz != NULL );
31444b6a
VS
972 wxCharBuffer tmp(nLength);
973 memcpy(tmp.data(), psz, nLength);
974 tmp.data()[nLength] = '\0';
975 inBuf = tmp;
976 psz = inBuf.data();
977 }
978
e87b7833
MB
979 // first get the size of the buffer we need
980 size_t nLen;
981 if ( psz )
982 {
983 // calculate the needed size ourselves or use the provided one
31444b6a 984 nLen = conv.MB2WC(NULL, psz, 0);
e87b7833
MB
985 }
986 else
987 {
988 // nothing to convert
989 nLen = 0;
990 }
991
992 // anything to do?
993 if ( (nLen != 0) && (nLen != (size_t)-1) )
994 {
995 if ( !Alloc(nLen) )
996 {
997 wxFAIL_MSG( _T("out of memory in wxString::wxString") );
998 }
999 else
1000 {
bb171551 1001 wxWCharBuffer buf(nLen);
e87b7833 1002 // MB2WC wants the buffer size, not the string length hence +1
31444b6a 1003 nLen = conv.MB2WC(buf.data(), psz, nLen + 1);
e87b7833
MB
1004
1005 if ( nLen != (size_t)-1 )
1006 {
1007 // initialized ok, set the real length as nLength specified by
1008 // the caller could be greater than the real string length
1009 assign(buf.data(), nLen);
1010 return;
1011 }
1012 //else: the conversion failed -- leave the string empty (what else?)
1013 }
1014 }
1015}
1016
1017#else // ANSI
1018
1019#if wxUSE_WCHAR_T
1020// from wide string
1021wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength)
1022{
31444b6a
VS
1023 // if nLength != npos, then we have to make a NULL-terminated copy
1024 // of first nLength chars of psz first because the input buffer to WC2MB
1025 // must always be NULL-terminated:
1026 wxWCharBuffer inBuf((const wchar_t *)NULL);
1027 if (nLength != npos)
1028 {
b65ee6fd 1029 wxASSERT( pwz != NULL );
31444b6a
VS
1030 wxWCharBuffer tmp(nLength);
1031 memcpy(tmp.data(), pwz, nLength * sizeof(wchar_t));
1032 tmp.data()[nLength] = '\0';
1033 inBuf = tmp;
1034 pwz = inBuf.data();
1035 }
1036
e87b7833
MB
1037 // first get the size of the buffer we need
1038 size_t nLen;
1039 if ( pwz )
1040 {
1041 // calculate the needed size ourselves or use the provided one
31444b6a 1042 nLen = conv.WC2MB(NULL, pwz, 0);
e87b7833
MB
1043 }
1044 else
1045 {
1046 // nothing to convert
1047 nLen = 0;
1048 }
1049
1050 // anything to do?
1051 if ( (nLen != 0) && (nLen != (size_t)-1) )
1052 {
1053 if ( !Alloc(nLen) )
1054 {
1055 wxFAIL_MSG( _T("out of memory in wxString::wxString") );
1056 }
1057 else
1058 {
1059 wxCharBuffer buf(nLen);
1060 // WC2MB wants the buffer size, not the string length
1061 if ( conv.WC2MB(buf.data(), pwz, nLen + 1) != (size_t)-1 )
1062 {
1063 // initialized ok
1064 assign(buf.data(), nLen);
1065 return;
1066 }
1067 //else: the conversion failed -- leave the string empty (what else?)
1068 }
1069 }
1070
1071 // leave empty
1072}
1073#endif // wxUSE_WCHAR_T
1074
1075#endif // Unicode/ANSI
1076
1077// shrink to minimal size (releasing extra memory)
1078bool wxString::Shrink()
1079{
1080 wxString tmp(begin(), end());
1081 swap(tmp);
1082 return tmp.length() == length();
1083}
1084
1085#if !wxUSE_STL
1086// get the pointer to writable buffer of (at least) nLen bytes
1087wxChar *wxString::GetWriteBuf(size_t nLen)
1088{
1089 if ( !AllocBeforeWrite(nLen) ) {
1090 // allocation failure handled by caller
1091 return NULL;
1092 }
1093
1094 wxASSERT( GetStringData()->nRefs == 1 );
1095 GetStringData()->Validate(FALSE);
1096
1097 return m_pchData;
1098}
1099
1100// put string back in a reasonable state after GetWriteBuf
1101void wxString::UngetWriteBuf()
1102{
1103 GetStringData()->nDataLength = wxStrlen(m_pchData);
1104 GetStringData()->Validate(TRUE);
1105}
1106
1107void wxString::UngetWriteBuf(size_t nLen)
1108{
1109 GetStringData()->nDataLength = nLen;
1110 GetStringData()->Validate(TRUE);
1111}
1112#endif
1113
1114// ---------------------------------------------------------------------------
1115// data access
1116// ---------------------------------------------------------------------------
1117
1118// all functions are inline in string.h
1119
1120// ---------------------------------------------------------------------------
1121// assignment operators
1122// ---------------------------------------------------------------------------
1123
1124#if !wxUSE_UNICODE
1125
1126// same as 'signed char' variant
1127wxString& wxString::operator=(const unsigned char* psz)
1128{
1129 *this = (const char *)psz;
1130 return *this;
1131}
1132
1133#if wxUSE_WCHAR_T
1134wxString& wxString::operator=(const wchar_t *pwz)
1135{
1136 wxString str(pwz);
1137 swap(str);
1138 return *this;
c801d85f 1139}
e87b7833
MB
1140#endif
1141
1142#endif
c801d85f
KB
1143
1144/*
c801d85f
KB
1145 * concatenation functions come in 5 flavours:
1146 * string + string
1147 * char + string and string + char
1148 * C str + string and string + C str
1149 */
1150
b1801e0e 1151wxString operator+(const wxString& str1, const wxString& str2)
c801d85f 1152{
e87b7833 1153#if !wxUSE_STL
b1801e0e
GD
1154 wxASSERT( str1.GetStringData()->IsValid() );
1155 wxASSERT( str2.GetStringData()->IsValid() );
e87b7833 1156#endif
097c080b 1157
b1801e0e
GD
1158 wxString s = str1;
1159 s += str2;
3168a13f 1160
c801d85f
KB
1161 return s;
1162}
1163
b1801e0e 1164wxString operator+(const wxString& str, wxChar ch)
c801d85f 1165{
e87b7833 1166#if !wxUSE_STL
b1801e0e 1167 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1168#endif
3168a13f 1169
b1801e0e 1170 wxString s = str;
3168a13f 1171 s += ch;
097c080b 1172
c801d85f
KB
1173 return s;
1174}
1175
b1801e0e 1176wxString operator+(wxChar ch, const wxString& str)
c801d85f 1177{
e87b7833 1178#if !wxUSE_STL
b1801e0e 1179 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1180#endif
097c080b 1181
3168a13f 1182 wxString s = ch;
b1801e0e 1183 s += str;
3168a13f 1184
c801d85f
KB
1185 return s;
1186}
1187
b1801e0e 1188wxString operator+(const wxString& str, const wxChar *psz)
c801d85f 1189{
e87b7833 1190#if !wxUSE_STL
b1801e0e 1191 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1192#endif
097c080b 1193
c801d85f 1194 wxString s;
b1801e0e
GD
1195 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1196 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1197 }
1198 s = str;
3168a13f
VZ
1199 s += psz;
1200
c801d85f
KB
1201 return s;
1202}
1203
b1801e0e 1204wxString operator+(const wxChar *psz, const wxString& str)
c801d85f 1205{
e87b7833 1206#if !wxUSE_STL
b1801e0e 1207 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1208#endif
097c080b 1209
c801d85f 1210 wxString s;
b1801e0e
GD
1211 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1212 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1213 }
3168a13f 1214 s = psz;
b1801e0e 1215 s += str;
3168a13f 1216
c801d85f
KB
1217 return s;
1218}
1219
1220// ===========================================================================
1221// other common string functions
1222// ===========================================================================
1223
b1ac3b56 1224#if wxUSE_UNICODE
e015c2a3
VZ
1225
1226wxString wxString::FromAscii(const char *ascii)
b1ac3b56
RR
1227{
1228 if (!ascii)
1229 return wxEmptyString;
e015c2a3 1230
b1ac3b56
RR
1231 size_t len = strlen( ascii );
1232 wxString res;
e015c2a3
VZ
1233
1234 if ( len )
1235 {
1236 wxStringBuffer buf(res, len);
1237
1238 wchar_t *dest = buf;
1239
1240 for ( ;; )
1241 {
1242 if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' )
1243 break;
1244 }
1245 }
1246
b1ac3b56
RR
1247 return res;
1248}
1249
2b5f62a0
VZ
1250wxString wxString::FromAscii(const char ascii)
1251{
1252 // What do we do with '\0' ?
1253
1254 wxString res;
1255 res += (wchar_t)(unsigned char) ascii;
8760bc65 1256
2b5f62a0
VZ
1257 return res;
1258}
1259
b1ac3b56
RR
1260const wxCharBuffer wxString::ToAscii() const
1261{
e015c2a3
VZ
1262 // this will allocate enough space for the terminating NUL too
1263 wxCharBuffer buffer(length());
b1ac3b56 1264
e015c2a3
VZ
1265 signed char *dest = (signed char *)buffer.data();
1266
1267 const wchar_t *pwc = c_str();
1268 for ( ;; )
b1ac3b56 1269 {
e015c2a3
VZ
1270 *dest++ = *pwc > SCHAR_MAX ? '_' : *pwc;
1271
1272 // the output string can't have embedded NULs anyhow, so we can safely
1273 // stop at first of them even if we do have any
1274 if ( !*pwc++ )
1275 break;
b1ac3b56 1276 }
e015c2a3 1277
b1ac3b56
RR
1278 return buffer;
1279}
e015c2a3
VZ
1280
1281#endif // Unicode
b1ac3b56 1282
c801d85f 1283// extract string of length nCount starting at nFirst
c801d85f
KB
1284wxString wxString::Mid(size_t nFirst, size_t nCount) const
1285{
e87b7833 1286 size_t nLen = length();
30d9011f 1287
e87b7833
MB
1288 // default value of nCount is npos and means "till the end"
1289 if ( nCount == npos )
30d9011f
VZ
1290 {
1291 nCount = nLen - nFirst;
1292 }
1293
c801d85f 1294 // out-of-bounds requests return sensible things
30d9011f
VZ
1295 if ( nFirst + nCount > nLen )
1296 {
1297 nCount = nLen - nFirst;
1298 }
c801d85f 1299
30d9011f
VZ
1300 if ( nFirst > nLen )
1301 {
1302 // AllocCopy() will return empty string
c801d85f 1303 nCount = 0;
30d9011f 1304 }
c801d85f 1305
e87b7833
MB
1306 wxString dest(*this, nFirst, nCount);
1307 if ( dest.length() != nCount ) {
b1801e0e
GD
1308 wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1309 }
30d9011f 1310
c801d85f
KB
1311 return dest;
1312}
1313
e87b7833 1314// check that the string starts with prefix and return the rest of the string
f6bcfd97
BP
1315// in the provided pointer if it is not NULL, otherwise return FALSE
1316bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
1317{
1318 wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
1319
1320 // first check if the beginning of the string matches the prefix: note
1321 // that we don't have to check that we don't run out of this string as
1322 // when we reach the terminating NUL, either prefix string ends too (and
1323 // then it's ok) or we break out of the loop because there is no match
1324 const wxChar *p = c_str();
1325 while ( *prefix )
1326 {
1327 if ( *prefix++ != *p++ )
1328 {
1329 // no match
1330 return FALSE;
1331 }
1332 }
1333
1334 if ( rest )
1335 {
1336 // put the rest of the string into provided pointer
1337 *rest = p;
1338 }
1339
1340 return TRUE;
1341}
1342
c801d85f
KB
1343// extract nCount last (rightmost) characters
1344wxString wxString::Right(size_t nCount) const
1345{
e87b7833
MB
1346 if ( nCount > length() )
1347 nCount = length();
c801d85f 1348
e87b7833
MB
1349 wxString dest(*this, length() - nCount, nCount);
1350 if ( dest.length() != nCount ) {
b1801e0e
GD
1351 wxFAIL_MSG( _T("out of memory in wxString::Right") );
1352 }
c801d85f
KB
1353 return dest;
1354}
1355
1356// get all characters after the last occurence of ch
1357// (returns the whole string if ch not found)
2bb67b80 1358wxString wxString::AfterLast(wxChar ch) const
c801d85f
KB
1359{
1360 wxString str;
1361 int iPos = Find(ch, TRUE);
3c67202d 1362 if ( iPos == wxNOT_FOUND )
c801d85f
KB
1363 str = *this;
1364 else
c8cfb486 1365 str = c_str() + iPos + 1;
c801d85f
KB
1366
1367 return str;
1368}
1369
1370// extract nCount first (leftmost) characters
1371wxString wxString::Left(size_t nCount) const
1372{
e87b7833
MB
1373 if ( nCount > length() )
1374 nCount = length();
c801d85f 1375
e87b7833
MB
1376 wxString dest(*this, 0, nCount);
1377 if ( dest.length() != nCount ) {
b1801e0e
GD
1378 wxFAIL_MSG( _T("out of memory in wxString::Left") );
1379 }
c801d85f
KB
1380 return dest;
1381}
1382
1383// get all characters before the first occurence of ch
1384// (returns the whole string if ch not found)
2bb67b80 1385wxString wxString::BeforeFirst(wxChar ch) const
c801d85f 1386{
e87b7833
MB
1387 int iPos = Find(ch);
1388 if ( iPos == wxNOT_FOUND ) iPos = length();
1389 return wxString(*this, 0, iPos);
c801d85f
KB
1390}
1391
1392/// get all characters before the last occurence of ch
1393/// (returns empty string if ch not found)
2bb67b80 1394wxString wxString::BeforeLast(wxChar ch) const
c801d85f
KB
1395{
1396 wxString str;
1397 int iPos = Find(ch, TRUE);
3c67202d 1398 if ( iPos != wxNOT_FOUND && iPos != 0 )
d1c9bbf6 1399 str = wxString(c_str(), iPos);
c801d85f
KB
1400
1401 return str;
1402}
1403
1404/// get all characters after the first occurence of ch
1405/// (returns empty string if ch not found)
2bb67b80 1406wxString wxString::AfterFirst(wxChar ch) const
c801d85f
KB
1407{
1408 wxString str;
1409 int iPos = Find(ch);
3c67202d 1410 if ( iPos != wxNOT_FOUND )
c801d85f
KB
1411 str = c_str() + iPos + 1;
1412
1413 return str;
1414}
1415
1416// replace first (or all) occurences of some substring with another one
a8f1f1b2
VZ
1417size_t
1418wxString::Replace(const wxChar *szOld, const wxChar *szNew, bool bReplaceAll)
c801d85f 1419{
a8f1f1b2
VZ
1420 // if we tried to replace an empty string we'd enter an infinite loop below
1421 wxCHECK_MSG( szOld && *szOld && szNew, 0,
1422 _T("wxString::Replace(): invalid parameter") );
1423
c86f1403 1424 size_t uiCount = 0; // count of replacements made
c801d85f 1425
2bb67b80 1426 size_t uiOldLen = wxStrlen(szOld);
c801d85f
KB
1427
1428 wxString strTemp;
e87b7833 1429 const wxChar *pCurrent = c_str();
2bb67b80 1430 const wxChar *pSubstr;
223d09f6 1431 while ( *pCurrent != wxT('\0') ) {
2bb67b80 1432 pSubstr = wxStrstr(pCurrent, szOld);
c801d85f
KB
1433 if ( pSubstr == NULL ) {
1434 // strTemp is unused if no replacements were made, so avoid the copy
1435 if ( uiCount == 0 )
1436 return 0;
1437
1438 strTemp += pCurrent; // copy the rest
1439 break; // exit the loop
1440 }
1441 else {
1442 // take chars before match
e87b7833
MB
1443 size_type len = strTemp.length();
1444 strTemp.append(pCurrent, pSubstr - pCurrent);
1445 if ( strTemp.length() != (size_t)(len + pSubstr - pCurrent) ) {
b1801e0e
GD
1446 wxFAIL_MSG( _T("out of memory in wxString::Replace") );
1447 return 0;
1448 }
c801d85f
KB
1449 strTemp += szNew;
1450 pCurrent = pSubstr + uiOldLen; // restart after match
1451
1452 uiCount++;
1453
1454 // stop now?
1455 if ( !bReplaceAll ) {
1456 strTemp += pCurrent; // copy the rest
1457 break; // exit the loop
1458 }
1459 }
1460 }
1461
1462 // only done if there were replacements, otherwise would have returned above
e87b7833 1463 swap(strTemp);
c801d85f
KB
1464
1465 return uiCount;
1466}
1467
1468bool wxString::IsAscii() const
1469{
2bb67b80 1470 const wxChar *s = (const wxChar*) *this;
c801d85f 1471 while(*s){
b1e4e7cc 1472 if(!isascii(*s)) return(FALSE);
c801d85f
KB
1473 s++;
1474 }
1475 return(TRUE);
1476}
dd1eaa89 1477
c801d85f
KB
1478bool wxString::IsWord() const
1479{
2bb67b80 1480 const wxChar *s = (const wxChar*) *this;
c801d85f 1481 while(*s){
2bb67b80 1482 if(!wxIsalpha(*s)) return(FALSE);
c801d85f
KB
1483 s++;
1484 }
1485 return(TRUE);
1486}
dd1eaa89 1487
c801d85f
KB
1488bool wxString::IsNumber() const
1489{
2bb67b80 1490 const wxChar *s = (const wxChar*) *this;
2f74ed28
GT
1491 if (wxStrlen(s))
1492 if ((s[0] == '-') || (s[0] == '+')) s++;
c801d85f 1493 while(*s){
2bb67b80 1494 if(!wxIsdigit(*s)) return(FALSE);
c801d85f
KB
1495 s++;
1496 }
1497 return(TRUE);
1498}
1499
c801d85f
KB
1500wxString wxString::Strip(stripType w) const
1501{
1502 wxString s = *this;
1503 if ( w & leading ) s.Trim(FALSE);
1504 if ( w & trailing ) s.Trim(TRUE);
1505 return s;
1506}
1507
c801d85f
KB
1508// ---------------------------------------------------------------------------
1509// case conversion
1510// ---------------------------------------------------------------------------
1511
1512wxString& wxString::MakeUpper()
1513{
e87b7833
MB
1514 for ( iterator it = begin(), en = end(); it != en; ++it )
1515 *it = (wxChar)wxToupper(*it);
c801d85f
KB
1516
1517 return *this;
1518}
1519
1520wxString& wxString::MakeLower()
1521{
e87b7833
MB
1522 for ( iterator it = begin(), en = end(); it != en; ++it )
1523 *it = (wxChar)wxTolower(*it);
c801d85f
KB
1524
1525 return *this;
1526}
1527
1528// ---------------------------------------------------------------------------
1529// trimming and padding
1530// ---------------------------------------------------------------------------
1531
576c608d
VZ
1532// some compilers (VC++ 6.0 not to name them) return TRUE for a call to
1533