]> git.saurik.com Git - wxWidgets.git/blob - src/common/string.cpp
Various VC++ 1.5 and other corrections
[wxWidgets.git] / src / common / string.cpp
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>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "string.h"
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__
31 #pragma hdrstop
32 #endif
33
34 #ifndef WX_PRECOMP
35 #include "wx/defs.h"
36 #include "wx/string.h"
37 #include "wx/intl.h"
38 #include "wx/thread.h"
39 #endif
40
41 #include <ctype.h>
42 #include <string.h>
43 #include <stdlib.h>
44
45 #ifdef __SALFORDC__
46 #include <clib.h>
47 #endif
48
49 #if wxUSE_WCSRTOMBS
50 #include <wchar.h> // for wcsrtombs(), see comments where it's used
51 #endif // GNU
52
53 #ifdef WXSTRING_IS_WXOBJECT
54 IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
55 #endif //WXSTRING_IS_WXOBJECT
56
57 #if wxUSE_UNICODE
58 #undef wxUSE_EXPERIMENTAL_PRINTF
59 #define wxUSE_EXPERIMENTAL_PRINTF 1
60 #endif
61
62 // allocating extra space for each string consumes more memory but speeds up
63 // the concatenation operations (nLen is the current string's length)
64 // NB: EXTRA_ALLOC must be >= 0!
65 #define EXTRA_ALLOC (19 - nLen % 16)
66
67 // ---------------------------------------------------------------------------
68 // static class variables definition
69 // ---------------------------------------------------------------------------
70
71 #ifdef wxSTD_STRING_COMPATIBILITY
72 const size_t wxString::npos = wxSTRING_MAXLEN;
73 #endif // wxSTD_STRING_COMPATIBILITY
74
75 // ----------------------------------------------------------------------------
76 // static data
77 // ----------------------------------------------------------------------------
78
79 // for an empty string, GetStringData() will return this address: this
80 // structure has the same layout as wxStringData and it's data() method will
81 // return the empty string (dummy pointer)
82 static const struct
83 {
84 wxStringData data;
85 wxChar dummy;
86 } g_strEmpty = { {-1, 0, 0}, wxT('\0') };
87
88 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
89 // must define this static for VA or else you get multiply defined symbols everywhere
90 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
91
92 #endif
93
94 // empty C style string: points to 'string data' byte of g_strEmpty
95 extern const wxChar WXDLLEXPORT *wxEmptyString = &g_strEmpty.dummy;
96
97 // ----------------------------------------------------------------------------
98 // conditional compilation
99 // ----------------------------------------------------------------------------
100
101 #if !defined(__WXSW__) && wxUSE_UNICODE
102 #ifdef wxUSE_EXPERIMENTAL_PRINTF
103 #undef wxUSE_EXPERIMENTAL_PRINTF
104 #endif
105 #define wxUSE_EXPERIMENTAL_PRINTF 1
106 #endif
107
108 // we want to find out if the current platform supports vsnprintf()-like
109 // function: for Unix this is done with configure, for Windows we test the
110 // compiler explicitly.
111 //
112 // FIXME currently, this is only for ANSI (!Unicode) strings, so we call this
113 // function wxVsnprintfA (A for ANSI), should also find one for Unicode
114 // strings in Unicode build
115 #ifdef __WXMSW__
116 #if defined(__VISUALC__) || wxUSE_NORLANDER_HEADERS
117 #define wxVsnprintfA _vsnprintf
118 #endif
119 #else // !Windows
120 #ifdef HAVE_VSNPRINTF
121 #define wxVsnprintfA vsnprintf
122 #endif
123 #endif // Windows/!Windows
124
125 #ifndef wxVsnprintfA
126 // in this case we'll use vsprintf() (which is ANSI and thus should be
127 // always available), but it's unsafe because it doesn't check for buffer
128 // size - so give a warning
129 #define wxVsnprintfA(buf, len, format, arg) vsprintf(buf, format, arg)
130
131 #if defined(__VISUALC__)
132 #pragma message("Using sprintf() because no snprintf()-like function defined")
133 #elif defined(__GNUG__) && !defined(__UNIX__)
134 #warning "Using sprintf() because no snprintf()-like function defined"
135 #elif defined(__MWERKS__)
136 #warning "Using sprintf() because no snprintf()-like function defined"
137 #endif //compiler
138 #endif // no vsnprintf
139
140 #ifdef _AIX
141 // AIX has vsnprintf, but there's no prototype in the system headers.
142 extern "C" int vsnprintf(char* str, size_t n, const char* format, va_list ap);
143 #endif
144
145 // ----------------------------------------------------------------------------
146 // global functions
147 // ----------------------------------------------------------------------------
148
149 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
150
151 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
152 // iostream ones.
153 //
154 // ATTN: you can _not_ use both of these in the same program!
155
156 istream& operator>>(istream& is, wxString& WXUNUSED(str))
157 {
158 #if 0
159 int w = is.width(0);
160 if ( is.ipfx(0) ) {
161 streambuf *sb = is.rdbuf();
162 str.erase();
163 while ( true ) {
164 int ch = sb->sbumpc ();
165 if ( ch == EOF ) {
166 is.setstate(ios::eofbit);
167 break;
168 }
169 else if ( isspace(ch) ) {
170 sb->sungetc();
171 break;
172 }
173
174 str += ch;
175 if ( --w == 1 )
176 break;
177 }
178 }
179
180 is.isfx();
181 if ( str.length() == 0 )
182 is.setstate(ios::failbit);
183 #endif
184 return is;
185 }
186
187 ostream& operator<<(ostream& os, const wxString& str)
188 {
189 os << str.c_str();
190 return os;
191 }
192
193 #endif //std::string compatibility
194
195 extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
196 const wxChar *format, va_list argptr)
197 {
198 #if wxUSE_UNICODE
199 // FIXME should use wvsnprintf() or whatever if it's available
200 wxString s;
201 int iLen = s.PrintfV(format, argptr);
202 if ( iLen != -1 )
203 {
204 wxStrncpy(buf, s.c_str(), iLen);
205 }
206
207 return iLen;
208 #else // ANSI
209 // vsnprintf() will not terminate the string with '\0' if there is not
210 // enough place, but we want the string to always be NUL terminated
211 int rc = wxVsnprintfA(buf, len - 1, format, argptr);
212 if ( rc == -1 )
213 {
214 buf[len] = 0;
215 }
216
217 return rc;
218 #endif // Unicode/ANSI
219 }
220
221 extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
222 const wxChar *format, ...)
223 {
224 va_list argptr;
225 va_start(argptr, format);
226
227 int iLen = wxVsnprintf(buf, len, format, argptr);
228
229 va_end(argptr);
230
231 return iLen;
232 }
233
234 // ----------------------------------------------------------------------------
235 // private classes
236 // ----------------------------------------------------------------------------
237
238 // this small class is used to gather statistics for performance tuning
239 //#define WXSTRING_STATISTICS
240 #ifdef WXSTRING_STATISTICS
241 class Averager
242 {
243 public:
244 Averager(const char *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
245 ~Averager()
246 { printf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
247
248 void Add(size_t n) { m_nTotal += n; m_nCount++; }
249
250 private:
251 size_t m_nCount, m_nTotal;
252 const char *m_sz;
253 } g_averageLength("allocation size"),
254 g_averageSummandLength("summand length"),
255 g_averageConcatHit("hit probability in concat"),
256 g_averageInitialLength("initial string length");
257
258 #define STATISTICS_ADD(av, val) g_average##av.Add(val)
259 #else
260 #define STATISTICS_ADD(av, val)
261 #endif // WXSTRING_STATISTICS
262
263 // ===========================================================================
264 // wxString class core
265 // ===========================================================================
266
267 // ---------------------------------------------------------------------------
268 // construction
269 // ---------------------------------------------------------------------------
270
271 // constructs string of <nLength> copies of character <ch>
272 wxString::wxString(wxChar ch, size_t nLength)
273 {
274 Init();
275
276 if ( nLength > 0 ) {
277 AllocBuffer(nLength);
278
279 #if wxUSE_UNICODE
280 // memset only works on char
281 for (size_t n=0; n<nLength; n++) m_pchData[n] = ch;
282 #else
283 memset(m_pchData, ch, nLength);
284 #endif
285 }
286 }
287
288 // takes nLength elements of psz starting at nPos
289 void wxString::InitWith(const wxChar *psz, size_t nPos, size_t nLength)
290 {
291 Init();
292
293 if ( nLength == wxSTRING_MAXLEN )
294 nLength = wxStrlen(psz + nPos);
295
296 wxASSERT_MSG( nPos + nLength <= wxStrlen(psz), _T("index out of bounds") );
297
298 STATISTICS_ADD(InitialLength, nLength);
299
300 if ( nLength > 0 ) {
301 // trailing '\0' is written in AllocBuffer()
302 AllocBuffer(nLength);
303 memcpy(m_pchData, psz + nPos, nLength*sizeof(wxChar));
304 }
305 }
306
307 #ifdef wxSTD_STRING_COMPATIBILITY
308
309 // poor man's iterators are "void *" pointers
310 wxString::wxString(const void *pStart, const void *pEnd)
311 {
312 InitWith((const wxChar *)pStart, 0,
313 (const wxChar *)pEnd - (const wxChar *)pStart);
314 }
315
316 #endif //std::string compatibility
317
318 #if wxUSE_UNICODE
319
320 // from multibyte string
321 wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
322 {
323 // first get necessary size
324 size_t nLen = psz ? conv.MB2WC((wchar_t *) NULL, psz, 0) : 0;
325
326 // nLength is number of *Unicode* characters here!
327 if ((nLen != (size_t)-1) && (nLen > nLength))
328 nLen = nLength;
329
330 // empty?
331 if ( (nLen != 0) && (nLen != (size_t)-1) ) {
332 AllocBuffer(nLen);
333 conv.MB2WC(m_pchData, psz, nLen);
334 }
335 else {
336 Init();
337 }
338 }
339
340 #else // ANSI
341
342 #if wxUSE_WCHAR_T
343 // from wide string
344 wxString::wxString(const wchar_t *pwz)
345 {
346 // first get necessary size
347 size_t nLen = pwz ? wxWC2MB((char *) NULL, pwz, 0) : 0;
348
349 // empty?
350 if ( (nLen != 0) && (nLen != (size_t)-1) ) {
351 AllocBuffer(nLen);
352 wxWC2MB(m_pchData, pwz, nLen);
353 }
354 else {
355 Init();
356 }
357 }
358 #endif // wxUSE_WCHAR_T
359
360 #endif // Unicode/ANSI
361
362 // ---------------------------------------------------------------------------
363 // memory allocation
364 // ---------------------------------------------------------------------------
365
366 // allocates memory needed to store a C string of length nLen
367 void wxString::AllocBuffer(size_t nLen)
368 {
369 // allocating 0 sized buffer doesn't make sense, all empty strings should
370 // reuse g_strEmpty
371 wxASSERT( nLen > 0 );
372
373 // make sure that we don't overflow
374 wxASSERT( nLen < (INT_MAX / sizeof(wxChar)) -
375 (sizeof(wxStringData) + EXTRA_ALLOC + 1) );
376
377 STATISTICS_ADD(Length, nLen);
378
379 // allocate memory:
380 // 1) one extra character for '\0' termination
381 // 2) sizeof(wxStringData) for housekeeping info
382 wxStringData* pData = (wxStringData*)
383 malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(wxChar));
384 pData->nRefs = 1;
385 pData->nDataLength = nLen;
386 pData->nAllocLength = nLen + EXTRA_ALLOC;
387 m_pchData = pData->data(); // data starts after wxStringData
388 m_pchData[nLen] = wxT('\0');
389 }
390
391 // must be called before changing this string
392 void wxString::CopyBeforeWrite()
393 {
394 wxStringData* pData = GetStringData();
395
396 if ( pData->IsShared() ) {
397 pData->Unlock(); // memory not freed because shared
398 size_t nLen = pData->nDataLength;
399 AllocBuffer(nLen);
400 memcpy(m_pchData, pData->data(), nLen*sizeof(wxChar));
401 }
402
403 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
404 }
405
406 // must be called before replacing contents of this string
407 void wxString::AllocBeforeWrite(size_t nLen)
408 {
409 wxASSERT( nLen != 0 ); // doesn't make any sense
410
411 // must not share string and must have enough space
412 wxStringData* pData = GetStringData();
413 if ( pData->IsShared() || pData->IsEmpty() ) {
414 // can't work with old buffer, get new one
415 pData->Unlock();
416 AllocBuffer(nLen);
417 }
418 else {
419 if ( nLen > pData->nAllocLength ) {
420 // realloc the buffer instead of calling malloc() again, this is more
421 // efficient
422 STATISTICS_ADD(Length, nLen);
423
424 nLen += EXTRA_ALLOC;
425
426 wxStringData *pDataOld = pData;
427 pData = (wxStringData*)
428 realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
429 if ( !pData ) {
430 // out of memory
431 free(pDataOld);
432
433 // FIXME we're going to crash...
434 return;
435 }
436
437 pData->nAllocLength = nLen;
438 m_pchData = pData->data();
439 }
440
441 // now we have enough space, just update the string length
442 pData->nDataLength = nLen;
443 }
444
445 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
446 }
447
448 // allocate enough memory for nLen characters
449 void wxString::Alloc(size_t nLen)
450 {
451 wxStringData *pData = GetStringData();
452 if ( pData->nAllocLength <= nLen ) {
453 if ( pData->IsEmpty() ) {
454 nLen += EXTRA_ALLOC;
455
456 wxStringData* pData = (wxStringData*)
457 malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
458 pData->nRefs = 1;
459 pData->nDataLength = 0;
460 pData->nAllocLength = nLen;
461 m_pchData = pData->data(); // data starts after wxStringData
462 m_pchData[0u] = wxT('\0');
463 }
464 else if ( pData->IsShared() ) {
465 pData->Unlock(); // memory not freed because shared
466 size_t nOldLen = pData->nDataLength;
467 AllocBuffer(nLen);
468 memcpy(m_pchData, pData->data(), nOldLen*sizeof(wxChar));
469 }
470 else {
471 nLen += EXTRA_ALLOC;
472
473 wxStringData *pDataOld = pData;
474 wxStringData *p = (wxStringData *)
475 realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(wxChar));
476
477 if ( p == NULL ) {
478 // don't leak memory
479 free(pDataOld);
480
481 // FIXME what to do on memory error?
482 return;
483 }
484
485 // it's not important if the pointer changed or not (the check for this
486 // is not faster than assigning to m_pchData in all cases)
487 p->nAllocLength = nLen;
488 m_pchData = p->data();
489 }
490 }
491 //else: we've already got enough
492 }
493
494 // shrink to minimal size (releasing extra memory)
495 void wxString::Shrink()
496 {
497 wxStringData *pData = GetStringData();
498
499 // this variable is unused in release build, so avoid the compiler warning
500 // by just not declaring it
501 #ifdef __WXDEBUG__
502 void *p =
503 #endif
504 realloc(pData, sizeof(wxStringData) + (pData->nDataLength + 1)*sizeof(wxChar));
505
506 // we rely on a reasonable realloc() implementation here - so far I haven't
507 // seen any which wouldn't behave like this
508
509 wxASSERT( p != NULL ); // can't free memory?
510 wxASSERT( p == pData ); // we're decrementing the size - block shouldn't move!
511 }
512
513 // get the pointer to writable buffer of (at least) nLen bytes
514 wxChar *wxString::GetWriteBuf(size_t nLen)
515 {
516 AllocBeforeWrite(nLen);
517
518 wxASSERT( GetStringData()->nRefs == 1 );
519 GetStringData()->Validate(FALSE);
520
521 return m_pchData;
522 }
523
524 // put string back in a reasonable state after GetWriteBuf
525 void wxString::UngetWriteBuf()
526 {
527 GetStringData()->nDataLength = wxStrlen(m_pchData);
528 GetStringData()->Validate(TRUE);
529 }
530
531 void wxString::UngetWriteBuf(size_t nLen)
532 {
533 GetStringData()->nDataLength = nLen;
534 GetStringData()->Validate(TRUE);
535 }
536
537 // ---------------------------------------------------------------------------
538 // data access
539 // ---------------------------------------------------------------------------
540
541 // all functions are inline in string.h
542
543 // ---------------------------------------------------------------------------
544 // assignment operators
545 // ---------------------------------------------------------------------------
546
547 // helper function: does real copy
548 void wxString::AssignCopy(size_t nSrcLen, const wxChar *pszSrcData)
549 {
550 if ( nSrcLen == 0 ) {
551 Reinit();
552 }
553 else {
554 AllocBeforeWrite(nSrcLen);
555 memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
556 GetStringData()->nDataLength = nSrcLen;
557 m_pchData[nSrcLen] = wxT('\0');
558 }
559 }
560
561 // assigns one string to another
562 wxString& wxString::operator=(const wxString& stringSrc)
563 {
564 wxASSERT( stringSrc.GetStringData()->IsValid() );
565
566 // don't copy string over itself
567 if ( m_pchData != stringSrc.m_pchData ) {
568 if ( stringSrc.GetStringData()->IsEmpty() ) {
569 Reinit();
570 }
571 else {
572 // adjust references
573 GetStringData()->Unlock();
574 m_pchData = stringSrc.m_pchData;
575 GetStringData()->Lock();
576 }
577 }
578
579 return *this;
580 }
581
582 // assigns a single character
583 wxString& wxString::operator=(wxChar ch)
584 {
585 AssignCopy(1, &ch);
586 return *this;
587 }
588
589 // assigns C string
590 wxString& wxString::operator=(const wxChar *psz)
591 {
592 AssignCopy(wxStrlen(psz), psz);
593 return *this;
594 }
595
596 #if !wxUSE_UNICODE
597
598 // same as 'signed char' variant
599 wxString& wxString::operator=(const unsigned char* psz)
600 {
601 *this = (const char *)psz;
602 return *this;
603 }
604
605 #if wxUSE_WCHAR_T
606 wxString& wxString::operator=(const wchar_t *pwz)
607 {
608 wxString str(pwz);
609 *this = str;
610 return *this;
611 }
612 #endif
613
614 #endif
615
616 // ---------------------------------------------------------------------------
617 // string concatenation
618 // ---------------------------------------------------------------------------
619
620 // add something to this string
621 void wxString::ConcatSelf(int nSrcLen, const wxChar *pszSrcData)
622 {
623 STATISTICS_ADD(SummandLength, nSrcLen);
624
625 // concatenating an empty string is a NOP
626 if ( nSrcLen > 0 ) {
627 wxStringData *pData = GetStringData();
628 size_t nLen = pData->nDataLength;
629 size_t nNewLen = nLen + nSrcLen;
630
631 // alloc new buffer if current is too small
632 if ( pData->IsShared() ) {
633 STATISTICS_ADD(ConcatHit, 0);
634
635 // we have to allocate another buffer
636 wxStringData* pOldData = GetStringData();
637 AllocBuffer(nNewLen);
638 memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxChar));
639 pOldData->Unlock();
640 }
641 else if ( nNewLen > pData->nAllocLength ) {
642 STATISTICS_ADD(ConcatHit, 0);
643
644 // we have to grow the buffer
645 Alloc(nNewLen);
646 }
647 else {
648 STATISTICS_ADD(ConcatHit, 1);
649
650 // the buffer is already big enough
651 }
652
653 // should be enough space
654 wxASSERT( nNewLen <= GetStringData()->nAllocLength );
655
656 // fast concatenation - all is done in our buffer
657 memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(wxChar));
658
659 m_pchData[nNewLen] = wxT('\0'); // put terminating '\0'
660 GetStringData()->nDataLength = nNewLen; // and fix the length
661 }
662 //else: the string to append was empty
663 }
664
665 /*
666 * concatenation functions come in 5 flavours:
667 * string + string
668 * char + string and string + char
669 * C str + string and string + C str
670 */
671
672 wxString operator+(const wxString& string1, const wxString& string2)
673 {
674 wxASSERT( string1.GetStringData()->IsValid() );
675 wxASSERT( string2.GetStringData()->IsValid() );
676
677 wxString s = string1;
678 s += string2;
679
680 return s;
681 }
682
683 wxString operator+(const wxString& string, wxChar ch)
684 {
685 wxASSERT( string.GetStringData()->IsValid() );
686
687 wxString s = string;
688 s += ch;
689
690 return s;
691 }
692
693 wxString operator+(wxChar ch, const wxString& string)
694 {
695 wxASSERT( string.GetStringData()->IsValid() );
696
697 wxString s = ch;
698 s += string;
699
700 return s;
701 }
702
703 wxString operator+(const wxString& string, const wxChar *psz)
704 {
705 wxASSERT( string.GetStringData()->IsValid() );
706
707 wxString s;
708 s.Alloc(wxStrlen(psz) + string.Len());
709 s = string;
710 s += psz;
711
712 return s;
713 }
714
715 wxString operator+(const wxChar *psz, const wxString& string)
716 {
717 wxASSERT( string.GetStringData()->IsValid() );
718
719 wxString s;
720 s.Alloc(wxStrlen(psz) + string.Len());
721 s = psz;
722 s += string;
723
724 return s;
725 }
726
727 // ===========================================================================
728 // other common string functions
729 // ===========================================================================
730
731 // ---------------------------------------------------------------------------
732 // simple sub-string extraction
733 // ---------------------------------------------------------------------------
734
735 // helper function: clone the data attached to this string
736 void wxString::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const
737 {
738 if ( nCopyLen == 0 ) {
739 dest.Init();
740 }
741 else {
742 dest.AllocBuffer(nCopyLen);
743 memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(wxChar));
744 }
745 }
746
747 // extract string of length nCount starting at nFirst
748 wxString wxString::Mid(size_t nFirst, size_t nCount) const
749 {
750 wxStringData *pData = GetStringData();
751 size_t nLen = pData->nDataLength;
752
753 // default value of nCount is wxSTRING_MAXLEN and means "till the end"
754 if ( nCount == wxSTRING_MAXLEN )
755 {
756 nCount = nLen - nFirst;
757 }
758
759 // out-of-bounds requests return sensible things
760 if ( nFirst + nCount > nLen )
761 {
762 nCount = nLen - nFirst;
763 }
764
765 if ( nFirst > nLen )
766 {
767 // AllocCopy() will return empty string
768 nCount = 0;
769 }
770
771 wxString dest;
772 AllocCopy(dest, nCount, nFirst);
773
774 return dest;
775 }
776
777 // extract nCount last (rightmost) characters
778 wxString wxString::Right(size_t nCount) const
779 {
780 if ( nCount > (size_t)GetStringData()->nDataLength )
781 nCount = GetStringData()->nDataLength;
782
783 wxString dest;
784 AllocCopy(dest, nCount, GetStringData()->nDataLength - nCount);
785 return dest;
786 }
787
788 // get all characters after the last occurence of ch
789 // (returns the whole string if ch not found)
790 wxString wxString::AfterLast(wxChar ch) const
791 {
792 wxString str;
793 int iPos = Find(ch, TRUE);
794 if ( iPos == wxNOT_FOUND )
795 str = *this;
796 else
797 str = c_str() + iPos + 1;
798
799 return str;
800 }
801
802 // extract nCount first (leftmost) characters
803 wxString wxString::Left(size_t nCount) const
804 {
805 if ( nCount > (size_t)GetStringData()->nDataLength )
806 nCount = GetStringData()->nDataLength;
807
808 wxString dest;
809 AllocCopy(dest, nCount, 0);
810 return dest;
811 }
812
813 // get all characters before the first occurence of ch
814 // (returns the whole string if ch not found)
815 wxString wxString::BeforeFirst(wxChar ch) const
816 {
817 wxString str;
818 for ( const wxChar *pc = m_pchData; *pc != wxT('\0') && *pc != ch; pc++ )
819 str += *pc;
820
821 return str;
822 }
823
824 /// get all characters before the last occurence of ch
825 /// (returns empty string if ch not found)
826 wxString wxString::BeforeLast(wxChar ch) const
827 {
828 wxString str;
829 int iPos = Find(ch, TRUE);
830 if ( iPos != wxNOT_FOUND && iPos != 0 )
831 str = wxString(c_str(), iPos);
832
833 return str;
834 }
835
836 /// get all characters after the first occurence of ch
837 /// (returns empty string if ch not found)
838 wxString wxString::AfterFirst(wxChar ch) const
839 {
840 wxString str;
841 int iPos = Find(ch);
842 if ( iPos != wxNOT_FOUND )
843 str = c_str() + iPos + 1;
844
845 return str;
846 }
847
848 // replace first (or all) occurences of some substring with another one
849 size_t wxString::Replace(const wxChar *szOld, const wxChar *szNew, bool bReplaceAll)
850 {
851 size_t uiCount = 0; // count of replacements made
852
853 size_t uiOldLen = wxStrlen(szOld);
854
855 wxString strTemp;
856 const wxChar *pCurrent = m_pchData;
857 const wxChar *pSubstr;
858 while ( *pCurrent != wxT('\0') ) {
859 pSubstr = wxStrstr(pCurrent, szOld);
860 if ( pSubstr == NULL ) {
861 // strTemp is unused if no replacements were made, so avoid the copy
862 if ( uiCount == 0 )
863 return 0;
864
865 strTemp += pCurrent; // copy the rest
866 break; // exit the loop
867 }
868 else {
869 // take chars before match
870 strTemp.ConcatSelf(pSubstr - pCurrent, pCurrent);
871 strTemp += szNew;
872 pCurrent = pSubstr + uiOldLen; // restart after match
873
874 uiCount++;
875
876 // stop now?
877 if ( !bReplaceAll ) {
878 strTemp += pCurrent; // copy the rest
879 break; // exit the loop
880 }
881 }
882 }
883
884 // only done if there were replacements, otherwise would have returned above
885 *this = strTemp;
886
887 return uiCount;
888 }
889
890 bool wxString::IsAscii() const
891 {
892 const wxChar *s = (const wxChar*) *this;
893 while(*s){
894 if(!isascii(*s)) return(FALSE);
895 s++;
896 }
897 return(TRUE);
898 }
899
900 bool wxString::IsWord() const
901 {
902 const wxChar *s = (const wxChar*) *this;
903 while(*s){
904 if(!wxIsalpha(*s)) return(FALSE);
905 s++;
906 }
907 return(TRUE);
908 }
909
910 bool wxString::IsNumber() const
911 {
912 const wxChar *s = (const wxChar*) *this;
913 while(*s){
914 if(!wxIsdigit(*s)) return(FALSE);
915 s++;
916 }
917 return(TRUE);
918 }
919
920 wxString wxString::Strip(stripType w) const
921 {
922 wxString s = *this;
923 if ( w & leading ) s.Trim(FALSE);
924 if ( w & trailing ) s.Trim(TRUE);
925 return s;
926 }
927
928 // ---------------------------------------------------------------------------
929 // case conversion
930 // ---------------------------------------------------------------------------
931
932 wxString& wxString::MakeUpper()
933 {
934 CopyBeforeWrite();
935
936 for ( wxChar *p = m_pchData; *p; p++ )
937 *p = (wxChar)wxToupper(*p);
938
939 return *this;
940 }
941
942 wxString& wxString::MakeLower()
943 {
944 CopyBeforeWrite();
945
946 for ( wxChar *p = m_pchData; *p; p++ )
947 *p = (wxChar)wxTolower(*p);
948
949 return *this;
950 }
951
952 // ---------------------------------------------------------------------------
953 // trimming and padding
954 // ---------------------------------------------------------------------------
955
956 // trims spaces (in the sense of isspace) from left or right side
957 wxString& wxString::Trim(bool bFromRight)
958 {
959 // first check if we're going to modify the string at all
960 if ( !IsEmpty() &&
961 (
962 (bFromRight && wxIsspace(GetChar(Len() - 1))) ||
963 (!bFromRight && wxIsspace(GetChar(0u)))
964 )
965 )
966 {
967 // ok, there is at least one space to trim
968 CopyBeforeWrite();
969
970 if ( bFromRight )
971 {
972 // find last non-space character
973 wxChar *psz = m_pchData + GetStringData()->nDataLength - 1;
974 while ( wxIsspace(*psz) && (psz >= m_pchData) )
975 psz--;
976
977 // truncate at trailing space start
978 *++psz = wxT('\0');
979 GetStringData()->nDataLength = psz - m_pchData;
980 }
981 else
982 {
983 // find first non-space character
984 const wxChar *psz = m_pchData;
985 while ( wxIsspace(*psz) )
986 psz++;
987
988 // fix up data and length
989 int nDataLength = GetStringData()->nDataLength - (psz - (const wxChar*) m_pchData);
990 memmove(m_pchData, psz, (nDataLength + 1)*sizeof(wxChar));
991 GetStringData()->nDataLength = nDataLength;
992 }
993 }
994
995 return *this;
996 }
997
998 // adds nCount characters chPad to the string from either side
999 wxString& wxString::Pad(size_t nCount, wxChar chPad, bool bFromRight)
1000 {
1001 wxString s(chPad, nCount);
1002
1003 if ( bFromRight )
1004 *this += s;
1005 else
1006 {
1007 s += *this;
1008 *this = s;
1009 }
1010
1011 return *this;
1012 }
1013
1014 // truncate the string
1015 wxString& wxString::Truncate(size_t uiLen)
1016 {
1017 if ( uiLen < Len() ) {
1018 CopyBeforeWrite();
1019
1020 *(m_pchData + uiLen) = wxT('\0');
1021 GetStringData()->nDataLength = uiLen;
1022 }
1023 //else: nothing to do, string is already short enough
1024
1025 return *this;
1026 }
1027
1028 // ---------------------------------------------------------------------------
1029 // finding (return wxNOT_FOUND if not found and index otherwise)
1030 // ---------------------------------------------------------------------------
1031
1032 // find a character
1033 int wxString::Find(wxChar ch, bool bFromEnd) const
1034 {
1035 const wxChar *psz = bFromEnd ? wxStrrchr(m_pchData, ch) : wxStrchr(m_pchData, ch);
1036
1037 return (psz == NULL) ? wxNOT_FOUND : psz - (const wxChar*) m_pchData;
1038 }
1039
1040 // find a sub-string (like strstr)
1041 int wxString::Find(const wxChar *pszSub) const
1042 {
1043 const wxChar *psz = wxStrstr(m_pchData, pszSub);
1044
1045 return (psz == NULL) ? wxNOT_FOUND : psz - (const wxChar*) m_pchData;
1046 }
1047
1048 // ----------------------------------------------------------------------------
1049 // conversion to numbers
1050 // ----------------------------------------------------------------------------
1051
1052 bool wxString::ToLong(long *val) const
1053 {
1054 wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToLong") );
1055
1056 const wxChar *start = c_str();
1057 wxChar *end;
1058 *val = wxStrtol(start, &end, 10);
1059
1060 // return TRUE only if scan was stopped by the terminating NUL and if the
1061 // string was not empty to start with
1062 return !*end && (end != start);
1063 }
1064
1065 bool wxString::ToULong(unsigned long *val) const
1066 {
1067 wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToULong") );
1068
1069 const wxChar *start = c_str();
1070 wxChar *end;
1071 *val = wxStrtoul(start, &end, 10);
1072
1073 // return TRUE only if scan was stopped by the terminating NUL and if the
1074 // string was not empty to start with
1075 return !*end && (end != start);
1076 }
1077
1078 bool wxString::ToDouble(double *val) const
1079 {
1080 wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToDouble") );
1081
1082 const wxChar *start = c_str();
1083 wxChar *end;
1084 *val = wxStrtod(start, &end);
1085
1086 // return TRUE only if scan was stopped by the terminating NUL and if the
1087 // string was not empty to start with
1088 return !*end && (end != start);
1089 }
1090
1091 // ---------------------------------------------------------------------------
1092 // formatted output
1093 // ---------------------------------------------------------------------------
1094
1095 /* static */
1096 wxString wxString::Format(const wxChar *pszFormat, ...)
1097 {
1098 va_list argptr;
1099 va_start(argptr, pszFormat);
1100
1101 wxString s;
1102 s.PrintfV(pszFormat, argptr);
1103
1104 va_end(argptr);
1105
1106 return s;
1107 }
1108
1109 /* static */
1110 wxString wxString::FormatV(const wxChar *pszFormat, va_list argptr)
1111 {
1112 wxString s;
1113 s.Printf(pszFormat, argptr);
1114 return s;
1115 }
1116
1117 int wxString::Printf(const wxChar *pszFormat, ...)
1118 {
1119 va_list argptr;
1120 va_start(argptr, pszFormat);
1121
1122 int iLen = PrintfV(pszFormat, argptr);
1123
1124 va_end(argptr);
1125
1126 return iLen;
1127 }
1128
1129 int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
1130 {
1131 #if wxUSE_EXPERIMENTAL_PRINTF
1132 // the new implementation
1133
1134 // buffer to avoid dynamic memory allocation each time for small strings
1135 char szScratch[1024];
1136
1137 Reinit();
1138 for (size_t n = 0; pszFormat[n]; n++)
1139 if (pszFormat[n] == wxT('%')) {
1140 static char s_szFlags[256] = "%";
1141 size_t flagofs = 1;
1142 bool adj_left = FALSE, in_prec = FALSE,
1143 prec_dot = FALSE, done = FALSE;
1144 int ilen = 0;
1145 size_t min_width = 0, max_width = wxSTRING_MAXLEN;
1146 do {
1147 #define CHECK_PREC if (in_prec && !prec_dot) { s_szFlags[flagofs++] = '.'; prec_dot = TRUE; }
1148 switch (pszFormat[++n]) {
1149 case wxT('\0'):
1150 done = TRUE;
1151 break;
1152 case wxT('%'):
1153 *this += wxT('%');
1154 done = TRUE;
1155 break;
1156 case wxT('#'):
1157 case wxT('0'):
1158 case wxT(' '):
1159 case wxT('+'):
1160 case wxT('\''):
1161 CHECK_PREC
1162 s_szFlags[flagofs++] = pszFormat[n];
1163 break;
1164 case wxT('-'):
1165 CHECK_PREC
1166 adj_left = TRUE;
1167 s_szFlags[flagofs++] = pszFormat[n];
1168 break;
1169 case wxT('.'):
1170 CHECK_PREC
1171 in_prec = TRUE;
1172 prec_dot = FALSE;
1173 max_width = 0;
1174 // dot will be auto-added to s_szFlags if non-negative number follows
1175 break;
1176 case wxT('h'):
1177 ilen = -1;
1178 CHECK_PREC
1179 s_szFlags[flagofs++] = pszFormat[n];
1180 break;
1181 case wxT('l'):
1182 ilen = 1;
1183 CHECK_PREC
1184 s_szFlags[flagofs++] = pszFormat[n];
1185 break;
1186 case wxT('q'):
1187 case wxT('L'):
1188 ilen = 2;
1189 CHECK_PREC
1190 s_szFlags[flagofs++] = pszFormat[n];
1191 break;
1192 case wxT('Z'):
1193 ilen = 3;
1194 CHECK_PREC
1195 s_szFlags[flagofs++] = pszFormat[n];
1196 break;
1197 case wxT('*'):
1198 {
1199 int len = va_arg(argptr, int);
1200 if (in_prec) {
1201 if (len<0) break;
1202 CHECK_PREC
1203 max_width = len;
1204 } else {
1205 if (len<0) {
1206 adj_left = !adj_left;
1207 s_szFlags[flagofs++] = '-';
1208 len = -len;
1209 }
1210 min_width = len;
1211 }
1212 flagofs += ::sprintf(s_szFlags+flagofs,"%d",len);
1213 }
1214 break;
1215 case wxT('1'): case wxT('2'): case wxT('3'):
1216 case wxT('4'): case wxT('5'): case wxT('6'):
1217 case wxT('7'): case wxT('8'): case wxT('9'):
1218 {
1219 int len = 0;
1220 CHECK_PREC
1221 while ((pszFormat[n]>=wxT('0')) && (pszFormat[n]<=wxT('9'))) {
1222 s_szFlags[flagofs++] = pszFormat[n];
1223 len = len*10 + (pszFormat[n] - wxT('0'));
1224 n++;
1225 }
1226 if (in_prec) max_width = len;
1227 else min_width = len;
1228 n--; // the main loop pre-increments n again
1229 }
1230 break;
1231 case wxT('d'):
1232 case wxT('i'):
1233 case wxT('o'):
1234 case wxT('u'):
1235 case wxT('x'):
1236 case wxT('X'):
1237 CHECK_PREC
1238 s_szFlags[flagofs++] = pszFormat[n];
1239 s_szFlags[flagofs] = '\0';
1240 if (ilen == 0 ) {
1241 int val = va_arg(argptr, int);
1242 ::sprintf(szScratch, s_szFlags, val);
1243 }
1244 else if (ilen == -1) {
1245 short int val = va_arg(argptr, short int);
1246 ::sprintf(szScratch, s_szFlags, val);
1247 }
1248 else if (ilen == 1) {
1249 long int val = va_arg(argptr, long int);
1250 ::sprintf(szScratch, s_szFlags, val);
1251 }
1252 else if (ilen == 2) {
1253 #if SIZEOF_LONG_LONG
1254 long long int val = va_arg(argptr, long long int);
1255 ::sprintf(szScratch, s_szFlags, val);
1256 #else
1257 long int val = va_arg(argptr, long int);
1258 ::sprintf(szScratch, s_szFlags, val);
1259 #endif
1260 }
1261 else if (ilen == 3) {
1262 size_t val = va_arg(argptr, size_t);
1263 ::sprintf(szScratch, s_szFlags, val);
1264 }
1265 *this += wxString(szScratch);
1266 done = TRUE;
1267 break;
1268 case wxT('e'):
1269 case wxT('E'):
1270 case wxT('f'):
1271 case wxT('g'):
1272 case wxT('G'):
1273 CHECK_PREC
1274 s_szFlags[flagofs++] = pszFormat[n];
1275 s_szFlags[flagofs] = '\0';
1276 if (ilen == 2) {
1277 long double val = va_arg(argptr, long double);
1278 ::sprintf(szScratch, s_szFlags, val);
1279 } else {
1280 double val = va_arg(argptr, double);
1281 ::sprintf(szScratch, s_szFlags, val);
1282 }
1283 *this += wxString(szScratch);
1284 done = TRUE;
1285 break;
1286 case wxT('p'):
1287 {
1288 void *val = va_arg(argptr, void *);
1289 CHECK_PREC
1290 s_szFlags[flagofs++] = pszFormat[n];
1291 s_szFlags[flagofs] = '\0';
1292 ::sprintf(szScratch, s_szFlags, val);
1293 *this += wxString(szScratch);
1294 done = TRUE;
1295 }
1296 break;
1297 case wxT('c'):
1298 {
1299 wxChar val = va_arg(argptr, int);
1300 // we don't need to honor padding here, do we?
1301 *this += val;
1302 done = TRUE;
1303 }
1304 break;
1305 case wxT('s'):
1306 if (ilen == -1) {
1307 // wx extension: we'll let %hs mean non-Unicode strings
1308 char *val = va_arg(argptr, char *);
1309 #if wxUSE_UNICODE
1310 // ASCII->Unicode constructor handles max_width right
1311 wxString s(val, wxConvLibc, max_width);
1312 #else
1313 size_t len = wxSTRING_MAXLEN;
1314 if (val) {
1315 for (len = 0; val[len] && (len<max_width); len++);
1316 } else val = wxT("(null)");
1317 wxString s(val, len);
1318 #endif
1319 if (s.Len() < min_width)
1320 s.Pad(min_width - s.Len(), wxT(' '), adj_left);
1321 *this += s;
1322 } else {
1323 wxChar *val = va_arg(argptr, wxChar *);
1324 size_t len = wxSTRING_MAXLEN;
1325 if (val) {
1326 for (len = 0; val[len] && (len<max_width); len++);
1327 } else val = wxT("(null)");
1328 wxString s(val, len);
1329 if (s.Len() < min_width)
1330 s.Pad(min_width - s.Len(), wxT(' '), adj_left);
1331 *this += s;
1332 }
1333 done = TRUE;
1334 break;
1335 case wxT('n'):
1336 if (ilen == 0) {
1337 int *val = va_arg(argptr, int *);
1338 *val = Len();
1339 }
1340 else if (ilen == -1) {
1341 short int *val = va_arg(argptr, short int *);
1342 *val = Len();
1343 }
1344 else if (ilen >= 1) {
1345 long int *val = va_arg(argptr, long int *);
1346 *val = Len();
1347 }
1348 done = TRUE;
1349 break;
1350 default:
1351 if (wxIsalpha(pszFormat[n]))
1352 // probably some flag not taken care of here yet
1353 s_szFlags[flagofs++] = pszFormat[n];
1354 else {
1355 // bad format
1356 *this += wxT('%'); // just to pass the glibc tst-printf.c
1357 n--;
1358 done = TRUE;
1359 }
1360 break;
1361 }
1362 #undef CHECK_PREC
1363 } while (!done);
1364 } else *this += pszFormat[n];
1365
1366 #else
1367 // buffer to avoid dynamic memory allocation each time for small strings
1368 char szScratch[1024];
1369
1370 // NB: wxVsnprintf() may return either less than the buffer size or -1 if
1371 // there is not enough place depending on implementation
1372 int iLen = wxVsnprintfA(szScratch, WXSIZEOF(szScratch), pszFormat, argptr);
1373 if ( iLen != -1 ) {
1374 // the whole string is in szScratch
1375 *this = szScratch;
1376 }
1377 else {
1378 bool outOfMemory = FALSE;
1379 int size = 2*WXSIZEOF(szScratch);
1380 while ( !outOfMemory ) {
1381 char *buf = GetWriteBuf(size);
1382 if ( buf )
1383 iLen = wxVsnprintfA(buf, size, pszFormat, argptr);
1384 else
1385 outOfMemory = TRUE;
1386
1387 UngetWriteBuf();
1388
1389 if ( iLen != -1 ) {
1390 // ok, there was enough space
1391 break;
1392 }
1393
1394 // still not enough, double it again
1395 size *= 2;
1396 }
1397
1398 if ( outOfMemory ) {
1399 // out of memory
1400 return -1;
1401 }
1402 }
1403 #endif // wxUSE_EXPERIMENTAL_PRINTF/!wxUSE_EXPERIMENTAL_PRINTF
1404
1405 return Len();
1406 }
1407
1408 // ----------------------------------------------------------------------------
1409 // misc other operations
1410 // ----------------------------------------------------------------------------
1411
1412 // returns TRUE if the string matches the pattern which may contain '*' and
1413 // '?' metacharacters (as usual, '?' matches any character and '*' any number
1414 // of them)
1415 bool wxString::Matches(const wxChar *pszMask) const
1416 {
1417 // check char by char
1418 const wxChar *pszTxt;
1419 for ( pszTxt = c_str(); *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
1420 switch ( *pszMask ) {
1421 case wxT('?'):
1422 if ( *pszTxt == wxT('\0') )
1423 return FALSE;
1424
1425 // pszText and pszMask will be incremented in the loop statement
1426
1427 break;
1428
1429 case wxT('*'):
1430 {
1431 // ignore special chars immediately following this one
1432 while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
1433 pszMask++;
1434
1435 // if there is nothing more, match
1436 if ( *pszMask == wxT('\0') )
1437 return TRUE;
1438
1439 // are there any other metacharacters in the mask?
1440 size_t uiLenMask;
1441 const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
1442
1443 if ( pEndMask != NULL ) {
1444 // we have to match the string between two metachars
1445 uiLenMask = pEndMask - pszMask;
1446 }
1447 else {
1448 // we have to match the remainder of the string
1449 uiLenMask = wxStrlen(pszMask);
1450 }
1451
1452 wxString strToMatch(pszMask, uiLenMask);
1453 const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
1454 if ( pMatch == NULL )
1455 return FALSE;
1456
1457 // -1 to compensate "++" in the loop
1458 pszTxt = pMatch + uiLenMask - 1;
1459 pszMask += uiLenMask - 1;
1460 }
1461 break;
1462
1463 default:
1464 if ( *pszMask != *pszTxt )
1465 return FALSE;
1466 break;
1467 }
1468 }
1469
1470 // match only if nothing left
1471 return *pszTxt == wxT('\0');
1472 }
1473
1474 // Count the number of chars
1475 int wxString::Freq(wxChar ch) const
1476 {
1477 int count = 0;
1478 int len = Len();
1479 for (int i = 0; i < len; i++)
1480 {
1481 if (GetChar(i) == ch)
1482 count ++;
1483 }
1484 return count;
1485 }
1486
1487 // convert to upper case, return the copy of the string
1488 wxString wxString::Upper() const
1489 { wxString s(*this); return s.MakeUpper(); }
1490
1491 // convert to lower case, return the copy of the string
1492 wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }
1493
1494 int wxString::sprintf(const wxChar *pszFormat, ...)
1495 {
1496 va_list argptr;
1497 va_start(argptr, pszFormat);
1498 int iLen = PrintfV(pszFormat, argptr);
1499 va_end(argptr);
1500 return iLen;
1501 }
1502
1503 // ---------------------------------------------------------------------------
1504 // standard C++ library string functions
1505 // ---------------------------------------------------------------------------
1506 #ifdef wxSTD_STRING_COMPATIBILITY
1507
1508 wxString& wxString::insert(size_t nPos, const wxString& str)
1509 {
1510 wxASSERT( str.GetStringData()->IsValid() );
1511 wxASSERT( nPos <= Len() );
1512
1513 if ( !str.IsEmpty() ) {
1514 wxString strTmp;
1515 wxChar *pc = strTmp.GetWriteBuf(Len() + str.Len());
1516 wxStrncpy(pc, c_str(), nPos);
1517 wxStrcpy(pc + nPos, str);
1518 wxStrcpy(pc + nPos + str.Len(), c_str() + nPos);
1519 strTmp.UngetWriteBuf();
1520 *this = strTmp;
1521 }
1522
1523 return *this;
1524 }
1525
1526 size_t wxString::find(const wxString& str, size_t nStart) const
1527 {
1528 wxASSERT( str.GetStringData()->IsValid() );
1529 wxASSERT( nStart <= Len() );
1530
1531 const wxChar *p = wxStrstr(c_str() + nStart, str);
1532
1533 return p == NULL ? npos : p - c_str();
1534 }
1535
1536 // VC++ 1.5 can't cope with the default argument in the header.
1537 #if !defined(__VISUALC__) || defined(__WIN32__)
1538 size_t wxString::find(const wxChar* sz, size_t nStart, size_t n) const
1539 {
1540 return find(wxString(sz, n), nStart);
1541 }
1542 #endif // VC++ 1.5
1543
1544 // Gives a duplicate symbol (presumably a case-insensitivity problem)
1545 #if !defined(__BORLANDC__)
1546 size_t wxString::find(wxChar ch, size_t nStart) const
1547 {
1548 wxASSERT( nStart <= Len() );
1549
1550 const wxChar *p = wxStrchr(c_str() + nStart, ch);
1551
1552 return p == NULL ? npos : p - c_str();
1553 }
1554 #endif
1555
1556 size_t wxString::rfind(const wxString& str, size_t nStart) const
1557 {
1558 wxASSERT( str.GetStringData()->IsValid() );
1559 wxASSERT( nStart <= Len() );
1560
1561 // TODO could be made much quicker than that
1562 const wxChar *p = c_str() + (nStart == npos ? Len() : nStart);
1563 while ( p >= c_str() + str.Len() ) {
1564 if ( wxStrncmp(p - str.Len(), str, str.Len()) == 0 )
1565 return p - str.Len() - c_str();
1566 p--;
1567 }
1568
1569 return npos;
1570 }
1571
1572 // VC++ 1.5 can't cope with the default argument in the header.
1573 #if !defined(__VISUALC__) || defined(__WIN32__)
1574 size_t wxString::rfind(const wxChar* sz, size_t nStart, size_t n) const
1575 {
1576 return rfind(wxString(sz, n == npos ? 0 : n), nStart);
1577 }
1578
1579 size_t wxString::rfind(wxChar ch, size_t nStart) const
1580 {
1581 if ( nStart == npos )
1582 {
1583 nStart = Len();
1584 }
1585 else
1586 {
1587 wxASSERT( nStart <= Len() );
1588 }
1589
1590 const wxChar *p = wxStrrchr(c_str(), ch);
1591
1592 if ( p == NULL )
1593 return npos;
1594
1595 size_t result = p - c_str();
1596 return ( result > nStart ) ? npos : result;
1597 }
1598 #endif // VC++ 1.5
1599
1600 size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
1601 {
1602 const wxChar *start = c_str() + nStart;
1603 const wxChar *firstOf = wxStrpbrk(start, sz);
1604 if ( firstOf )
1605 return firstOf - c_str();
1606 else
1607 return npos;
1608 }
1609
1610 size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
1611 {
1612 if ( nStart == npos )
1613 {
1614 nStart = Len();
1615 }
1616 else
1617 {
1618 wxASSERT( nStart <= Len() );
1619 }
1620
1621 for ( const wxChar *p = c_str() + length() - 1; p >= c_str(); p-- )
1622 {
1623 if ( wxStrchr(sz, *p) )
1624 return p - c_str();
1625 }
1626
1627 return npos;
1628 }
1629
1630 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
1631 {
1632 if ( nStart == npos )
1633 {
1634 nStart = Len();
1635 }
1636 else
1637 {
1638 wxASSERT( nStart <= Len() );
1639 }
1640
1641 size_t nAccept = wxStrspn(c_str() + nStart, sz);
1642 if ( nAccept >= length() - nStart )
1643 return npos;
1644 else
1645 return nAccept;
1646 }
1647
1648 size_t wxString::find_first_not_of(wxChar ch, size_t nStart) const
1649 {
1650 wxASSERT( nStart <= Len() );
1651
1652 for ( const wxChar *p = c_str() + nStart; *p; p++ )
1653 {
1654 if ( *p != ch )
1655 return p - c_str();
1656 }
1657
1658 return npos;
1659 }
1660
1661 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
1662 {
1663 if ( nStart == npos )
1664 {
1665 nStart = Len();
1666 }
1667 else
1668 {
1669 wxASSERT( nStart <= Len() );
1670 }
1671
1672 for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
1673 {
1674 if ( !wxStrchr(sz, *p) )
1675 return p - c_str();
1676 }
1677
1678 return npos;
1679 }
1680
1681 size_t wxString::find_last_not_of(wxChar ch, size_t nStart) const
1682 {
1683 if ( nStart == npos )
1684 {
1685 nStart = Len();
1686 }
1687 else
1688 {
1689 wxASSERT( nStart <= Len() );
1690 }
1691
1692 for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
1693 {
1694 if ( *p != ch )
1695 return p - c_str();
1696 }
1697
1698 return npos;
1699 }
1700
1701 wxString& wxString::erase(size_t nStart, size_t nLen)
1702 {
1703 wxString strTmp(c_str(), nStart);
1704 if ( nLen != npos ) {
1705 wxASSERT( nStart + nLen <= Len() );
1706
1707 strTmp.append(c_str() + nStart + nLen);
1708 }
1709
1710 *this = strTmp;
1711 return *this;
1712 }
1713
1714 wxString& wxString::replace(size_t nStart, size_t nLen, const wxChar *sz)
1715 {
1716 wxASSERT( nStart + nLen <= wxStrlen(sz) );
1717
1718 wxString strTmp;
1719 if ( nStart != 0 )
1720 strTmp.append(c_str(), nStart);
1721 strTmp += sz;
1722 strTmp.append(c_str() + nStart + nLen);
1723
1724 *this = strTmp;
1725 return *this;
1726 }
1727
1728 wxString& wxString::replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch)
1729 {
1730 return replace(nStart, nLen, wxString(ch, nCount));
1731 }
1732
1733 wxString& wxString::replace(size_t nStart, size_t nLen,
1734 const wxString& str, size_t nStart2, size_t nLen2)
1735 {
1736 return replace(nStart, nLen, str.substr(nStart2, nLen2));
1737 }
1738
1739 wxString& wxString::replace(size_t nStart, size_t nLen,
1740 const wxChar* sz, size_t nCount)
1741 {
1742 return replace(nStart, nLen, wxString(sz, nCount));
1743 }
1744
1745 #endif //std::string compatibility
1746
1747 // ============================================================================
1748 // ArrayString
1749 // ============================================================================
1750
1751 // size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
1752 #define ARRAY_MAXSIZE_INCREMENT 4096
1753 #ifndef ARRAY_DEFAULT_INITIAL_SIZE // also defined in dynarray.h
1754 #define ARRAY_DEFAULT_INITIAL_SIZE (16)
1755 #endif
1756
1757 #define STRING(p) ((wxString *)(&(p)))
1758
1759 // ctor
1760 wxArrayString::wxArrayString(bool autoSort)
1761 {
1762 m_nSize =
1763 m_nCount = 0;
1764 m_pItems = (wxChar **) NULL;
1765 m_autoSort = autoSort;
1766 }
1767
1768 // copy ctor
1769 wxArrayString::wxArrayString(const wxArrayString& src)
1770 {
1771 m_nSize =
1772 m_nCount = 0;
1773 m_pItems = (wxChar **) NULL;
1774 m_autoSort = src.m_autoSort;
1775
1776 *this = src;
1777 }
1778
1779 // assignment operator
1780 wxArrayString& wxArrayString::operator=(const wxArrayString& src)
1781 {
1782 if ( m_nSize > 0 )
1783 Clear();
1784
1785 Copy(src);
1786
1787 return *this;
1788 }
1789
1790 void wxArrayString::Copy(const wxArrayString& src)
1791 {
1792 if ( src.m_nCount > ARRAY_DEFAULT_INITIAL_SIZE )
1793 Alloc(src.m_nCount);
1794
1795 for ( size_t n = 0; n < src.m_nCount; n++ )
1796 Add(src[n]);
1797 }
1798
1799 // grow the array
1800 void wxArrayString::Grow()
1801 {
1802 // only do it if no more place
1803 if( m_nCount == m_nSize ) {
1804 if( m_nSize == 0 ) {
1805 // was empty, alloc some memory
1806 m_nSize = ARRAY_DEFAULT_INITIAL_SIZE;
1807 m_pItems = new wxChar *[m_nSize];
1808 }
1809 else {
1810 // otherwise when it's called for the first time, nIncrement would be 0
1811 // and the array would never be expanded
1812 #if defined(__VISAGECPP__) && defined(__WXDEBUG__)
1813 int array_size = ARRAY_DEFAULT_INITIAL_SIZE;
1814 wxASSERT( array_size != 0 );
1815 #else
1816 wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
1817 #endif
1818
1819 // add 50% but not too much
1820 size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
1821 ? ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;
1822 if ( nIncrement > ARRAY_MAXSIZE_INCREMENT )
1823 nIncrement = ARRAY_MAXSIZE_INCREMENT;
1824 m_nSize += nIncrement;
1825 wxChar **pNew = new wxChar *[m_nSize];
1826
1827 // copy data to new location
1828 memcpy(pNew, m_pItems, m_nCount*sizeof(wxChar *));
1829
1830 // delete old memory (but do not release the strings!)
1831 wxDELETEA(m_pItems);
1832
1833 m_pItems = pNew;
1834 }
1835 }
1836 }
1837
1838 void wxArrayString::Free()
1839 {
1840 for ( size_t n = 0; n < m_nCount; n++ ) {
1841 STRING(m_pItems[n])->GetStringData()->Unlock();
1842 }
1843 }
1844
1845 // deletes all the strings from the list
1846 void wxArrayString::Empty()
1847 {
1848 Free();
1849
1850 m_nCount = 0;
1851 }
1852
1853 // as Empty, but also frees memory
1854 void wxArrayString::Clear()
1855 {
1856 Free();
1857
1858 m_nSize =
1859 m_nCount = 0;
1860
1861 wxDELETEA(m_pItems);
1862 }
1863
1864 // dtor
1865 wxArrayString::~wxArrayString()
1866 {
1867 Free();
1868
1869 wxDELETEA(m_pItems);
1870 }
1871
1872 // pre-allocates memory (frees the previous data!)
1873 void wxArrayString::Alloc(size_t nSize)
1874 {
1875 wxASSERT( nSize > 0 );
1876
1877 // only if old buffer was not big enough
1878 if ( nSize > m_nSize ) {
1879 Free();
1880 wxDELETEA(m_pItems);
1881 m_pItems = new wxChar *[nSize];
1882 m_nSize = nSize;
1883 }
1884
1885 m_nCount = 0;
1886 }
1887
1888 // minimizes the memory usage by freeing unused memory
1889 void wxArrayString::Shrink()
1890 {
1891 // only do it if we have some memory to free
1892 if( m_nCount < m_nSize ) {
1893 // allocates exactly as much memory as we need
1894 wxChar **pNew = new wxChar *[m_nCount];
1895
1896 // copy data to new location
1897 memcpy(pNew, m_pItems, m_nCount*sizeof(wxChar *));
1898 delete [] m_pItems;
1899 m_pItems = pNew;
1900 }
1901 }
1902
1903 // searches the array for an item (forward or backwards)
1904 int wxArrayString::Index(const wxChar *sz, bool bCase, bool bFromEnd) const
1905 {
1906 if ( m_autoSort ) {
1907 // use binary search in the sorted array
1908 wxASSERT_MSG( bCase && !bFromEnd,
1909 wxT("search parameters ignored for auto sorted array") );
1910
1911 size_t i,
1912 lo = 0,
1913 hi = m_nCount;
1914 int res;
1915 while ( lo < hi ) {
1916 i = (lo + hi)/2;
1917
1918 res = wxStrcmp(sz, m_pItems[i]);
1919 if ( res < 0 )
1920 hi = i;
1921 else if ( res > 0 )
1922 lo = i + 1;
1923 else
1924 return i;
1925 }
1926
1927 return wxNOT_FOUND;
1928 }
1929 else {
1930 // use linear search in unsorted array
1931 if ( bFromEnd ) {
1932 if ( m_nCount > 0 ) {
1933 size_t ui = m_nCount;
1934 do {
1935 if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) )
1936 return ui;
1937 }
1938 while ( ui != 0 );
1939 }
1940 }
1941 else {
1942 for( size_t ui = 0; ui < m_nCount; ui++ ) {
1943 if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) )
1944 return ui;
1945 }
1946 }
1947 }
1948
1949 return wxNOT_FOUND;
1950 }
1951
1952 // add item at the end
1953 size_t wxArrayString::Add(const wxString& str)
1954 {
1955 if ( m_autoSort ) {
1956 // insert the string at the correct position to keep the array sorted
1957 size_t i,
1958 lo = 0,
1959 hi = m_nCount;
1960 int res;
1961 while ( lo < hi ) {
1962 i = (lo + hi)/2;
1963
1964 res = wxStrcmp(str, m_pItems[i]);
1965 if ( res < 0 )
1966 hi = i;
1967 else if ( res > 0 )
1968 lo = i + 1;
1969 else {
1970 lo = hi = i;
1971 break;
1972 }
1973 }
1974
1975 wxASSERT_MSG( lo == hi, wxT("binary search broken") );
1976
1977 Insert(str, lo);
1978
1979 return (size_t)lo;
1980 }
1981 else {
1982 wxASSERT( str.GetStringData()->IsValid() );
1983
1984 Grow();
1985
1986 // the string data must not be deleted!
1987 str.GetStringData()->Lock();
1988
1989 // just append
1990 m_pItems[m_nCount] = (wxChar *)str.c_str(); // const_cast
1991
1992 return m_nCount++;
1993 }
1994 }
1995
1996 // add item at the given position
1997 void wxArrayString::Insert(const wxString& str, size_t nIndex)
1998 {
1999 wxASSERT( str.GetStringData()->IsValid() );
2000
2001 wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArrayString::Insert") );
2002
2003 Grow();
2004
2005 memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex],
2006 (m_nCount - nIndex)*sizeof(wxChar *));
2007
2008 str.GetStringData()->Lock();
2009 m_pItems[nIndex] = (wxChar *)str.c_str();
2010
2011 m_nCount++;
2012 }
2013
2014 // removes item from array (by index)
2015 void wxArrayString::Remove(size_t nIndex)
2016 {
2017 wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArrayString::Remove") );
2018
2019 // release our lock
2020 Item(nIndex).GetStringData()->Unlock();
2021
2022 memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],
2023 (m_nCount - nIndex - 1)*sizeof(wxChar *));
2024 m_nCount--;
2025 }
2026
2027 // removes item from array (by value)
2028 void wxArrayString::Remove(const wxChar *sz)
2029 {
2030 int iIndex = Index(sz);
2031
2032 wxCHECK_RET( iIndex != wxNOT_FOUND,
2033 wxT("removing inexistent element in wxArrayString::Remove") );
2034
2035 Remove(iIndex);
2036 }
2037
2038 // ----------------------------------------------------------------------------
2039 // sorting
2040 // ----------------------------------------------------------------------------
2041
2042 // we can only sort one array at a time with the quick-sort based
2043 // implementation
2044 #if wxUSE_THREADS
2045 // need a critical section to protect access to gs_compareFunction and
2046 // gs_sortAscending variables
2047 static wxCriticalSection *gs_critsectStringSort = NULL;
2048
2049 // call this before the value of the global sort vars is changed/after
2050 // you're finished with them
2051 #define START_SORT() wxASSERT( !gs_critsectStringSort ); \
2052 gs_critsectStringSort = new wxCriticalSection; \
2053 gs_critsectStringSort->Enter()
2054 #define END_SORT() gs_critsectStringSort->Leave(); \
2055 delete gs_critsectStringSort; \
2056 gs_critsectStringSort = NULL
2057 #else // !threads
2058 #define START_SORT()
2059 #define END_SORT()
2060 #endif // wxUSE_THREADS
2061
2062 // function to use for string comparaison
2063 static wxArrayString::CompareFunction gs_compareFunction = NULL;
2064
2065 // if we don't use the compare function, this flag tells us if we sort the
2066 // array in ascending or descending order
2067 static bool gs_sortAscending = TRUE;
2068
2069 // function which is called by quick sort
2070 static int LINKAGEMODE wxStringCompareFunction(const void *first, const void *second)
2071 {
2072 wxString *strFirst = (wxString *)first;
2073 wxString *strSecond = (wxString *)second;
2074
2075 if ( gs_compareFunction ) {
2076 return gs_compareFunction(*strFirst, *strSecond);
2077 }
2078 else {
2079 // maybe we should use wxStrcoll
2080 int result = wxStrcmp(strFirst->c_str(), strSecond->c_str());
2081
2082 return gs_sortAscending ? result : -result;
2083 }
2084 }
2085
2086 // sort array elements using passed comparaison function
2087 void wxArrayString::Sort(CompareFunction compareFunction)
2088 {
2089 START_SORT();
2090
2091 wxASSERT( !gs_compareFunction ); // must have been reset to NULL
2092 gs_compareFunction = compareFunction;
2093
2094 DoSort();
2095
2096 END_SORT();
2097 }
2098
2099 void wxArrayString::Sort(bool reverseOrder)
2100 {
2101 START_SORT();
2102
2103 wxASSERT( !gs_compareFunction ); // must have been reset to NULL
2104 gs_sortAscending = !reverseOrder;
2105
2106 DoSort();
2107
2108 END_SORT();
2109 }
2110
2111 void wxArrayString::DoSort()
2112 {
2113 wxCHECK_RET( !m_autoSort, wxT("can't use this method with sorted arrays") );
2114
2115 // just sort the pointers using qsort() - of course it only works because
2116 // wxString() *is* a pointer to its data
2117 qsort(m_pItems, m_nCount, sizeof(wxChar *), wxStringCompareFunction);
2118 }
2119