#ifndef WX_PRECOMP
#include "wx/string.h"
#include "wx/wxcrtvararg.h"
+ #include "wx/log.h"
#endif
#include <ctype.h>
#include "wx/vector.h"
#include "wx/xlocale.h"
+#ifdef __WXMSW__
+ #include "wx/msw/wrapwin.h"
+#endif // __WXMSW__
+
// string handling functions used by wxString:
#if wxUSE_UNICODE_UTF8
#define wxStringMemcpy memcpy
}
#endif
-#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
-const char* wxCStrData::AsChar() const
-{
-#if wxUSE_UNICODE_UTF8
- if ( wxLocaleIsUtf8 )
- return AsInternal();
-#endif
- // under non-UTF8 locales, we have to convert the internal UTF-8
- // representation using wxConvLibc and cache the result
-
- wxString *str = wxConstCast(m_str, wxString);
-
- // convert the string:
- //
- // FIXME-UTF8: we'd like to do the conversion in the existing buffer (if we
- // have it) but it's unfortunately not obvious to implement
- // because we don't know how big buffer do we need for the
- // given string length (in case of multibyte encodings, e.g.
- // ISO-2022-JP or UTF-8 when internal representation is wchar_t)
- //
- // One idea would be to store more than just m_convertedToChar
- // in wxString: then we could record the length of the string
- // which was converted the last time and try to reuse the same
- // buffer if the current length is not greater than it (this
- // could still fail because string could have been modified in
- // place but it would work most of the time, so we'd do it and
- // only allocate the new buffer if in-place conversion returned
- // an error). We could also store a bit saying if the string
- // was modified since the last conversion (and update it in all
- // operation modifying the string, of course) to avoid unneeded
- // consequential conversions. But both of these ideas require
- // adding more fields to wxString and require profiling results
- // to be sure that we really gain enough from them to justify
- // doing it.
- wxScopedCharBuffer buf(str->mb_str());
-
- // if it failed, return empty string and not NULL to avoid crashes in code
- // written with either wxWidgets 2 wxString or std::string behaviour in
- // mind: neither of them ever returns NULL and so we shouldn't neither
- if ( !buf )
- return "";
-
- if ( str->m_convertedToChar &&
- strlen(buf) == strlen(str->m_convertedToChar) )
- {
- // keep the same buffer for as long as possible, so that several calls
- // to c_str() in a row still work:
- strcpy(str->m_convertedToChar, buf);
- }
- else
- {
- str->m_convertedToChar = buf.release();
- }
-
- // and keep it:
- return str->m_convertedToChar + m_offset;
-}
-#endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
-
-#if !wxUSE_UNICODE_WCHAR
-const wchar_t* wxCStrData::AsWChar() const
-{
- wxString *str = wxConstCast(m_str, wxString);
-
- // convert the string:
- wxScopedWCharBuffer buf(str->wc_str());
-
- // notice that here, unlike above in AsChar(), conversion can't fail as our
- // internal UTF-8 is always well-formed -- or the string was corrupted and
- // all bets are off anyhow
-
- // FIXME-UTF8: do the conversion in-place in the existing buffer
- if ( str->m_convertedToWChar &&
- wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
- {
- // keep the same buffer for as long as possible, so that several calls
- // to c_str() in a row still work:
- memcpy(str->m_convertedToWChar, buf, sizeof(wchar_t) * wxWcslen(buf));
- }
- else
- {
- str->m_convertedToWChar = buf.release();
- }
-
- // and keep it:
- return str->m_convertedToWChar + m_offset;
-}
-#endif // !wxUSE_UNICODE_WCHAR
-
// ===========================================================================
// wxString class core
// ===========================================================================
// and then to UTF-8:
SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
// widechar -> UTF-8 conversion isn't supposed to ever fail:
- wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
+ wxASSERT_MSG( buf.data, wxT("conversion to UTF-8 failed") );
return buf;
}
}
#endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
+// This std::string::c_str()-like method returns a wide char pointer to string
+// contents. In wxUSE_UNICODE_WCHAR case it is trivial as it can simply return
+// a pointer to the internal representation. Otherwise a conversion is required
+// and it returns a temporary buffer.
+//
+// However for compatibility with c_str() and to avoid breaking existing code
+// doing
+//
+// for ( const wchar_t *p = s.wc_str(); *p; p++ )
+// ... use *p...
+//
+// we actually need to ensure that the returned buffer is _not_ temporary and
+// so we use wxString::m_convertedToWChar to store the returned data
+#if !wxUSE_UNICODE_WCHAR
-#if wxUSE_UNICODE_WCHAR
-
-//Convert wxString in Unicode mode to a multi-byte string
-const wxScopedCharBuffer wxString::mb_str(const wxMBConv& conv) const
+const wchar_t *wxString::AsWChar(const wxMBConv& conv) const
{
- // NB: Length passed to cWC2MB() doesn't include terminating NUL, it's
- // added by it automatically. If we passed length()+1 here, it would
- // create a buffer with 2 trailing NULs of length one greater than
- // expected.
- return conv.cWC2MB(wx_str(), length(), NULL);
-}
+ const char * const strMB = m_impl.c_str();
+ const size_t lenMB = m_impl.length();
-#elif wxUSE_UNICODE_UTF8
+ // find out the size of the buffer needed
+ const size_t lenWC = conv.ToWChar(NULL, 0, strMB, lenMB);
+ if ( lenWC == wxCONV_FAILED )
+ return NULL;
-const wxScopedWCharBuffer wxString::wc_str() const
-{
- // NB: Length passed to cMB2WC() doesn't include terminating NUL, it's
- // added by it automatically. If we passed length()+1 here, it would
- // create a buffer with 2 trailing NULs of length one greater than
- // expected.
- return wxMBConvStrictUTF8().cMB2WC
- (
- m_impl.c_str(),
- m_impl.length(),
- NULL
- );
+ // keep the same buffer if the string size didn't change: this is not only
+ // an optimization but also ensure that code which modifies string
+ // character by character (without changing its length) can continue to use
+ // the pointer returned by a previous wc_str() call even after changing the
+ // string
+
+ // TODO-UTF8: we could check for ">" instead of "!=" here as this would
+ // allow to save on buffer reallocations but at the cost of
+ // consuming (even) more memory, we should benchmark this to
+ // determine if it's worth doing
+ if ( !m_convertedToWChar.m_str || lenWC != m_convertedToWChar.m_len )
+ {
+ if ( !const_cast<wxString *>(this)->m_convertedToWChar.Extend(lenWC) )
+ return NULL;
+ }
+
+ // finally do convert
+ m_convertedToWChar.m_str[lenWC] = L'\0';
+ if ( conv.ToWChar(m_convertedToWChar.m_str, lenWC,
+ strMB, lenMB) == wxCONV_FAILED )
+ return NULL;
+
+ return m_convertedToWChar.m_str;
}
-const wxScopedCharBuffer wxString::mb_str(const wxMBConv& conv) const
+#endif // !wxUSE_UNICODE_WCHAR
+
+
+// Same thing for mb_str() which returns a normal char pointer to string
+// contents: this always requires converting it to the specified encoding in
+// non-ANSI build except if we need to convert to UTF-8 and this is what we
+// already use internally.
+#if wxUSE_UNICODE
+
+const char *wxString::AsChar(const wxMBConv& conv) const
{
+#if wxUSE_UNICODE_UTF8
if ( conv.IsUTF8() )
- return wxScopedCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length());
+ return m_impl.c_str();
- wxScopedWCharBuffer wcBuf(wc_str());
- if ( !wcBuf.length() )
- return wxCharBuffer("");
+ const wchar_t * const strWC = AsWChar(wxMBConvStrictUTF8());
+ const size_t lenWC = m_convertedToWChar.m_len;
+#else // wxUSE_UNICODE_WCHAR
+ const wchar_t * const strWC = m_impl.c_str();
+ const size_t lenWC = m_impl.length();
+#endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
- return conv.cWC2MB(wcBuf.data(), wcBuf.length(), NULL);
-}
+ const size_t lenMB = conv.FromWChar(NULL, 0, strWC, lenWC);
+ if ( lenMB == wxCONV_FAILED )
+ return NULL;
-#else // ANSI
+ if ( !m_convertedToChar.m_str || lenMB != m_convertedToChar.m_len )
+ {
+ if ( !const_cast<wxString *>(this)->m_convertedToChar.Extend(lenMB) )
+ return NULL;
+ }
-//Converts this string to a wide character string if unicode
-//mode is not enabled and wxUSE_WCHAR_T is enabled
-const wxScopedWCharBuffer wxString::wc_str(const wxMBConv& conv) const
-{
- // NB: Length passed to cMB2WC() doesn't include terminating NUL, it's
- // added by it automatically. If we passed length()+1 here, it would
- // create a buffer with 2 trailing NULs of length one greater than
- // expected.
- return conv.cMB2WC(wx_str(), length(), NULL);
+ m_convertedToChar.m_str[lenMB] = '\0';
+ if ( conv.FromWChar(m_convertedToChar.m_str, lenMB,
+ strWC, lenWC) == wxCONV_FAILED )
+ return NULL;
+
+ return m_convertedToChar.m_str;
}
-#endif // Unicode/ANSI
+#endif // wxUSE_UNICODE
// shrink to minimal size (releasing extra memory)
bool wxString::Shrink()
wxString s;
if ( !s.Alloc(strlen(psz) + str.length()) ) {
- wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+ wxFAIL_MSG( wxT("out of memory in wxString::operator+") );
}
s += str;
s += psz;
wxString s;
if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
- wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+ wxFAIL_MSG( wxT("out of memory in wxString::operator+") );
}
s += str;
s += pwz;
wxString s;
if ( !s.Alloc(strlen(psz) + str.length()) ) {
- wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+ wxFAIL_MSG( wxT("out of memory in wxString::operator+") );
}
s = psz;
s += str;
wxString s;
if ( !s.Alloc(wxWcslen(pwz) + str.length()) ) {
- wxFAIL_MSG( _T("out of memory in wxString::operator+") );
+ wxFAIL_MSG( wxT("out of memory in wxString::operator+") );
}
s = pwz;
s += str;
size_t wxString::find_first_of(const wxChar* sz, size_t nStart, size_t n) const
{
- wxASSERT_MSG( nStart <= length(), _T("invalid index") );
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
size_t idx = nStart;
for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const
{
- wxASSERT_MSG( nStart <= length(), _T("invalid index") );
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
size_t idx = nStart;
for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
}
else
{
- wxASSERT_MSG( nStart <= len, _T("invalid index") );
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
}
size_t idx = nStart;
}
else
{
- wxASSERT_MSG( nStart <= len, _T("invalid index") );
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
}
size_t idx = nStart;
size_t wxString::find_first_not_of(wxUniChar ch, size_t nStart) const
{
- wxASSERT_MSG( nStart <= length(), _T("invalid index") );
+ wxASSERT_MSG( nStart <= length(), wxT("invalid index") );
size_t idx = nStart;
for ( const_iterator i = begin() + nStart; i != end(); ++idx, ++i )
}
else
{
- wxASSERT_MSG( nStart <= len, _T("invalid index") );
+ wxASSERT_MSG( nStart <= len, wxT("invalid index") );
}
size_t idx = nStart;
int wxString::CmpNoCase(const wxString& s) const
{
-#if wxUSE_UNICODE_UTF8
- // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
+#if defined(__WXMSW__) && !wxUSE_UNICODE_UTF8
+ // prefer to use CompareString() if available as it's more efficient than
+ // doing it manual or even using wxStricmp() (see #10375)
+ switch ( ::CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE,
+ m_impl.c_str(), m_impl.length(),
+ s.m_impl.c_str(), s.m_impl.length()) )
+ {
+ case CSTR_LESS_THAN:
+ return -1;
+
+ case CSTR_EQUAL:
+ return 0;
+
+ case CSTR_GREATER_THAN:
+ return 1;
+
+ default:
+ wxFAIL_MSG( "unexpected CompareString() return value" );
+ // fall through
+ case 0:
+ wxLogLastError("CompareString");
+ // use generic code below
+ }
+#endif // __WXMSW__ && !wxUSE_UNICODE_UTF8
+
+ // do the comparison manually: notice that we can't use wxStricmp() as it
+ // doesn't handle embedded NULs
+
+ // FIXME-UTF8: use wxUniChar::ToLower/ToUpper once added
const_iterator i1 = begin();
const_iterator end1 = end();
const_iterator i2 = s.begin();
else if ( len1 > len2 )
return 1;
return 0;
-#else // wxUSE_UNICODE_WCHAR or ANSI
- return wxStricmp(m_impl.c_str(), s.m_impl.c_str());
-#endif
}
{
unsigned char c = (unsigned char)*ascii++;
wxASSERT_MSG( c < 0x80,
- _T("Non-ASCII value passed to FromAscii().") );
+ wxT("Non-ASCII value passed to FromAscii().") );
*dest++ = (wchar_t)c;
}
unsigned char c = (unsigned char)ascii;
- wxASSERT_MSG( c < 0x80, _T("Non-ASCII value passed to FromAscii().") );
+ 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));
wxString dest(*this, nFirst, nCount);
if ( dest.length() != nCount )
{
- wxFAIL_MSG( _T("out of memory in wxString::Mid") );
+ wxFAIL_MSG( wxT("out of memory in wxString::Mid") );
}
return dest;
wxString dest(*this, length() - nCount, nCount);
if ( dest.length() != nCount ) {
- wxFAIL_MSG( _T("out of memory in wxString::Right") );
+ wxFAIL_MSG( wxT("out of memory in wxString::Right") );
}
return dest;
}
wxString dest(*this, 0, nCount);
if ( dest.length() != nCount ) {
- wxFAIL_MSG( _T("out of memory in wxString::Left") );
+ wxFAIL_MSG( wxT("out of memory in wxString::Left") );
}
return dest;
}
{
// if we tried to replace an empty string we'd enter an infinite loop below
wxCHECK_MSG( !strOld.empty(), 0,
- _T("wxString::Replace(): invalid parameter") );
+ wxT("wxString::Replace(): invalid parameter") );
wxSTRING_INVALIDATE_CACHE();
const_iterator i = begin();
- if ( *i == _T('-') || *i == _T('+') )
+ if ( *i == wxT('-') || *i == wxT('+') )
++i;
for ( ; i != end(); ++i )
#endif
#define WX_STRING_TO_X_TYPE_START \
- wxCHECK_MSG( pVal, false, _T("NULL output pointer") ); \
+ wxCHECK_MSG( pVal, false, wxT("NULL output pointer") ); \
DO_IF_NOT_WINCE( errno = 0; ) \
const wxStringCharType *start = wx_str(); \
wxStringCharType *end;
+// notice that we return false without modifying the output parameter at all if
+// nothing could be parsed but we do modify it and return false then if we did
+// parse something successfully but not the entire string
#define WX_STRING_TO_X_TYPE_END \
- /* return true only if scan was stopped by the terminating NUL and */ \
- /* if the string was not empty to start with and no under/overflow */ \
- /* occurred: */ \
- if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) ) \
+ if ( end == start DO_IF_NOT_WINCE(|| errno == ERANGE) ) \
return false; \
*pVal = val; \
- return true;
+ return !*end;
bool wxString::ToLong(long *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
long val = wxStrtol(start, &end, base);
bool wxString::ToULong(unsigned long *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
unsigned long val = wxStrtoul(start, &end, base);
bool wxString::ToLongLong(wxLongLong_t *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
wxLongLong_t val = wxStrtoll(start, &end, base);
bool wxString::ToULongLong(wxULongLong_t *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
wxULongLong_t val = wxStrtoull(start, &end, base);
bool wxString::ToCLong(long *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
-#if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
+#if (wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE) && defined(wxHAS_XLOCALE_SUPPORT)
long val = wxStrtol_lA(start, &end, base, wxCLocale);
#else
long val = wxStrtol_l(start, &end, base, wxCLocale);
bool wxString::ToCULong(unsigned long *pVal, int base) const
{
- wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+ wxASSERT_MSG( !base || (base > 1 && base <= 36), wxT("invalid base") );
WX_STRING_TO_X_TYPE_START
-#if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
+#if (wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE) && defined(wxHAS_XLOCALE_SUPPORT)
unsigned long val = wxStrtoul_lA(start, &end, base, wxCLocale);
#else
unsigned long val = wxStrtoul_l(start, &end, base, wxCLocale);
bool wxString::ToCDouble(double *pVal) const
{
WX_STRING_TO_X_TYPE_START
-#if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE
+#if (wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE) && defined(wxHAS_XLOCALE_SUPPORT)
double val = wxStrtod_lA(start, &end, wxCLocale);
#else
double val = wxStrtod_l(start, &end, wxCLocale);
// always do it manually
// FIXME: This really seems to be the wrong and would be an off-by-one
// bug except the code above allocates an extra character.
- buf[size] = _T('\0');
+ buf[size] = wxT('\0');
// vsnprintf() may return either -1 (traditional Unix behaviour) or the
// total number of characters which would have been written if the
wxString pattern;
pattern.reserve(wxStrlen(pszMask));
- pattern += _T('^');
+ pattern += wxT('^');
while ( *pszMask )
{
switch ( *pszMask )
{
- case _T('?'):
- pattern += _T('.');
+ case wxT('?'):
+ pattern += wxT('.');
break;
- case _T('*'):
- pattern += _T(".*");
+ case wxT('*'):
+ pattern += wxT(".*");
break;
- case _T('^'):
- case _T('.'):
- case _T('$'):
- case _T('('):
- case _T(')'):
- case _T('|'):
- case _T('+'):
- case _T('\\'):
+ case wxT('^'):
+ case wxT('.'):
+ case wxT('$'):
+ case wxT('('):
+ case wxT(')'):
+ case wxT('|'):
+ case wxT('+'):
+ case wxT('\\'):
// these characters are special in a RE, quote them
// (however note that we don't quote '[' and ']' to allow
// using them for Unix shell like matching)
- pattern += _T('\\');
+ pattern += wxT('\\');
// fall through
default:
pszMask++;
}
- pattern += _T('$');
+ pattern += wxT('$');
// and now use it
return wxRegEx(pattern, wxRE_NOSUB | wxRE_EXTENDED).Matches(c_str());
projects / wxWidgets.git / blobdiff