]> git.saurik.com Git - wxWidgets.git/blob - src/common/string.cpp
Changed m_children to GetChildren() -- not all ports are the same!
[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 #endif
39
40 #include <ctype.h>
41 #include <string.h>
42 #include <stdlib.h>
43
44 // This probably isn't right, what should it be Vadim?
45 // Otherwise we end up with no wxVsprintf defined.
46 #ifdef __WXMOTIF__
47 #define HAVE_VPRINTF
48 #endif
49
50 #ifdef wxUSE_WCSRTOMBS
51 #include <wchar.h> // for wcsrtombs(), see comments where it's used
52 #endif // GNU
53
54 #ifdef WXSTRING_IS_WXOBJECT
55 IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
56 #endif //WXSTRING_IS_WXOBJECT
57
58 // allocating extra space for each string consumes more memory but speeds up
59 // the concatenation operations (nLen is the current string's length)
60 // NB: EXTRA_ALLOC must be >= 0!
61 #define EXTRA_ALLOC (19 - nLen % 16)
62
63 // ---------------------------------------------------------------------------
64 // static class variables definition
65 // ---------------------------------------------------------------------------
66
67 #ifdef STD_STRING_COMPATIBILITY
68 const size_t wxString::npos = STRING_MAXLEN;
69 #endif
70
71 // ----------------------------------------------------------------------------
72 // static data
73 // ----------------------------------------------------------------------------
74
75 // for an empty string, GetStringData() will return this address: this
76 // structure has the same layout as wxStringData and it's data() method will
77 // return the empty string (dummy pointer)
78 static const struct
79 {
80 wxStringData data;
81 char dummy;
82 } g_strEmpty = { {-1, 0, 0}, '\0' };
83
84 // empty C style string: points to 'string data' byte of g_strEmpty
85 extern const char *g_szNul = &g_strEmpty.dummy;
86
87 // ----------------------------------------------------------------------------
88 // conditional compilation
89 // ----------------------------------------------------------------------------
90
91 // we want to find out if the current platform supports vsnprintf()-like
92 // function: for Unix this is done with configure, for Windows we test the
93 // compiler explicitly.
94 #ifdef __WXMSW__
95 #ifdef _MSC_VER
96 #define wxVsprintf _vsnprintf
97 #endif
98 #else // !Windows
99 #ifdef HAVE_VSNPRINTF
100 #define wxVsprintf vsnprintf
101 #endif
102 #endif // Windows/!Windows
103
104 #ifndef wxVsprintf
105 // in this case we'll use vsprintf() (which is ANSI and thus should be
106 // always available), but it's unsafe because it doesn't check for buffer
107 // size - so give a warning
108 #define wxVsprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr)
109 #pragma message("Using sprintf() because no snprintf()-like function defined")
110 #endif
111
112 // ----------------------------------------------------------------------------
113 // global functions
114 // ----------------------------------------------------------------------------
115
116 #ifdef STD_STRING_COMPATIBILITY
117
118 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
119 // iostream ones.
120 //
121 // ATTN: you can _not_ use both of these in the same program!
122 #if wxUSE_IOSTREAMH
123 #include <iostream.h>
124 #define NAMESPACE
125 #else
126 #include <iostream>
127 # ifdef _MSC_VER
128 using namespace std;
129 # endif
130 // for msvc (bcc50+ also) you don't need these NAMESPACE defines,
131 // using namespace std; takes care of that.
132 #define NAMESPACE std::
133 #endif
134
135 #ifdef __WXMSW__
136 #ifdef _MSC_VER
137 #define wxVsprintf _vsnprintf
138 #endif
139 #else
140 #if defined ( HAVE_VSNPRINTF )
141 #define wxVsprintf vsnprintf
142 #endif
143 #endif
144
145 #ifndef wxVsprintf
146 // vsprintf() is ANSI so we can always use it, but it's unsafe!
147 #define wxVsprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr)
148 #pragma message("Using sprintf() because no snprintf()-like function defined")
149 #endif
150
151 NAMESPACE istream& operator>>(NAMESPACE istream& is, wxString& WXUNUSED(str))
152 {
153 #if 0
154 int w = is.width(0);
155 if ( is.ipfx(0) ) {
156 NAMESPACE streambuf *sb = is.rdbuf();
157 str.erase();
158 while ( true ) {
159 int ch = sb->sbumpc ();
160 if ( ch == EOF ) {
161 is.setstate(NAMESPACE ios::eofbit);
162 break;
163 }
164 else if ( isspace(ch) ) {
165 sb->sungetc();
166 break;
167 }
168
169 str += ch;
170 if ( --w == 1 )
171 break;
172 }
173 }
174
175 is.isfx();
176 if ( str.length() == 0 )
177 is.setstate(NAMESPACE ios::failbit);
178 #endif
179 return is;
180 }
181
182 #endif //std::string compatibility
183
184 // ----------------------------------------------------------------------------
185 // private classes
186 // ----------------------------------------------------------------------------
187
188 // this small class is used to gather statistics for performance tuning
189 //#define WXSTRING_STATISTICS
190 #ifdef WXSTRING_STATISTICS
191 class Averager
192 {
193 public:
194 Averager(const char *sz) { m_sz = sz; m_nTotal = m_nCount = 0; }
195 ~Averager()
196 { printf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); }
197
198 void Add(size_t n) { m_nTotal += n; m_nCount++; }
199
200 private:
201 size_t m_nCount, m_nTotal;
202 const char *m_sz;
203 } g_averageLength("allocation size"),
204 g_averageSummandLength("summand length"),
205 g_averageConcatHit("hit probability in concat"),
206 g_averageInitialLength("initial string length");
207
208 #define STATISTICS_ADD(av, val) g_average##av.Add(val)
209 #else
210 #define STATISTICS_ADD(av, val)
211 #endif // WXSTRING_STATISTICS
212
213 // ===========================================================================
214 // wxString class core
215 // ===========================================================================
216
217 // ---------------------------------------------------------------------------
218 // construction
219 // ---------------------------------------------------------------------------
220
221 // constructs string of <nLength> copies of character <ch>
222 wxString::wxString(char ch, size_t nLength)
223 {
224 Init();
225
226 if ( nLength > 0 ) {
227 AllocBuffer(nLength);
228
229 wxASSERT( sizeof(char) == 1 ); // can't use memset if not
230
231 memset(m_pchData, ch, nLength);
232 }
233 }
234
235 // takes nLength elements of psz starting at nPos
236 void wxString::InitWith(const char *psz, size_t nPos, size_t nLength)
237 {
238 Init();
239
240 wxASSERT( nPos <= Strlen(psz) );
241
242 if ( nLength == STRING_MAXLEN )
243 nLength = Strlen(psz + nPos);
244
245 STATISTICS_ADD(InitialLength, nLength);
246
247 if ( nLength > 0 ) {
248 // trailing '\0' is written in AllocBuffer()
249 AllocBuffer(nLength);
250 memcpy(m_pchData, psz + nPos, nLength*sizeof(char));
251 }
252 }
253
254 // the same as previous constructor, but for compilers using unsigned char
255 wxString::wxString(const unsigned char* psz, size_t nLength)
256 {
257 InitWith((const char *)psz, 0, nLength);
258 }
259
260 #ifdef STD_STRING_COMPATIBILITY
261
262 // poor man's iterators are "void *" pointers
263 wxString::wxString(const void *pStart, const void *pEnd)
264 {
265 InitWith((const char *)pStart, 0,
266 (const char *)pEnd - (const char *)pStart);
267 }
268
269 #endif //std::string compatibility
270
271 // from wide string
272 wxString::wxString(const wchar_t *pwz)
273 {
274 // first get necessary size
275
276 // NB: GNU libc5 wcstombs() is completely broken, don't use it (it doesn't
277 // honor the 3rd parameter, thus it will happily crash here).
278 #ifdef wxUSE_WCSRTOMBS
279 // don't know if it's really needed (or if we can pass NULL), but better safe
280 // than quick
281 mbstate_t mbstate;
282 size_t nLen = wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
283 #else // !GNU libc
284 size_t nLen = wcstombs((char *) NULL, pwz, 0);
285 #endif // GNU
286
287 // empty?
288 if ( nLen != 0 ) {
289 AllocBuffer(nLen);
290 wcstombs(m_pchData, pwz, nLen);
291 }
292 else {
293 Init();
294 }
295 }
296
297 // ---------------------------------------------------------------------------
298 // memory allocation
299 // ---------------------------------------------------------------------------
300
301 // allocates memory needed to store a C string of length nLen
302 void wxString::AllocBuffer(size_t nLen)
303 {
304 wxASSERT( nLen > 0 ); //
305 wxASSERT( nLen <= INT_MAX-1 ); // max size (enough room for 1 extra)
306
307 STATISTICS_ADD(Length, nLen);
308
309 // allocate memory:
310 // 1) one extra character for '\0' termination
311 // 2) sizeof(wxStringData) for housekeeping info
312 wxStringData* pData = (wxStringData*)
313 malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(char));
314 pData->nRefs = 1;
315 pData->nDataLength = nLen;
316 pData->nAllocLength = nLen + EXTRA_ALLOC;
317 m_pchData = pData->data(); // data starts after wxStringData
318 m_pchData[nLen] = '\0';
319 }
320
321 // must be called before changing this string
322 void wxString::CopyBeforeWrite()
323 {
324 wxStringData* pData = GetStringData();
325
326 if ( pData->IsShared() ) {
327 pData->Unlock(); // memory not freed because shared
328 size_t nLen = pData->nDataLength;
329 AllocBuffer(nLen);
330 memcpy(m_pchData, pData->data(), nLen*sizeof(char));
331 }
332
333 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
334 }
335
336 // must be called before replacing contents of this string
337 void wxString::AllocBeforeWrite(size_t nLen)
338 {
339 wxASSERT( nLen != 0 ); // doesn't make any sense
340
341 // must not share string and must have enough space
342 wxStringData* pData = GetStringData();
343 if ( pData->IsShared() || (nLen > pData->nAllocLength) ) {
344 // can't work with old buffer, get new one
345 pData->Unlock();
346 AllocBuffer(nLen);
347 }
348
349 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
350 }
351
352 // allocate enough memory for nLen characters
353 void wxString::Alloc(size_t nLen)
354 {
355 wxStringData *pData = GetStringData();
356 if ( pData->nAllocLength <= nLen ) {
357 if ( pData->IsEmpty() ) {
358 nLen += EXTRA_ALLOC;
359
360 wxStringData* pData = (wxStringData*)
361 malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(char));
362 pData->nRefs = 1;
363 pData->nDataLength = 0;
364 pData->nAllocLength = nLen;
365 m_pchData = pData->data(); // data starts after wxStringData
366 m_pchData[0u] = '\0';
367 }
368 else if ( pData->IsShared() ) {
369 pData->Unlock(); // memory not freed because shared
370 size_t nOldLen = pData->nDataLength;
371 AllocBuffer(nLen);
372 memcpy(m_pchData, pData->data(), nOldLen*sizeof(char));
373 }
374 else {
375 nLen += EXTRA_ALLOC;
376
377 wxStringData *p = (wxStringData *)
378 realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(char));
379
380 if ( p == NULL ) {
381 // @@@ what to do on memory error?
382 return;
383 }
384
385 // it's not important if the pointer changed or not (the check for this
386 // is not faster than assigning to m_pchData in all cases)
387 p->nAllocLength = nLen;
388 m_pchData = p->data();
389 }
390 }
391 //else: we've already got enough
392 }
393
394 // shrink to minimal size (releasing extra memory)
395 void wxString::Shrink()
396 {
397 wxStringData *pData = GetStringData();
398
399 // this variable is unused in release build, so avoid the compiler warning by
400 // just not declaring it
401 #ifdef __WXDEBUG__
402 void *p =
403 #endif
404 realloc(pData, sizeof(wxStringData) + (pData->nDataLength + 1)*sizeof(char));
405
406 wxASSERT( p != NULL ); // can't free memory?
407 wxASSERT( p == pData ); // we're decrementing the size - block shouldn't move!
408 }
409
410 // get the pointer to writable buffer of (at least) nLen bytes
411 char *wxString::GetWriteBuf(size_t nLen)
412 {
413 AllocBeforeWrite(nLen);
414
415 wxASSERT( GetStringData()->nRefs == 1 );
416 GetStringData()->Validate(FALSE);
417
418 return m_pchData;
419 }
420
421 // put string back in a reasonable state after GetWriteBuf
422 void wxString::UngetWriteBuf()
423 {
424 GetStringData()->nDataLength = strlen(m_pchData);
425 GetStringData()->Validate(TRUE);
426 }
427
428 // ---------------------------------------------------------------------------
429 // data access
430 // ---------------------------------------------------------------------------
431
432 // all functions are inline in string.h
433
434 // ---------------------------------------------------------------------------
435 // assignment operators
436 // ---------------------------------------------------------------------------
437
438 // helper function: does real copy
439 void wxString::AssignCopy(size_t nSrcLen, const char *pszSrcData)
440 {
441 if ( nSrcLen == 0 ) {
442 Reinit();
443 }
444 else {
445 AllocBeforeWrite(nSrcLen);
446 memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(char));
447 GetStringData()->nDataLength = nSrcLen;
448 m_pchData[nSrcLen] = '\0';
449 }
450 }
451
452 // assigns one string to another
453 wxString& wxString::operator=(const wxString& stringSrc)
454 {
455 wxASSERT( stringSrc.GetStringData()->IsValid() );
456
457 // don't copy string over itself
458 if ( m_pchData != stringSrc.m_pchData ) {
459 if ( stringSrc.GetStringData()->IsEmpty() ) {
460 Reinit();
461 }
462 else {
463 // adjust references
464 GetStringData()->Unlock();
465 m_pchData = stringSrc.m_pchData;
466 GetStringData()->Lock();
467 }
468 }
469
470 return *this;
471 }
472
473 // assigns a single character
474 wxString& wxString::operator=(char ch)
475 {
476 AssignCopy(1, &ch);
477 return *this;
478 }
479
480 // assigns C string
481 wxString& wxString::operator=(const char *psz)
482 {
483 AssignCopy(Strlen(psz), psz);
484 return *this;
485 }
486
487 // same as 'signed char' variant
488 wxString& wxString::operator=(const unsigned char* psz)
489 {
490 *this = (const char *)psz;
491 return *this;
492 }
493
494 wxString& wxString::operator=(const wchar_t *pwz)
495 {
496 wxString str(pwz);
497 *this = str;
498 return *this;
499 }
500
501 // ---------------------------------------------------------------------------
502 // string concatenation
503 // ---------------------------------------------------------------------------
504
505 // add something to this string
506 void wxString::ConcatSelf(int nSrcLen, const char *pszSrcData)
507 {
508 STATISTICS_ADD(SummandLength, nSrcLen);
509
510 // concatenating an empty string is a NOP
511 if ( nSrcLen > 0 ) {
512 wxStringData *pData = GetStringData();
513 size_t nLen = pData->nDataLength;
514 size_t nNewLen = nLen + nSrcLen;
515
516 // alloc new buffer if current is too small
517 if ( pData->IsShared() ) {
518 STATISTICS_ADD(ConcatHit, 0);
519
520 // we have to allocate another buffer
521 wxStringData* pOldData = GetStringData();
522 AllocBuffer(nNewLen);
523 memcpy(m_pchData, pOldData->data(), nLen*sizeof(char));
524 pOldData->Unlock();
525 }
526 else if ( nNewLen > pData->nAllocLength ) {
527 STATISTICS_ADD(ConcatHit, 0);
528
529 // we have to grow the buffer
530 Alloc(nNewLen);
531 }
532 else {
533 STATISTICS_ADD(ConcatHit, 1);
534
535 // the buffer is already big enough
536 }
537
538 // should be enough space
539 wxASSERT( nNewLen <= GetStringData()->nAllocLength );
540
541 // fast concatenation - all is done in our buffer
542 memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(char));
543
544 m_pchData[nNewLen] = '\0'; // put terminating '\0'
545 GetStringData()->nDataLength = nNewLen; // and fix the length
546 }
547 //else: the string to append was empty
548 }
549
550 /*
551 * concatenation functions come in 5 flavours:
552 * string + string
553 * char + string and string + char
554 * C str + string and string + C str
555 */
556
557 wxString operator+(const wxString& string1, const wxString& string2)
558 {
559 wxASSERT( string1.GetStringData()->IsValid() );
560 wxASSERT( string2.GetStringData()->IsValid() );
561
562 wxString s = string1;
563 s += string2;
564
565 return s;
566 }
567
568 wxString operator+(const wxString& string, char ch)
569 {
570 wxASSERT( string.GetStringData()->IsValid() );
571
572 wxString s = string;
573 s += ch;
574
575 return s;
576 }
577
578 wxString operator+(char ch, const wxString& string)
579 {
580 wxASSERT( string.GetStringData()->IsValid() );
581
582 wxString s = ch;
583 s += string;
584
585 return s;
586 }
587
588 wxString operator+(const wxString& string, const char *psz)
589 {
590 wxASSERT( string.GetStringData()->IsValid() );
591
592 wxString s;
593 s.Alloc(Strlen(psz) + string.Len());
594 s = string;
595 s += psz;
596
597 return s;
598 }
599
600 wxString operator+(const char *psz, const wxString& string)
601 {
602 wxASSERT( string.GetStringData()->IsValid() );
603
604 wxString s;
605 s.Alloc(Strlen(psz) + string.Len());
606 s = psz;
607 s += string;
608
609 return s;
610 }
611
612 // ===========================================================================
613 // other common string functions
614 // ===========================================================================
615
616 // ---------------------------------------------------------------------------
617 // simple sub-string extraction
618 // ---------------------------------------------------------------------------
619
620 // helper function: clone the data attached to this string
621 void wxString::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const
622 {
623 if ( nCopyLen == 0 ) {
624 dest.Init();
625 }
626 else {
627 dest.AllocBuffer(nCopyLen);
628 memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(char));
629 }
630 }
631
632 // extract string of length nCount starting at nFirst
633 wxString wxString::Mid(size_t nFirst, size_t nCount) const
634 {
635 wxStringData *pData = GetStringData();
636 size_t nLen = pData->nDataLength;
637
638 // default value of nCount is STRING_MAXLEN and means "till the end"
639 if ( nCount == STRING_MAXLEN )
640 {
641 nCount = nLen - nFirst;
642 }
643
644 // out-of-bounds requests return sensible things
645 if ( nFirst + nCount > nLen )
646 {
647 nCount = nLen - nFirst;
648 }
649
650 if ( nFirst > nLen )
651 {
652 // AllocCopy() will return empty string
653 nCount = 0;
654 }
655
656 wxString dest;
657 AllocCopy(dest, nCount, nFirst);
658
659 return dest;
660 }
661
662 // extract nCount last (rightmost) characters
663 wxString wxString::Right(size_t nCount) const
664 {
665 if ( nCount > (size_t)GetStringData()->nDataLength )
666 nCount = GetStringData()->nDataLength;
667
668 wxString dest;
669 AllocCopy(dest, nCount, GetStringData()->nDataLength - nCount);
670 return dest;
671 }
672
673 // get all characters after the last occurence of ch
674 // (returns the whole string if ch not found)
675 wxString wxString::Right(char ch) const
676 {
677 wxString str;
678 int iPos = Find(ch, TRUE);
679 if ( iPos == NOT_FOUND )
680 str = *this;
681 else
682 str = c_str() + iPos + 1;
683
684 return str;
685 }
686
687 // extract nCount first (leftmost) characters
688 wxString wxString::Left(size_t nCount) const
689 {
690 if ( nCount > (size_t)GetStringData()->nDataLength )
691 nCount = GetStringData()->nDataLength;
692
693 wxString dest;
694 AllocCopy(dest, nCount, 0);
695 return dest;
696 }
697
698 // get all characters before the first occurence of ch
699 // (returns the whole string if ch not found)
700 wxString wxString::Left(char ch) const
701 {
702 wxString str;
703 for ( const char *pc = m_pchData; *pc != '\0' && *pc != ch; pc++ )
704 str += *pc;
705
706 return str;
707 }
708
709 /// get all characters before the last occurence of ch
710 /// (returns empty string if ch not found)
711 wxString wxString::Before(char ch) const
712 {
713 wxString str;
714 int iPos = Find(ch, TRUE);
715 if ( iPos != NOT_FOUND && iPos != 0 )
716 str = wxString(c_str(), iPos);
717
718 return str;
719 }
720
721 /// get all characters after the first occurence of ch
722 /// (returns empty string if ch not found)
723 wxString wxString::After(char ch) const
724 {
725 wxString str;
726 int iPos = Find(ch);
727 if ( iPos != NOT_FOUND )
728 str = c_str() + iPos + 1;
729
730 return str;
731 }
732
733 // replace first (or all) occurences of some substring with another one
734 size_t wxString::Replace(const char *szOld, const char *szNew, bool bReplaceAll)
735 {
736 size_t uiCount = 0; // count of replacements made
737
738 size_t uiOldLen = Strlen(szOld);
739
740 wxString strTemp;
741 const char *pCurrent = m_pchData;
742 const char *pSubstr;
743 while ( *pCurrent != '\0' ) {
744 pSubstr = strstr(pCurrent, szOld);
745 if ( pSubstr == NULL ) {
746 // strTemp is unused if no replacements were made, so avoid the copy
747 if ( uiCount == 0 )
748 return 0;
749
750 strTemp += pCurrent; // copy the rest
751 break; // exit the loop
752 }
753 else {
754 // take chars before match
755 strTemp.ConcatSelf(pSubstr - pCurrent, pCurrent);
756 strTemp += szNew;
757 pCurrent = pSubstr + uiOldLen; // restart after match
758
759 uiCount++;
760
761 // stop now?
762 if ( !bReplaceAll ) {
763 strTemp += pCurrent; // copy the rest
764 break; // exit the loop
765 }
766 }
767 }
768
769 // only done if there were replacements, otherwise would have returned above
770 *this = strTemp;
771
772 return uiCount;
773 }
774
775 bool wxString::IsAscii() const
776 {
777 const char *s = (const char*) *this;
778 while(*s){
779 if(!isascii(*s)) return(FALSE);
780 s++;
781 }
782 return(TRUE);
783 }
784
785 bool wxString::IsWord() const
786 {
787 const char *s = (const char*) *this;
788 while(*s){
789 if(!isalpha(*s)) return(FALSE);
790 s++;
791 }
792 return(TRUE);
793 }
794
795 bool wxString::IsNumber() const
796 {
797 const char *s = (const char*) *this;
798 while(*s){
799 if(!isdigit(*s)) return(FALSE);
800 s++;
801 }
802 return(TRUE);
803 }
804
805 wxString wxString::Strip(stripType w) const
806 {
807 wxString s = *this;
808 if ( w & leading ) s.Trim(FALSE);
809 if ( w & trailing ) s.Trim(TRUE);
810 return s;
811 }
812
813 // ---------------------------------------------------------------------------
814 // case conversion
815 // ---------------------------------------------------------------------------
816
817 wxString& wxString::MakeUpper()
818 {
819 CopyBeforeWrite();
820
821 for ( char *p = m_pchData; *p; p++ )
822 *p = (char)toupper(*p);
823
824 return *this;
825 }
826
827 wxString& wxString::MakeLower()
828 {
829 CopyBeforeWrite();
830
831 for ( char *p = m_pchData; *p; p++ )
832 *p = (char)tolower(*p);
833
834 return *this;
835 }
836
837 // ---------------------------------------------------------------------------
838 // trimming and padding
839 // ---------------------------------------------------------------------------
840
841 // trims spaces (in the sense of isspace) from left or right side
842 wxString& wxString::Trim(bool bFromRight)
843 {
844 // first check if we're going to modify the string at all
845 if ( !IsEmpty() &&
846 (
847 (bFromRight && isspace(GetChar(Len() - 1))) ||
848 (!bFromRight && isspace(GetChar(0u)))
849 )
850 )
851 {
852 // ok, there is at least one space to trim
853 CopyBeforeWrite();
854
855 if ( bFromRight )
856 {
857 // find last non-space character
858 char *psz = m_pchData + GetStringData()->nDataLength - 1;
859 while ( isspace(*psz) && (psz >= m_pchData) )
860 psz--;
861
862 // truncate at trailing space start
863 *++psz = '\0';
864 GetStringData()->nDataLength = psz - m_pchData;
865 }
866 else
867 {
868 // find first non-space character
869 const char *psz = m_pchData;
870 while ( isspace(*psz) )
871 psz++;
872
873 // fix up data and length
874 int nDataLength = GetStringData()->nDataLength - (psz - m_pchData);
875 memmove(m_pchData, psz, (nDataLength + 1)*sizeof(char));
876 GetStringData()->nDataLength = nDataLength;
877 }
878 }
879
880 return *this;
881 }
882
883 // adds nCount characters chPad to the string from either side
884 wxString& wxString::Pad(size_t nCount, char chPad, bool bFromRight)
885 {
886 wxString s(chPad, nCount);
887
888 if ( bFromRight )
889 *this += s;
890 else
891 {
892 s += *this;
893 *this = s;
894 }
895
896 return *this;
897 }
898
899 // truncate the string
900 wxString& wxString::Truncate(size_t uiLen)
901 {
902 *(m_pchData + uiLen) = '\0';
903 GetStringData()->nDataLength = uiLen;
904
905 return *this;
906 }
907
908 // ---------------------------------------------------------------------------
909 // finding (return NOT_FOUND if not found and index otherwise)
910 // ---------------------------------------------------------------------------
911
912 // find a character
913 int wxString::Find(char ch, bool bFromEnd) const
914 {
915 const char *psz = bFromEnd ? strrchr(m_pchData, ch) : strchr(m_pchData, ch);
916
917 return (psz == NULL) ? NOT_FOUND : psz - m_pchData;
918 }
919
920 // find a sub-string (like strstr)
921 int wxString::Find(const char *pszSub) const
922 {
923 const char *psz = strstr(m_pchData, pszSub);
924
925 return (psz == NULL) ? NOT_FOUND : psz - m_pchData;
926 }
927
928 // ---------------------------------------------------------------------------
929 // stream-like operators
930 // ---------------------------------------------------------------------------
931 wxString& wxString::operator<<(int i)
932 {
933 wxString res;
934 res.Printf("%d", i);
935
936 return (*this) << res;
937 }
938
939 wxString& wxString::operator<<(float f)
940 {
941 wxString res;
942 res.Printf("%f", f);
943
944 return (*this) << res;
945 }
946
947 wxString& wxString::operator<<(double d)
948 {
949 wxString res;
950 res.Printf("%g", d);
951
952 return (*this) << res;
953 }
954
955 // ---------------------------------------------------------------------------
956 // formatted output
957 // ---------------------------------------------------------------------------
958 int wxString::Printf(const char *pszFormat, ...)
959 {
960 va_list argptr;
961 va_start(argptr, pszFormat);
962
963 int iLen = PrintfV(pszFormat, argptr);
964
965 va_end(argptr);
966
967 return iLen;
968 }
969
970 int wxString::PrintfV(const char* pszFormat, va_list argptr)
971 {
972 // static buffer to avoid dynamic memory allocation each time
973 static char s_szScratch[1024];
974
975 // NB: wxVsprintf() may return either less than the buffer size or -1 if there
976 // is not enough place depending on implementation
977 int iLen = wxVsprintf(s_szScratch, WXSIZEOF(s_szScratch), pszFormat, argptr);
978 char *buffer;
979 if ( iLen < (int)WXSIZEOF(s_szScratch) ) {
980 buffer = s_szScratch;
981 }
982 else {
983 int size = WXSIZEOF(s_szScratch) * 2;
984 buffer = (char *)malloc(size);
985 while ( buffer != NULL ) {
986 iLen = wxVsprintf(buffer, WXSIZEOF(s_szScratch), pszFormat, argptr);
987 if ( iLen < size ) {
988 // ok, there was enough space
989 break;
990 }
991
992 // still not enough, double it again
993 buffer = (char *)realloc(buffer, size *= 2);
994 }
995
996 if ( !buffer ) {
997 // out of memory
998 return -1;
999 }
1000 }
1001
1002 AllocBeforeWrite(iLen);
1003 strcpy(m_pchData, buffer);
1004
1005 if ( buffer != s_szScratch )
1006 free(buffer);
1007
1008 return iLen;
1009 }
1010
1011 // ----------------------------------------------------------------------------
1012 // misc other operations
1013 // ----------------------------------------------------------------------------
1014 bool wxString::Matches(const char *pszMask) const
1015 {
1016 // check char by char
1017 const char *pszTxt;
1018 for ( pszTxt = c_str(); *pszMask != '\0'; pszMask++, pszTxt++ ) {
1019 switch ( *pszMask ) {
1020 case '?':
1021 if ( *pszTxt == '\0' )
1022 return FALSE;
1023
1024 pszTxt++;
1025 pszMask++;
1026 break;
1027
1028 case '*':
1029 {
1030 // ignore special chars immediately following this one
1031 while ( *pszMask == '*' || *pszMask == '?' )
1032 pszMask++;
1033
1034 // if there is nothing more, match
1035 if ( *pszMask == '\0' )
1036 return TRUE;
1037
1038 // are there any other metacharacters in the mask?
1039 size_t uiLenMask;
1040 const char *pEndMask = strpbrk(pszMask, "*?");
1041
1042 if ( pEndMask != NULL ) {
1043 // we have to match the string between two metachars
1044 uiLenMask = pEndMask - pszMask;
1045 }
1046 else {
1047 // we have to match the remainder of the string
1048 uiLenMask = strlen(pszMask);
1049 }
1050
1051 wxString strToMatch(pszMask, uiLenMask);
1052 const char* pMatch = strstr(pszTxt, strToMatch);
1053 if ( pMatch == NULL )
1054 return FALSE;
1055
1056 // -1 to compensate "++" in the loop
1057 pszTxt = pMatch + uiLenMask - 1;
1058 pszMask += uiLenMask - 1;
1059 }
1060 break;
1061
1062 default:
1063 if ( *pszMask != *pszTxt )
1064 return FALSE;
1065 break;
1066 }
1067 }
1068
1069 // match only if nothing left
1070 return *pszTxt == '\0';
1071 }
1072
1073 // ---------------------------------------------------------------------------
1074 // standard C++ library string functions
1075 // ---------------------------------------------------------------------------
1076 #ifdef STD_STRING_COMPATIBILITY
1077
1078 wxString& wxString::insert(size_t nPos, const wxString& str)
1079 {
1080 wxASSERT( str.GetStringData()->IsValid() );
1081 wxASSERT( nPos <= Len() );
1082
1083 if ( !str.IsEmpty() ) {
1084 wxString strTmp;
1085 char *pc = strTmp.GetWriteBuf(Len() + str.Len());
1086 strncpy(pc, c_str(), nPos);
1087 strcpy(pc + nPos, str);
1088 strcpy(pc + nPos + str.Len(), c_str() + nPos);
1089 strTmp.UngetWriteBuf();
1090 *this = strTmp;
1091 }
1092
1093 return *this;
1094 }
1095
1096 size_t wxString::find(const wxString& str, size_t nStart) const
1097 {
1098 wxASSERT( str.GetStringData()->IsValid() );
1099 wxASSERT( nStart <= Len() );
1100
1101 const char *p = strstr(c_str() + nStart, str);
1102
1103 return p == NULL ? npos : p - c_str();
1104 }
1105
1106 // VC++ 1.5 can't cope with the default argument in the header.
1107 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
1108 size_t wxString::find(const char* sz, size_t nStart, size_t n) const
1109 {
1110 return find(wxString(sz, n == npos ? 0 : n), nStart);
1111 }
1112 #endif
1113
1114 size_t wxString::find(char ch, size_t nStart) const
1115 {
1116 wxASSERT( nStart <= Len() );
1117
1118 const char *p = strchr(c_str() + nStart, ch);
1119
1120 return p == NULL ? npos : p - c_str();
1121 }
1122
1123 size_t wxString::rfind(const wxString& str, size_t nStart) const
1124 {
1125 wxASSERT( str.GetStringData()->IsValid() );
1126 wxASSERT( nStart <= Len() );
1127
1128 // # could be quicker than that
1129 const char *p = c_str() + (nStart == npos ? Len() : nStart);
1130 while ( p >= c_str() + str.Len() ) {
1131 if ( strncmp(p - str.Len(), str, str.Len()) == 0 )
1132 return p - str.Len() - c_str();
1133 p--;
1134 }
1135
1136 return npos;
1137 }
1138
1139 // VC++ 1.5 can't cope with the default argument in the header.
1140 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
1141 size_t wxString::rfind(const char* sz, size_t nStart, size_t n) const
1142 {
1143 return rfind(wxString(sz, n == npos ? 0 : n), nStart);
1144 }
1145
1146 size_t wxString::rfind(char ch, size_t nStart) const
1147 {
1148 wxASSERT( nStart <= Len() );
1149
1150 const char *p = strrchr(c_str() + nStart, ch);
1151
1152 return p == NULL ? npos : p - c_str();
1153 }
1154 #endif
1155
1156 wxString wxString::substr(size_t nStart, size_t nLen) const
1157 {
1158 // npos means 'take all'
1159 if ( nLen == npos )
1160 nLen = 0;
1161
1162 wxASSERT( nStart + nLen <= Len() );
1163
1164 return wxString(c_str() + nStart, nLen == npos ? 0 : nLen);
1165 }
1166
1167 wxString& wxString::erase(size_t nStart, size_t nLen)
1168 {
1169 wxString strTmp(c_str(), nStart);
1170 if ( nLen != npos ) {
1171 wxASSERT( nStart + nLen <= Len() );
1172
1173 strTmp.append(c_str() + nStart + nLen);
1174 }
1175
1176 *this = strTmp;
1177 return *this;
1178 }
1179
1180 wxString& wxString::replace(size_t nStart, size_t nLen, const char *sz)
1181 {
1182 wxASSERT( nStart + nLen <= Strlen(sz) );
1183
1184 wxString strTmp;
1185 if ( nStart != 0 )
1186 strTmp.append(c_str(), nStart);
1187 strTmp += sz;
1188 strTmp.append(c_str() + nStart + nLen);
1189
1190 *this = strTmp;
1191 return *this;
1192 }
1193
1194 wxString& wxString::replace(size_t nStart, size_t nLen, size_t nCount, char ch)
1195 {
1196 return replace(nStart, nLen, wxString(ch, nCount));
1197 }
1198
1199 wxString& wxString::replace(size_t nStart, size_t nLen,
1200 const wxString& str, size_t nStart2, size_t nLen2)
1201 {
1202 return replace(nStart, nLen, str.substr(nStart2, nLen2));
1203 }
1204
1205 wxString& wxString::replace(size_t nStart, size_t nLen,
1206 const char* sz, size_t nCount)
1207 {
1208 return replace(nStart, nLen, wxString(sz, nCount));
1209 }
1210
1211 #endif //std::string compatibility
1212
1213 // ============================================================================
1214 // ArrayString
1215 // ============================================================================
1216
1217 // size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
1218 #define ARRAY_MAXSIZE_INCREMENT 4096
1219 #ifndef ARRAY_DEFAULT_INITIAL_SIZE // also defined in dynarray.h
1220 #define ARRAY_DEFAULT_INITIAL_SIZE (16)
1221 #endif
1222
1223 #define STRING(p) ((wxString *)(&(p)))
1224
1225 // ctor
1226 wxArrayString::wxArrayString()
1227 {
1228 m_nSize =
1229 m_nCount = 0;
1230 m_pItems = (char **) NULL;
1231 }
1232
1233 // copy ctor
1234 wxArrayString::wxArrayString(const wxArrayString& src)
1235 {
1236 m_nSize =
1237 m_nCount = 0;
1238 m_pItems = (char **) NULL;
1239
1240 *this = src;
1241 }
1242
1243 // assignment operator
1244 wxArrayString& wxArrayString::operator=(const wxArrayString& src)
1245 {
1246 if ( m_nSize > 0 )
1247 Clear();
1248
1249 if ( src.m_nCount > ARRAY_DEFAULT_INITIAL_SIZE )
1250 Alloc(src.m_nCount);
1251
1252 // we can't just copy the pointers here because otherwise we would share
1253 // the strings with another array
1254 for ( size_t n = 0; n < src.m_nCount; n++ )
1255 Add(src[n]);
1256
1257 if ( m_nCount != 0 )
1258 memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(char *));
1259
1260 return *this;
1261 }
1262
1263 // grow the array
1264 void wxArrayString::Grow()
1265 {
1266 // only do it if no more place
1267 if( m_nCount == m_nSize ) {
1268 if( m_nSize == 0 ) {
1269 // was empty, alloc some memory
1270 m_nSize = ARRAY_DEFAULT_INITIAL_SIZE;
1271 m_pItems = new char *[m_nSize];
1272 }
1273 else {
1274 // otherwise when it's called for the first time, nIncrement would be 0
1275 // and the array would never be expanded
1276 wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
1277
1278 // add 50% but not too much
1279 size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
1280 ? ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;
1281 if ( nIncrement > ARRAY_MAXSIZE_INCREMENT )
1282 nIncrement = ARRAY_MAXSIZE_INCREMENT;
1283 m_nSize += nIncrement;
1284 char **pNew = new char *[m_nSize];
1285
1286 // copy data to new location
1287 memcpy(pNew, m_pItems, m_nCount*sizeof(char *));
1288
1289 // delete old memory (but do not release the strings!)
1290 wxDELETEA(m_pItems);
1291
1292 m_pItems = pNew;
1293 }
1294 }
1295 }
1296
1297 void wxArrayString::Free()
1298 {
1299 for ( size_t n = 0; n < m_nCount; n++ ) {
1300 STRING(m_pItems[n])->GetStringData()->Unlock();
1301 }
1302 }
1303
1304 // deletes all the strings from the list
1305 void wxArrayString::Empty()
1306 {
1307 Free();
1308
1309 m_nCount = 0;
1310 }
1311
1312 // as Empty, but also frees memory
1313 void wxArrayString::Clear()
1314 {
1315 Free();
1316
1317 m_nSize =
1318 m_nCount = 0;
1319
1320 wxDELETEA(m_pItems);
1321 }
1322
1323 // dtor
1324 wxArrayString::~wxArrayString()
1325 {
1326 Free();
1327
1328 wxDELETEA(m_pItems);
1329 }
1330
1331 // pre-allocates memory (frees the previous data!)
1332 void wxArrayString::Alloc(size_t nSize)
1333 {
1334 wxASSERT( nSize > 0 );
1335
1336 // only if old buffer was not big enough
1337 if ( nSize > m_nSize ) {
1338 Free();
1339 wxDELETEA(m_pItems);
1340 m_pItems = new char *[nSize];
1341 m_nSize = nSize;
1342 }
1343
1344 m_nCount = 0;
1345 }
1346
1347 // searches the array for an item (forward or backwards)
1348 int wxArrayString::Index(const char *sz, bool bCase, bool bFromEnd) const
1349 {
1350 if ( bFromEnd ) {
1351 if ( m_nCount > 0 ) {
1352 size_t ui = m_nCount;
1353 do {
1354 if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) )
1355 return ui;
1356 }
1357 while ( ui != 0 );
1358 }
1359 }
1360 else {
1361 for( size_t ui = 0; ui < m_nCount; ui++ ) {
1362 if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) )
1363 return ui;
1364 }
1365 }
1366
1367 return NOT_FOUND;
1368 }
1369
1370 // add item at the end
1371 void wxArrayString::Add(const wxString& str)
1372 {
1373 wxASSERT( str.GetStringData()->IsValid() );
1374
1375 Grow();
1376
1377 // the string data must not be deleted!
1378 str.GetStringData()->Lock();
1379 m_pItems[m_nCount++] = (char *)str.c_str();
1380 }
1381
1382 // add item at the given position
1383 void wxArrayString::Insert(const wxString& str, size_t nIndex)
1384 {
1385 wxASSERT( str.GetStringData()->IsValid() );
1386
1387 wxCHECK_RET( nIndex <= m_nCount, ("bad index in wxArrayString::Insert") );
1388
1389 Grow();
1390
1391 memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex],
1392 (m_nCount - nIndex)*sizeof(char *));
1393
1394 str.GetStringData()->Lock();
1395 m_pItems[nIndex] = (char *)str.c_str();
1396
1397 m_nCount++;
1398 }
1399
1400 // removes item from array (by index)
1401 void wxArrayString::Remove(size_t nIndex)
1402 {
1403 wxCHECK_RET( nIndex <= m_nCount, _("bad index in wxArrayString::Remove") );
1404
1405 // release our lock
1406 Item(nIndex).GetStringData()->Unlock();
1407
1408 memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],
1409 (m_nCount - nIndex - 1)*sizeof(char *));
1410 m_nCount--;
1411 }
1412
1413 // removes item from array (by value)
1414 void wxArrayString::Remove(const char *sz)
1415 {
1416 int iIndex = Index(sz);
1417
1418 wxCHECK_RET( iIndex != NOT_FOUND,
1419 _("removing inexistent element in wxArrayString::Remove") );
1420
1421 Remove(iIndex);
1422 }
1423
1424 // sort array elements using passed comparaison function
1425
1426 void wxArrayString::Sort(bool WXUNUSED(bCase), bool WXUNUSED(bReverse) )
1427 {
1428 //@@@@ TO DO
1429 //qsort(m_pItems, m_nCount, sizeof(char *), fCmp);
1430 }