]> git.saurik.com Git - wxWidgets.git/blame - src/common/string.cpp
Better alphabetized the event handler macros
[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 }
06386448 211 wxMemcpy(m_pchData, psz + nPos, nLength);
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
d775fa82 253 return false;
b1801e0e 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');
d775fa82 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
d775fa82 274 return false;
b1801e0e 275 }
44d271da 276 wxMemcpy(m_pchData, pData->data(), nLen);
c801d85f
KB
277 }
278
3bbb630a 279 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
b1801e0e 280
d775fa82 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
d775fa82 296 return false;
b1801e0e 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
d775fa82 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 325
d775fa82 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
d775fa82 371 return false;
b1801e0e 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
d775fa82 385 return false;
b1801e0e 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
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{
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
dcb68102 477 //anchor
7663d0d4
WS
478 const wxChar* p = (const wxChar*)wxMemchr(c_str() + nStart,
479 str.c_str()[0],
7c9b5f42 480 length() - nStart);
7663d0d4 481
dcb68102
RN
482 if(!p)
483 return npos;
484
485 while(p - c_str() + str.length() <= length() &&
486 wxMemcmp(p, str.c_str(), str.length()) )
487 {
488 //anchor again
7663d0d4
WS
489 p = (const wxChar*)wxMemchr(++p,
490 str.c_str()[0],
7c9b5f42 491 length() - (p - c_str()));
e87b7833 492
dcb68102
RN
493 if(!p)
494 return npos;
495 }
7663d0d4 496
dcb68102 497 return (p - c_str() + str.length() <= length()) ? p - c_str() : npos;
097c080b
VZ
498}
499
e87b7833 500size_t wxStringBase::find(const wxChar* sz, size_t nStart, size_t n) const
8f06a017 501{
e87b7833 502 return find(wxStringBase(sz, n), nStart);
8f06a017
RD
503}
504
e87b7833
MB
505size_t wxStringBase::find(wxChar ch, size_t nStart) const
506{
507 wxASSERT( nStart <= length() );
c801d85f 508
7c9b5f42 509 const wxChar *p = (const wxChar*)wxMemchr(c_str() + nStart, ch, length() - nStart);
c801d85f 510
e87b7833 511 return p == NULL ? npos : p - c_str();
c801d85f
KB
512}
513
e87b7833 514size_t wxStringBase::rfind(const wxStringBase& str, size_t nStart) const
c801d85f 515{
e2101186
MB
516 wxASSERT( str.GetStringData()->IsValid() );
517 wxASSERT( nStart == npos || nStart <= length() );
518
519 if ( length() >= str.length() )
520 {
521 // avoids a corner case later
522 if ( length() == 0 && str.length() == 0 )
523 return 0;
524
525 // "top" is the point where search starts from
526 size_t top = length() - str.length();
c801d85f 527
e2101186
MB
528 if ( nStart == npos )
529 nStart = length() - 1;
530 if ( nStart < top )
531 top = nStart;
532
533 const wxChar *cursor = c_str() + top;
534 do
535 {
dcb68102
RN
536 if ( wxMemcmp(cursor, str.c_str(),
537 str.length()) == 0 )
e2101186
MB
538 {
539 return cursor - c_str();
540 }
78e6050b 541 } while ( cursor-- > c_str() );
e2101186 542 }
d775fa82 543
e2101186 544 return npos;
c801d85f
KB
545}
546
e87b7833 547size_t wxStringBase::rfind(const wxChar* sz, size_t nStart, size_t n) const
c801d85f 548{
e87b7833 549 return rfind(wxStringBase(sz, n), nStart);
c801d85f
KB
550}
551
e87b7833 552size_t wxStringBase::rfind(wxChar ch, size_t nStart) const
c801d85f 553{
e87b7833
MB
554 if ( nStart == npos )
555 {
556 nStart = length();
557 }
558 else
559 {
560 wxASSERT( nStart <= length() );
561 }
c801d85f 562
93c83507
MB
563 const wxChar *actual;
564 for ( actual = c_str() + ( nStart == npos ? length() : nStart + 1 );
565 actual > c_str(); --actual )
566 {
567 if ( *(actual - 1) == ch )
568 return (actual - 1) - c_str();
569 }
e87b7833 570
93c83507 571 return npos;
c801d85f
KB
572}
573
e87b7833 574size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart) const
c801d85f 575{
dcb68102
RN
576 wxASSERT(nStart <= length());
577
578 size_t len = wxStrlen(sz);
579
580 size_t i;
581 for(i = nStart; i < this->length(); ++i)
582 {
583 if (wxMemchr(sz, *(c_str() + i), len))
584 break;
585 }
586
587 if(i == this->length())
e87b7833 588 return npos;
dcb68102
RN
589 else
590 return i;
c801d85f 591}
e87b7833 592
e2101186
MB
593size_t wxStringBase::find_first_of(const wxChar* sz, size_t nStart,
594 size_t n) const
595{
596 return find_first_of(wxStringBase(sz, n), nStart);
597}
598
e87b7833
MB
599size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart) const
600{
601 if ( nStart == npos )
602 {
e2101186 603 nStart = length() - 1;
e87b7833
MB
604 }
605 else
606 {
65c75abe
VZ
607 wxASSERT_MSG( nStart <= length(),
608 _T("invalid index in find_last_of()") );
e87b7833
MB
609 }
610
dcb68102 611 size_t len = wxStrlen(sz);
7663d0d4 612
e2101186 613 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833 614 {
dcb68102 615 if ( wxMemchr(sz, *p, len) )
e87b7833
MB
616 return p - c_str();
617 }
618
619 return npos;
620}
621
e2101186
MB
622size_t wxStringBase::find_last_of(const wxChar* sz, size_t nStart,
623 size_t n) const
624{
625 return find_last_of(wxStringBase(sz, n), nStart);
626}
627
e87b7833
MB
628size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart) const
629{
630 if ( nStart == npos )
631 {
632 nStart = length();
633 }
634 else
635 {
636 wxASSERT( nStart <= length() );
637 }
638
dcb68102
RN
639 size_t len = wxStrlen(sz);
640
641 size_t i;
642 for(i = nStart; i < this->length(); ++i)
643 {
644 if (!wxMemchr(sz, *(c_str() + i), len))
645 break;
646 }
647
648 if(i == this->length())
649 return npos;
650 else
651 return i;
e2101186
MB
652}
653
654size_t wxStringBase::find_first_not_of(const wxChar* sz, size_t nStart,
655 size_t n) const
656{
657 return find_first_not_of(wxStringBase(sz, n), nStart);
e87b7833
MB
658}
659
660size_t wxStringBase::find_first_not_of(wxChar ch, size_t nStart) const
661{
662 wxASSERT( nStart <= length() );
663
664 for ( const wxChar *p = c_str() + nStart; *p; p++ )
665 {
666 if ( *p != ch )
667 return p - c_str();
668 }
669
670 return npos;
671}
672
673size_t wxStringBase::find_last_not_of(const wxChar* sz, size_t nStart) const
674{
675 if ( nStart == npos )
676 {
e2101186 677 nStart = length() - 1;
e87b7833
MB
678 }
679 else
680 {
681 wxASSERT( nStart <= length() );
682 }
683
dcb68102
RN
684 size_t len = wxStrlen(sz);
685
e2101186 686 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833 687 {
dcb68102
RN
688 if ( !wxMemchr(sz, *p,len) )
689 return p - c_str();
e87b7833
MB
690 }
691
692 return npos;
693}
694
e2101186
MB
695size_t wxStringBase::find_last_not_of(const wxChar* sz, size_t nStart,
696 size_t n) const
697{
698 return find_last_not_of(wxStringBase(sz, n), nStart);
699}
700
e87b7833
MB
701size_t wxStringBase::find_last_not_of(wxChar ch, size_t nStart) const
702{
703 if ( nStart == npos )
704 {
e2101186 705 nStart = length() - 1;
e87b7833
MB
706 }
707 else
708 {
709 wxASSERT( nStart <= length() );
710 }
711
e2101186 712 for ( const wxChar *p = c_str() + nStart; p >= c_str(); --p )
e87b7833
MB
713 {
714 if ( *p != ch )
715 return p - c_str();
716 }
717
718 return npos;
719}
720
721wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
722 const wxChar *sz)
723{
724 wxASSERT_MSG( nStart <= length(),
725 _T("index out of bounds in wxStringBase::replace") );
726 size_t strLen = length() - nStart;
727 nLen = strLen < nLen ? strLen : nLen;
728
729 wxStringBase strTmp;
730 strTmp.reserve(length()); // micro optimisation to avoid multiple mem allocs
731
732 if ( nStart != 0 )
733 strTmp.append(c_str(), nStart);
734 strTmp.append(sz);
735 strTmp.append(c_str() + nStart + nLen);
736
737 swap(strTmp);
738 return *this;
739}
740
741wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
742 size_t nCount, wxChar ch)
743{
7663d0d4 744 return replace(nStart, nLen, wxStringBase(nCount, ch).c_str());
e87b7833
MB
745}
746
747wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
748 const wxStringBase& str,
749 size_t nStart2, size_t nLen2)
750{
751 return replace(nStart, nLen, str.substr(nStart2, nLen2));
752}
753
754wxStringBase& wxStringBase::replace(size_t nStart, size_t nLen,
755 const wxChar* sz, size_t nCount)
756{
757 return replace(nStart, nLen, wxStringBase(sz, nCount).c_str());
758}
759
760wxStringBase wxStringBase::substr(size_t nStart, size_t nLen) const
761{
762 if ( nLen == npos )
763 nLen = length() - nStart;
764 return wxStringBase(*this, nStart, nLen);
765}
766
767// assigns one string to another
768wxStringBase& wxStringBase::operator=(const wxStringBase& stringSrc)
769{
770 wxASSERT( stringSrc.GetStringData()->IsValid() );
771
772 // don't copy string over itself
773 if ( m_pchData != stringSrc.m_pchData ) {
774 if ( stringSrc.GetStringData()->IsEmpty() ) {
775 Reinit();
776 }
777 else {
778 // adjust references
779 GetStringData()->Unlock();
780 m_pchData = stringSrc.m_pchData;
781 GetStringData()->Lock();
782 }
783 }
784
785 return *this;
786}
787
788// assigns a single character
789wxStringBase& wxStringBase::operator=(wxChar ch)
790{
791 if ( !AssignCopy(1, &ch) ) {
792 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(wxChar)") );
793 }
794 return *this;
795}
796
797// assigns C string
798wxStringBase& wxStringBase::operator=(const wxChar *psz)
799{
800 if ( !AssignCopy(wxStrlen(psz), psz) ) {
801 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(const wxChar *)") );
802 }
803 return *this;
804}
805
806// helper function: does real copy
807bool wxStringBase::AssignCopy(size_t nSrcLen, const wxChar *pszSrcData)
808{
809 if ( nSrcLen == 0 ) {
810 Reinit();
811 }
812 else {
813 if ( !AllocBeforeWrite(nSrcLen) ) {
814 // allocation failure handled by caller
d775fa82 815 return false;
e87b7833
MB
816 }
817 memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
818 GetStringData()->nDataLength = nSrcLen;
819 m_pchData[nSrcLen] = wxT('\0');
820 }
d775fa82 821 return true;
e87b7833
MB
822}
823
824// ---------------------------------------------------------------------------
825// string concatenation
826// ---------------------------------------------------------------------------
c801d85f 827
c801d85f 828// add something to this string
e87b7833
MB
829bool wxStringBase::ConcatSelf(size_t nSrcLen, const wxChar *pszSrcData,
830 size_t nMaxLen)
c801d85f 831{
3168a13f 832 STATISTICS_ADD(SummandLength, nSrcLen);
c801d85f 833
e87b7833
MB
834 nSrcLen = nSrcLen < nMaxLen ? nSrcLen : nMaxLen;
835
05488905
VZ
836 // concatenating an empty string is a NOP
837 if ( nSrcLen > 0 ) {
838 wxStringData *pData = GetStringData();
839 size_t nLen = pData->nDataLength;
840 size_t nNewLen = nLen + nSrcLen;
c801d85f 841
05488905
VZ
842 // alloc new buffer if current is too small
843 if ( pData->IsShared() ) {
844 STATISTICS_ADD(ConcatHit, 0);
3168a13f 845
05488905
VZ
846 // we have to allocate another buffer
847 wxStringData* pOldData = GetStringData();
b1801e0e
GD
848 if ( !AllocBuffer(nNewLen) ) {
849 // allocation failure handled by caller
d775fa82 850 return false;
b1801e0e 851 }
2bb67b80 852 memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxChar));
05488905
VZ
853 pOldData->Unlock();
854 }
855 else if ( nNewLen > pData->nAllocLength ) {
856 STATISTICS_ADD(ConcatHit, 0);
3168a13f 857
e87b7833 858 reserve(nNewLen);
05488905 859 // we have to grow the buffer
e87b7833 860 if ( capacity() < nNewLen ) {
b1801e0e 861 // allocation failure handled by caller
d775fa82 862 return false;
b1801e0e 863 }
05488905
VZ
864 }
865 else {
866 STATISTICS_ADD(ConcatHit, 1);
3168a13f 867
05488905
VZ
868 // the buffer is already big enough
869 }
3168a13f 870
05488905
VZ
871 // should be enough space
872 wxASSERT( nNewLen <= GetStringData()->nAllocLength );
3168a13f 873
05488905 874 // fast concatenation - all is done in our buffer
2bb67b80 875 memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(wxChar));
3168a13f 876
e87b7833
MB
877 m_pchData[nNewLen] = wxT('\0'); // put terminating '\0'
878 GetStringData()->nDataLength = nNewLen; // and fix the length
879 }
880 //else: the string to append was empty
d775fa82 881 return true;
e87b7833
MB
882}
883
884// ---------------------------------------------------------------------------
885// simple sub-string extraction
886// ---------------------------------------------------------------------------
887
888// helper function: clone the data attached to this string
889bool wxStringBase::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const
890{
891 if ( nCopyLen == 0 ) {
892 dest.Init();
893 }
894 else {
895 if ( !dest.AllocBuffer(nCopyLen) ) {
896 // allocation failure handled by caller
d775fa82 897 return false;
e87b7833
MB
898 }
899 memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(wxChar));
900 }
d775fa82 901 return true;
e87b7833
MB
902}
903
904#endif // !wxUSE_STL
905
906#if !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
907
908#if !wxUSE_STL
909 #define STRINGCLASS wxStringBase
910#else
911 #define STRINGCLASS wxString
912#endif
913
914static inline int wxDoCmp(const wxChar* s1, size_t l1,
915 const wxChar* s2, size_t l2)
916{
917 if( l1 == l2 )
dcb68102 918 return wxMemcmp(s1, s2, l1);
e87b7833
MB
919 else if( l1 < l2 )
920 {
dcb68102 921 int ret = wxMemcmp(s1, s2, l1);
e87b7833
MB
922 return ret == 0 ? -1 : ret;
923 }
924 else if( l1 > l2 )
925 {
dcb68102 926 int ret = wxMemcmp(s1, s2, l2);
e87b7833
MB
927 return ret == 0 ? +1 : ret;
928 }
929
930 wxFAIL; // must never get there
931 return 0; // quiet compilers
932}
933
e87b7833
MB
934int STRINGCLASS::compare(const wxStringBase& str) const
935{
936 return ::wxDoCmp(data(), length(), str.data(), str.length());
937}
938
e87b7833
MB
939int STRINGCLASS::compare(size_t nStart, size_t nLen,
940 const wxStringBase& str) const
941{
942 wxASSERT(nStart <= length());
943 size_type strLen = length() - nStart;
944 nLen = strLen < nLen ? strLen : nLen;
945 return ::wxDoCmp(data() + nStart, nLen, str.data(), str.length());
946}
947
948int STRINGCLASS::compare(size_t nStart, size_t nLen,
949 const wxStringBase& str,
950 size_t nStart2, size_t nLen2) const
951{
952 wxASSERT(nStart <= length());
953 wxASSERT(nStart2 <= str.length());
954 size_type strLen = length() - nStart,
955 strLen2 = str.length() - nStart2;
956 nLen = strLen < nLen ? strLen : nLen;
957 nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
958 return ::wxDoCmp(data() + nStart, nLen, str.data() + nStart2, nLen2);
959}
960
e87b7833
MB
961int STRINGCLASS::compare(const wxChar* sz) const
962{
963 size_t nLen = wxStrlen(sz);
964 return ::wxDoCmp(data(), length(), sz, nLen);
965}
966
e87b7833
MB
967int STRINGCLASS::compare(size_t nStart, size_t nLen,
968 const wxChar* sz, size_t nCount) const
969{
970 wxASSERT(nStart <= length());
971 size_type strLen = length() - nStart;
972 nLen = strLen < nLen ? strLen : nLen;
973 if( nCount == npos )
974 nCount = wxStrlen(sz);
975
976 return ::wxDoCmp(data() + nStart, nLen, sz, nCount);
977}
978
979#undef STRINGCLASS
980
981#endif // !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
982
983// ===========================================================================
984// wxString class core
985// ===========================================================================
986
987// ---------------------------------------------------------------------------
06386448
RN
988// common conversion routines
989// ---------------------------------------------------------------------------
990
03ff8fda
RN
991size_t wxString::WorstEncodingCase(size_t len, wxMBConv& WXUNUSED(conv))
992{
993 //Worst case for UTF7
994 return len * 5;
995}
996
06386448
RN
997#if wxUSE_WCHAR_T
998
19db911a
RN
999//Convert a wide character string of a specified length
1000//to a multi-byte character string, ignoring intermittent null characters
215f9d70 1001//returns the actual length of the string
c81fc334 1002inline size_t wxMbstr(char* szBuffer, const wchar_t* szString,
215f9d70 1003 size_t nStringLen, wxMBConv& conv)
06386448
RN
1004{
1005 const wchar_t* szEnd = szString + nStringLen + 1;
1006 const wchar_t* szPos = szString;
1007 const wchar_t* szStart = szPos;
7663d0d4 1008
215f9d70 1009 size_t nActualLength = 0;
7663d0d4 1010
06386448
RN
1011 //Convert the string until the length() is reached, continuing the
1012 //loop every time a null character is reached
1013 while(szPos != szEnd)
1014 {
1015 wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
1016
1017 //Get the length of the current (sub)string
1018 size_t nLen = conv.WC2MB(NULL, szPos, 0);
7663d0d4 1019
bdd8f35a
RN
1020 //Invalid conversion?
1021 if( nLen == (size_t)-1 )
1022 {
1023 szBuffer[0] = '\0';
1024 return 0;
1025 }
1026
03ff8fda 1027 //Increase the actual length (+1 for current null character)
215f9d70 1028 nActualLength += nLen + 1;
7663d0d4 1029
03ff8fda
RN
1030 //If this is true it means buffer overflow
1031 wxASSERT( nActualLength <= wxString::WorstEncodingCase(nStringLen, conv) + 1 );
7663d0d4 1032
06386448 1033 //Convert the current (sub)string
bdd8f35a 1034 if(conv.WC2MB(&szBuffer[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
06386448
RN
1035 {
1036 //error - return empty buffer
1037 wxFAIL_MSG(wxT("Error converting wide-character string to a multi-byte string"));
c81fc334 1038 szBuffer[0] = '\0';
215f9d70 1039 return 0;
7663d0d4
WS
1040 }
1041
06386448
RN
1042 //Increment to next (sub)string
1043 //Note that we have to use wxWcslen here instead of nLen
1044 //here because XX2XX gives us the size of the output buffer,
1045 //not neccessarly the length of the string
1046 szPos += wxWcslen(szPos) + 1;
1047 }
7663d0d4 1048
215f9d70 1049 return nActualLength - 1; //success - return actual length
06386448
RN
1050}
1051
19db911a
RN
1052//Convert a multi-byte character string of a specified length
1053//to a wide character string, ignoring intermittent null characters
7663d0d4 1054//returns the actual length
c81fc334 1055inline size_t wxWcstr( wchar_t* szBuffer, const char* szString,
7663d0d4 1056 size_t nStringLen, wxMBConv& conv)
06386448
RN
1057{
1058 const char* szEnd = szString + nStringLen + 1;
1059 const char* szPos = szString;
1060 const char* szStart = szPos;
215f9d70
RN
1061
1062 size_t nActualLength = 0;
7663d0d4 1063
06386448
RN
1064 //Convert the string until the length() is reached, continuing the
1065 //loop every time a null character is reached
1066 while(szPos != szEnd)
1067 {
1068 wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
1069
1070 //Get the length of the current (sub)string
1071 size_t nLen = conv.MB2WC(NULL, szPos, 0);
7663d0d4 1072
bdd8f35a
RN
1073 //Invalid conversion?
1074 if( nLen == (size_t)-1 )
1075 {
1076 szBuffer[0] = '\0';
1077 return 0;
1078 }
1079
03ff8fda 1080 //Increase the actual length (+1 for current null character)
215f9d70 1081 nActualLength += nLen + 1;
7663d0d4 1082
03ff8fda
RN
1083 //If this is true it means buffer overflow
1084 wxASSERT(nActualLength <= nStringLen + 1);
215f9d70 1085
06386448 1086 //Convert the current (sub)string
bdd8f35a 1087 if ( conv.MB2WC(&szBuffer[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
06386448
RN
1088 {
1089 //error - return empty buffer
1090 wxFAIL_MSG(wxT("Error converting multi-byte string to a wide-character string"));
c81fc334 1091 szBuffer[0] = '\0';
215f9d70 1092 return 0;
7663d0d4
WS
1093 }
1094
06386448
RN
1095 //Increment to next (sub)string
1096 //Note that we have to use strlen here instead of nLen
1097 //here because XX2XX gives us the size of the output buffer,
1098 //not neccessarly the length of the string
1099 szPos += strlen(szPos) + 1;
1100 }
7663d0d4 1101
215f9d70 1102 return nActualLength - 1; //success - return actual length
06386448
RN
1103}
1104
1105#endif //wxUSE_WCHAR_T
1106
1107// ---------------------------------------------------------------------------
1108// construction and conversion
e87b7833
MB
1109// ---------------------------------------------------------------------------
1110
1111#if wxUSE_UNICODE
1112
1113// from multibyte string
1114wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
1115{
31444b6a
VS
1116 // if nLength != npos, then we have to make a NULL-terminated copy
1117 // of first nLength bytes of psz first because the input buffer to MB2WC
1118 // must always be NULL-terminated:
1119 wxCharBuffer inBuf((const char *)NULL);
1120 if (nLength != npos)
1121 {
b65ee6fd 1122 wxASSERT( psz != NULL );
31444b6a
VS
1123 wxCharBuffer tmp(nLength);
1124 memcpy(tmp.data(), psz, nLength);
1125 tmp.data()[nLength] = '\0';
1126 inBuf = tmp;
1127 psz = inBuf.data();
1128 }
d775fa82 1129
e87b7833
MB
1130 // first get the size of the buffer we need
1131 size_t nLen;
1132 if ( psz )
1133 {
1134 // calculate the needed size ourselves or use the provided one
06386448
RN
1135 if (nLength == npos)
1136 nLen = strlen(psz);
1137 else
1138 nLen = nLength;
e87b7833
MB
1139 }
1140 else
1141 {
1142 // nothing to convert
1143 nLen = 0;
1144 }
1145
1146 // anything to do?
1147 if ( (nLen != 0) && (nLen != (size_t)-1) )
1148 {
215f9d70 1149 //When converting mb->wc it never inflates to more characters than the length
c81fc334 1150 wxStringBufferLength internalBuffer(*this, nLen + 1);
215f9d70 1151
c81fc334
RN
1152 //Do the actual conversion & Set the length of the buffer
1153 internalBuffer.SetLength(
1154 wxWcstr(internalBuffer, psz, nLen, conv)
1155 );
e87b7833 1156 }
7663d0d4 1157}
265d5cce 1158
06386448 1159//Convert wxString in Unicode mode to a multi-byte string
265d5cce
RN
1160const wxCharBuffer wxString::mb_str(wxMBConv& conv) const
1161{
03ff8fda
RN
1162 //Create the buffer
1163 wxCharBuffer buffer( wxString::WorstEncodingCase(length(), conv) + 1);
215f9d70
RN
1164
1165 //Do the actual conversion (will return a blank string on error)
c81fc334 1166 wxMbstr(buffer.data(), (*this).c_str(), length(), conv);
7663d0d4 1167
215f9d70 1168 return buffer;
e87b7833
MB
1169}
1170
1171#else // ANSI
1172
1173#if wxUSE_WCHAR_T
1174// from wide string
1175wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength)
1176{
31444b6a
VS
1177 // if nLength != npos, then we have to make a NULL-terminated copy
1178 // of first nLength chars of psz first because the input buffer to WC2MB
1179 // must always be NULL-terminated:
1180 wxWCharBuffer inBuf((const wchar_t *)NULL);
1181 if (nLength != npos)
1182 {
b65ee6fd 1183 wxASSERT( pwz != NULL );
31444b6a
VS
1184 wxWCharBuffer tmp(nLength);
1185 memcpy(tmp.data(), pwz, nLength * sizeof(wchar_t));
1186 tmp.data()[nLength] = '\0';
1187 inBuf = tmp;
1188 pwz = inBuf.data();
1189 }
d775fa82 1190
e87b7833
MB
1191 // first get the size of the buffer we need
1192 size_t nLen;
1193 if ( pwz )
1194 {
1195 // calculate the needed size ourselves or use the provided one
06386448
RN
1196 if (nLength == npos)
1197 nLen = wxWcslen(pwz);
1198 else
1199 nLen = nLength;
e87b7833
MB
1200 }
1201 else
1202 {
1203 // nothing to convert
1204 nLen = 0;
1205 }
1206
1207 // anything to do?
1208 if ( (nLen != 0) && (nLen != (size_t)-1) )
1209 {
03ff8fda
RN
1210 //Create a wxStringBufferLength which will access the internal
1211 //C char pointer in non-stl mode
1212 wxStringBufferLength internalBuffer(*this, wxString::WorstEncodingCase(nLen, conv) + 1);
7663d0d4 1213
c81fc334
RN
1214 //Do the actual conversion & Set the length of the buffer
1215 internalBuffer.SetLength(
1216 wxMbstr(internalBuffer, pwz, nLen, conv)
1217 );
e87b7833 1218 }
e87b7833 1219}
265d5cce 1220
7663d0d4 1221//Converts this string to a wide character string if unicode
06386448 1222//mode is not enabled and wxUSE_WCHAR_T is enabled
265d5cce
RN
1223const wxWCharBuffer wxString::wc_str(wxMBConv& conv) const
1224{
215f9d70
RN
1225 //mb->wc never inflates to more than the length
1226 wxWCharBuffer buffer(length() + 1);
7663d0d4 1227
06386448 1228 //Do the actual conversion (will return a blank string on error)
c81fc334 1229 wxWcstr(buffer.data(), (*this).c_str(), length(), conv);
7663d0d4 1230
215f9d70 1231 return buffer;
265d5cce 1232}
7663d0d4 1233
e87b7833
MB
1234#endif // wxUSE_WCHAR_T
1235
1236#endif // Unicode/ANSI
1237
1238// shrink to minimal size (releasing extra memory)
1239bool wxString::Shrink()
1240{
1241 wxString tmp(begin(), end());
1242 swap(tmp);
1243 return tmp.length() == length();
1244}
1245
1246#if !wxUSE_STL
1247// get the pointer to writable buffer of (at least) nLen bytes
1248wxChar *wxString::GetWriteBuf(size_t nLen)
1249{
1250 if ( !AllocBeforeWrite(nLen) ) {
1251 // allocation failure handled by caller
1252 return NULL;
1253 }
1254
1255 wxASSERT( GetStringData()->nRefs == 1 );
d775fa82 1256 GetStringData()->Validate(false);
e87b7833
MB
1257
1258 return m_pchData;
1259}
1260
1261// put string back in a reasonable state after GetWriteBuf
1262void wxString::UngetWriteBuf()
1263{
1264 GetStringData()->nDataLength = wxStrlen(m_pchData);
d775fa82 1265 GetStringData()->Validate(true);
e87b7833
MB
1266}
1267
1268void wxString::UngetWriteBuf(size_t nLen)
1269{
1270 GetStringData()->nDataLength = nLen;
d775fa82 1271 GetStringData()->Validate(true);
e87b7833
MB
1272}
1273#endif
1274
1275// ---------------------------------------------------------------------------
1276// data access
1277// ---------------------------------------------------------------------------
1278
1279// all functions are inline in string.h
1280
1281// ---------------------------------------------------------------------------
1282// assignment operators
1283// ---------------------------------------------------------------------------
1284
1285#if !wxUSE_UNICODE
1286
1287// same as 'signed char' variant
1288wxString& wxString::operator=(const unsigned char* psz)
1289{
1290 *this = (const char *)psz;
1291 return *this;
1292}
1293
1294#if wxUSE_WCHAR_T
1295wxString& wxString::operator=(const wchar_t *pwz)
1296{
1297 wxString str(pwz);
1298 swap(str);
1299 return *this;
c801d85f 1300}
e87b7833
MB
1301#endif
1302
1303#endif
c801d85f
KB
1304
1305/*
c801d85f
KB
1306 * concatenation functions come in 5 flavours:
1307 * string + string
1308 * char + string and string + char
1309 * C str + string and string + C str
1310 */
1311
b1801e0e 1312wxString operator+(const wxString& str1, const wxString& str2)
c801d85f 1313{
e87b7833 1314#if !wxUSE_STL
b1801e0e
GD
1315 wxASSERT( str1.GetStringData()->IsValid() );
1316 wxASSERT( str2.GetStringData()->IsValid() );
e87b7833 1317#endif
097c080b 1318
b1801e0e
GD
1319 wxString s = str1;
1320 s += str2;
3168a13f 1321
c801d85f
KB
1322 return s;
1323}
1324
b1801e0e 1325wxString operator+(const wxString& str, wxChar ch)
c801d85f 1326{
e87b7833 1327#if !wxUSE_STL
b1801e0e 1328 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1329#endif
3168a13f 1330
b1801e0e 1331 wxString s = str;
3168a13f 1332 s += ch;
097c080b 1333
c801d85f
KB
1334 return s;
1335}
1336
b1801e0e 1337wxString operator+(wxChar ch, const wxString& str)
c801d85f 1338{
e87b7833 1339#if !wxUSE_STL
b1801e0e 1340 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1341#endif
097c080b 1342
3168a13f 1343 wxString s = ch;
b1801e0e 1344 s += str;
3168a13f 1345
c801d85f
KB
1346 return s;
1347}
1348
b1801e0e 1349wxString operator+(const wxString& str, const wxChar *psz)
c801d85f 1350{
e87b7833 1351#if !wxUSE_STL
b1801e0e 1352 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1353#endif
097c080b 1354
c801d85f 1355 wxString s;
b1801e0e
GD
1356 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1357 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1358 }
1359 s = str;
3168a13f
VZ
1360 s += psz;
1361
c801d85f
KB
1362 return s;
1363}
1364
b1801e0e 1365wxString operator+(const wxChar *psz, const wxString& str)
c801d85f 1366{
e87b7833 1367#if !wxUSE_STL
b1801e0e 1368 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1369#endif
097c080b 1370
c801d85f 1371 wxString s;
b1801e0e
GD
1372 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1373 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1374 }
3168a13f 1375 s = psz;
b1801e0e 1376 s += str;
3168a13f 1377
c801d85f
KB
1378 return s;
1379}
1380
1381// ===========================================================================
1382// other common string functions
1383// ===========================================================================
1384
dcb68102
RN
1385int wxString::Cmp(const wxString& s) const
1386{
1387 return compare(s);
1388}
1389
1390int wxString::Cmp(const wxChar* psz) const
1391{
1392 return compare(psz);
1393}
1394
1395static inline int wxDoCmpNoCase(const wxChar* s1, size_t l1,
1396 const wxChar* s2, size_t l2)
1397{
1398 size_t i;
1399
1400 if( l1 == l2 )
1401 {
1402 for(i = 0; i < l1; ++i)
1403 {
1404 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1405 break;
1406 }
1407 return i == l1 ? 0 : s1[i] < s2[i] ? -1 : 1;
1408 }
1409 else if( l1 < l2 )
1410 {
1411 for(i = 0; i < l1; ++i)
1412 {
1413 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1414 break;
1415 }
1416 return i == l1 ? -1 : s1[i] < s2[i] ? -1 : 1;
1417 }
1418 else if( l1 > l2 )
1419 {
1420 for(i = 0; i < l2; ++i)
1421 {
1422 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1423 break;
1424 }
1425 return i == l2 ? 1 : s1[i] < s2[i] ? -1 : 1;
1426 }
1427
1428 wxFAIL; // must never get there
1429 return 0; // quiet compilers
1430}
1431
1432int wxString::CmpNoCase(const wxString& s) const
1433{
1434 return wxDoCmpNoCase(data(), length(), s.data(), s.length());
1435}
1436
1437int wxString::CmpNoCase(const wxChar* psz) const
1438{
1439 int nLen = wxStrlen(psz);
1440
1441 return wxDoCmpNoCase(data(), length(), psz, nLen);
1442}
1443
1444
b1ac3b56 1445#if wxUSE_UNICODE
e015c2a3 1446
cf6bedce
SC
1447#ifdef __MWERKS__
1448#ifndef __SCHAR_MAX__
1449#define __SCHAR_MAX__ 127
1450#endif
1451#endif
1452
e015c2a3 1453wxString wxString::FromAscii(const char *ascii)
b1ac3b56
RR
1454{
1455 if (!ascii)
1456 return wxEmptyString;
e015c2a3 1457
b1ac3b56
RR
1458 size_t len = strlen( ascii );
1459 wxString res;
e015c2a3
VZ
1460
1461 if ( len )
1462 {
1463 wxStringBuffer buf(res, len);
1464
1465 wchar_t *dest = buf;
1466
1467 for ( ;; )
1468 {
1469 if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' )
1470 break;
1471 }
1472 }
1473
b1ac3b56
RR
1474 return res;
1475}
1476
2b5f62a0
VZ
1477wxString wxString::FromAscii(const char ascii)
1478{
1479 // What do we do with '\0' ?
1480
1481 wxString res;
1482 res += (wchar_t)(unsigned char) ascii;
8760bc65 1483
2b5f62a0
VZ
1484 return res;
1485}
1486
b1ac3b56
RR
1487const wxCharBuffer wxString::ToAscii() const
1488{
e015c2a3
VZ
1489 // this will allocate enough space for the terminating NUL too
1490 wxCharBuffer buffer(length());
b1ac3b56 1491
e015c2a3
VZ
1492 signed char *dest = (signed char *)buffer.data();
1493
1494 const wchar_t *pwc = c_str();
1495 for ( ;; )
b1ac3b56 1496 {
930357bd 1497 *dest++ = *pwc > SCHAR_MAX ? wxT('_') : *pwc;
e015c2a3
VZ
1498
1499 // the output string can't have embedded NULs anyhow, so we can safely
1500 // stop at first of them even if we do have any
1501 if ( !*pwc++ )
1502 break;
b1ac3b56 1503 }
e015c2a3 1504
b1ac3b56
RR
1505 return buffer;
1506}
e015c2a3
VZ
1507
1508#endif // Unicode
b1ac3b56 1509
c801d85f 1510// extract string of length nCount starting at nFirst
c801d85f
KB
1511wxString wxString::Mid(size_t nFirst, size_t nCount) const
1512{
e87b7833 1513 size_t nLen = length();
30d9011f 1514
e87b7833
MB
1515 // default value of nCount is npos and means "till the end"
1516 if ( nCount == npos )
30d9011f
VZ
1517 {
1518 nCount = nLen - nFirst;
1519 }
1520
c801d85f 1521 // out-of-bounds requests return sensible things
30d9011f
VZ
1522 if ( nFirst + nCount > nLen )
1523 {
1524 nCount = nLen - nFirst;
1525 }
c801d85f 1526
30d9011f
VZ
1527 if ( nFirst > nLen )
1528 {
1529 // AllocCopy() will return empty string
c801d85f 1530 nCount = 0;
30d9011f 1531 }
c801d85f 1532
e87b7833
MB
1533 wxString dest(*this, nFirst, nCount);
1534 if ( dest.length() != nCount ) {
b1801e0e
GD
1535 wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1536 }
30d9011f 1537
c801d85f
KB
1538 return dest;
1539}
1540
e87b7833 1541// check that the string starts with prefix and return the rest of the string
d775fa82 1542// in the provided pointer if it is not NULL, otherwise return false
f6bcfd97
BP
1543bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
1544{
1545 wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
1546
1547 // first check if the beginning of the string matches the prefix: note
1548 // that we don't have to check that we don't run out of this string as
1549 // when we reach the terminating NUL, either prefix string ends too (and
1550 // then it's ok) or we break out of the loop because there is no match
1551 const wxChar *p = c_str();
1552 while ( *prefix )
1553 {
1554 if ( *prefix++ != *p++ )
1555 {
1556 // no match
d775fa82 1557 return false;
f6bcfd97
BP
1558 }
1559 }
1560
1561 if ( rest )
1562 {
1563 // put the rest of the string into provided pointer
1564 *rest = p;
1565 }
1566
d775fa82 1567 return true;
f6bcfd97
BP
1568}
1569
c801d85f
KB
1570// extract nCount last (rightmost) characters
1571wxString wxString::Right(size_t nCount) const
1572{
e87b7833
MB
1573 if ( nCount > length() )
1574 nCount = length();
c801d85f 1575
e87b7833
MB
1576 wxString dest(*this, length() - nCount, nCount);
1577 if ( dest.length() != nCount ) {
b1801e0e
GD
1578 wxFAIL_MSG( _T("out of memory in wxString::Right") );
1579 }
c801d85f
KB
1580 return dest;
1581}
1582
1583// get all characters after the last occurence of ch
1584// (returns the whole string if ch not found)
2bb67b80 1585wxString wxString::AfterLast(wxChar ch) const
c801d85f
KB
1586{
1587 wxString str;
d775fa82 1588 int iPos = Find(ch, true);
3c67202d 1589 if ( iPos == wxNOT_FOUND )
c801d85f
KB
1590 str = *this;
1591 else
c8cfb486 1592 str = c_str() + iPos + 1;
c801d85f
KB
1593
1594 return str;
1595}
1596
1597// extract nCount first (leftmost) characters
1598wxString wxString::Left(size_t nCount) const
1599{
e87b7833
MB
1600 if ( nCount > length() )
1601 nCount = length();
c801d85f 1602
e87b7833
MB
1603 wxString dest(*this, 0, nCount);
1604 if ( dest.length() != nCount ) {
b1801e0e
GD
1605 wxFAIL_MSG( _T("out of memory in wxString::Left") );
1606 }
c801d85f
KB
1607 return dest;
1608}
1609
1610// get all characters before the first occurence of ch
1611// (returns the whole string if ch not found)
2bb67b80 1612wxString wxString::BeforeFirst(wxChar ch) const
c801d85f 1613{
e87b7833
MB
1614 int iPos = Find(ch);
1615 if ( iPos == wxNOT_FOUND ) iPos = length();
1616 return wxString(*this, 0, iPos);
c801d85f
KB
1617}
1618
1619/// get all characters before the last occurence of ch
1620/// (returns empty string if ch not found)
2bb67b80 1621wxString wxString::BeforeLast(wxChar ch) const
c801d85f
KB
1622{
1623 wxString str;
d775fa82 1624 int iPos = Find(ch, true);
3c67202d 1625 if ( iPos != wxNOT_FOUND && iPos != 0 )
d1c9bbf6 1626 str = wxString(c_str(), iPos);
c801d85f
KB
1627
1628 return str;
1629}
1630
1631/// get all characters after the first occurence of ch
1632/// (returns empty string if ch not found)
2bb67b80 1633wxString wxString::AfterFirst(wxChar ch) const
c801d85f
KB
1634{
1635 wxString str;
1636 int iPos = Find(ch);
3c67202d 1637 if ( iPos != wxNOT_FOUND )
c801d85f
KB
1638 str = c_str() + iPos + 1;
1639
1640 return str;
1641}
1642
1643// replace first (or all) occurences of some substring with another one
a8f1f1b2
VZ
1644size_t
1645wxString::Replace(const wxChar *szOld, const wxChar *szNew, bool bReplaceAll)
c801d85f 1646{
a8f1f1b2
VZ
1647 // if we tried to replace an empty string we'd enter an infinite loop below
1648 wxCHECK_MSG( szOld && *szOld && szNew, 0,
1649 _T("wxString::Replace(): invalid parameter") );
1650
c86f1403 1651 size_t uiCount = 0; // count of replacements made
c801d85f 1652
2bb67b80 1653 size_t uiOldLen = wxStrlen(szOld);
c801d85f
KB
1654
1655 wxString strTemp;
e87b7833 1656 const wxChar *pCurrent = c_str();
2bb67b80 1657 const wxChar *pSubstr;
223d09f6 1658 while ( *pCurrent != wxT('\0') ) {
2bb67b80 1659 pSubstr = wxStrstr(pCurrent, szOld);
c801d85f
KB
1660 if ( pSubstr == NULL ) {
1661 // strTemp is unused if no replacements were made, so avoid the copy
1662 if ( uiCount == 0 )
1663 return 0;
1664
1665 strTemp += pCurrent; // copy the rest
1666 break; // exit the loop
1667 }
1668 else {
1669 // take chars before match
e87b7833
MB
1670 size_type len = strTemp.length();
1671 strTemp.append(pCurrent, pSubstr - pCurrent);
1672 if ( strTemp.length() != (size_t)(len + pSubstr - pCurrent) ) {
b1801e0e
GD
1673 wxFAIL_MSG( _T("out of memory in wxString::Replace") );
1674 return 0;
1675 }
c801d85f
KB
1676 strTemp += szNew;
1677 pCurrent = pSubstr + uiOldLen; // restart after match
1678
1679 uiCount++;
1680
1681 // stop now?
1682 if ( !bReplaceAll ) {
1683 strTemp += pCurrent; // copy the rest
1684 break; // exit the loop
1685 }
1686 }
1687 }
1688
1689 // only done if there were replacements, otherwise would have returned above
e87b7833 1690 swap(strTemp);
c801d85f
KB
1691
1692 return uiCount;
1693}
1694
1695bool wxString::IsAscii() const
1696{
2bb67b80 1697 const wxChar *s = (const wxChar*) *this;
c801d85f 1698 while(*s){
d775fa82 1699 if(!isascii(*s)) return(false);
c801d85f
KB
1700 s++;
1701 }
d775fa82 1702 return(true);
c801d85f 1703}
dd1eaa89 1704
c801d85f
KB
1705bool wxString::IsWord() const
1706{
2bb67b80 1707 const wxChar *s = (const wxChar*) *this;
c801d85f 1708 while(*s){
d775fa82 1709 if(!wxIsalpha(*s)) return(false);
c801d85f
KB
1710 s++;
1711 }
d775fa82 1712 return(true);
c801d85f 1713}
dd1eaa89 1714
c801d85f
KB
1715bool wxString::IsNumber() const
1716{
2bb67b80 1717 const wxChar *s = (const wxChar*) *this;
2f74ed28 1718 if (wxStrlen(s))
930357bd 1719 if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++;
c801d85f 1720 while(*s){
d775fa82 1721 if(!wxIsdigit(*s)) return(false);
c801d85f
KB
1722 s++;
1723 }
d775fa82 1724 return(true);
c801d85f
KB
1725}
1726
c801d85f
KB
1727wxString wxString::Strip(stripType w) const
1728{
1729 wxString s = *this;
d775fa82
WS
1730 if ( w & leading ) s.Trim(false);
1731 if ( w & trailing ) s.Trim(true);
c801d85f
KB
1732 return s;
1733}
1734
c801d85f
KB
1735// ---------------------------------------------------------------------------
1736// case conversion
1737// ---------------------------------------------------------------------------
1738
1739wxString& wxString::MakeUpper()
1740{
e87b7833
MB
1741 for ( iterator it = begin(), en = end(); it != en; ++it )
1742 *it = (wxChar)wxToupper(*it);
c801d85f
KB
1743
1744 return *this;
1745}
1746
1747wxString& wxString::MakeLower()
1748{
e87b7833
MB
1749 for ( iterator it = begin(), en = end(); it != en; ++it )
1750 *it = (wxChar)wxTolower(*it);
c801d85f
KB
1751
1752 return *this;
1753}
1754
1755// ---------------------------------------------------------------------------
1756// trimming and padding
1757// ---------------------------------------------------------------------------
1758
d775fa82 1759// some compilers (VC++ 6.0 not to name them) return true for a call to
576c608d
VZ
1760