]> git.saurik.com Git - wxWidgets.git/blob - src/common/string.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't allow docks to be resized such that panes overlap
[wxWidgets.git] / src / common / string.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/string.cpp
3 // Purpose: wxString class
4 // Author: Vadim Zeitlin, Ryan Norton
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // (c) 2004 Ryan Norton <wxprojects@comcast.net>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ===========================================================================
14 // headers, declarations, constants
15 // ===========================================================================
16
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif
23
24 #ifndef WX_PRECOMP
25 #include "wx/string.h"
26 #include "wx/wxcrtvararg.h"
27 #endif
28
29 #include <ctype.h>
30
31 #ifndef __WXWINCE__
32 #include <errno.h>
33 #endif
34
35 #include <string.h>
36 #include <stdlib.h>
37
38 #include "wx/hashmap.h"
39 #include "wx/vector.h"
40 #include "wx/xlocale.h"
41
42 // string handling functions used by wxString:
43 #if wxUSE_UNICODE_UTF8
44 #define wxStringMemcpy memcpy
45 #define wxStringMemcmp memcmp
46 #define wxStringMemchr memchr
47 #define wxStringStrlen strlen
48 #else
49 #define wxStringMemcpy wxTmemcpy
50 #define wxStringMemcmp wxTmemcmp
51 #define wxStringMemchr wxTmemchr
52 #define wxStringStrlen wxStrlen
53 #endif
54
55 // ----------------------------------------------------------------------------
56 // global variables
57 // ----------------------------------------------------------------------------
58
59 namespace wxPrivate
60 {
61
62 static UntypedBufferData s_untypedNullData(NULL, 0);
63
64 UntypedBufferData * const untypedNullDataPtr = &s_untypedNullData;
65
66 } // namespace wxPrivate
67
68 // ---------------------------------------------------------------------------
69 // static class variables definition
70 // ---------------------------------------------------------------------------
71
72 //According to STL _must_ be a -1 size_t
73 const size_t wxString::npos = (size_t) -1;
74
75 #if wxUSE_STRING_POS_CACHE
76
77 #ifdef wxHAS_COMPILER_TLS
78
79 wxTLS_TYPE(wxString::Cache) wxString::ms_cache;
80
81 #else // !wxHAS_COMPILER_TLS
82
83 struct wxStrCacheInitializer
84 {
85 wxStrCacheInitializer()
86 {
87 // calling this function triggers s_cache initialization in it, and
88 // from now on it becomes safe to call from multiple threads
89 wxString::GetCache();
90 }
91 };
92
93 /*
94 wxString::Cache& wxString::GetCache()
95 {
96 static wxTLS_TYPE(Cache) s_cache;
97
98 return wxTLS_VALUE(s_cache);
99 }
100 */
101
102 static wxStrCacheInitializer gs_stringCacheInit;
103
104 #endif // wxHAS_COMPILER_TLS/!wxHAS_COMPILER_TLS
105
106 // gdb seems to be unable to display thread-local variables correctly, at least
107 // not my 6.4.98 version under amd64, so provide this debugging helper to do it
108 #if wxDEBUG_LEVEL >= 2
109
110 struct wxStrCacheDumper
111 {
112 static void ShowAll()
113 {
114 puts("*** wxString cache dump:");
115 for ( unsigned n = 0; n < wxString::Cache::SIZE; n++ )
116 {
117 const wxString::Cache::Element&
118 c = wxString::GetCacheBegin()[n];
119
120 printf("\t%u%s\t%p: pos=(%lu, %lu), len=%ld\n",
121 n,
122 n == wxString::LastUsedCacheElement() ? " [*]" : "",
123 c.str,
124 (unsigned long)c.pos,
125 (unsigned long)c.impl,
126 (long)c.len);
127 }
128 }
129 };
130
131 void wxDumpStrCache() { wxStrCacheDumper::ShowAll(); }
132
133 #endif // wxDEBUG_LEVEL >= 2
134
135 #ifdef wxPROFILE_STRING_CACHE
136
137 wxString::CacheStats wxString::ms_cacheStats;
138
139 struct wxStrCacheStatsDumper
140 {
141 ~wxStrCacheStatsDumper()
142 {
143 const wxString::CacheStats& stats = wxString::ms_cacheStats;
144
145 if ( stats.postot )
146 {
147 puts("*** wxString cache statistics:");
148 printf("\tTotal non-trivial calls to PosToImpl(): %u\n",
149 stats.postot);
150 printf("\tHits %u (of which %u not used) or %.2f%%\n",
151 stats.poshits,
152 stats.mishits,
153 100.*float(stats.poshits - stats.mishits)/stats.postot);
154 printf("\tAverage position requested: %.2f\n",
155 float(stats.sumpos) / stats.postot);
156 printf("\tAverage offset after cached hint: %.2f\n",
157 float(stats.sumofs) / stats.postot);
158 }
159
160 if ( stats.lentot )
161 {
162 printf("\tNumber of calls to length(): %u, hits=%.2f%%\n",
163 stats.lentot, 100.*float(stats.lenhits)/stats.lentot);
164 }
165 }
166 };
167
168 static wxStrCacheStatsDumper s_showCacheStats;
169
170 #endif // wxPROFILE_STRING_CACHE
171
172 #endif // wxUSE_STRING_POS_CACHE
173
174 // ----------------------------------------------------------------------------
175 // global functions
176 // ----------------------------------------------------------------------------
177
178 #if wxUSE_STD_IOSTREAM
179
180 #include <iostream>
181
182 wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
183 {
184 #if wxUSE_UNICODE && !wxUSE_UNICODE_UTF8
185 const wxScopedCharBuffer buf(str.AsCharBuf());
186 if ( !buf )
187 os.clear(wxSTD ios_base::failbit);
188 else
189 os << buf.data();
190
191 return os;
192 #else
193 return os << str.AsInternal();
194 #endif
195 }
196
197 wxSTD ostream& operator<<(wxSTD ostream& os, const wxString& str)
198 {
199 return os << str.c_str();
200 }
201
202 wxSTD ostream& operator<<(wxSTD ostream& os, const wxScopedCharBuffer& str)
203 {
204 return os << str.data();
205 }
206
207 #ifndef __BORLANDC__
208 wxSTD ostream& operator<<(wxSTD ostream& os, const wxScopedWCharBuffer& str)
209 {
210 return os << str.data();
211 }
212 #endif
213
214 #if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
215
216 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxString& str)
217 {
218 return wos << str.wc_str();
219 }
220
221 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxCStrData& str)
222 {
223 return wos << str.AsWChar();
224 }
225
226 wxSTD wostream& operator<<(wxSTD wostream& wos, const wxScopedWCharBuffer& str)
227 {
228 return wos << str.data();
229 }
230
231 #endif // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
232
233 #endif // wxUSE_STD_IOSTREAM
234
235 // ===========================================================================
236 // wxString class core
237 // ===========================================================================
238
239 #if wxUSE_UNICODE_UTF8
240
241 void wxString::PosLenToImpl(size_t pos, size_t len,
242 size_t *implPos, size_t *implLen) const
243 {
244 if ( pos == npos )
245 {
246 *implPos = npos;
247 }
248 else // have valid start position
249 {
250 const const_iterator b = GetIterForNthChar(pos);
251 *implPos = wxStringImpl::const_iterator(b.impl()) - m_impl.begin();
252 if ( len == npos )
253 {
254 *implLen = npos;
255 }
256 else // have valid length too
257 {
258 // we need to handle the case of length specifying a substring
259 // going beyond the end of the string, just as std::string does
260 const const_iterator e(end());
261 const_iterator i(b);
262 while ( len && i <= e )
263 {
264 ++i;
265 --len;
266 }
267
268 *implLen = i.impl() - b.impl();
269 }
270 }
271 }
272
273 #endif // wxUSE_UNICODE_UTF8
274
275 // ----------------------------------------------------------------------------
276 // wxCStrData converted strings caching
277 // ----------------------------------------------------------------------------
278
279 // FIXME-UTF8: temporarily disabled because it doesn't work with global
280 // string objects; re-enable after fixing this bug and benchmarking
281 // performance to see if using a hash is a good idea at all
282 #if 0
283
284 // For backward compatibility reasons, it must be possible to assign the value
285 // returned by wxString::c_str() to a char* or wchar_t* variable and work with
286 // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick,
287 // because the memory would be freed immediately, but it has to be valid as long
288 // as the string is not modified, so that code like this still works:
289 //
290 // const wxChar *s = str.c_str();
291 // while ( s ) { ... }
292
293 // FIXME-UTF8: not thread safe!
294 // FIXME-UTF8: we currently clear the cached conversion only when the string is
295 // destroyed, but we should do it when the string is modified, to
296 // keep memory usage down
297 // FIXME-UTF8: we do the conversion every time As[W]Char() is called, but if we
298 // invalidated the cache on every change, we could keep the previous
299 // conversion
300 // FIXME-UTF8: add tracing of usage of these two methods - new code is supposed
301 // to use mb_str() or wc_str() instead of (const [w]char*)c_str()
302
303 template<typename T>
304 static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
305 {
306 typename T::iterator i = hash.find(wxConstCast(s, wxString));
307 if ( i != hash.end() )
308 {
309 free(i->second);
310 hash.erase(i);
311 }
312 }
313
314 #if wxUSE_UNICODE
315 // NB: non-STL implementation doesn't compile with "const wxString*" key type,
316 // so we have to use wxString* here and const-cast when used
317 WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual,
318 wxStringCharConversionCache);
319 static wxStringCharConversionCache gs_stringsCharCache;
320
321 const char* wxCStrData::AsChar() const
322 {
323 // remove previously cache value, if any (see FIXMEs above):
324 DeleteStringFromConversionCache(gs_stringsCharCache, m_str);
325
326 // convert the string and keep it:
327 const char *s = gs_stringsCharCache[wxConstCast(m_str, wxString)] =
328 m_str->mb_str().release();
329
330 return s + m_offset;
331 }
332 #endif // wxUSE_UNICODE
333
334 #if !wxUSE_UNICODE_WCHAR
335 WX_DECLARE_HASH_MAP(wxString*, wchar_t*, wxPointerHash, wxPointerEqual,
336 wxStringWCharConversionCache);
337 static wxStringWCharConversionCache gs_stringsWCharCache;
338
339 const wchar_t* wxCStrData::AsWChar() const
340 {
341 // remove previously cache value, if any (see FIXMEs above):
342 DeleteStringFromConversionCache(gs_stringsWCharCache, m_str);
343
344 // convert the string and keep it:
345 const wchar_t *s = gs_stringsWCharCache[wxConstCast(m_str, wxString)] =
346 m_str->wc_str().release();
347
348 return s + m_offset;
349 }
350 #endif // !wxUSE_UNICODE_WCHAR
351
352 wxString::~wxString()
353 {
354 #if wxUSE_UNICODE
355 // FIXME-UTF8: do this only if locale is not UTF8 if wxUSE_UNICODE_UTF8
356 DeleteStringFromConversionCache(gs_stringsCharCache, this);
357 #endif
358 #if !wxUSE_UNICODE_WCHAR
359 DeleteStringFromConversionCache(gs_stringsWCharCache, this);
360 #endif
361 }
362 #endif
363
364 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
365 const char* wxCStrData::AsChar() const
366 {
367 #if wxUSE_UNICODE_UTF8
368 if ( wxLocaleIsUtf8 )
369 return AsInternal();
370 #endif
371 // under non-UTF8 locales, we have to convert the internal UTF-8
372 // representation using wxConvLibc and cache the result
373
374 wxString *str = wxConstCast(m_str, wxString);
375
376 // convert the string:
377 //
378 // FIXME-UTF8: we'd like to do the conversion in the existing buffer (if we
379 // have it) but it's unfortunately not obvious to implement
380 // because we don't know how big buffer do we need for the
381 // given string length (in case of multibyte encodings, e.g.
382 // ISO-2022-JP or UTF-8 when internal representation is wchar_t)
383 //
384 // One idea would be to store more than just m_convertedToChar
385 // in wxString: then we could record the length of the string
386 // which was converted the last time and try to reuse the same
387 // buffer if the current length is not greater than it (this
388 // could still fail because string could have been modified in
389 // place but it would work most of the time, so we'd do it and
390 // only allocate the new buffer if in-place conversion returned
391 // an error). We could also store a bit saying if the string
392 // was modified since the last conversion (and update it in all
393 // operation modifying the string, of course) to avoid unneeded
394 // consequential conversions. But both of these ideas require
395 // adding more fields to wxString and require profiling results
396 // to be sure that we really gain enough from them to justify
397 // doing it.
398 wxScopedCharBuffer buf(str->mb_str());
399
400 // if it failed, return empty string and not NULL to avoid crashes in code
401 // written with either wxWidgets 2 wxString or std::string behaviour in
402 // mind: neither of them ever returns NULL and so we shouldn't neither
403 if ( !buf )
404 return "";
405
406 if ( str->m_convertedToChar &&
407 strlen(buf) == strlen(str->m_convertedToChar) )
408 {
409 // keep the same buffer for as long as possible, so that several calls
410 // to c_str() in a row still work:
411 strcpy(str->m_convertedToChar, buf);
412 }
413 else
414 {
415 str->m_convertedToChar = buf.release();
416 }
417
418 // and keep it:
419 return str->m_convertedToChar + m_offset;
420 }
421 #endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
422
423 #if !wxUSE_UNICODE_WCHAR
424 const wchar_t* wxCStrData::AsWChar() const
425 {
426 wxString *str = wxConstCast(m_str, wxString);
427
428 // convert the string:
429 wxScopedWCharBuffer buf(str->wc_str());
430
431 // notice that here, unlike above in AsChar(), conversion can't fail as our
432 // internal UTF-8 is always well-formed -- or the string was corrupted and
433 // all bets are off anyhow
434
435 // FIXME-UTF8: do the conversion in-place in the existing buffer
436 if ( str->m_convertedToWChar &&
437 wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
438 {
439 // keep the same buffer for as long as possible, so that several calls
440 // to c_str() in a row still work:
441 memcpy(str->m_convertedToWChar, buf, sizeof(wchar_t) * wxWcslen(buf));
442 }
443 else
444 {
445 str->m_convertedToWChar = buf.release();
446 }
447
448 // and keep it:
449 return str->m_convertedToWChar + m_offset;
450 }
451 #endif // !wxUSE_UNICODE_WCHAR
452
453 // ===========================================================================
454 // wxString class core
455 // ===========================================================================
456
457 // ---------------------------------------------------------------------------
458 // construction and conversion
459 // ---------------------------------------------------------------------------
460
461 #if wxUSE_UNICODE_WCHAR
462 /* static */
463 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
464 const wxMBConv& conv)
465 {
466 // anything to do?
467 if ( !psz || nLength == 0 )
468 return SubstrBufFromMB(wxWCharBuffer(L""), 0);
469
470 if ( nLength == npos )
471 nLength = wxNO_LEN;
472
473 size_t wcLen;
474 wxScopedWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
475 if ( !wcLen )
476 return SubstrBufFromMB(wxWCharBuffer(L""), 0);
477 else
478 return SubstrBufFromMB(wcBuf, wcLen);
479 }
480 #endif // wxUSE_UNICODE_WCHAR
481
482 #if wxUSE_UNICODE_UTF8
483 /* static */
484 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
485 const wxMBConv& conv)
486 {
487 // anything to do?
488 if ( !psz || nLength == 0 )
489 return SubstrBufFromMB(wxCharBuffer(""), 0);
490
491 // if psz is already in UTF-8, we don't have to do the roundtrip to
492 // wchar_t* and back:
493 if ( conv.IsUTF8() )
494 {
495 // we need to validate the input because UTF8 iterators assume valid
496 // UTF-8 sequence and psz may be invalid:
497 if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
498 {
499 // we must pass the real string length to SubstrBufFromMB ctor
500 if ( nLength == npos )
501 nLength = psz ? strlen(psz) : 0;
502 return SubstrBufFromMB(wxScopedCharBuffer::CreateNonOwned(psz, nLength),
503 nLength);
504 }
505 // else: do the roundtrip through wchar_t*
506 }
507
508 if ( nLength == npos )
509 nLength = wxNO_LEN;
510
511 // first convert to wide string:
512 size_t wcLen;
513 wxScopedWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
514 if ( !wcLen )
515 return SubstrBufFromMB(wxCharBuffer(""), 0);
516
517 // and then to UTF-8:
518 SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
519 // widechar -> UTF-8 conversion isn't supposed to ever fail:
520 wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
521
522 return buf;
523 }
524 #endif // wxUSE_UNICODE_UTF8
525
526 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
527 /* static */
528 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
529 const wxMBConv& conv)
530 {
531 // anything to do?
532 if ( !pwz || nLength == 0 )
533 return SubstrBufFromWC(wxCharBuffer(""), 0);
534
535 if ( nLength == npos )
536 nLength = wxNO_LEN;
537
538 size_t mbLen;
539 wxScopedCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
540 if ( !mbLen )
541 return SubstrBufFromWC(wxCharBuffer(""), 0);
542 else
543 return SubstrBufFromWC(mbBuf, mbLen);
544 }
545 #endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
546
547
548 #if wxUSE_UNICODE_WCHAR
549
550 //Convert wxString in Unicode mode to a multi-byte string
551 const wxScopedCharBuffer wxString::mb_str(const wxMBConv& conv) const
552 {
553 // NB: Length passed to cWC2MB() doesn't include terminating NUL, it's
554 // added by it automatically. If we passed length()+1 here, it would
555 // create a buffer with 2 trailing NULs of length one greater than
556 // expected.
557 return conv.cWC2MB(wx_str(), length(), NULL);
558 }
559
560 #elif wxUSE_UNICODE_UTF8
561
562 const wxScopedWCharBuffer wxString::wc_str() const
563 {
564 // NB: Length passed to cMB2WC() doesn't include terminating NUL, it's
565 // added by it automatically. If we passed length()+1 here, it would
566 // create a buffer with 2 trailing NULs of length one greater than
567 // expected.
568 return wxMBConvStrictUTF8().cMB2WC
569 (
570 m_impl.c_str(),
571 m_impl.length(),
572 NULL
573 );
574 }
575
576 const wxScopedCharBuffer wxString::mb_str(const wxMBConv& conv) const
577 {
578 if ( conv.IsUTF8() )
579 return wxScopedCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length());
580
581 wxScopedWCharBuffer wcBuf(wc_str());
582 if ( !wcBuf.length() )
583 return wxCharBuffer("");
584
585 return conv.cWC2MB(wcBuf.data(), wcBuf.length(), NULL);
586 }
587
588 #else // ANSI
589
590 //Converts this string to a wide character string if unicode
591 //mode is not enabled and wxUSE_WCHAR_T is enabled
592 const wxScopedWCharBuffer wxString::wc_str(const wxMBConv& conv) const
593 {
594 // NB: Length passed to cMB2WC() doesn't include terminating NUL, it's
595 // added by it automatically. If we passed length()+1 here, it would
596 // create a buffer with 2 trailing NULs of length one greater than
597 // expected.
598 return conv.cMB2WC(wx_str(), length(), NULL);
599 }
600
601 #endif // Unicode/ANSI
602
603 // shrink to minimal size (releasing extra memory)
604 bool wxString::Shrink()
605 {
606 wxString tmp(begin(), end());
607 swap(tmp);
608 return tmp.length() == length();
609 }
610
611 // deprecated compatibility code:
612 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
613 wxStringCharType *wxString::GetWriteBuf(size_t nLen)
614 {
615 return DoGetWriteBuf(nLen);
616 }
617
618 void wxString::UngetWriteBuf()
619 {
620 DoUngetWriteBuf();
621 }
622
623 void wxString::UngetWriteBuf(size_t nLen)
624 {
625 DoUngetWriteBuf(nLen);
626 }
627 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
628
629
630 // ---------------------------------------------------------------------------
631 // data access
632 // ---------------------------------------------------------------------------
633
634 // all functions are inline in string.h
635
636 // ---------------------------------------------------------------------------
637 // concatenation operators
638 // ---------------------------------------------------------------------------
639
640 /*
641 * concatenation functions come in 5 flavours:
642 * string + string
643 * char + string and string + char
644 * C str + string and string + C str
645 */
646
647 wxString operator+(const wxString& str1, const wxString& str2)
648 {
649 #if !wxUSE_STL_BASED_WXSTRING
650 wxASSERT( str1.IsValid() );
651 wxASSERT( str2.IsValid() );
652 #endif
653
654 wxString s = str1;
655 s += str2;
656
657 return s;
658 }
659
660 wxString operator+(const wxString& str, wxUniChar ch)
661 {
662 #if !wxUSE_STL_BASED_WXSTRING
663 wxASSERT( str.IsValid() );
664 #endif
665
666 wxString s = str;
667 s += ch;
668
669 return s;
670 }
671
672 wxString operator+(wxUniChar ch, const wxString& str)
673 {
674 #if !wxUSE_STL_BASED_WXSTRING
675 wxASSERT( str.IsValid() );
676 #endif
677
678 wxString s = ch;
679 s += str;
680
681 return s;
682 }
683
684 wxString operator+(const wxString& str, const char *psz)
685 {
686 #if !wxUSE_STL_BASED_WXSTRING
687 wxASSERT( str.IsValid() );
688 #endif
689
690 wxString s;
691 if ( !s.Alloc(strlen(psz) + str.length()) ) {
692 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
693 }
694 s += str;
695 s += psz;
696
697 return s;
698 }
699
700 wxString operator+(const wxString& str, const wchar_t *pwz)
701 {
702 #if !wxUSE_STL_BASED_WXSTRING
703 wxASSERT( str.IsValid() );
704 #endif
705
706 wxString s;
707 if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
708 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
709 }
710 s += str;
711 s += pwz;
712
713 return s;
714 }
715
716 wxString operator+(const char *psz, const wxString& str)
717 {
718 #if !wxUSE_STL_BASED_WXSTRING
719 wxASSERT( str.IsValid() );
720 #endif
721
722 wxString s;
723 if ( !s.Alloc(strlen(psz) + str.length()) ) {
724 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
725 }
726 s = psz;
727 s += str;
728
729 return s;
730 }
731
732 wxString operator+(const wchar_t *pwz, const wxString& str)
733 {
734 #if !wxUSE_STL_BASED_WXSTRING
735 wxASSERT( str.IsValid() );
736 #endif
737
738 wxString s;
739 if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
740 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
741 }
742 s = pwz;
743 s += str;
744
745 return s;
746 }
747
748 // ---------------------------------------------------------------------------
749 // string comparison
750 // ---------------------------------------------------------------------------
751
752 bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const
753 {
754 return (length() == 1) && (compareWithCase ? GetChar(0u) == c
755 : wxToupper(GetChar(0u)) == wxToupper(c));
756 }
757
758 #ifdef HAVE_STD_STRING_COMPARE
759
760 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
761 // UTF-8 encoded strings too, thanks to UTF-8's design which allows us to
762 // sort strings in characters code point order by sorting the byte sequence
763 // in byte values order (i.e. what strcmp() and memcmp() do).
764
765 int wxString::compare(const wxString& str) const
766 {
767 return m_impl.compare(str.m_impl);
768 }
769
770 int wxString::compare(size_t nStart, size_t nLen,
771 const wxString& str) const
772 {
773 size_t pos, len;
774 PosLenToImpl(nStart, nLen, &pos, &len);
775 return m_impl.compare(pos, len, str.m_impl);
776 }
777
778 int wxString::compare(size_t nStart, size_t nLen,
779 const wxString& str,
780 size_t nStart2, size_t nLen2) const
781 {
782 size_t pos, len;
783 PosLenToImpl(nStart, nLen, &pos, &len);
784
785 size_t pos2, len2;
786 str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
787
788 return m_impl.compare(pos, len, str.m_impl, pos2, len2);
789 }
790
791 int wxString::compare(const char* sz) const
792 {
793 return m_impl.compare(ImplStr(sz));
794 }
795
796 int wxString::compare(const wchar_t* sz) const
797 {
798 return m_impl.compare(ImplStr(sz));
799 }
800
801 int wxString::compare(size_t nStart, size_t nLen,
802 const char* sz, size_t nCount) const
803 {
804 size_t pos, len;
805 PosLenToImpl(nStart, nLen, &pos, &len);
806
807 SubstrBufFromMB str(ImplStr(sz, nCount));
808
809 return m_impl.compare(pos, len, str.data, str.len);
810 }
811
812 int wxString::compare(size_t nStart, size_t nLen,
813 const wchar_t* sz, size_t nCount) const
814 {
815 size_t pos, len;
816 PosLenToImpl(nStart, nLen, &pos, &len);
817
818 SubstrBufFromWC str(ImplStr(sz, nCount));
819
820 return m_impl.compare(pos, len, str.data, str.len);
821 }
822
823 #else // !HAVE_STD_STRING_COMPARE
824
825 static inline int wxDoCmp(const wxStringCharType* s1, size_t l1,
826 const wxStringCharType* s2, size_t l2)
827 {
828 if( l1 == l2 )
829 return wxStringMemcmp(s1, s2, l1);
830 else if( l1 < l2 )
831 {
832 int ret = wxStringMemcmp(s1, s2, l1);
833 return ret == 0 ? -1 : ret;
834 }
835 else
836 {
837 int ret = wxStringMemcmp(s1, s2, l2);
838 return ret == 0 ? +1 : ret;
839 }
840 }
841
842 int wxString::compare(const wxString& str) const
843 {
844 return ::wxDoCmp(m_impl.data(), m_impl.length(),
845 str.m_impl.data(), str.m_impl.length());
846 }
847
848 int wxString::compare(size_t nStart, size_t nLen,
849 const wxString& str) const
850 {
851 wxASSERT(nStart <= length());
852 size_type strLen = length() - nStart;
853 nLen = strLen < nLen ? strLen : nLen;
854
855 size_t pos, len;
856 PosLenToImpl(nStart, nLen, &pos, &len);
857
858 return ::wxDoCmp(m_impl.data() + pos, len,
859 str.m_impl.data(), str.m_impl.length());
860 }
861
862 int wxString::compare(size_t nStart, size_t nLen,
863 const wxString& str,
864 size_t nStart2, size_t nLen2) const
865 {
866 wxASSERT(nStart <= length());
867 wxASSERT(nStart2 <= str.length());
868 size_type strLen = length() - nStart,
869 strLen2 = str.length() - nStart2;
870 nLen = strLen < nLen ? strLen : nLen;
871 nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
872
873 size_t pos, len;
874 PosLenToImpl(nStart, nLen, &pos, &len);
875 size_t pos2, len2;
876 str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
877
878 return ::wxDoCmp(m_impl.data() + pos, len,
879 str.m_impl.data() + pos2, len2);
880 }
881
882 int wxString::compare(const char* sz) const
883 {
884 SubstrBufFromMB str(ImplStr(sz, npos));
885 if ( str.len == npos )
886 str.len = wxStringStrlen(str.data);
887 return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
888 }
889
890 int wxString::compare(const wchar_t* sz) const
891 {
892 SubstrBufFromWC str(ImplStr(sz, npos));
893 if ( str.len == npos )
894 str.len = wxStringStrlen(str.data);
895 return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
896 }
897
898 int wxString::compare(size_t nStart, size_t nLen,
899 const char* sz, size_t nCount) const
900 {
901 wxASSERT(nStart <= length());
902 size_type strLen = length() - nStart;
903 nLen = strLen < nLen ? strLen : nLen;
904
905 size_t pos, len;
906 PosLenToImpl(nStart, nLen, &pos, &len);
907
908 SubstrBufFromMB str(ImplStr(sz, nCount));
909 if ( str.len == npos )
910 str.len = wxStringStrlen(str.data);
911
912 return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
913 }
914
915 int wxString::compare(size_t nStart, size_t nLen,
916 const wchar_t* sz, size_t nCount) const
917 {
918 wxASSERT(nStart <= length());
919 size_type strLen = length() - nStart;
920 nLen = strLen < nLen ? strLen : nLen;
921
922 size_t pos, len;
923 PosLenToImpl(nStart, nLen, &pos, &len);
924
925 SubstrBufFromWC str(ImplStr(sz, nCount));
926 if ( str.len == npos )
927 str.len = wxStringStrlen(str.data);
928
929 return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
930 }
931
932 #endif // HAVE_STD_STRING_COMPARE/!HAVE_STD_STRING_COMPARE
933
934
935 // ---------------------------------------------------------------------------
936 // find_{first,last}_[not]_of functions
937 // ---------------------------------------------------------------------------
938
939 #if !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
940
941 // NB: All these functions are implemented with the argument being wxChar*,
942 // i.e. widechar string in any Unicode build, even though native string
943 // representation is char* in the UTF-8 build. This is because we couldn't
944 // use memchr() to determine if a character is in a set encoded as UTF-8.
945
946 size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
947 {
948 return find_first_of(sz, nStart, wxStrlen(sz));
949 }
950
951 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
952 {
953 return find_first_not_of(sz, nStart, wxStrlen(sz));
954 }
955
956 size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
957 {
958 wxASSERT_MSG( nStart <= length(), _T("invalid index") );
959
960 size_t idx = nStart;
961 for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
962 {
963 if ( wxTmemchr(sz, *i, n) )
964 return idx;
965 }
966
967 return npos;
968 }
969
970 size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
971 {
972 wxASSERT_MSG( nStart <= length(), _T("invalid index") );
973
974 size_t idx = nStart;
975 for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
976 {
977 if ( !wxTmemchr(sz, *i, n) )
978 return idx;
979 }
980
981 return npos;
982 }
983
984
985 size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
986 {
987 return find_last_of(sz, nStart, wxStrlen(sz));
988 }
989
990 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
991 {
992 return find_last_not_of(sz, nStart, wxStrlen(sz));
993 }
994
995 size_t wxString::find_last_of(const wxChar* sz, size_t nStart, size_t n) const
996 {
997 size_t len = length();
998
999 if ( nStart == npos )
1000 {
1001 nStart = len - 1;
1002 }
1003 else
1004 {
1005 wxASSERT_MSG( nStart <= len, _T("invalid index") );
1006 }
1007
1008 size_t idx = nStart;
1009 for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1010 i != rend(); --idx, ++i )
1011 {
1012 if ( wxTmemchr(sz, *i, n) )
1013 return idx;
1014 }
1015
1016 return npos;
1017 }
1018
1019 size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const
1020 {
1021 size_t len = length();
1022
1023 if ( nStart == npos )
1024 {
1025 nStart = len - 1;
1026 }
1027 else
1028 {
1029 wxASSERT_MSG( nStart <= len, _T("invalid index") );
1030 }
1031
1032 size_t idx = nStart;
1033 for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1034 i != rend(); --idx, ++i )
1035 {
1036 if ( !wxTmemchr(sz, *i, n) )
1037 return idx;
1038 }
1039
1040 return npos;
1041 }
1042
1043 size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
1044 {
1045 wxASSERT_MSG( nStart <= length(), _T("invalid index") );
1046
1047 size_t idx = nStart;
1048 for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
1049 {
1050 if ( *i != ch )
1051 return idx;
1052 }
1053
1054 return npos;
1055 }
1056
1057 size_t wxString::find_last_not_of(wxUniChar ch, size_t nStart) const
1058 {
1059 size_t len = length();
1060
1061 if ( nStart == npos )
1062 {
1063 nStart = len - 1;
1064 }
1065 else
1066 {
1067 wxASSERT_MSG( nStart <= len, _T("invalid index") );
1068 }
1069
1070 size_t idx = nStart;
1071 for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
1072 i != rend(); --idx, ++i )
1073 {
1074 if ( *i != ch )
1075 return idx;
1076 }
1077
1078 return npos;
1079 }
1080
1081 // the functions above were implemented for wchar_t* arguments in Unicode
1082 // build and char* in ANSI build; below are implementations for the other
1083 // version:
1084 #if wxUSE_UNICODE
1085 #define wxOtherCharType char
1086 #define STRCONV (const wxChar*)wxConvLibc.cMB2WC
1087 #else
1088 #define wxOtherCharType wchar_t
1089 #define STRCONV (const wxChar*)wxConvLibc.cWC2MB
1090 #endif
1091
1092 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart) const
1093 { return find_first_of(STRCONV(sz), nStart); }
1094
1095 size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart,
1096 size_t n) const
1097 { return find_first_of(STRCONV(sz, n, NULL), nStart, n); }
1098 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart) const
1099 { return find_last_of(STRCONV(sz), nStart); }
1100 size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart,
1101 size_t n) const
1102 { return find_last_of(STRCONV(sz, n, NULL), nStart, n); }
1103 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart) const
1104 { return find_first_not_of(STRCONV(sz), nStart); }
1105 size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart,
1106 size_t n) const
1107 { return find_first_not_of(STRCONV(sz, n, NULL), nStart, n); }
1108 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart) const
1109 { return find_last_not_of(STRCONV(sz), nStart); }
1110 size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart,
1111 size_t n) const
1112 { return find_last_not_of(STRCONV(sz, n, NULL), nStart, n); }
1113
1114 #undef wxOtherCharType
1115 #undef STRCONV
1116
1117 #endif // !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
1118
1119 // ===========================================================================
1120 // other common string functions
1121 // ===========================================================================
1122
1123 int wxString::CmpNoCase(const wxString& s) const
1124 {
1125 #if wxUSE_UNICODE_UTF8
1126 // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
1127
1128 const_iterator i1 = begin();
1129 const_iterator end1 = end();
1130 const_iterator i2 = s.begin();
1131 const_iterator end2 = s.end();
1132
1133 for ( ; i1 != end1 && i2 != end2; ++i1, ++i2 )
1134 {
1135 wxUniChar lower1 = (wxChar)wxTolower(*i1);
1136 wxUniChar lower2 = (wxChar)wxTolower(*i2);
1137 if ( lower1 != lower2 )
1138 return lower1 < lower2 ? -1 : 1;
1139 }
1140
1141 size_t len1 = length();
1142 size_t len2 = s.length();
1143
1144 if ( len1 < len2 )
1145 return -1;
1146 else if ( len1 > len2 )
1147 return 1;
1148 return 0;
1149 #else // wxUSE_UNICODE_WCHAR or ANSI
1150 return wxStricmp(m_impl.c_str(), s.m_impl.c_str());
1151 #endif
1152 }
1153
1154
1155 #if wxUSE_UNICODE
1156
1157 #ifdef __MWERKS__
1158 #ifndef __SCHAR_MAX__
1159 #define __SCHAR_MAX__ 127
1160 #endif
1161 #endif
1162
1163 wxString wxString::FromAscii(const char *ascii, size_t len)
1164 {
1165 if (!ascii || len == 0)
1166 return wxEmptyString;
1167
1168 wxString res;
1169
1170 {
1171 wxStringInternalBuffer buf(res, len);
1172 wxStringCharType *dest = buf;
1173
1174 for ( ; len > 0; --len )
1175 {
1176 unsigned char c = (unsigned char)*ascii++;
1177 wxASSERT_MSG( c < 0x80,
1178 _T("Non-ASCII value passed to FromAscii().") );
1179
1180 *dest++ = (wchar_t)c;
1181 }
1182 }
1183
1184 return res;
1185 }
1186
1187 wxString wxString::FromAscii(const char *ascii)
1188 {
1189 return FromAscii(ascii, wxStrlen(ascii));
1190 }
1191
1192 wxString wxString::FromAscii(char ascii)
1193 {
1194 // What do we do with '\0' ?
1195
1196 unsigned char c = (unsigned char)ascii;
1197
1198 wxASSERT_MSG( c < 0x80, _T("Non-ASCII value passed to FromAscii().") );
1199
1200 // NB: the cast to wchar_t causes interpretation of 'ascii' as Latin1 value
1201 return wxString(wxUniChar((wchar_t)c));
1202 }
1203
1204 const wxScopedCharBuffer wxString::ToAscii() const
1205 {
1206 // this will allocate enough space for the terminating NUL too
1207 wxCharBuffer buffer(length());
1208 char *dest = buffer.data();
1209
1210 for ( const_iterator i = begin(); i != end(); ++i )
1211 {
1212 wxUniChar c(*i);
1213 // FIXME-UTF8: unify substituted char ('_') with wxUniChar ('?')
1214 *dest++ = c.IsAscii() ? (char)c : '_';
1215
1216 // the output string can't have embedded NULs anyhow, so we can safely
1217 // stop at first of them even if we do have any
1218 if ( !c )
1219 break;
1220 }
1221
1222 return buffer;
1223 }
1224
1225 #endif // wxUSE_UNICODE
1226
1227 // extract string of length nCount starting at nFirst
1228 wxString wxString::Mid(size_t nFirst, size_t nCount) const
1229 {
1230 size_t nLen = length();
1231
1232 // default value of nCount is npos and means "till the end"
1233 if ( nCount == npos )
1234 {
1235 nCount = nLen - nFirst;
1236 }
1237
1238 // out-of-bounds requests return sensible things
1239 if ( nFirst + nCount > nLen )
1240 {
1241 nCount = nLen - nFirst;
1242 }
1243
1244 if ( nFirst > nLen )
1245 {
1246 // AllocCopy() will return empty string
1247 return wxEmptyString;
1248 }
1249
1250 wxString dest(*this, nFirst, nCount);
1251 if ( dest.length() != nCount )
1252 {
1253 wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1254 }
1255
1256 return dest;
1257 }
1258
1259 // check that the string starts with prefix and return the rest of the string
1260 // in the provided pointer if it is not NULL, otherwise return false
1261 bool wxString::StartsWith(const wxString& prefix, wxString *rest) const
1262 {
1263 if ( compare(0, prefix.length(), prefix) != 0 )
1264 return false;
1265
1266 if ( rest )
1267 {
1268 // put the rest of the string into provided pointer
1269 rest->assign(*this, prefix.length(), npos);
1270 }
1271
1272 return true;
1273 }
1274
1275
1276 // check that the string ends with suffix and return the rest of it in the
1277 // provided pointer if it is not NULL, otherwise return false
1278 bool wxString::EndsWith(const wxString& suffix, wxString *rest) const
1279 {
1280 int start = length() - suffix.length();
1281
1282 if ( start < 0 || compare(start, npos, suffix) != 0 )
1283 return false;
1284
1285 if ( rest )
1286 {
1287 // put the rest of the string into provided pointer
1288 rest->assign(*this, 0, start);
1289 }
1290
1291 return true;
1292 }
1293
1294
1295 // extract nCount last (rightmost) characters
1296 wxString wxString::Right(size_t nCount) const
1297 {
1298 if ( nCount > length() )
1299 nCount = length();
1300
1301 wxString dest(*this, length() - nCount, nCount);
1302 if ( dest.length() != nCount ) {
1303 wxFAIL_MSG( _T("out of memory in wxString::Right") );
1304 }
1305 return dest;
1306 }
1307
1308 // get all characters after the last occurrence of ch
1309 // (returns the whole string if ch not found)
1310 wxString wxString::AfterLast(wxUniChar ch) const
1311 {
1312 wxString str;
1313 int iPos = Find(ch, true);
1314 if ( iPos == wxNOT_FOUND )
1315 str = *this;
1316 else
1317 str.assign(*this, iPos + 1, npos);
1318
1319 return str;
1320 }
1321
1322 // extract nCount first (leftmost) characters
1323 wxString wxString::Left(size_t nCount) const
1324 {
1325 if ( nCount > length() )
1326 nCount = length();
1327
1328 wxString dest(*this, 0, nCount);
1329 if ( dest.length() != nCount ) {
1330 wxFAIL_MSG( _T("out of memory in wxString::Left") );
1331 }
1332 return dest;
1333 }
1334
1335 // get all characters before the first occurrence of ch
1336 // (returns the whole string if ch not found)
1337 wxString wxString::BeforeFirst(wxUniChar ch) const
1338 {
1339 int iPos = Find(ch);
1340 if ( iPos == wxNOT_FOUND )
1341 iPos = length();
1342 return wxString(*this, 0, iPos);
1343 }
1344
1345 /// get all characters before the last occurrence of ch
1346 /// (returns empty string if ch not found)
1347 wxString wxString::BeforeLast(wxUniChar ch) const
1348 {
1349 wxString str;
1350 int iPos = Find(ch, true);
1351 if ( iPos != wxNOT_FOUND && iPos != 0 )
1352 str = wxString(c_str(), iPos);
1353
1354 return str;
1355 }
1356
1357 /// get all characters after the first occurrence of ch
1358 /// (returns empty string if ch not found)
1359 wxString wxString::AfterFirst(wxUniChar ch) const
1360 {
1361 wxString str;
1362 int iPos = Find(ch);
1363 if ( iPos != wxNOT_FOUND )
1364 str.assign(*this, iPos + 1, npos);
1365
1366 return str;
1367 }
1368
1369 // replace first (or all) occurrences of some substring with another one
1370 size_t wxString::Replace(const wxString& strOld,
1371 const wxString& strNew, bool bReplaceAll)
1372 {
1373 // if we tried to replace an empty string we'd enter an infinite loop below
1374 wxCHECK_MSG( !strOld.empty(), 0,
1375 _T("wxString::Replace(): invalid parameter") );
1376
1377 wxSTRING_INVALIDATE_CACHE();
1378
1379 size_t uiCount = 0; // count of replacements made
1380
1381 // optimize the special common case: replacement of one character by
1382 // another one (in UTF-8 case we can only do this for ASCII characters)
1383 //
1384 // benchmarks show that this special version is around 3 times faster
1385 // (depending on the proportion of matching characters and UTF-8/wchar_t
1386 // build)
1387 if ( strOld.m_impl.length() == 1 && strNew.m_impl.length() == 1 )
1388 {
1389 const wxStringCharType chOld = strOld.m_impl[0],
1390 chNew = strNew.m_impl[0];
1391
1392 // this loop is the simplified version of the one below
1393 for ( size_t pos = 0; ; )
1394 {
1395 pos = m_impl.find(chOld, pos);
1396 if ( pos == npos )
1397 break;
1398
1399 m_impl[pos++] = chNew;
1400
1401 uiCount++;
1402
1403 if ( !bReplaceAll )
1404 break;
1405 }
1406 }
1407 else if ( !bReplaceAll)
1408 {
1409 size_t pos = m_impl.find(strOld, 0);
1410 if ( pos != npos )
1411 {
1412 m_impl.replace(pos, strOld.m_impl.length(), strNew.m_impl);
1413 uiCount = 1;
1414 }
1415 }
1416 else // replace all occurrences
1417 {
1418 const size_t uiOldLen = strOld.m_impl.length();
1419 const size_t uiNewLen = strNew.m_impl.length();
1420
1421 // first scan the string to find all positions at which the replacement
1422 // should be made
1423 wxVector<size_t> replacePositions;
1424
1425 size_t pos;
1426 for ( pos = m_impl.find(strOld.m_impl, 0);
1427 pos != npos;
1428 pos = m_impl.find(strOld.m_impl, pos + uiOldLen))
1429 {
1430 replacePositions.push_back(pos);
1431 ++uiCount;
1432 }
1433
1434 if ( !uiCount )
1435 return 0;
1436
1437 // allocate enough memory for the whole new string
1438 wxString tmp;
1439 tmp.m_impl.reserve(m_impl.length() + uiCount*(uiNewLen - uiOldLen));
1440
1441 // copy this string to tmp doing replacements on the fly
1442 size_t replNum = 0;
1443 for ( pos = 0; replNum < uiCount; replNum++ )
1444 {
1445 const size_t nextReplPos = replacePositions[replNum];
1446
1447 if ( pos != nextReplPos )
1448 {
1449 tmp.m_impl.append(m_impl, pos, nextReplPos - pos);
1450 }
1451
1452 tmp.m_impl.append(strNew.m_impl);
1453 pos = nextReplPos + uiOldLen;
1454 }
1455
1456 if ( pos != m_impl.length() )
1457 {
1458 // append the rest of the string unchanged
1459 tmp.m_impl.append(m_impl, pos, m_impl.length() - pos);
1460 }
1461
1462 swap(tmp);
1463 }
1464
1465 return uiCount;
1466 }
1467
1468 bool wxString::IsAscii() const
1469 {
1470 for ( const_iterator i = begin(); i != end(); ++i )
1471 {
1472 if ( !(*i).IsAscii() )
1473 return false;
1474 }
1475
1476 return true;
1477 }
1478
1479 bool wxString::IsWord() const
1480 {
1481 for ( const_iterator i = begin(); i != end(); ++i )
1482 {
1483 if ( !wxIsalpha(*i) )
1484 return false;
1485 }
1486
1487 return true;
1488 }
1489
1490 bool wxString::IsNumber() const
1491 {
1492 if ( empty() )
1493 return true;
1494
1495 const_iterator i = begin();
1496
1497 if ( *i == _T('-') || *i == _T('+') )
1498 ++i;
1499
1500 for ( ; i != end(); ++i )
1501 {
1502 if ( !wxIsdigit(*i) )
1503 return false;
1504 }
1505
1506 return true;
1507 }
1508
1509 wxString wxString::Strip(stripType w) const
1510 {
1511 wxString s = *this;
1512 if ( w & leading ) s.Trim(false);
1513 if ( w & trailing ) s.Trim(true);
1514 return s;
1515 }
1516
1517 // ---------------------------------------------------------------------------
1518 // case conversion
1519 // ---------------------------------------------------------------------------
1520
1521 wxString& wxString::MakeUpper()
1522 {
1523 for ( iterator it = begin(), en = end(); it != en; ++it )
1524 *it = (wxChar)wxToupper(*it);
1525
1526 return *this;
1527 }
1528
1529 wxString& wxString::MakeLower()
1530 {
1531 for ( iterator it = begin(), en = end(); it != en; ++it )
1532 *it = (wxChar)wxTolower(*it);
1533
1534 return *this;
1535 }
1536
1537 wxString& wxString::MakeCapitalized()
1538 {
1539 const iterator en = end();
1540 iterator it = begin();
1541 if ( it != en )
1542 {
1543 *it = (wxChar)wxToupper(*it);
1544 for ( ++it; it != en; ++it )
1545 *it = (wxChar)wxTolower(*it);
1546 }
1547
1548 return *this;
1549 }
1550
1551 // ---------------------------------------------------------------------------
1552 // trimming and padding
1553 // ---------------------------------------------------------------------------
1554
1555 // some compilers (VC++ 6.0 not to name them) return true for a call to
1556 // isspace('\xEA') in the C locale which seems to be broken to me, but we have
1557 // to live with this by checking that the character is a 7 bit one - even if
1558 // this may fail to detect some spaces (I don't know if Unicode doesn't have
1559 // space-like symbols somewhere except in the first 128 chars), it is arguably
1560 // still better than trimming away accented letters
1561 inline int wxSafeIsspace(wxChar ch) { return (ch < 127) && wxIsspace(ch); }
1562
1563 // trims spaces (in the sense of isspace) from left or right side
1564 wxString& wxString::Trim(bool bFromRight)
1565 {
1566 // first check if we're going to modify the string at all
1567 if ( !empty() &&
1568 (
1569 (bFromRight && wxSafeIsspace(GetChar(length() - 1))) ||
1570 (!bFromRight && wxSafeIsspace(GetChar(0u)))
1571 )
1572 )
1573 {
1574 if ( bFromRight )
1575 {
1576 // find last non-space character
1577 reverse_iterator psz = rbegin();
1578 while ( (psz != rend()) && wxSafeIsspace(*psz) )
1579 ++psz;
1580
1581 // truncate at trailing space start
1582 erase(psz.base(), end());
1583 }
1584 else
1585 {
1586 // find first non-space character
1587 iterator psz = begin();
1588 while ( (psz != end()) && wxSafeIsspace(*psz) )
1589 ++psz;
1590
1591 // fix up data and length
1592 erase(begin(), psz);
1593 }
1594 }
1595
1596 return *this;
1597 }
1598
1599 // adds nCount characters chPad to the string from either side
1600 wxString& wxString::Pad(size_t nCount, wxUniChar chPad, bool bFromRight)
1601 {
1602 wxString s(chPad, nCount);
1603
1604 if ( bFromRight )
1605 *this += s;
1606 else
1607 {
1608 s += *this;
1609 swap(s);
1610 }
1611
1612 return *this;
1613 }
1614
1615 // truncate the string
1616 wxString& wxString::Truncate(size_t uiLen)
1617 {
1618 if ( uiLen < length() )
1619 {
1620 erase(begin() + uiLen, end());
1621 }
1622 //else: nothing to do, string is already short enough
1623
1624 return *this;
1625 }
1626
1627 // ---------------------------------------------------------------------------
1628 // finding (return wxNOT_FOUND if not found and index otherwise)
1629 // ---------------------------------------------------------------------------
1630
1631 // find a character
1632 int wxString::Find(wxUniChar ch, bool bFromEnd) const
1633 {
1634 size_type idx = bFromEnd ? find_last_of(ch) : find_first_of(ch);
1635
1636 return (idx == npos) ? wxNOT_FOUND : (int)idx;
1637 }
1638
1639 // ----------------------------------------------------------------------------
1640 // conversion to numbers
1641 // ----------------------------------------------------------------------------
1642
1643 // The implementation of all the functions below is exactly the same so factor
1644 // it out. Note that number extraction works correctly on UTF-8 strings, so
1645 // we can use wxStringCharType and wx_str() for maximum efficiency.
1646
1647 #ifndef __WXWINCE__
1648 #define DO_IF_NOT_WINCE(x) x
1649 #else
1650 #define DO_IF_NOT_WINCE(x)
1651 #endif
1652
1653 #define WX_STRING_TO_X_TYPE_START \
1654 wxCHECK_MSG( pVal, false, _T("NULL output pointer") ); \
1655 DO_IF_NOT_WINCE( errno = 0; ) \
1656 const wxStringCharType *start = wx_str(); \
1657 wxStringCharType *end;
1658
1659 #define WX_STRING_TO_X_TYPE_END \
1660 /* return true only if scan was stopped by the terminating NUL and */ \
1661 /* if the string was not empty to start with and no under/overflow */ \
1662 /* occurred: */ \
1663 if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) ) \
1664 return false; \
1665 *pVal = val; \
1666 return true;
1667
1668 bool wxString::ToLong(long *pVal, int base) const
1669 {
1670 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1671
1672 WX_STRING_TO_X_TYPE_START
1673 long val = wxStrtol(start, &end, base);
1674 WX_STRING_TO_X_TYPE_END
1675 }
1676
1677 bool wxString::ToULong(unsigned long *pVal, int base) const
1678 {
1679 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1680
1681 WX_STRING_TO_X_TYPE_START
1682 unsigned long val = wxStrtoul(start, &end, base);
1683 WX_STRING_TO_X_TYPE_END
1684 }
1685
1686 bool wxString::ToLongLong(wxLongLong_t *pVal, int base) const
1687 {
1688 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1689
1690 WX_STRING_TO_X_TYPE_START
1691 wxLongLong_t val = wxStrtoll(start, &end, base);
1692 WX_STRING_TO_X_TYPE_END
1693 }
1694
1695 bool wxString::ToULongLong(wxULongLong_t *pVal, int base) const
1696 {
1697 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1698
1699 WX_STRING_TO_X_TYPE_START
1700 wxULongLong_t val = wxStrtoull(start, &end, base);
1701 WX_STRING_TO_X_TYPE_END
1702 }
1703
1704 bool wxString::ToDouble(double *pVal) const
1705 {
1706 WX_STRING_TO_X_TYPE_START
1707 double val = wxStrtod(start, &end);
1708 WX_STRING_TO_X_TYPE_END
1709 }
1710
1711 #if wxUSE_XLOCALE
1712
1713 bool wxString::ToCLong(long *pVal, int base) const
1714 {
1715 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1716
1717 WX_STRING_TO_X_TYPE_START
1718 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1719 long val = wxStrtol_lA(start, &end, base, wxCLocale);
1720 #else
1721 long val = wxStrtol_l(start, &end, base, wxCLocale);
1722 #endif
1723 WX_STRING_TO_X_TYPE_END
1724 }
1725
1726 bool wxString::ToCULong(unsigned long *pVal, int base) const
1727 {
1728 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
1729
1730 WX_STRING_TO_X_TYPE_START
1731 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1732 unsigned long val = wxStrtoul_lA(start, &end, base, wxCLocale);
1733 #else
1734 unsigned long val = wxStrtoul_l(start, &end, base, wxCLocale);
1735 #endif
1736 WX_STRING_TO_X_TYPE_END
1737 }
1738
1739 bool wxString::ToCDouble(double *pVal) const
1740 {
1741 WX_STRING_TO_X_TYPE_START
1742 #if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
1743 double val = wxStrtod_lA(start, &end, wxCLocale);
1744 #else
1745 double val = wxStrtod_l(start, &end, wxCLocale);
1746 #endif
1747 WX_STRING_TO_X_TYPE_END
1748 }
1749
1750 #endif // wxUSE_XLOCALE
1751
1752 // ---------------------------------------------------------------------------
1753 // formatted output
1754 // ---------------------------------------------------------------------------
1755
1756 #if !wxUSE_UTF8_LOCALE_ONLY
1757 /* static */
1758 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1759 wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...)
1760 #else
1761 wxString wxString::DoFormatWchar(const wxChar *format, ...)
1762 #endif
1763 {
1764 va_list argptr;
1765 va_start(argptr, format);
1766
1767 wxString s;
1768 s.PrintfV(format, argptr);
1769
1770 va_end(argptr);
1771
1772 return s;
1773 }
1774 #endif // !wxUSE_UTF8_LOCALE_ONLY
1775
1776 #if wxUSE_UNICODE_UTF8
1777 /* static */
1778 wxString wxString::DoFormatUtf8(const char *format, ...)
1779 {
1780 va_list argptr;
1781 va_start(argptr, format);
1782
1783 wxString s;
1784 s.PrintfV(format, argptr);
1785
1786 va_end(argptr);
1787
1788 return s;
1789 }
1790 #endif // wxUSE_UNICODE_UTF8
1791
1792 /* static */
1793 wxString wxString::FormatV(const wxString& format, va_list argptr)
1794 {
1795 wxString s;
1796 s.PrintfV(format, argptr);
1797 return s;
1798 }
1799
1800 #if !wxUSE_UTF8_LOCALE_ONLY
1801 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1802 int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...)
1803 #else
1804 int wxString::DoPrintfWchar(const wxChar *format, ...)
1805 #endif
1806 {
1807 va_list argptr;
1808 va_start(argptr, format);
1809
1810 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1811 // get a pointer to the wxString instance; we have to use dynamic_cast<>
1812 // because it's the only cast that works safely for downcasting when
1813 // multiple inheritance is used:
1814 wxString *str = static_cast<wxString*>(this);
1815 #else
1816 wxString *str = this;
1817 #endif
1818
1819 int iLen = str->PrintfV(format, argptr);
1820
1821 va_end(argptr);
1822
1823 return iLen;
1824 }
1825 #endif // !wxUSE_UTF8_LOCALE_ONLY
1826
1827 #if wxUSE_UNICODE_UTF8
1828 int wxString::DoPrintfUtf8(const char *format, ...)
1829 {
1830 va_list argptr;
1831 va_start(argptr, format);
1832
1833 int iLen = PrintfV(format, argptr);
1834
1835 va_end(argptr);
1836
1837 return iLen;
1838 }
1839 #endif // wxUSE_UNICODE_UTF8
1840
1841 /*
1842 Uses wxVsnprintf and places the result into the this string.
1843
1844 In ANSI build, wxVsnprintf is effectively vsnprintf but in Unicode build
1845 it is vswprintf. Due to a discrepancy between vsnprintf and vswprintf in
1846 the ISO C99 (and thus SUSv3) standard the return value for the case of
1847 an undersized buffer is inconsistent. For conforming vsnprintf
1848 implementations the function must return the number of characters that
1849 would have been printed had the buffer been large enough. For conforming
1850 vswprintf implementations the function must return a negative number
1851 and set errno.
1852
1853 What vswprintf sets errno to is undefined but Darwin seems to set it to
1854 EOVERFLOW. The only expected errno are EILSEQ and EINVAL. Both of
1855 those are defined in the standard and backed up by several conformance
1856 statements. Note that ENOMEM mentioned in the manual page does not
1857 apply to swprintf, only wprintf and fwprintf.
1858
1859 Official manual page:
1860 http://www.opengroup.org/onlinepubs/009695399/functions/swprintf.html
1861
1862 Some conformance statements (AIX, Solaris):
1863 http://www.opengroup.org/csq/view.mhtml?RID=ibm%2FSD1%2F3
1864 http://www.theopengroup.org/csq/view.mhtml?norationale=1&noreferences=1&RID=Fujitsu%2FSE2%2F10
1865
1866 Since EILSEQ and EINVAL are rather common but EOVERFLOW is not and since
1867 EILSEQ and EINVAL are specifically defined to mean the error is other than
1868 an undersized buffer and no other errno are defined we treat those two
1869 as meaning hard errors and everything else gets the old behavior which
1870 is to keep looping and increasing buffer size until the function succeeds.
1871
1872 In practice it's impossible to determine before compilation which behavior
1873 may be used. The vswprintf function may have vsnprintf-like behavior or
1874 vice-versa. Behavior detected on one release can theoretically change
1875 with an updated release. Not to mention that configure testing for it
1876 would require the test to be run on the host system, not the build system
1877 which makes cross compilation difficult. Therefore, we make no assumptions
1878 about behavior and try our best to handle every known case, including the
1879 case where wxVsnprintf returns a negative number and fails to set errno.
1880
1881 There is yet one more non-standard implementation and that is our own.
1882 Fortunately, that can be detected at compile-time.
1883
1884 On top of all that, ISO C99 explicitly defines snprintf to write a null
1885 character to the last position of the specified buffer. That would be at
1886 at the given buffer size minus 1. It is supposed to do this even if it
1887 turns out that the buffer is sized too small.
1888
1889 Darwin (tested on 10.5) follows the C99 behavior exactly.
1890
1891 Glibc 2.6 almost follows the C99 behavior except vswprintf never sets
1892 errno even when it fails. However, it only seems to ever fail due
1893 to an undersized buffer.
1894 */
1895 #if wxUSE_UNICODE_UTF8
1896 template<typename BufferType>
1897 #else
1898 // we only need one version in non-UTF8 builds and at least two Windows
1899 // compilers have problems with this function template, so use just one
1900 // normal function here
1901 #endif
1902 static int DoStringPrintfV(wxString& str,
1903 const wxString& format, va_list argptr)
1904 {
1905 int size = 1024;
1906
1907 for ( ;; )
1908 {
1909 #if wxUSE_UNICODE_UTF8
1910 BufferType tmp(str, size + 1);
1911 typename BufferType::CharType *buf = tmp;
1912 #else
1913 wxStringBuffer tmp(str, size + 1);
1914 wxChar *buf = tmp;
1915 #endif
1916
1917 if ( !buf )
1918 {
1919 // out of memory
1920
1921 // in UTF-8 build, leaving uninitialized junk in the buffer
1922 // could result in invalid non-empty UTF-8 string, so just
1923 // reset the string to empty on failure:
1924 buf[0] = '\0';
1925 return -1;
1926 }
1927
1928 // wxVsnprintf() may modify the original arg pointer, so pass it
1929 // only a copy
1930 va_list argptrcopy;
1931 wxVaCopy(argptrcopy, argptr);
1932
1933 #ifndef __WXWINCE__
1934 // Set errno to 0 to make it determinate if wxVsnprintf fails to set it.
1935 errno = 0;
1936 #endif
1937 int len = wxVsnprintf(buf, size, format, argptrcopy);
1938 va_end(argptrcopy);
1939
1940 // some implementations of vsnprintf() don't NUL terminate
1941 // the string if there is not enough space for it so
1942 // always do it manually
1943 // FIXME: This really seems to be the wrong and would be an off-by-one
1944 // bug except the code above allocates an extra character.
1945 buf[size] = _T('\0');
1946
1947 // vsnprintf() may return either -1 (traditional Unix behaviour) or the
1948 // total number of characters which would have been written if the
1949 // buffer were large enough (newer standards such as Unix98)
1950 if ( len < 0 )
1951 {
1952 // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or
1953 // wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF
1954 // is true if *both* of them use our own implementation,
1955 // otherwise we can't be sure
1956 #if wxUSE_WXVSNPRINTF
1957 // we know that our own implementation of wxVsnprintf() returns -1
1958 // only for a format error - thus there's something wrong with
1959 // the user's format string
1960 buf[0] = '\0';
1961 return -1;
1962 #else // possibly using system version
1963 // assume it only returns error if there is not enough space, but
1964 // as we don't know how much we need, double the current size of
1965 // the buffer
1966 #ifndef __WXWINCE__
1967 if( (errno == EILSEQ) || (errno == EINVAL) )
1968 // If errno was set to one of the two well-known hard errors
1969 // then fail immediately to avoid an infinite loop.
1970 return -1;
1971 else
1972 #endif // __WXWINCE__
1973 // still not enough, as we don't know how much we need, double the
1974 // current size of the buffer
1975 size *= 2;
1976 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
1977 }
1978 else if ( len >= size )
1979 {
1980 #if wxUSE_WXVSNPRINTF
1981 // we know that our own implementation of wxVsnprintf() returns
1982 // size+1 when there's not enough space but that's not the size
1983 // of the required buffer!
1984 size *= 2; // so we just double the current size of the buffer
1985 #else
1986 // some vsnprintf() implementations NUL-terminate the buffer and
1987 // some don't in len == size case, to be safe always add 1
1988 // FIXME: I don't quite understand this comment. The vsnprintf
1989 // function is specifically defined to return the number of
1990 // characters printed not including the null terminator.
1991 // So OF COURSE you need to add 1 to get the right buffer size.
1992 // The following line is definitely correct, no question.
1993 size = len + 1;
1994 #endif
1995 }
1996 else // ok, there was enough space
1997 {
1998 break;
1999 }
2000 }
2001
2002 // we could have overshot
2003 str.Shrink();
2004
2005 return str.length();
2006 }
2007
2008 int wxString::PrintfV(const wxString& format, va_list argptr)
2009 {
2010 #if wxUSE_UNICODE_UTF8
2011 #if wxUSE_STL_BASED_WXSTRING
2012 typedef wxStringTypeBuffer<char> Utf8Buffer;
2013 #else
2014 typedef wxStringInternalBuffer Utf8Buffer;
2015 #endif
2016 #endif
2017
2018 #if wxUSE_UTF8_LOCALE_ONLY
2019 return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
2020 #else
2021 #if wxUSE_UNICODE_UTF8
2022 if ( wxLocaleIsUtf8 )
2023 return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
2024 else
2025 // wxChar* version
2026 return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);
2027 #else
2028 return DoStringPrintfV(*this, format, argptr);
2029 #endif // UTF8/WCHAR
2030 #endif
2031 }
2032
2033 // ----------------------------------------------------------------------------
2034 // misc other operations
2035 // ----------------------------------------------------------------------------
2036
2037 // returns true if the string matches the pattern which may contain '*' and
2038 // '?' metacharacters (as usual, '?' matches any character and '*' any number
2039 // of them)
2040 bool wxString::Matches(const wxString& mask) const
2041 {
2042 // I disable this code as it doesn't seem to be faster (in fact, it seems
2043 // to be much slower) than the old, hand-written code below and using it
2044 // here requires always linking with libregex even if the user code doesn't
2045 // use it
2046 #if 0 // wxUSE_REGEX
2047 // first translate the shell-like mask into a regex
2048 wxString pattern;
2049 pattern.reserve(wxStrlen(pszMask));
2050
2051 pattern += _T('^');
2052 while ( *pszMask )
2053 {
2054 switch ( *pszMask )
2055 {
2056 case _T('?'):
2057 pattern += _T('.');
2058 break;
2059
2060 case _T('*'):
2061 pattern += _T(".*");
2062 break;
2063
2064 case _T('^'):
2065 case _T('.'):
2066 case _T('$'):
2067 case _T('('):
2068 case _T(')'):
2069 case _T('|'):
2070 case _T('+'):
2071 case _T('\\'):
2072 // these characters are special in a RE, quote them
2073 // (however note that we don't quote '[' and ']' to allow
2074 // using them for Unix shell like matching)
2075 pattern += _T('\\');
2076 // fall through
2077
2078 default:
2079 pattern += *pszMask;
2080 }
2081
2082 pszMask++;
2083 }
2084 pattern += _T('$');
2085
2086 // and now use it
2087 return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
2088 #else // !wxUSE_REGEX
2089 // TODO: this is, of course, awfully inefficient...
2090
2091 // FIXME-UTF8: implement using iterators, remove #if
2092 #if wxUSE_UNICODE_UTF8
2093 const wxScopedWCharBuffer maskBuf = mask.wc_str();
2094 const wxScopedWCharBuffer txtBuf = wc_str();
2095 const wxChar *pszMask = maskBuf.data();
2096 const wxChar *pszTxt = txtBuf.data();
2097 #else
2098 const wxChar *pszMask = mask.wx_str();
2099 // the char currently being checked
2100 const wxChar *pszTxt = wx_str();
2101 #endif
2102
2103 // the last location where '*' matched
2104 const wxChar *pszLastStarInText = NULL;
2105 const wxChar *pszLastStarInMask = NULL;
2106
2107 match:
2108 for ( ; *pszMask != wxT('\0'); pszMask++, pszTxt++ ) {
2109 switch ( *pszMask ) {
2110 case wxT('?'):
2111 if ( *pszTxt == wxT('\0') )
2112 return false;
2113
2114 // pszTxt and pszMask will be incremented in the loop statement
2115
2116 break;
2117
2118 case wxT('*'):
2119 {
2120 // remember where we started to be able to backtrack later
2121 pszLastStarInText = pszTxt;
2122 pszLastStarInMask = pszMask;
2123
2124 // ignore special chars immediately following this one
2125 // (should this be an error?)
2126 while ( *pszMask == wxT('*') || *pszMask == wxT('?') )
2127 pszMask++;
2128
2129 // if there is nothing more, match
2130 if ( *pszMask == wxT('\0') )
2131 return true;
2132
2133 // are there any other metacharacters in the mask?
2134 size_t uiLenMask;
2135 const wxChar *pEndMask = wxStrpbrk(pszMask, wxT("*?"));
2136
2137 if ( pEndMask != NULL ) {
2138 // we have to match the string between two metachars
2139 uiLenMask = pEndMask - pszMask;
2140 }
2141 else {
2142 // we have to match the remainder of the string
2143 uiLenMask = wxStrlen(pszMask);
2144 }
2145
2146 wxString strToMatch(pszMask, uiLenMask);
2147 const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
2148 if ( pMatch == NULL )
2149 return false;
2150
2151 // -1 to compensate "++" in the loop
2152 pszTxt = pMatch + uiLenMask - 1;
2153 pszMask += uiLenMask - 1;
2154 }
2155 break;
2156
2157 default:
2158 if ( *pszMask != *pszTxt )
2159 return false;
2160 break;
2161 }
2162 }
2163
2164 // match only if nothing left
2165 if ( *pszTxt == wxT('\0') )
2166 return true;
2167
2168 // if we failed to match, backtrack if we can
2169 if ( pszLastStarInText ) {
2170 pszTxt = pszLastStarInText + 1;
2171 pszMask = pszLastStarInMask;
2172
2173 pszLastStarInText = NULL;
2174
2175 // don't bother resetting pszLastStarInMask, it's unnecessary
2176
2177 goto match;
2178 }
2179
2180 return false;
2181 #endif // wxUSE_REGEX/!wxUSE_REGEX
2182 }
2183
2184 // Count the number of chars
2185 int wxString::Freq(wxUniChar ch) const
2186 {
2187 int count = 0;
2188 for ( const_iterator i = begin(); i != end(); ++i )
2189 {
2190 if ( *i == ch )
2191 count ++;
2192 }
2193 return count;
2194 }
2195
wxWidgets (Impactor)