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