+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+
+ SubstrBufFromMB str(ImplStr(sz, nCount));
+
+ return m_impl.compare(pos, len, str.data, str.len);
+}
+
+int wxString::compare(size_t nStart, size_t nLen,
+ const wchar_t* sz, size_t nCount) const
+{
+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+
+ SubstrBufFromWC str(ImplStr(sz, nCount));
+
+ return m_impl.compare(pos, len, str.data, str.len);
+}
+
+#else // !HAVE_STD_STRING_COMPARE
+
+static inline int wxDoCmp(const wxStringCharType* s1, size_t l1,
+ const wxStringCharType* s2, size_t l2)
+{
+ if( l1 == l2 )
+ return wxStringMemcmp(s1, s2, l1);
+ else if( l1 < l2 )
+ {
+ int ret = wxStringMemcmp(s1, s2, l1);
+ return ret == 0 ? -1 : ret;
+ }
+ else
+ {
+ int ret = wxStringMemcmp(s1, s2, l2);
+ return ret == 0 ? +1 : ret;
+ }
+}
+
+int wxString::compare(const wxString& str) const
+{
+ return ::wxDoCmp(m_impl.data(), m_impl.length(),
+ str.m_impl.data(), str.m_impl.length());
+}
+
+int wxString::compare(size_t nStart, size_t nLen,
+ const wxString& str) const
+{
+ wxASSERT(nStart <= length());
+ size_type strLen = length() - nStart;
+ nLen = strLen < nLen ? strLen : nLen;
+
+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+
+ return ::wxDoCmp(m_impl.data() + pos, len,
+ str.m_impl.data(), str.m_impl.length());
+}
+
+int wxString::compare(size_t nStart, size_t nLen,
+ const wxString& str,
+ size_t nStart2, size_t nLen2) const
+{
+ wxASSERT(nStart <= length());
+ wxASSERT(nStart2 <= str.length());
+ size_type strLen = length() - nStart,
+ strLen2 = str.length() - nStart2;
+ nLen = strLen < nLen ? strLen : nLen;
+ nLen2 = strLen2 < nLen2 ? strLen2 : nLen2;
+
+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+ size_t pos2, len2;
+ str.PosLenToImpl(nStart2, nLen2, &pos2, &len2);
+
+ return ::wxDoCmp(m_impl.data() + pos, len,
+ str.m_impl.data() + pos2, len2);
+}
+
+int wxString::compare(const char* sz) const
+{
+ SubstrBufFromMB str(ImplStr(sz, npos));
+ if ( str.len == npos )
+ str.len = wxStringStrlen(str.data);
+ return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
+}
+
+int wxString::compare(const wchar_t* sz) const
+{
+ SubstrBufFromWC str(ImplStr(sz, npos));
+ if ( str.len == npos )
+ str.len = wxStringStrlen(str.data);
+ return ::wxDoCmp(m_impl.data(), m_impl.length(), str.data, str.len);
+}
+
+int wxString::compare(size_t nStart, size_t nLen,
+ const char* sz, size_t nCount) const
+{
+ wxASSERT(nStart <= length());
+ size_type strLen = length() - nStart;
+ nLen = strLen < nLen ? strLen : nLen;
+
+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+
+ SubstrBufFromMB str(ImplStr(sz, nCount));
+ if ( str.len == npos )
+ str.len = wxStringStrlen(str.data);
+
+ return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
+}
+
+int wxString::compare(size_t nStart, size_t nLen,
+ const wchar_t* sz, size_t nCount) const
+{
+ wxASSERT(nStart <= length());
+ size_type strLen = length() - nStart;
+ nLen = strLen < nLen ? strLen : nLen;
+
+ size_t pos, len;
+ PosLenToImpl(nStart, nLen, &pos, &len);
+
+ SubstrBufFromWC str(ImplStr(sz, nCount));
+ if ( str.len == npos )
+ str.len = wxStringStrlen(str.data);
+
+ return ::wxDoCmp(m_impl.data() + pos, len, str.data, str.len);
+}
+
+#endif // HAVE_STD_STRING_COMPARE/!HAVE_STD_STRING_COMPARE
+
+
+// ---------------------------------------------------------------------------
+// find_{first,last}_[not]_of functions
+// ---------------------------------------------------------------------------
+
+#if !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
+
+// NB: All these functions are implemented with the argument being wxChar*,
+// i.e. widechar string in any Unicode build, even though native string
+// representation is char* in the UTF-8 build. This is because we couldn't
+// use memchr() to determine if a character is in a set encoded as UTF-8.
+
+size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
+{
+ return find_first_of(sz, nStart, wxStrlen(sz));
+}
+
+size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
+{
+ return find_first_not_of(sz, nStart, wxStrlen(sz));
+}
+
+size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
+{
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
+
+ size_t idx = nStart;
+ for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
+ {
+ if ( wxTmemchr(sz, *i, n) )
+ return idx;
+ }
+
+ return npos;
+}
+
+size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
+{
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
+
+ size_t idx = nStart;
+ for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
+ {
+ if ( !wxTmemchr(sz, *i, n) )
+ return idx;
+ }
+
+ return npos;
+}
+
+
+size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
+{
+ return find_last_of(sz, nStart, wxStrlen(sz));
+}
+
+size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
+{
+ return find_last_not_of(sz, nStart, wxStrlen(sz));
+}
+
+size_t wxString::find_last_of(const wxChar* sz, size_t nStart, size_t n) const
+{
+ size_t len = length();
+
+ if ( nStart == npos )
+ {
+ nStart = len - 1;
+ }
+ else
+ {
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
+ }
+
+ size_t idx = nStart;
+ for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
+ i != rend(); --idx, ++i )
+ {
+ if ( wxTmemchr(sz, *i, n) )
+ return idx;
+ }
+
+ return npos;
+}
+
+size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const
+{
+ size_t len = length();
+
+ if ( nStart == npos )
+ {
+ nStart = len - 1;
+ }
+ else
+ {
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
+ }
+
+ size_t idx = nStart;
+ for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
+ i != rend(); --idx, ++i )
+ {
+ if ( !wxTmemchr(sz, *i, n) )
+ return idx;
+ }
+
+ return npos;
+}
+
+size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
+{
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
+
+ size_t idx = nStart;
+ for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
+ {
+ if ( *i != ch )
+ return idx;
+ }
+
+ return npos;
+}
+
+size_t wxString::find_last_not_of(wxUniChar ch, size_t nStart) const
+{
+ size_t len = length();
+
+ if ( nStart == npos )
+ {
+ nStart = len - 1;
+ }
+ else
+ {
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
+ }
+
+ size_t idx = nStart;
+ for ( const_reverse_iterator i = rbegin() + (len - nStart - 1);
+ i != rend(); --idx, ++i )
+ {
+ if ( *i != ch )
+ return idx;
+ }
+
+ return npos;
+}
+
+// the functions above were implemented for wchar_t* arguments in Unicode
+// build and char* in ANSI build; below are implementations for the other
+// version:
+#if wxUSE_UNICODE
+ #define wxOtherCharType char
+ #define STRCONV (const wxChar*)wxConvLibc.cMB2WC
+#else
+ #define wxOtherCharType wchar_t
+ #define STRCONV (const wxChar*)wxConvLibc.cWC2MB
+#endif
+
+size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart) const
+ { return find_first_of(STRCONV(sz), nStart); }
+
+size_t wxString::find_first_of(const wxOtherCharType* sz, size_t nStart,
+ size_t n) const
+ { return find_first_of(STRCONV(sz, n, NULL), nStart, n); }
+size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart) const
+ { return find_last_of(STRCONV(sz), nStart); }
+size_t wxString::find_last_of(const wxOtherCharType* sz, size_t nStart,
+ size_t n) const
+ { return find_last_of(STRCONV(sz, n, NULL), nStart, n); }
+size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart) const
+ { return find_first_not_of(STRCONV(sz), nStart); }
+size_t wxString::find_first_not_of(const wxOtherCharType* sz, size_t nStart,
+ size_t n) const
+ { return find_first_not_of(STRCONV(sz, n, NULL), nStart, n); }
+size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart) const
+ { return find_last_not_of(STRCONV(sz), nStart); }
+size_t wxString::find_last_not_of(const wxOtherCharType* sz, size_t nStart,
+ size_t n) const
+ { return find_last_not_of(STRCONV(sz, n, NULL), nStart, n); }
+
+#undef wxOtherCharType
+#undef STRCONV
+
+#endif // !wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
+
+// ===========================================================================
+// other common string functions
+// ===========================================================================
+
+int wxString::CmpNoCase(const wxString& s) const
+{
+#if !wxUSE_UNICODE_UTF8
+ // We compare NUL-delimited chunks of the strings inside the loop. We will
+ // do as many iterations as there are embedded NULs in the string, i.e.
+ // usually we will run it just once.
+
+ typedef const wxStringImpl::value_type *pchar_type;
+ const pchar_type thisBegin = m_impl.c_str();
+ const pchar_type thatBegin = s.m_impl.c_str();
+
+ const pchar_type thisEnd = thisBegin + m_impl.length();
+ const pchar_type thatEnd = thatBegin + s.m_impl.length();
+
+ pchar_type thisCur = thisBegin;
+ pchar_type thatCur = thatBegin;
+
+ int rc;
+ for ( ;; )
+ {
+ // Compare until the next NUL, if the strings differ this is the final
+ // result.
+ rc = wxStricmp(thisCur, thatCur);
+ if ( rc )
+ break;
+
+ const size_t lenChunk = wxStrlen(thisCur);
+ thisCur += lenChunk;
+ thatCur += lenChunk;
+
+ // Skip all the NULs as wxStricmp() doesn't handle them.
+ for ( ; !*thisCur; thisCur++, thatCur++ )
+ {
+ // Check if we exhausted either of the strings.
+ if ( thisCur == thisEnd )
+ {
+ // This one is exhausted, is the other one too?
+ return thatCur == thatEnd ? 0 : -1;
+ }
+
+ if ( thatCur == thatEnd )
+ {
+ // Because of the test above we know that this one is not
+ // exhausted yet so it's greater than the other one that is.
+ return 1;
+ }
+
+ if ( *thatCur )
+ {
+ // Anything non-NUL is greater than NUL.
+ return -1;
+ }
+ }
+ }
+
+ return rc;
+#else // wxUSE_UNICODE_UTF8
+ // CRT functions can't be used for case-insensitive comparison of UTF-8
+ // strings so do it in the naive, simple and inefficient way.
+
+ // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
+ const_iterator i1 = begin();
+ const_iterator end1 = end();
+ const_iterator i2 = s.begin();
+ const_iterator end2 = s.end();
+
+ for ( ; i1 != end1 && i2 != end2; ++i1, ++i2 )
+ {
+ wxUniChar lower1 = (wxChar)wxTolower(*i1);
+ wxUniChar lower2 = (wxChar)wxTolower(*i2);
+ if ( lower1 != lower2 )
+ return lower1 < lower2 ? -1 : 1;
+ }
+
+ size_t len1 = length();
+ size_t len2 = s.length();
+
+ if ( len1 < len2 )
+ return -1;
+ else if ( len1 > len2 )
+ return 1;
+ return 0;
+#endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
+}
+
+
+#if wxUSE_UNICODE
+
+#ifdef __MWERKS__
+#ifndef __SCHAR_MAX__
+#define __SCHAR_MAX__ 127
+#endif
+#endif
+
+wxString wxString::FromAscii(const char *ascii, size_t len)
+{
+ if (!ascii || len == 0)
+ return wxEmptyString;
+
+ wxString res;
+
+ {
+ wxStringInternalBuffer buf(res, len);
+ wxStringCharType *dest = buf;
+
+ for ( ; len > 0; --len )
+ {
+ unsigned char c = (unsigned char)*ascii++;
+ wxASSERT_MSG( c < 0x80,
+ wxT("Non-ASCII value passed to FromAscii().") );
+
+ *dest++ = (wchar_t)c;
+ }
+ }
+
+ return res;
+}
+
+wxString wxString::FromAscii(const char *ascii)
+{
+ return FromAscii(ascii, wxStrlen(ascii));
+}
+
+wxString wxString::FromAscii(char ascii)
+{
+ // What do we do with '\0' ?
+
+ unsigned char c = (unsigned char)ascii;
+
+ wxASSERT_MSG( c < 0x80, wxT("Non-ASCII value passed to FromAscii().") );
+
+ // NB: the cast to wchar_t causes interpretation of 'ascii' as Latin1 value
+ return wxString(wxUniChar((wchar_t)c));
+}
+
+const wxScopedCharBuffer wxString::ToAscii() const
+{
+ // this will allocate enough space for the terminating NUL too
+ wxCharBuffer buffer(length());
+ char *dest = buffer.data();
+
+ for ( const_iterator i = begin(); i != end(); ++i )
+ {
+ wxUniChar c(*i);
+ // FIXME-UTF8: unify substituted char ('_') with wxUniChar ('?')
+ *dest++ = c.IsAscii() ? (char)c : '_';
+
+ // the output string can't have embedded NULs anyhow, so we can safely
+ // stop at first of them even if we do have any
+ if ( !c )
+ break;
+ }
+
+ return buffer;
+}
+
+#endif // wxUSE_UNICODE
+
+// extract string of length nCount starting at nFirst
+wxString wxString::Mid(size_t nFirst, size_t nCount) const
+{
+ size_t nLen = length();
+
+ // default value of nCount is npos and means "till the end"
+ if ( nCount == npos )
+ {
+ nCount = nLen - nFirst;
+ }
+
+ // out-of-bounds requests return sensible things
+ if ( nFirst + nCount > nLen )
+ {
+ nCount = nLen - nFirst;
+ }
+
+ if ( nFirst > nLen )
+ {
+ // AllocCopy() will return empty string
+ return wxEmptyString;
+ }
+
+ wxString dest(*this, nFirst, nCount);
+ if ( dest.length() != nCount )
+ {
+ wxFAIL_MSG( wxT("out of memory in wxString::Mid") );
+ }
+
+ return dest;
+}
+
+// check that the string starts with prefix and return the rest of the string
+// in the provided pointer if it is not NULL, otherwise return false
+bool wxString::StartsWith(const wxString& prefix, wxString *rest) const
+{
+ if ( compare(0, prefix.length(), prefix) != 0 )
+ return false;
+
+ if ( rest )
+ {
+ // put the rest of the string into provided pointer
+ rest->assign(*this, prefix.length(), npos);
+ }
+
+ return true;
+}
+
+
+// check that the string ends with suffix and return the rest of it in the
+// provided pointer if it is not NULL, otherwise return false
+bool wxString::EndsWith(const wxString& suffix, wxString *rest) const
+{
+ int start = length() - suffix.length();
+
+ if ( start < 0 || compare(start, npos, suffix) != 0 )
+ return false;
+
+ if ( rest )
+ {
+ // put the rest of the string into provided pointer
+ rest->assign(*this, 0, start);
+ }
+
+ return true;
+}
+
+
+// extract nCount last (rightmost) characters
+wxString wxString::Right(size_t nCount) const
+{
+ if ( nCount > length() )
+ nCount = length();
+
+ wxString dest(*this, length() - nCount, nCount);
+ if ( dest.length() != nCount ) {
+ wxFAIL_MSG( wxT("out of memory in wxString::Right") );
+ }
+ return dest;
+}
+
+// get all characters after the last occurrence of ch
+// (returns the whole string if ch not found)
+wxString wxString::AfterLast(wxUniChar ch) const
+{
+ wxString str;
+ int iPos = Find(ch, true);
+ if ( iPos == wxNOT_FOUND )
+ str = *this;
+ else
+ str.assign(*this, iPos + 1, npos);
projects / wxWidgets.git / blobdiff