X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/11aac4baa6172481674b017e8529ad7ef18758fd..1c0338c5615c351371f704b326634f58d0bf7da9:/src/common/string.cpp diff --git a/src/common/string.cpp b/src/common/string.cpp index 410039b0bc..d36f85bd5a 100644 --- a/src/common/string.cpp +++ b/src/common/string.cpp @@ -10,13 +10,6 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -/* - * About ref counting: - * 1) all empty strings use g_strEmpty, nRefs = -1 (set in Init()) - * 2) AllocBuffer() sets nRefs to 1, Lock() increments it by one - * 3) Unlock() decrements nRefs and frees memory if it goes to 0 - */ - // =========================================================================== // headers, declarations, constants // =========================================================================== @@ -30,6 +23,7 @@ #ifndef WX_PRECOMP #include "wx/string.h" + #include "wx/wxcrtvararg.h" #endif #include @@ -45,7 +39,7 @@ #include #endif -#include +#include "wx/hashmap.h" // string handling functions used by wxString: #if wxUSE_UNICODE_UTF8 @@ -80,9 +74,9 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str) { // FIXME-UTF8: always, not only if wxUSE_UNICODE #if wxUSE_UNICODE && !defined(__BORLANDC__) - return os << str.AsWChar(); + return os << (const wchar_t*)str.AsWCharBuf(); #else - return os << str.AsChar(); + return os << (const char*)str.AsCharBuf(); #endif } @@ -105,10 +99,47 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str) #endif // wxUSE_STD_IOSTREAM +// =========================================================================== +// wxString class core +// =========================================================================== + +#if wxUSE_UNICODE_UTF8 + +void wxString::PosLenToImpl(size_t pos, size_t len, + size_t *implPos, size_t *implLen) const +{ + if ( pos == npos ) + *implPos = npos; + else + { + const_iterator i = begin() + pos; + *implPos = wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); + if ( len == npos ) + *implLen = npos; + else + { + // too large length is interpreted as "to the end of the string" + // FIXME-UTF8: verify this is the case in std::string, assert + // otherwise + if ( pos + len > length() ) + len = length() - pos; + + *implLen = (i + len).impl() - i.impl(); + } + } +} + +#endif // wxUSE_UNICODE_UTF8 + // ---------------------------------------------------------------------------- // wxCStrData converted strings caching // ---------------------------------------------------------------------------- +// FIXME-UTF8: temporarily disabled because it doesn't work with global +// string objects; re-enable after fixing this bug and benchmarking +// performance to see if using a hash is a good idea at all +#if 0 + // For backward compatibility reasons, it must be possible to assign the value // returned by wxString::c_str() to a char* or wchar_t* variable and work with // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick, @@ -131,7 +162,7 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str) template static inline void DeleteStringFromConversionCache(T& hash, const wxString *s) { - typename T::iterator i = hash.find(s); + typename T::iterator i = hash.find(wxConstCast(s, wxString)); if ( i != hash.end() ) { free(i->second); @@ -140,6 +171,8 @@ static inline void DeleteStringFromConversionCache(T& hash, const wxString *s) } #if wxUSE_UNICODE +// NB: non-STL implementation doesn't compile with "const wxString*" key type, +// so we have to use wxString* here and const-cast when used WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual, wxStringCharConversionCache); static wxStringCharConversionCache gs_stringsCharCache; @@ -150,7 +183,8 @@ const char* wxCStrData::AsChar() const DeleteStringFromConversionCache(gs_stringsCharCache, m_str); // convert the string and keep it: - const char *s = gs_stringsCharCache[m_str] = m_str->mb_str().release(); + const char *s = gs_stringsCharCache[wxConstCast(m_str, wxString)] = + m_str->mb_str().release(); return s + m_offset; } @@ -167,20 +201,13 @@ const wchar_t* wxCStrData::AsWChar() const DeleteStringFromConversionCache(gs_stringsWCharCache, m_str); // convert the string and keep it: - const wchar_t *s = gs_stringsWCharCache[m_str] = m_str->wc_str().release(); + const wchar_t *s = gs_stringsWCharCache[wxConstCast(m_str, wxString)] = + m_str->wc_str().release(); return s + m_offset; } #endif // !wxUSE_UNICODE_WCHAR -// =========================================================================== -// wxString class core -// =========================================================================== - -// --------------------------------------------------------------------------- -// construction and conversion -// --------------------------------------------------------------------------- - wxString::~wxString() { #if wxUSE_UNICODE @@ -191,15 +218,83 @@ wxString::~wxString() DeleteStringFromConversionCache(gs_stringsWCharCache, this); #endif } +#endif -#if wxUSE_UNICODE +#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: + wxCharBuffer buf(str->mb_str()); + + // FIXME-UTF8: do the conversion in-place in the existing buffer + 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: + wxWCharBuffer buf(str->wc_str()); + + // 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 +// =========================================================================== + +// --------------------------------------------------------------------------- +// construction and conversion +// --------------------------------------------------------------------------- + +#if wxUSE_UNICODE_WCHAR /* static */ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength, const wxMBConv& conv) { // anything to do? if ( !psz || nLength == 0 ) - return SubstrBufFromMB(); + return SubstrBufFromMB(L"", 0); if ( nLength == npos ) nLength = wxNO_LEN; @@ -207,18 +302,60 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength, size_t wcLen; wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen)); if ( !wcLen ) - return SubstrBufFromMB(); + return SubstrBufFromMB(_T(""), 0); else return SubstrBufFromMB(wcBuf, wcLen); } -#else +#endif // wxUSE_UNICODE_WCHAR + +#if wxUSE_UNICODE_UTF8 +/* static */ +wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength, + const wxMBConv& conv) +{ + // anything to do? + if ( !psz || nLength == 0 ) + return SubstrBufFromMB("", 0); + + // if psz is already in UTF-8, we don't have to do the roundtrip to + // wchar_t* and back: + if ( conv.IsUTF8() ) + { + // we need to validate the input because UTF8 iterators assume valid + // UTF-8 sequence and psz may be invalid: + if ( wxStringOperations::IsValidUtf8String(psz, nLength) ) + { + return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength); + } + // else: do the roundtrip through wchar_t* + } + + if ( nLength == npos ) + nLength = wxNO_LEN; + + // first convert to wide string: + size_t wcLen; + wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen)); + if ( !wcLen ) + return SubstrBufFromMB("", 0); + + // 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") ); + + return buf; +} +#endif // wxUSE_UNICODE_UTF8 + +#if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE /* static */ wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength, const wxMBConv& conv) { // anything to do? if ( !pwz || nLength == 0 ) - return SubstrBufFromWC(); + return SubstrBufFromWC("", 0); if ( nLength == npos ) nLength = wxNO_LEN; @@ -226,34 +363,62 @@ wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLengt size_t mbLen; wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen)); if ( !mbLen ) - return SubstrBufFromWC(); + return SubstrBufFromWC("", 0); else return SubstrBufFromWC(mbBuf, mbLen); } -#endif +#endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE -#if wxUSE_UNICODE +#if wxUSE_UNICODE_WCHAR //Convert wxString in Unicode mode to a multi-byte string const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const { - return conv.cWC2MB(c_str(), length() + 1 /* size, not length */, NULL); + return conv.cWC2MB(wx_str(), length() + 1 /* size, not length */, NULL); } -#else // ANSI +#elif wxUSE_UNICODE_UTF8 + +const wxWCharBuffer wxString::wc_str() const +{ + return wxMBConvStrictUTF8().cMB2WC + ( + m_impl.c_str(), + m_impl.length() + 1, // size, not length + NULL + ); +} + +const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const +{ + if ( conv.IsUTF8() ) + return wxCharBuffer::CreateNonOwned(m_impl.c_str()); -#if wxUSE_WCHAR_T + // FIXME-UTF8: use wc_str() here once we have buffers with length + + size_t wcLen; + wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC + ( + m_impl.c_str(), + m_impl.length() + 1, // size + &wcLen + )); + if ( !wcLen ) + return wxCharBuffer(""); + + return conv.cWC2MB(wcBuf, wcLen, NULL); +} + +#else // ANSI //Converts this string to a wide character string if unicode //mode is not enabled and wxUSE_WCHAR_T is enabled const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const { - return conv.cMB2WC(c_str(), length() + 1 /* size, not length */, NULL); + return conv.cMB2WC(wx_str(), length() + 1 /* size, not length */, NULL); } -#endif // wxUSE_WCHAR_T - #endif // Unicode/ANSI // shrink to minimal size (releasing extra memory) @@ -266,7 +431,7 @@ bool wxString::Shrink() // deprecated compatibility code: #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 -wxChar *wxString::GetWriteBuf(size_t nLen) +wxStringCharType *wxString::GetWriteBuf(size_t nLen) { return DoGetWriteBuf(nLen); } @@ -405,6 +570,12 @@ wxString operator+(const wchar_t *pwz, const wxString& str) // string comparison // --------------------------------------------------------------------------- +bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const +{ + return (length() == 1) && (compareWithCase ? GetChar(0u) == c + : wxToupper(GetChar(0u)) == wxToupper(c)); +} + #ifdef HAVE_STD_STRING_COMPARE // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with @@ -807,63 +978,69 @@ int wxString::CmpNoCase(const wxString& s) const #endif #endif -wxString wxString::FromAscii(const char *ascii) +wxString wxString::FromAscii(const char *ascii, size_t len) { - if (!ascii) + if (!ascii || len == 0) return wxEmptyString; - size_t len = strlen( ascii ); wxString res; - if ( len ) { - wxStringBuffer buf(res, len); - - wchar_t *dest = buf; + wxImplStringBuffer buf(res, len); + wxStringCharType *dest = buf; - for ( ;; ) + for ( ; len > 0; --len ) { - if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' ) - break; + unsigned char c = (unsigned char)*ascii++; + wxASSERT_MSG( c < 0x80, + _T("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(const char ascii) { // What do we do with '\0' ? - wxString res; - res += (wchar_t)(unsigned char) ascii; + unsigned char c = (unsigned char)ascii; - return res; + wxASSERT_MSG( c < 0x80, _T("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 wxCharBuffer wxString::ToAscii() const { // this will allocate enough space for the terminating NUL too wxCharBuffer buffer(length()); - - char *dest = buffer.data(); - const wchar_t *pwc = c_str(); - for ( ;; ) + for ( const_iterator i = begin(); i != end(); ++i ) { - *dest++ = (char)(*pwc > SCHAR_MAX ? wxT('_') : *pwc); + 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 ( !*pwc++ ) + if ( !c ) break; } return buffer; } -#endif // Unicode +#endif // wxUSE_UNICODE // extract string of length nCount starting at nFirst wxString wxString::Mid(size_t nFirst, size_t nCount) const @@ -899,28 +1076,15 @@ wxString wxString::Mid(size_t nFirst, size_t nCount) const // 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 wxChar *prefix, wxString *rest) const +bool wxString::StartsWith(const wxString& prefix, wxString *rest) const { - wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") ); - - // first check if the beginning of the string matches the prefix: note - // that we don't have to check that we don't run out of this string as - // when we reach the terminating NUL, either prefix string ends too (and - // then it's ok) or we break out of the loop because there is no match - const wxChar *p = c_str(); - while ( *prefix ) - { - if ( *prefix++ != *p++ ) - { - // no match - return false; - } - } + if ( compare(0, prefix.length(), prefix) != 0 ) + return false; if ( rest ) { // put the rest of the string into provided pointer - *rest = p; + rest->assign(*this, prefix.length(), npos); } return true; @@ -929,12 +1093,11 @@ bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const // 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 wxChar *suffix, wxString *rest) const +bool wxString::EndsWith(const wxString& suffix, wxString *rest) const { - wxASSERT_MSG( suffix, _T("invalid parameter in wxString::EndssWith") ); + int start = length() - suffix.length(); - int start = length() - wxStrlen(suffix); - if ( start < 0 || wxStrcmp(wx_str() + start, suffix) != 0 ) + if ( start < 0 || compare(start, npos, suffix) != 0 ) return false; if ( rest ) @@ -1065,34 +1228,43 @@ size_t wxString::Replace(const wxString& strOld, bool wxString::IsAscii() const { - const wxChar *s = (const wxChar*) *this; - while(*s){ - if(!isascii(*s)) return(false); - s++; - } - return(true); + for ( const_iterator i = begin(); i != end(); ++i ) + { + if ( !(*i).IsAscii() ) + return false; + } + + return true; } bool wxString::IsWord() const { - const wxChar *s = (const wxChar*) *this; - while(*s){ - if(!wxIsalpha(*s)) return(false); - s++; - } - return(true); + for ( const_iterator i = begin(); i != end(); ++i ) + { + if ( !wxIsalpha(*i) ) + return false; + } + + return true; } bool wxString::IsNumber() const { - const wxChar *s = (const wxChar*) *this; - if (wxStrlen(s)) - if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++; - while(*s){ - if(!wxIsdigit(*s)) return(false); - s++; - } - return(true); + if ( empty() ) + return true; + + const_iterator i = begin(); + + if ( *i == _T('-') || *i == _T('+') ) + ++i; + + for ( ; i != end(); ++i ) + { + if ( !wxIsdigit(*i) ) + return false; + } + + return true; } wxString wxString::Strip(stripType w) const @@ -1215,14 +1387,15 @@ int wxString::Find(wxUniChar ch, bool bFromEnd) const // conversion to numbers // ---------------------------------------------------------------------------- -// the implementation of all the functions below is exactly the same so factor -// it out +// The implementation of all the functions below is exactly the same so factor +// it out. Note that number extraction works correctly on UTF-8 strings, so +// we can use wxStringCharType and wx_str() for maximum efficiency. -template -bool wxStringToIntType(const wxChar *start, +template +bool wxStringToIntType(const wxStringCharType *start, T *val, int base, - F func) + T (*func)(const wxStringCharType*, wxStringCharType**, int)) { wxCHECK_MSG( val, false, _T("NULL output pointer") ); wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") ); @@ -1231,7 +1404,7 @@ bool wxStringToIntType(const wxChar *start, errno = 0; #endif - wxChar *end; + wxStringCharType *end; *val = (*func)(start, &end, base); // return true only if scan was stopped by the terminating NUL and if the @@ -1245,36 +1418,22 @@ bool wxStringToIntType(const wxChar *start, bool wxString::ToLong(long *val, int base) const { - return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtol); + return wxStringToIntType(wx_str(), val, base, wxStrtol); } bool wxString::ToULong(unsigned long *val, int base) const { - return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoul); + return wxStringToIntType(wx_str(), val, base, wxStrtoul); } bool wxString::ToLongLong(wxLongLong_t *val, int base) const { -#ifdef wxHAS_STRTOLL - return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll); -#else - // TODO: implement this ourselves - wxUnusedVar(val); - wxUnusedVar(base); - return false; -#endif // wxHAS_STRTOLL + return wxStringToIntType(wx_str(), val, base, wxStrtoll); } bool wxString::ToULongLong(wxULongLong_t *val, int base) const { -#ifdef wxHAS_STRTOLL - return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull); -#else - // TODO: implement this ourselves - wxUnusedVar(val); - wxUnusedVar(base); - return false; -#endif + return wxStringToIntType(wx_str(), val, base, wxStrtoull); } bool wxString::ToDouble(double *val) const @@ -1302,11 +1461,12 @@ bool wxString::ToDouble(double *val) const // formatted output // --------------------------------------------------------------------------- +#if !wxUSE_UTF8_LOCALE_ONLY /* static */ #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN -wxString wxStringPrintfMixinBase::DoFormat(const wxChar *format, ...) +wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...) #else -wxString wxString::DoFormat(const wxChar *format, ...) +wxString wxString::DoFormatWchar(const wxChar *format, ...) #endif { va_list argptr; @@ -1319,6 +1479,23 @@ wxString wxString::DoFormat(const wxChar *format, ...) return s; } +#endif // !wxUSE_UTF8_LOCALE_ONLY + +#if wxUSE_UNICODE_UTF8 +/* static */ +wxString wxString::DoFormatUtf8(const char *format, ...) +{ + va_list argptr; + va_start(argptr, format); + + wxString s; + s.PrintfV(format, argptr); + + va_end(argptr); + + return s; +} +#endif // wxUSE_UNICODE_UTF8 /* static */ wxString wxString::FormatV(const wxString& format, va_list argptr) @@ -1328,10 +1505,11 @@ wxString wxString::FormatV(const wxString& format, va_list argptr) return s; } +#if !wxUSE_UTF8_LOCALE_ONLY #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN -int wxStringPrintfMixinBase::DoPrintf(const wxChar *format, ...) +int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...) #else -int wxString::DoPrintf(const wxChar *format, ...) +int wxString::DoPrintfWchar(const wxChar *format, ...) #endif { va_list argptr; @@ -1352,19 +1530,52 @@ int wxString::DoPrintf(const wxChar *format, ...) return iLen; } +#endif // !wxUSE_UTF8_LOCALE_ONLY -int wxString::PrintfV(const wxString& format, va_list argptr) +#if wxUSE_UNICODE_UTF8 +int wxString::DoPrintfUtf8(const char *format, ...) +{ + va_list argptr; + va_start(argptr, format); + + int iLen = PrintfV(format, argptr); + + va_end(argptr); + + return iLen; +} +#endif // wxUSE_UNICODE_UTF8 + +#if wxUSE_UNICODE_UTF8 +template +#else +// we only need one version in non-UTF8 builds and at least two Windows +// compilers have problems with this function template, so use just one +// normal function here +#endif +static int DoStringPrintfV(wxString& str, + const wxString& format, va_list argptr) { int size = 1024; for ( ;; ) { - wxStringBuffer tmp(*this, size + 1); +#if wxUSE_UNICODE_UTF8 + BufferType tmp(str, size + 1); + typename BufferType::CharType *buf = tmp; +#else + wxStringBuffer tmp(str, size + 1); wxChar *buf = tmp; +#endif if ( !buf ) { // out of memory + + // in UTF-8 build, leaving uninitialized junk in the buffer + // could result in invalid non-empty UTF-8 string, so just + // reset the string to empty on failure: + buf[0] = '\0'; return -1; } @@ -1385,14 +1596,20 @@ int wxString::PrintfV(const wxString& format, va_list argptr) // buffer were large enough (newer standards such as Unix98) if ( len < 0 ) { + // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or + // wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF + // is true if *both* of them use our own implementation, + // otherwise we can't be sure #if wxUSE_WXVSNPRINTF // we know that our own implementation of wxVsnprintf() returns -1 // only for a format error - thus there's something wrong with // the user's format string + buf[0] = '\0'; return -1; -#else // assume that system version only returns error if not enough space - // still not enough, as we don't know how much we need, double the - // current size of the buffer +#else // possibly using system version + // assume it only returns error if there is not enough space, but + // as we don't know how much we need, double the current size of + // the buffer size *= 2; #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF } @@ -1416,9 +1633,34 @@ int wxString::PrintfV(const wxString& format, va_list argptr) } // we could have overshot - Shrink(); + str.Shrink(); + + return str.length(); +} + +int wxString::PrintfV(const wxString& format, va_list argptr) +{ +#if wxUSE_UNICODE_UTF8 + #if wxUSE_STL_BASED_WXSTRING + typedef wxStringTypeBuffer Utf8Buffer; + #else + typedef wxImplStringBuffer Utf8Buffer; + #endif +#endif - return length(); +#if wxUSE_UTF8_LOCALE_ONLY + return DoStringPrintfV(*this, format, argptr); +#else + #if wxUSE_UNICODE_UTF8 + if ( wxLocaleIsUtf8 ) + return DoStringPrintfV(*this, format, argptr); + else + // wxChar* version + return DoStringPrintfV(*this, format, argptr); + #else + return DoStringPrintfV(*this, format, argptr); + #endif // UTF8/WCHAR +#endif } // ----------------------------------------------------------------------------