]> git.saurik.com Git - wxWidgets.git/blame - src/common/string.cpp
Moved print dialog data conversion code
[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
06386448
RN
987// ---------------------------------------------------------------------------
988// construction and conversion
e87b7833
MB
989// ---------------------------------------------------------------------------
990
991#if wxUSE_UNICODE
992
993// from multibyte string
994wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
995{
31444b6a
VS
996 // if nLength != npos, then we have to make a NULL-terminated copy
997 // of first nLength bytes of psz first because the input buffer to MB2WC
998 // must always be NULL-terminated:
999 wxCharBuffer inBuf((const char *)NULL);
1000 if (nLength != npos)
1001 {
b65ee6fd 1002 wxASSERT( psz != NULL );
31444b6a
VS
1003 wxCharBuffer tmp(nLength);
1004 memcpy(tmp.data(), psz, nLength);
1005 tmp.data()[nLength] = '\0';
1006 inBuf = tmp;
1007 psz = inBuf.data();
1008 }
d775fa82 1009
e87b7833
MB
1010 // first get the size of the buffer we need
1011 size_t nLen;
1012 if ( psz )
1013 {
1014 // calculate the needed size ourselves or use the provided one
06386448
RN
1015 if (nLength == npos)
1016 nLen = strlen(psz);
1017 else
1018 nLen = nLength;
e87b7833
MB
1019 }
1020 else
1021 {
1022 // nothing to convert
1023 nLen = 0;
1024 }
1025
e4e3bbb4 1026
e87b7833
MB
1027 // anything to do?
1028 if ( (nLen != 0) && (nLen != (size_t)-1) )
1029 {
e4e3bbb4
RN
1030 //Get length of converted string
1031 size_t dwConvLen = conv.MB2WC(NULL, psz, 0, nLen);
1032
1033 //if valid, do the conversion
1034 if (dwConvLen != (size_t) -1)
1035 {
1036 //Get internal buffer
1037 wxStringBufferLength internalBuffer(*this, dwConvLen + 1);
215f9d70 1038
e4e3bbb4
RN
1039 //Do the actual conversion & Set the length of the buffer
1040 internalBuffer.SetLength(
1041 conv.MB2WC(internalBuffer, psz, dwConvLen + 1, nLen)
1042 );
1043 }
e87b7833 1044 }
7663d0d4 1045}
265d5cce 1046
06386448 1047//Convert wxString in Unicode mode to a multi-byte string
265d5cce
RN
1048const wxCharBuffer wxString::mb_str(wxMBConv& conv) const
1049{
e4e3bbb4
RN
1050 //Get length of converted string
1051 size_t dwConvLen = conv.WC2MB(NULL, (*this).c_str(), 0, length());
215f9d70 1052
e4e3bbb4
RN
1053 //if valid, do the conversion
1054 if (dwConvLen != (size_t) -1)
1055 {
1056 //Create good buffer
1057 wxCharBuffer buffer(dwConvLen + 1);
1058
1059 //Do the actual conversion
1060 conv.WC2MB(buffer.data(), (*this).c_str(), dwConvLen + 1, length());
1061
1062 return buffer;
1063 }
7663d0d4 1064
e4e3bbb4
RN
1065 //create bogus buffer
1066 wxCharBuffer buffer(1);
1067 buffer.data()[0u] = 0;
215f9d70 1068 return buffer;
e87b7833
MB
1069}
1070
1071#else // ANSI
1072
1073#if wxUSE_WCHAR_T
1074// from wide string
1075wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength)
1076{
31444b6a
VS
1077 // if nLength != npos, then we have to make a NULL-terminated copy
1078 // of first nLength chars of psz first because the input buffer to WC2MB
1079 // must always be NULL-terminated:
1080 wxWCharBuffer inBuf((const wchar_t *)NULL);
1081 if (nLength != npos)
1082 {
b65ee6fd 1083 wxASSERT( pwz != NULL );
31444b6a
VS
1084 wxWCharBuffer tmp(nLength);
1085 memcpy(tmp.data(), pwz, nLength * sizeof(wchar_t));
1086 tmp.data()[nLength] = '\0';
1087 inBuf = tmp;
1088 pwz = inBuf.data();
1089 }
d775fa82 1090
e87b7833
MB
1091 // first get the size of the buffer we need
1092 size_t nLen;
1093 if ( pwz )
1094 {
1095 // calculate the needed size ourselves or use the provided one
06386448
RN
1096 if (nLength == npos)
1097 nLen = wxWcslen(pwz);
1098 else
1099 nLen = nLength;
e87b7833
MB
1100 }
1101 else
1102 {
1103 // nothing to convert
1104 nLen = 0;
1105 }
1106
1107 // anything to do?
1108 if ( (nLen != 0) && (nLen != (size_t)-1) )
1109 {
e4e3bbb4
RN
1110 //Get length of converted string
1111 size_t dwConvLen = conv.WC2MB(NULL, pwz, 0, nLen);
1112
1113 //if valid, do the conversion
1114 if (dwConvLen != (size_t) -1)
1115 {
1116 //Get internal buffer
1117 wxStringBufferLength internalBuffer(*this, dwConvLen + 1);
1118
1119 //Do the actual conversion & Set the length of the buffer
1120 internalBuffer.SetLength(
dbb6c0a9 1121 conv.WC2MB(internalBuffer, pwz, dwConvLen + 1, nLen)
e4e3bbb4
RN
1122 );
1123 }
e87b7833 1124 }
e87b7833 1125}
265d5cce 1126
7663d0d4 1127//Converts this string to a wide character string if unicode
06386448 1128//mode is not enabled and wxUSE_WCHAR_T is enabled
265d5cce
RN
1129const wxWCharBuffer wxString::wc_str(wxMBConv& conv) const
1130{
e4e3bbb4
RN
1131 //Get length of converted string
1132 size_t dwConvLen = conv.MB2WC(NULL, (*this).c_str(), 0, length());
7663d0d4 1133
e4e3bbb4
RN
1134 //if valid, do the conversion
1135 if (dwConvLen != (size_t) -1)
1136 {
1137 //Create good buffer
1138 wxWCharBuffer buffer(dwConvLen + 1);
1139
1140 //Do the actual conversion
1141 conv.MB2WC(buffer.data(), (*this).c_str(), dwConvLen + 1, length());
1142
1143 return buffer;
1144 }
7663d0d4 1145
e4e3bbb4
RN
1146 //create bogus buffer
1147 wxWCharBuffer buffer(1);
1148 buffer.data()[0u] = 0;
215f9d70 1149 return buffer;
265d5cce 1150}
7663d0d4 1151
e87b7833
MB
1152#endif // wxUSE_WCHAR_T
1153
1154#endif // Unicode/ANSI
1155
1156// shrink to minimal size (releasing extra memory)
1157bool wxString::Shrink()
1158{
1159 wxString tmp(begin(), end());
1160 swap(tmp);
1161 return tmp.length() == length();
1162}
1163
1164#if !wxUSE_STL
1165// get the pointer to writable buffer of (at least) nLen bytes
1166wxChar *wxString::GetWriteBuf(size_t nLen)
1167{
1168 if ( !AllocBeforeWrite(nLen) ) {
1169 // allocation failure handled by caller
1170 return NULL;
1171 }
1172
1173 wxASSERT( GetStringData()->nRefs == 1 );
d775fa82 1174 GetStringData()->Validate(false);
e87b7833
MB
1175
1176 return m_pchData;
1177}
1178
1179// put string back in a reasonable state after GetWriteBuf
1180void wxString::UngetWriteBuf()
1181{
1182 GetStringData()->nDataLength = wxStrlen(m_pchData);
d775fa82 1183 GetStringData()->Validate(true);
e87b7833
MB
1184}
1185
1186void wxString::UngetWriteBuf(size_t nLen)
1187{
1188 GetStringData()->nDataLength = nLen;
d775fa82 1189 GetStringData()->Validate(true);
e87b7833
MB
1190}
1191#endif
1192
1193// ---------------------------------------------------------------------------
1194// data access
1195// ---------------------------------------------------------------------------
1196
1197// all functions are inline in string.h
1198
1199// ---------------------------------------------------------------------------
1200// assignment operators
1201// ---------------------------------------------------------------------------
1202
1203#if !wxUSE_UNICODE
1204
1205// same as 'signed char' variant
1206wxString& wxString::operator=(const unsigned char* psz)
1207{
1208 *this = (const char *)psz;
1209 return *this;
1210}
1211
1212#if wxUSE_WCHAR_T
1213wxString& wxString::operator=(const wchar_t *pwz)
1214{
1215 wxString str(pwz);
1216 swap(str);
1217 return *this;
c801d85f 1218}
e87b7833
MB
1219#endif
1220
1221#endif
c801d85f
KB
1222
1223/*
c801d85f
KB
1224 * concatenation functions come in 5 flavours:
1225 * string + string
1226 * char + string and string + char
1227 * C str + string and string + C str
1228 */
1229
b1801e0e 1230wxString operator+(const wxString& str1, const wxString& str2)
c801d85f 1231{
e87b7833 1232#if !wxUSE_STL
b1801e0e
GD
1233 wxASSERT( str1.GetStringData()->IsValid() );
1234 wxASSERT( str2.GetStringData()->IsValid() );
e87b7833 1235#endif
097c080b 1236
b1801e0e
GD
1237 wxString s = str1;
1238 s += str2;
3168a13f 1239
c801d85f
KB
1240 return s;
1241}
1242
b1801e0e 1243wxString operator+(const wxString& str, wxChar ch)
c801d85f 1244{
e87b7833 1245#if !wxUSE_STL
b1801e0e 1246 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1247#endif
3168a13f 1248
b1801e0e 1249 wxString s = str;
3168a13f 1250 s += ch;
097c080b 1251
c801d85f
KB
1252 return s;
1253}
1254
b1801e0e 1255wxString operator+(wxChar ch, const wxString& str)
c801d85f 1256{
e87b7833 1257#if !wxUSE_STL
b1801e0e 1258 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1259#endif
097c080b 1260
3168a13f 1261 wxString s = ch;
b1801e0e 1262 s += str;
3168a13f 1263
c801d85f
KB
1264 return s;
1265}
1266
b1801e0e 1267wxString operator+(const wxString& str, const wxChar *psz)
c801d85f 1268{
e87b7833 1269#if !wxUSE_STL
b1801e0e 1270 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1271#endif
097c080b 1272
c801d85f 1273 wxString s;
b1801e0e
GD
1274 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1275 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1276 }
1277 s = str;
3168a13f
VZ
1278 s += psz;
1279
c801d85f
KB
1280 return s;
1281}
1282
b1801e0e 1283wxString operator+(const wxChar *psz, const wxString& str)
c801d85f 1284{
e87b7833 1285#if !wxUSE_STL
b1801e0e 1286 wxASSERT( str.GetStringData()->IsValid() );
e87b7833 1287#endif
097c080b 1288
c801d85f 1289 wxString s;
b1801e0e
GD
1290 if ( !s.Alloc(wxStrlen(psz) + str.Len()) ) {
1291 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1292 }
3168a13f 1293 s = psz;
b1801e0e 1294 s += str;
3168a13f 1295
c801d85f
KB
1296 return s;
1297}
1298
1299// ===========================================================================
1300// other common string functions
1301// ===========================================================================
1302
dcb68102
RN
1303int wxString::Cmp(const wxString& s) const
1304{
1305 return compare(s);
1306}
1307
1308int wxString::Cmp(const wxChar* psz) const
1309{
1310 return compare(psz);
1311}
1312
1313static inline int wxDoCmpNoCase(const wxChar* s1, size_t l1,
1314 const wxChar* s2, size_t l2)
1315{
1316 size_t i;
1317
1318 if( l1 == l2 )
1319 {
1320 for(i = 0; i < l1; ++i)
1321 {
1322 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1323 break;
1324 }
1325 return i == l1 ? 0 : s1[i] < s2[i] ? -1 : 1;
1326 }
1327 else if( l1 < l2 )
1328 {
1329 for(i = 0; i < l1; ++i)
1330 {
1331 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1332 break;
1333 }
1334 return i == l1 ? -1 : s1[i] < s2[i] ? -1 : 1;
1335 }
1336 else if( l1 > l2 )
1337 {
1338 for(i = 0; i < l2; ++i)
1339 {
1340 if(wxTolower(s1[i]) != wxTolower(s2[i]))
1341 break;
1342 }
1343 return i == l2 ? 1 : s1[i] < s2[i] ? -1 : 1;
1344 }
1345
1346 wxFAIL; // must never get there
1347 return 0; // quiet compilers
1348}
1349
1350int wxString::CmpNoCase(const wxString& s) const
1351{
1352 return wxDoCmpNoCase(data(), length(), s.data(), s.length());
1353}
1354
1355int wxString::CmpNoCase(const wxChar* psz) const
1356{
1357 int nLen = wxStrlen(psz);
1358
1359 return wxDoCmpNoCase(data(), length(), psz, nLen);
1360}
1361
1362
b1ac3b56 1363#if wxUSE_UNICODE
e015c2a3 1364
cf6bedce
SC
1365#ifdef __MWERKS__
1366#ifndef __SCHAR_MAX__
1367#define __SCHAR_MAX__ 127
1368#endif
1369#endif
1370
e015c2a3 1371wxString wxString::FromAscii(const char *ascii)
b1ac3b56
RR
1372{
1373 if (!ascii)
1374 return wxEmptyString;
e015c2a3 1375
b1ac3b56
RR
1376 size_t len = strlen( ascii );
1377 wxString res;
e015c2a3
VZ
1378
1379 if ( len )
1380 {
1381 wxStringBuffer buf(res, len);
1382
1383 wchar_t *dest = buf;
1384
1385 for ( ;; )
1386 {
1387 if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' )
1388 break;
1389 }
1390 }
1391
b1ac3b56
RR
1392 return res;
1393}
1394
2b5f62a0
VZ
1395wxString wxString::FromAscii(const char ascii)
1396{
1397 // What do we do with '\0' ?
1398
1399 wxString res;
1400 res += (wchar_t)(unsigned char) ascii;
8760bc65 1401
2b5f62a0
VZ
1402 return res;
1403}
1404
b1ac3b56
RR
1405const wxCharBuffer wxString::ToAscii() const
1406{
e015c2a3
VZ
1407 // this will allocate enough space for the terminating NUL too
1408 wxCharBuffer buffer(length());
b1ac3b56 1409
e015c2a3
VZ
1410 signed char *dest = (signed char *)buffer.data();
1411
1412 const wchar_t *pwc = c_str();
1413 for ( ;; )
b1ac3b56 1414 {
930357bd 1415 *dest++ = *pwc > SCHAR_MAX ? wxT('_') : *pwc;
e015c2a3
VZ
1416
1417 // the output string can't have embedded NULs anyhow, so we can safely
1418 // stop at first of them even if we do have any
1419 if ( !*pwc++ )
1420 break;
b1ac3b56 1421 }
e015c2a3 1422
b1ac3b56
RR
1423 return buffer;
1424}
e015c2a3
VZ
1425
1426#endif // Unicode
b1ac3b56 1427
c801d85f 1428// extract string of length nCount starting at nFirst
c801d85f
KB
1429wxString wxString::Mid(size_t nFirst, size_t nCount) const
1430{
e87b7833 1431 size_t nLen = length();
30d9011f 1432
e87b7833
MB
1433 // default value of nCount is npos and means "till the end"
1434 if ( nCount == npos )
30d9011f
VZ
1435 {
1436 nCount = nLen - nFirst;
1437 }
1438
c801d85f 1439 // out-of-bounds requests return sensible things
30d9011f
VZ
1440 if ( nFirst + nCount > nLen )
1441 {
1442 nCount = nLen - nFirst;
1443 }
c801d85f 1444
30d9011f
VZ
1445 if ( nFirst > nLen )
1446 {
1447 // AllocCopy() will return empty string
c801d85f 1448 nCount = 0;
30d9011f 1449 }
c801d85f 1450
e87b7833
MB
1451 wxString dest(*this, nFirst, nCount);
1452 if ( dest.length() != nCount ) {
b1801e0e
GD
1453 wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1454 }
30d9011f 1455
c801d85f
KB
1456 return dest;
1457}
1458
e87b7833 1459// check that the string starts with prefix and return the rest of the string
d775fa82 1460// in the provided pointer if it is not NULL, otherwise return false
f6bcfd97
BP
1461bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
1462{
1463 wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
1464
1465 // first check if the beginning of the string matches the prefix: note
1466 // that we don't have to check that we don't run out of this string as
1467 // when we reach the terminating NUL, either prefix string ends too (and
1468 // then it's ok) or we break out of the loop because there is no match
1469 const wxChar *p = c_str();
1470 while ( *prefix )
1471 {
1472 if ( *prefix++ != *p++ )
1473 {
1474 // no match
d775fa82 1475 return false;
f6bcfd97
BP
1476 }
1477 }
1478
1479 if ( rest )
1480 {
1481 // put the rest of the string into provided pointer
1482 *rest = p;
1483 }
1484
d775fa82 1485 return true;
f6bcfd97
BP
1486}
1487
c801d85f
KB
1488// extract nCount last (rightmost) characters
1489wxString wxString::Right(size_t nCount) const
1490{
e87b7833
MB
1491 if ( nCount > length() )
1492 nCount = length();
c801d85f 1493
e87b7833
MB
1494 wxString dest(*this, length() - nCount, nCount);
1495 if ( dest.length() != nCount ) {
b1801e0e
GD
1496 wxFAIL_MSG( _T("out of memory in wxString::Right") );
1497 }
c801d85f
KB
1498 return dest;
1499}
1500
1501// get all characters after the last occurence of ch
1502// (returns the whole string if ch not found)
2bb67b80 1503wxString wxString::AfterLast(wxChar ch) const
c801d85f
KB
1504{
1505 wxString str;
d775fa82 1506 int iPos = Find(ch, true);
3c67202d 1507 if ( iPos == wxNOT_FOUND )
c801d85f
KB
1508 str = *this;
1509 else
c8cfb486 1510 str = c_str() + iPos + 1;
c801d85f
KB
1511
1512 return str;
1513}
1514
1515// extract nCount first (leftmost) characters
1516wxString wxString::Left(size_t nCount) const
1517{
e87b7833
MB
1518 if ( nCount > length() )
1519 nCount = length();
c801d85f 1520
e87b7833
MB
1521 wxString dest(*this, 0, nCount);
1522 if ( dest.length() != nCount ) {
b1801e0e
GD
1523 wxFAIL_MSG( _T("out of memory in wxString::Left") );
1524 }
c801d85f
KB
1525 return dest;
1526}
1527
1528// get all characters before the first occurence of ch
1529// (returns the whole string if ch not found)
2bb67b80 1530wxString wxString::BeforeFirst(wxChar ch) const
c801d85f 1531{
e87b7833
MB
1532 int iPos = Find(ch);
1533 if ( iPos == wxNOT_FOUND ) iPos = length();
1534 return wxString(*this, 0, iPos);
c801d85f
KB
1535}
1536
1537/// get all characters before the last occurence of ch
1538/// (returns empty string if ch not found)
2bb67b80 1539wxString wxString::BeforeLast(wxChar ch) const
c801d85f
KB
1540{
1541 wxString str;
d775fa82 1542 int iPos = Find(ch, true);
3c67202d 1543 if ( iPos != wxNOT_FOUND && iPos != 0 )
d1c9bbf6 1544 str = wxString(c_str(), iPos);
c801d85f
KB
1545
1546 return str;
1547}
1548
1549/// get all characters after the first occurence of ch
1550/// (returns empty string if ch not found)
2bb67b80 1551wxString wxString::AfterFirst(wxChar ch) const
c801d85f
KB
1552{
1553 wxString str;
1554 int iPos = Find(ch);
3c67202d 1555 if ( iPos != wxNOT_FOUND )
c801d85f
KB
1556 str = c_str() + iPos + 1;
1557
1558 return str;
1559}
1560
1561// replace first (or all) occurences of some substring with another one
a8f1f1b2
VZ
1562size_t
1563wxString::Replace(const wxChar *szOld, const wxChar *szNew, bool bReplaceAll)
c801d85f 1564{
a8f1f1b2
VZ
1565 // if we tried to replace an empty string we'd enter an infinite loop below
1566 wxCHECK_MSG( szOld && *szOld && szNew, 0,
1567 _T("wxString::Replace(): invalid parameter") );
1568
c86f1403 1569 size_t uiCount = 0; // count of replacements made
c801d85f 1570
2bb67b80 1571 size_t uiOldLen = wxStrlen(szOld);
c801d85f
KB
1572
1573 wxString strTemp;
e87b7833 1574 const wxChar *pCurrent = c_str();
2bb67b80 1575 const wxChar *pSubstr;
223d09f6 1576 while ( *pCurrent != wxT('\0') ) {
2bb67b80 1577 pSubstr = wxStrstr(pCurrent, szOld);
c801d85f
KB
1578 if ( pSubstr == NULL ) {
1579 // strTemp is unused if no replacements were made, so avoid the copy
1580 if ( uiCount == 0 )
1581 return 0;
1582
1583 strTemp += pCurrent; // copy the rest
1584 break; // exit the loop
1585 }
1586 else {
1587 // take chars before match
e87b7833
MB
1588 size_type len = strTemp.length();
1589 strTemp.append(pCurrent, pSubstr - pCurrent);
1590 if ( strTemp.length() != (size_t)(len + pSubstr - pCurrent) ) {
b1801e0e
GD
1591 wxFAIL_MSG( _T("out of memory in wxString::Replace") );
1592 return 0;
1593 }
c801d85f
KB
1594 strTemp += szNew;
1595 pCurrent = pSubstr + uiOldLen; // restart after match
1596
1597 uiCount++;
1598
1599 // stop now?
1600 if ( !bReplaceAll ) {
1601 strTemp += pCurrent; // copy the rest
1602 break; // exit the loop
1603 }
1604 }
1605 }
1606
1607 // only done if there were replacements, otherwise would have returned above
e87b7833 1608 swap(strTemp);
c801d85f
KB
1609
1610 return uiCount;
1611}
1612
1613bool wxString::IsAscii() const
1614{
2bb67b80 1615 const wxChar *s = (const wxChar*) *this;
c801d85f 1616 while(*s){
d775fa82 1617 if(!isascii(*s)) return(false);
c801d85f
KB
1618 s++;
1619 }
d775fa82 1620 return(true);
c801d85f 1621}
dd1eaa89 1622
c801d85f
KB
1623bool wxString::IsWord() const
1624{
2bb67b80 1625 const wxChar *s = (const wxChar*) *this;
c801d85f 1626 while(*s){
d775fa82 1627 if(!wxIsalpha(*s)) return(false);
c801d85f
KB
1628 s++;
1629 }
d775fa82 1630 return(true);
c801d85f 1631}
dd1eaa89 1632
c801d85f
KB
1633bool wxString::IsNumber() const
1634{
2bb67b80 1635 const wxChar *s = (const wxChar*) *this;
2f74ed28 1636 if (wxStrlen(s))
930357bd 1637 if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++;
c801d85f 1638 while(*s){
d775fa82 1639 if(!wxIsdigit(*s)) return(false);
c801d85f
KB
1640 s++;
1641 }
d775fa82 1642 return(true);
c801d85f
KB
1643}
1644
c801d85f
KB
1645wxString wxString::Strip(stripType w) const
1646{
1647 wxString s = *this;
d775fa82
WS
1648 if ( w & leading ) s.Trim(false);
1649 if ( w & trailing ) s.Trim(true);
c801d85f
KB
1650 return s;
1651}
1652
c801d85f
KB
1653// ---------------------------------------------------------------------------
1654// case conversion
1655// ---------------------------------------------------------------------------
1656
1657wxString& wxString::MakeUpper()
1658{
e87b7833
MB
1659 for ( iterator it = begin(), en = end(); it != en; ++it )
1660 *it = (wxChar)wxToupper(*it);
c801d85f
KB
1661
1662 return *this;
1663}
1664
1665wxString& wxString::MakeLower()
1666{
e87b7833
MB
1667 for ( iterator it = begin(), en = end(); it != en; ++it )
1668 *it = (wxChar)wxTolower(*it);
c801d85f
KB
1669
1670 return *this;
1671}
1672
1673// ---------------------------------------------------------------------------
1674// trimming and padding
1675// ---------------------------------------------------------------------------
1676
d775fa82 1677// some compilers (VC++ 6.0 not to name them) return true for a call to
576c608d
VZ
1678