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