X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8c3b65d941ffaf5c207881ca56bfe9c37b3604c5..49efebe2471223dafe8591aeeb194b8d4adc78bd:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 10a7d9085b..5d207a6b7f 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -69,7 +69,9 @@ // use in DLL build under pre-Vista Windows so we disable this code for now, if // anybody really needs to use UTF-8 build under Windows with this optimization // it would have to be re-tested and probably corrected -#if wxUSE_UNICODE_UTF8 && !defined(__WXMSW__) +// CS: under OSX release builds the string destructor/cache cleanup sometimes +// crashes, disable until we find the true reason or a better workaround +#if wxUSE_UNICODE_UTF8 && !defined(__WXMSW__) && !defined(__WXOSX__) #define wxUSE_STRING_POS_CACHE 1 #else #define wxUSE_STRING_POS_CACHE 0 @@ -207,7 +209,7 @@ inline int Stricmp(const char *psz1, const char *psz2) // Lightweight object returned by wxString::c_str() and implicitly convertible // to either const char* or const wchar_t*. -class WXDLLIMPEXP_BASE wxCStrData +class wxCStrData { private: // Ctors; for internal use by wxString and wxCStrData only @@ -223,19 +225,19 @@ public: inline ~wxCStrData(); - // methods defined inline below must be declared inline or mingw32 3.4.5 - // warns about " defined locally after being referenced with - // dllimport linkage" -#if wxUSE_UNICODE_WCHAR - inline -#endif - const wchar_t* AsWChar() const; + // AsWChar() and AsChar() can't be defined here as they use wxString and so + // must come after it and because of this won't be inlined when called from + // wxString methods (without a lot of work to extract these wxString methods + // from inside the class itself). But we still define them being inline + // below to let compiler inline them from elsewhere. And because of this we + // must declare them as inline here because otherwise some compilers give + // warnings about them, e.g. mingw32 3.4.5 warns about " defined + // locally after being referenced with dllimport linkage" while IRIX + // mipsPro 7.4 warns about "function declared inline after being called". + inline const wchar_t* AsWChar() const; operator const wchar_t*() const { return AsWChar(); } -#if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY - inline -#endif - const char* AsChar() const; + inline const char* AsChar() const; const unsigned char* AsUnsignedChar() const { return (const unsigned char *) AsChar(); } operator const char*() const { return AsChar(); } @@ -243,8 +245,16 @@ public: operator const void*() const { return AsChar(); } - inline const wxCharBuffer AsCharBuf() const; - inline const wxWCharBuffer AsWCharBuf() const; + // returns buffers that are valid as long as the associated wxString exists + const wxScopedCharBuffer AsCharBuf() const + { + return wxScopedCharBuffer::CreateNonOwned(AsChar()); + } + + const wxScopedWCharBuffer AsWCharBuf() const + { + return wxScopedWCharBuffer::CreateNonOwned(AsWChar()); + } inline wxString AsString() const; @@ -260,9 +270,11 @@ public: wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); } #endif // size_t != unsigned int - // these operators are needed to emulate the pointer semantics of c_str(): + // These operators are needed to emulate the pointer semantics of c_str(): // expressions like "wxChar *p = str.c_str() + 1;" should continue to work - // (we need both versions to resolve ambiguities): + // (we need both versions to resolve ambiguities). Note that this means + // the 'n' value is interpreted as addition to char*/wchar_t* pointer, it + // is *not* number of Unicode characters in wxString. wxCStrData operator+(int n) const { return wxCStrData(m_str, m_offset + n, m_owned); } wxCStrData operator+(long n) const @@ -276,7 +288,7 @@ public: wxCStrData operator-(ptrdiff_t n) const { wxASSERT_MSG( n <= (ptrdiff_t)m_offset, - _T("attempt to construct address before the beginning of the string") ); + wxT("attempt to construct address before the beginning of the string") ); return wxCStrData(m_str, m_offset - n, m_owned); } @@ -285,8 +297,16 @@ public: inline wxUniChar operator*() const; private: + // the wxString this object was returned for const wxString *m_str; + // Offset into c_str() return value. Note that this is *not* offset in + // m_str in Unicode characters. Instead, it is index into the + // char*/wchar_t* buffer returned by c_str(). It's interpretation depends + // on how is the wxCStrData instance used: if it is eventually cast to + // const char*, m_offset will be in bytes form string's start; if it is + // cast to const wchar_t*, it will be in wchar_t values. size_t m_offset; + // should m_str be deleted, i.e. is it owned by us? bool m_owned; friend class WXDLLIMPEXP_FWD_BASE wxString; @@ -348,7 +368,7 @@ public: // these are duplicated wxString methods, they're also declared below // if !wxNEEDS_WXSTRING_PRINTF_MIXIN: - // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1; + // static wxString Format(const wString& format, ...) WX_ATTRIBUTE_PRINTF_1; WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType::type, Format, 1, (const wxFormatString&), DoFormatWchar, DoFormatUtf8) @@ -370,7 +390,7 @@ public: // int Printf(const wxString& format, ...); WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&), DoPrintfWchar, DoPrintfUtf8) - // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2; + // int sprintf(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_2; WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&), DoPrintfWchar, DoPrintfUtf8) @@ -388,6 +408,7 @@ protected: #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN // "non dll-interface class 'wxStringPrintfMixin' used as base interface // for dll-interface class 'wxString'" -- this is OK in our case + #pragma warning (push) #pragma warning (disable:4275) #endif @@ -424,7 +445,7 @@ private: // the node belongs to a particular iterator instance, it's not copied // when a copy of the iterator is made - DECLARE_NO_COPY_CLASS(wxStringIteratorNode) + wxDECLARE_NO_COPY_CLASS(wxStringIteratorNode); }; #endif // wxUSE_UNICODE_UTF8 @@ -474,14 +495,14 @@ private: #if wxUSE_UNICODE_UTF8 // even char* -> char* needs conversion, from locale charset to UTF-8 - typedef SubstrBufFromType SubstrBufFromWC; - typedef SubstrBufFromType SubstrBufFromMB; + typedef SubstrBufFromType SubstrBufFromWC; + typedef SubstrBufFromType SubstrBufFromMB; #elif wxUSE_UNICODE_WCHAR - typedef SubstrBufFromType SubstrBufFromWC; - typedef SubstrBufFromType SubstrBufFromMB; + typedef SubstrBufFromType SubstrBufFromWC; + typedef SubstrBufFromType SubstrBufFromMB; #else - typedef SubstrBufFromType SubstrBufFromMB; - typedef SubstrBufFromType SubstrBufFromWC; + typedef SubstrBufFromType SubstrBufFromMB; + typedef SubstrBufFromType SubstrBufFromWC; #endif @@ -510,8 +531,8 @@ private: { return str ? str : wxT(""); } static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); } - static wxWCharBuffer ImplStr(const char* str, - const wxMBConv& conv = wxConvLibc) + static wxScopedWCharBuffer ImplStr(const char* str, + const wxMBConv& conv = wxConvLibc) { return ConvertStr(str, npos, conv).data; } static SubstrBufFromMB ImplStr(const char* str, size_t n, const wxMBConv& conv = wxConvLibc) @@ -523,7 +544,7 @@ private: static const SubstrBufFromMB ImplStr(const char* str, size_t n, const wxMBConv& WXUNUSED(conv) = wxConvLibc) { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); } - static wxCharBuffer ImplStr(const wchar_t* str) + static wxScopedCharBuffer ImplStr(const wchar_t* str) { return ConvertStr(str, npos, wxConvLibc).data; } static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) { return ConvertStr(str, n, wxConvLibc); } @@ -548,14 +569,14 @@ private: #else // wxUSE_UNICODE_UTF8 - static wxCharBuffer ImplStr(const char* str, - const wxMBConv& conv = wxConvLibc) + static wxScopedCharBuffer ImplStr(const char* str, + const wxMBConv& conv = wxConvLibc) { return ConvertStr(str, npos, conv).data; } static SubstrBufFromMB ImplStr(const char* str, size_t n, const wxMBConv& conv = wxConvLibc) { return ConvertStr(str, n, conv); } - static wxCharBuffer ImplStr(const wchar_t* str) + static wxScopedCharBuffer ImplStr(const wchar_t* str) { return ConvertStr(str, npos, wxMBConvUTF8()).data; } static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) { return ConvertStr(str, n, wxMBConvUTF8()); } @@ -594,26 +615,38 @@ private: unsigned lastUsed; }; - // notice that we must use an accessor function and not a static variable - // because when the TLS variables support is implemented in the library (and - // not by the compiler), the global s_cache variable could be not yet - // initialized when a ctor of another global object is executed and if that - // ctor uses any wxString methods, bad things happen - static Cache& GetCache() +#ifndef wxHAS_COMPILER_TLS + // we must use an accessor function and not a static variable when the TLS + // variables support is implemented in the library (and not by the compiler) + // because the global s_cache variable could be not yet initialized when a + // ctor of another global object is executed and if that ctor uses any + // wxString methods, bad things happen + // + // however notice that this approach does not work when compiler TLS is used, + // at least not with g++ 4.1.2 under amd64 as it apparently compiles code + // using this accessor incorrectly when optimizations are enabled (-O2 is + // enough) -- luckily we don't need it then neither as static __thread + // variables are initialized by 0 anyhow then and so we can use the variable + // directly + WXEXPORT static Cache& GetCache() { static wxTLS_TYPE(Cache) s_cache; return wxTLS_VALUE(s_cache); } - static Cache::Element *GetCacheBegin() { return GetCache().cached; } - static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; } - static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; } - // this helper struct is used to ensure that GetCache() is called during // static initialization time, i.e. before any threads creation, as otherwise // the static s_cache construction inside GetCache() wouldn't be MT-safe friend struct wxStrCacheInitializer; +#else // wxHAS_COMPILER_TLS + static wxTLS_TYPE(Cache) ms_cache; + static Cache& GetCache() { return wxTLS_VALUE(ms_cache); } +#endif // !wxHAS_COMPILER_TLS/wxHAS_COMPILER_TLS + + static Cache::Element *GetCacheBegin() { return GetCache().cached; } + static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; } + static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; } // this is used in debug builds only to provide a convenient function, // callable from a debugger, to show the cache contents @@ -659,7 +692,15 @@ private: // profiling seems to show a small but consistent gain if we use this // simple loop instead of starting from the last used element (there are // a lot of misses in this function...) - for ( Cache::Element *c = GetCacheBegin(); c != GetCacheEnd(); c++ ) + Cache::Element * const cacheBegin = GetCacheBegin(); +#ifndef wxHAS_COMPILER_TLS + // during destruction tls calls may return NULL, in this case return NULL + // immediately without accessing anything else + if ( cacheBegin == NULL ) + return NULL; +#endif + Cache::Element * const cacheEnd = GetCacheEnd(); + for ( Cache::Element *c = cacheBegin; c != cacheEnd; c++ ) { if ( c->str == this ) return c; @@ -721,7 +762,9 @@ private: // used for length caching only so far, i.e. it doesn't count as a hit // from our point of view if ( cache->pos ) + { wxCACHE_PROFILE_FIELD_INC(poshits); + } if ( pos == cache->pos ) return cache->impl; @@ -962,10 +1005,10 @@ public: { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } private: - iterator(wxString *str, underlying_iterator ptr) - : m_cur(ptr), m_node(str, &m_cur) {} + iterator(wxString *wxstr, underlying_iterator ptr) + : m_cur(ptr), m_node(wxstr, &m_cur) {} - wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); } + wxString* str() const { return const_cast(m_node.m_str); } wxStringIteratorNode m_node; @@ -1007,8 +1050,8 @@ public: private: // for internal wxString use only: - const_iterator(const wxString *str, underlying_iterator ptr) - : m_cur(ptr), m_node(str, &m_cur) {} + const_iterator(const wxString *wxstr, underlying_iterator ptr) + : m_cur(ptr), m_node(wxstr, &m_cur) {} const wxString* str() const { return m_node.m_str; } @@ -1241,10 +1284,10 @@ public: wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength) { assign(pwz, nLength); } - wxString(const wxCharBuffer& buf) - { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length - wxString(const wxWCharBuffer& buf) - { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length + wxString(const wxScopedCharBuffer& buf) + { assign(buf.data(), buf.length()); } + wxString(const wxScopedWCharBuffer& buf) + { assign(buf.data(), buf.length()); } // NB: this version uses m_impl.c_str() to force making a copy of the // string, so that "wxString(str.c_str())" idiom for passing strings @@ -1298,29 +1341,51 @@ public: // Unlike ctor from std::string, we provide conversion to std::string only // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default), - // because it conflicts with operator const char/wchar_t*: -#if wxUSE_STL + // because it conflicts with operator const char/wchar_t* but we still + // provide explicit conversions to std::[w]string for convenience in any case +#if wxUSE_STD_STRING + // We can avoid a copy if we already use this string type internally, + // otherwise we create a copy on the fly: #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING - // wxStringImpl is std::string in the encoding we want - operator const wxStdWideString&() const { return m_impl; } + #define wxStringToStdWstringRetType const wxStdWideString& + const wxStdWideString& ToStdWstring() const { return m_impl; } #else // wxStringImpl is either not std::string or needs conversion - operator wxStdWideString() const - // FIXME-UTF8: broken for embedded NULs - { return wxStdWideString(wc_str()); } + #define wxStringToStdWstringRetType wxStdWideString + wxStdWideString ToStdWstring() const + { + wxScopedWCharBuffer buf(wc_str()); + return wxStdWideString(buf.data(), buf.length()); + } #endif #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING // wxStringImpl is std::string in the encoding we want - operator const std::string&() const { return m_impl; } + #define wxStringToStdStringRetType const std::string& + const std::string& ToStdString() const { return m_impl; } #else // wxStringImpl is either not std::string or needs conversion - operator std::string() const - // FIXME-UTF8: broken for embedded NULs - { return std::string(mb_str()); } + #define wxStringToStdStringRetType std::string + std::string ToStdString() const + { + wxScopedCharBuffer buf(mb_str()); + return std::string(buf.data(), buf.length()); + } #endif + +#if wxUSE_STL + // In wxUSE_STL case we also provide implicit conversions as there is no + // ambiguity with the const char/wchar_t* ones as they are disabled in this + // build (for consistency with std::basic_string<>) + operator wxStringToStdStringRetType() const { return ToStdString(); } + operator wxStringToStdWstringRetType() const { return ToStdWstring(); } #endif // wxUSE_STL +#undef wxStringToStdStringRetType +#undef wxStringToStdWstringRetType + +#endif // wxUSE_STD_STRING + wxString Clone() const { // make a deep copy of the string, i.e. the returned string will have @@ -1436,12 +1501,7 @@ public: // truncate the string to given length wxString& Truncate(size_t uiLen); // empty string contents - void Empty() - { - Truncate(0); - - wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") ); - } + void Empty() { clear(); } // empty the string and free memory void Clear() { clear(); } @@ -1471,14 +1531,14 @@ public: // get last character wxUniChar Last() const { - wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); + wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") ); return *rbegin(); } // get writable last character wxUniCharRef Last() { - wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); + wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") ); return *rbegin(); } @@ -1509,11 +1569,53 @@ public: { return at(n); } #endif // size_t != unsigned int - // explicit conversion to C string (use this with printf()!) + + /* + Overview of wxString conversions, implicit and explicit: + + - wxString has a std::[w]string-like c_str() method, however it does + not return a C-style string directly but instead returns wxCStrData + helper object which is convertible to either "char *" narrow string + or "wchar_t *" wide string. Usually the correct conversion will be + applied by the compiler automatically but if this doesn't happen you + need to explicitly choose one using wxCStrData::AsChar() or AsWChar() + methods or another wxString conversion function. + + - One of the places where the conversion does *NOT* happen correctly is + when c_str() is passed to a vararg function such as printf() so you + must *NOT* use c_str() with them. Either use wxPrintf() (all wx + functions do handle c_str() correctly, even if they appear to be + vararg (but they're not, really)) or add an explicit AsChar() or, if + compatibility with previous wxWidgets versions is important, add a + cast to "const char *". + + - In non-STL mode only, wxString is also implicitly convertible to + wxCStrData. The same warning as above applies. + + - c_str() is polymorphic as it can be converted to either narrow or + wide string. If you explicitly need one or the other, choose to use + mb_str() (for narrow) or wc_str() (for wide) instead. Notice that + these functions can return either the pointer to string directly (if + this is what the string uses internally) or a temporary buffer + containing the string and convertible to it. Again, conversion will + usually be done automatically by the compiler but beware of the + vararg functions: you need an explicit cast when using them. + + - There are also non-const versions of mb_str() and wc_str() called + char_str() and wchar_str(). They are only meant to be used with + non-const-correct functions and they always return buffers. + + - Finally wx_str() returns whatever string representation is used by + wxString internally. It may be either a narrow or wide string + depending on wxWidgets build mode but it will always be a raw pointer + (and not a buffer). + */ + + // explicit conversion to wxCStrData wxCStrData c_str() const { return wxCStrData(this); } wxCStrData data() const { return c_str(); } - // implicit conversion to C string + // implicit conversion to wxCStrData operator wxCStrData() const { return c_str(); } // the first two operators conflict with operators for conversion to @@ -1565,7 +1667,7 @@ public: if ( len ) *len = length(); - return wxCharTypeBuffer::CreateNonOwned(wx_str()); + return wxCharTypeBuffer::CreateNonOwned(wx_str(), length()); #endif // Unicode build kind } @@ -1579,7 +1681,7 @@ public: static wxString FromAscii(const char *ascii, size_t len); static wxString FromAscii(const char *ascii); static wxString FromAscii(char ascii); - const wxCharBuffer ToAscii() const; + const wxScopedCharBuffer ToAscii() const; #else // ANSI static wxString FromAscii(const char *ascii) { return wxString( ascii ); } static wxString FromAscii(const char *ascii, size_t len) @@ -1634,8 +1736,8 @@ public: return FromImpl(wxStringImpl(utf8, len)); } - const char* utf8_str() const { return wx_str(); } - const char* ToUTF8() const { return wx_str(); } + const wxScopedCharBuffer utf8_str() const + { return wxCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length()); } // this function exists in UTF-8 build only and returns the length of the // internal UTF-8 representation @@ -1650,33 +1752,39 @@ public: "string must be valid UTF-8" ); return s; } - const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); } - const wxCharBuffer ToUTF8() const { return utf8_str(); } + const wxScopedCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); } #else // ANSI static wxString FromUTF8(const char *utf8) { return wxString(wxMBConvUTF8().cMB2WC(utf8)); } static wxString FromUTF8(const char *utf8, size_t len) { size_t wlen; - wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen)); + wxScopedWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen)); return wxString(buf.data(), wlen); } static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos) { size_t wlen; - wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, - len == npos ? wxNO_LEN : len, - &wlen)); + wxScopedWCharBuffer buf + ( + wxMBConvUTF8().cMB2WC + ( + utf8, + len == npos ? wxNO_LEN : len, + &wlen + ) + ); wxASSERT_MSG( !utf8 || !*utf8 || wlen, "string must be valid UTF-8" ); return wxString(buf.data(), wlen); } - const wxCharBuffer utf8_str() const + const wxScopedCharBuffer utf8_str() const { return wxMBConvUTF8().cWC2MB(wc_str()); } - const wxCharBuffer ToUTF8() const { return utf8_str(); } #endif + const wxScopedCharBuffer ToUTF8() const { return utf8_str(); } + // functions for storing binary data in wxString: #if wxUSE_UNICODE static wxString From8BitData(const char *data, size_t len) @@ -1684,7 +1792,8 @@ public: // version for NUL-terminated data: static wxString From8BitData(const char *data) { return wxString(data, wxConvISO8859_1); } - const wxCharBuffer To8BitData() const { return mb_str(wxConvISO8859_1); } + const wxScopedCharBuffer To8BitData() const + { return mb_str(wxConvISO8859_1); } #else // ANSI static wxString From8BitData(const char *data, size_t len) { return wxString(data, len); } @@ -1703,53 +1812,67 @@ public: // accepting the file names. The return value is always the same, but the // type differs because a function may either return pointer to the buffer // directly or have to use intermediate buffer for translation. + #if wxUSE_UNICODE + // this is an optimization: even though using mb_str(wxConvLibc) does the + // same thing (i.e. returns pointer to internal representation as locale is + // always an UTF-8 one) in wxUSE_UTF8_LOCALE_ONLY case, we can avoid the + // extra checks and the temporary buffer construction by providing a + // separate mb_str() overload #if wxUSE_UTF8_LOCALE_ONLY const char* mb_str() const { return wx_str(); } - const wxCharBuffer mb_str(const wxMBConv& conv) const; -#else - const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const; -#endif + const wxScopedCharBuffer mb_str(const wxMBConv& conv) const + { + return AsCharBuf(conv); + } +#else // !wxUSE_UTF8_LOCALE_ONLY + const wxScopedCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const + { + return AsCharBuf(conv); + } +#endif // wxUSE_UTF8_LOCALE_ONLY/!wxUSE_UTF8_LOCALE_ONLY const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } #if wxUSE_UNICODE_WCHAR const wchar_t* wc_str() const { return wx_str(); } #elif wxUSE_UNICODE_UTF8 - const wxWCharBuffer wc_str() const; + const wxScopedWCharBuffer wc_str() const + { return AsWCharBuf(wxMBConvStrictUTF8()); } #endif // for compatibility with !wxUSE_UNICODE version const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const { return wc_str(); } #if wxMBFILES - const wxCharBuffer fn_str() const { return mb_str(wxConvFile); } + const wxScopedCharBuffer fn_str() const { return mb_str(wxConvFile); } #else // !wxMBFILES const wxWX2WCbuf fn_str() const { return wc_str(); } #endif // wxMBFILES/!wxMBFILES #else // ANSI - const wxChar* mb_str() const { return wx_str(); } + const char* mb_str() const { return wx_str(); } // for compatibility with wxUSE_UNICODE version const char* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); } const wxWX2MBbuf mbc_str() const { return mb_str(); } -#if wxUSE_WCHAR_T - const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const; -#endif // wxUSE_WCHAR_T - const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); } + const wxScopedWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const + { return AsWCharBuf(conv); } + + const wxScopedCharBuffer fn_str() const + { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); } #endif // Unicode/ANSI #if wxUSE_UNICODE_UTF8 - const wxWCharBuffer t_str() const { return wc_str(); } + const wxScopedWCharBuffer t_str() const { return wc_str(); } #elif wxUSE_UNICODE_WCHAR const wchar_t* t_str() const { return wx_str(); } #else const char* t_str() const { return wx_str(); } -#endif +#endif // overloaded assignment @@ -1839,12 +1962,12 @@ public: wxString& operator=(const unsigned char *psz) { return operator=((const char*)psz); } - // from wxWCharBuffer - wxString& operator=(const wxWCharBuffer& s) - { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs - // from wxCharBuffer - wxString& operator=(const wxCharBuffer& s) - { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs + // from wxScopedWCharBuffer + wxString& operator=(const wxScopedWCharBuffer& s) + { return assign(s); } + // from wxScopedCharBuffer + wxString& operator=(const wxScopedCharBuffer& s) + { return assign(s); } // string concatenation // in place concatenation @@ -1858,7 +1981,7 @@ public: { #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 wxASSERT_MSG( s.IsValid(), - _T("did you forget to call UngetWriteBuf()?") ); + wxT("did you forget to call UngetWriteBuf()?") ); #endif append(s); @@ -1879,10 +2002,10 @@ public: wxString& operator<<(wchar_t ch) { append(1, ch); return *this; } // string += buffer (i.e. from wxGetString) - wxString& operator<<(const wxWCharBuffer& s) - { return operator<<((const wchar_t *)s); } - wxString& operator<<(const wxCharBuffer& s) - { return operator<<((const char *)s); } + wxString& operator<<(const wxScopedWCharBuffer& s) + { return append(s); } + wxString& operator<<(const wxScopedCharBuffer& s) + { return append(s); } // string += C string wxString& Append(const wxString& s) @@ -1900,9 +2023,9 @@ public: { append(pwz); return *this; } wxString& Append(const wxCStrData& psz) { append(psz); return *this; } - wxString& Append(const wxCharBuffer& psz) + wxString& Append(const wxScopedCharBuffer& psz) { append(psz); return *this; } - wxString& Append(const wxWCharBuffer& psz) + wxString& Append(const wxScopedWCharBuffer& psz) { append(psz); return *this; } wxString& Append(const char* psz, size_t nLen) { append(psz, nLen); return *this; } @@ -1910,9 +2033,9 @@ public: { append(pwz, nLen); return *this; } wxString& Append(const wxCStrData& psz, size_t nLen) { append(psz, nLen); return *this; } - wxString& Append(const wxCharBuffer& psz, size_t nLen) + wxString& Append(const wxScopedCharBuffer& psz, size_t nLen) { append(psz, nLen); return *this; } - wxString& Append(const wxWCharBuffer& psz, size_t nLen) + wxString& Append(const wxScopedWCharBuffer& psz, size_t nLen) { append(psz, nLen); return *this; } // append count copies of given character wxString& Append(wxUniChar ch, size_t count = 1u) @@ -1952,36 +2075,34 @@ public: // stream-like functions // insert an int into string wxString& operator<<(int i) - { return (*this) << Format(_T("%d"), i); } + { return (*this) << Format(wxT("%d"), i); } // insert an unsigned int into string wxString& operator<<(unsigned int ui) - { return (*this) << Format(_T("%u"), ui); } + { return (*this) << Format(wxT("%u"), ui); } // insert a long into string wxString& operator<<(long l) - { return (*this) << Format(_T("%ld"), l); } + { return (*this) << Format(wxT("%ld"), l); } // insert an unsigned long into string wxString& operator<<(unsigned long ul) - { return (*this) << Format(_T("%lu"), ul); } + { return (*this) << Format(wxT("%lu"), ul); } #if defined wxLongLong_t && !defined wxLongLongIsLong // insert a long long if they exist and aren't longs wxString& operator<<(wxLongLong_t ll) { - const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d"); - return (*this) << Format(fmt, ll); + return (*this) << Format("%" wxLongLongFmtSpec "d", ll); } // insert an unsigned long long wxString& operator<<(wxULongLong_t ull) { - const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u"); - return (*this) << Format(fmt , ull); + return (*this) << Format("%" wxLongLongFmtSpec "u" , ull); } #endif // wxLongLong_t && !wxLongLongIsLong // insert a float into string wxString& operator<<(float f) - { return (*this) << Format(_T("%f"), f); } + { return (*this) << Format(wxT("%f"), f); } // insert a double into string wxString& operator<<(double d) - { return (*this) << Format(_T("%g"), d); } + { return (*this) << Format(wxT("%g"), d); } // string comparison // case-sensitive comparison (returns a value < 0, = 0 or > 0) @@ -1993,9 +2114,9 @@ public: { return compare(s); } int Cmp(const wxCStrData& s) const { return compare(s); } - int Cmp(const wxCharBuffer& s) const + int Cmp(const wxScopedCharBuffer& s) const { return compare(s); } - int Cmp(const wxWCharBuffer& s) const + int Cmp(const wxScopedWCharBuffer& s) const { return compare(s); } // same as Cmp() but not case-sensitive int CmpNoCase(const wxString& s) const; @@ -2018,9 +2139,9 @@ public: bool IsSameAs(const wxCStrData& str, bool compareWithCase = true) const { return IsSameAs(str.AsString(), compareWithCase); } - bool IsSameAs(const wxCharBuffer& str, bool compareWithCase = true) const + bool IsSameAs(const wxScopedCharBuffer& str, bool compareWithCase = true) const { return IsSameAs(str.data(), compareWithCase); } - bool IsSameAs(const wxWCharBuffer& str, bool compareWithCase = true) const + bool IsSameAs(const wxScopedWCharBuffer& str, bool compareWithCase = true) const { return IsSameAs(str.data(), compareWithCase); } // comparison with a single character: returns true if equal bool IsSameAs(wxUniChar c, bool compareWithCase = true) const; @@ -2058,16 +2179,16 @@ public: wxString Left(size_t nCount) const; // get last nCount characters wxString Right(size_t nCount) const; - // get all characters before the first occurance of ch + // get all characters before the first occurrence of ch // (returns the whole string if ch not found) wxString BeforeFirst(wxUniChar ch) const; - // get all characters before the last occurence of ch + // get all characters before the last occurrence of ch // (returns empty string if ch not found) wxString BeforeLast(wxUniChar ch) const; - // get all characters after the first occurence of ch + // get all characters after the first occurrence of ch // (returns empty string if ch not found) wxString AfterFirst(wxUniChar ch) const; - // get all characters after the last occurence of ch + // get all characters after the last occurrence of ch // (returns the whole string if ch not found) wxString AfterLast(wxUniChar ch) const; @@ -2127,12 +2248,12 @@ public: int Find(const wxCStrData& sub) const { return Find(sub.AsString()); } - int Find(const wxCharBuffer& sub) const + int Find(const wxScopedCharBuffer& sub) const { return Find(sub.data()); } - int Find(const wxWCharBuffer& sub) const + int Find(const wxScopedWCharBuffer& sub) const { return Find(sub.data()); } - // replace first (or all of bReplaceAll) occurences of substring with + // replace first (or all of bReplaceAll) occurrences of substring with // another string, returns the number of replacements made size_t Replace(const wxString& strOld, const wxString& strNew, @@ -2141,24 +2262,33 @@ public: // check if the string contents matches a mask containing '*' and '?' bool Matches(const wxString& mask) const; - // conversion to numbers: all functions return true only if the whole - // string is a number and put the value of this number into the pointer - // provided, the base is the numeric base in which the conversion should be - // done and must be comprised between 2 and 36 or be 0 in which case the - // standard C rules apply (leading '0' => octal, "0x" => hex) - // convert to a signed integer - bool ToLong(long *val, int base = 10) const; - // convert to an unsigned integer - bool ToULong(unsigned long *val, int base = 10) const; - // convert to wxLongLong + // conversion to numbers: all functions return true only if the whole + // string is a number and put the value of this number into the pointer + // provided, the base is the numeric base in which the conversion should be + // done and must be comprised between 2 and 36 or be 0 in which case the + // standard C rules apply (leading '0' => octal, "0x" => hex) + // convert to a signed integer + bool ToLong(long *val, int base = 10) const; + // convert to an unsigned integer + bool ToULong(unsigned long *val, int base = 10) const; + // convert to wxLongLong #if defined(wxLongLong_t) - bool ToLongLong(wxLongLong_t *val, int base = 10) const; - // convert to wxULongLong - bool ToULongLong(wxULongLong_t *val, int base = 10) const; + bool ToLongLong(wxLongLong_t *val, int base = 10) const; + // convert to wxULongLong + bool ToULongLong(wxULongLong_t *val, int base = 10) const; #endif // wxLongLong_t - // convert to a double - bool ToDouble(double *val) const; - + // convert to a double + bool ToDouble(double *val) const; + +#if wxUSE_XLOCALE + // conversions to numbers using C locale + // convert to a signed integer + bool ToCLong(long *val, int base = 10) const; + // convert to an unsigned integer + bool ToCULong(unsigned long *val, int base = 10) const; + // convert to a double + bool ToCDouble(double *val) const; +#endif #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // formatted input/output @@ -2184,7 +2314,7 @@ public: #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // returns the string containing the result of Printf() to it - // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1; + // static wxString Format(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_1; WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxFormatString&), DoFormatWchar, DoFormatUtf8) #ifdef __WATCOMC__ @@ -2233,7 +2363,7 @@ public: #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // use Printf() // (take 'this' into account in attribute parameter count) - // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2; + // int sprintf(const wxString& format, ...) WX_ATTRIBUTE_PRINTF_2; WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&), DoPrintfWchar, DoPrintfUtf8) #ifdef __WATCOMC__ @@ -2314,7 +2444,7 @@ public: CreateConstIterator(last).impl()) { wxASSERT_MSG( first.m_str == last.m_str, - _T("pointers must be into the same string") ); + wxT("pointers must be into the same string") ); } #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER @@ -2374,15 +2504,15 @@ public: wxString& append(const wxCStrData& str) { return append(str.AsString()); } - wxString& append(const wxCharBuffer& str) - { return append(str.data()); } - wxString& append(const wxWCharBuffer& str) - { return append(str.data()); } + wxString& append(const wxScopedCharBuffer& str) + { return append(str.data(), str.length()); } + wxString& append(const wxScopedWCharBuffer& str) + { return append(str.data(), str.length()); } wxString& append(const wxCStrData& str, size_t n) { return append(str.AsString(), 0, n); } - wxString& append(const wxCharBuffer& str, size_t n) + wxString& append(const wxScopedCharBuffer& str, size_t n) { return append(str.data(), n); } - wxString& append(const wxWCharBuffer& str, size_t n) + wxString& append(const wxScopedWCharBuffer& str, size_t n) { return append(str.data(), n); } // append n copies of ch @@ -2506,15 +2636,15 @@ public: wxString& assign(const wxCStrData& str) { return assign(str.AsString()); } - wxString& assign(const wxCharBuffer& str) - { return assign(str.data()); } - wxString& assign(const wxWCharBuffer& str) - { return assign(str.data()); } + wxString& assign(const wxScopedCharBuffer& str) + { return assign(str.data(), str.length()); } + wxString& assign(const wxScopedWCharBuffer& str) + { return assign(str.data(), str.length()); } wxString& assign(const wxCStrData& str, size_t len) { return assign(str.AsString(), len); } - wxString& assign(const wxCharBuffer& str, size_t len) + wxString& assign(const wxScopedCharBuffer& str, size_t len) { return assign(str.data(), len); } - wxString& assign(const wxWCharBuffer& str, size_t len) + wxString& assign(const wxScopedWCharBuffer& str, size_t len) { return assign(str.data(), len); } // same as `= n copies of ch' @@ -2565,9 +2695,9 @@ public: int compare(const wchar_t* sz) const; int compare(const wxCStrData& str) const { return compare(str.AsString()); } - int compare(const wxCharBuffer& str) const + int compare(const wxScopedCharBuffer& str) const { return compare(str.data()); } - int compare(const wxWCharBuffer& str) const + int compare(const wxScopedWCharBuffer& str) const { return compare(str.data()); } // comparison with a substring int compare(size_t nStart, size_t nLen, const wxString& str) const; @@ -2948,14 +3078,14 @@ public: SubstrBufFromWC str(ImplStr(sz, n)); return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len)); } - size_t find(const wxCharBuffer& s, size_t nStart = 0, size_t n = npos) const + size_t find(const wxScopedCharBuffer& s, size_t nStart = 0, size_t n = npos) const { return find(s.data(), nStart, n); } - size_t find(const wxWCharBuffer& s, size_t nStart = 0, size_t n = npos) const + size_t find(const wxScopedWCharBuffer& s, size_t nStart = 0, size_t n = npos) const { return find(s.data(), nStart, n); } size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const { return find(s.AsWChar(), nStart, n); } - // find the first occurence of character ch after nStart + // find the first occurrence of character ch after nStart size_t find(wxUniChar ch, size_t nStart = 0) const { #if wxUSE_UNICODE_UTF8 @@ -2994,9 +3124,9 @@ public: SubstrBufFromWC str(ImplStr(sz, n)); return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len)); } - size_t rfind(const wxCharBuffer& s, size_t nStart = npos, size_t n = npos) const + size_t rfind(const wxScopedCharBuffer& s, size_t nStart = npos, size_t n = npos) const { return rfind(s.data(), nStart, n); } - size_t rfind(const wxWCharBuffer& s, size_t nStart = npos, size_t n = npos) const + size_t rfind(const wxScopedWCharBuffer& s, size_t nStart = npos, size_t n = npos) const { return rfind(s.data(), nStart, n); } size_t rfind(const wxCStrData& s, size_t nStart = npos, size_t n = npos) const { return rfind(s.AsWChar(), nStart, n); } @@ -3021,7 +3151,7 @@ public: size_t rfind(wchar_t ch, size_t nStart = npos) const { return rfind(wxUniChar(ch), nStart); } - // find first/last occurence of any character (not) in the set: + // find first/last occurrence of any character (not) in the set: #if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 // FIXME-UTF8: this is not entirely correct, because it doesn't work if // sizeof(wchar_t)==2 and surrogates are present in the string; @@ -3112,7 +3242,7 @@ public: size_t find_last_of(wxUniChar c, size_t nStart = npos) const { return rfind(c, nStart); } - // find first/last occurence of any character not in the set + // find first/last occurrence of any character not in the set // as strspn() (starting from nStart), returns npos on failure size_t find_first_not_of(const wxString& str, size_t nStart = 0) const @@ -3182,54 +3312,54 @@ public: // and additional overloads for the versions taking strings: size_t find_first_of(const wxCStrData& sz, size_t nStart = 0) const { return find_first_of(sz.AsString(), nStart); } - size_t find_first_of(const wxCharBuffer& sz, size_t nStart = 0) const + size_t find_first_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const { return find_first_of(sz.data(), nStart); } - size_t find_first_of(const wxWCharBuffer& sz, size_t nStart = 0) const + size_t find_first_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const { return find_first_of(sz.data(), nStart); } size_t find_first_of(const wxCStrData& sz, size_t nStart, size_t n) const { return find_first_of(sz.AsWChar(), nStart, n); } - size_t find_first_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + size_t find_first_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const { return find_first_of(sz.data(), nStart, n); } - size_t find_first_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + size_t find_first_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const { return find_first_of(sz.data(), nStart, n); } size_t find_last_of(const wxCStrData& sz, size_t nStart = 0) const { return find_last_of(sz.AsString(), nStart); } - size_t find_last_of(const wxCharBuffer& sz, size_t nStart = 0) const + size_t find_last_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const { return find_last_of(sz.data(), nStart); } - size_t find_last_of(const wxWCharBuffer& sz, size_t nStart = 0) const + size_t find_last_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const { return find_last_of(sz.data(), nStart); } size_t find_last_of(const wxCStrData& sz, size_t nStart, size_t n) const { return find_last_of(sz.AsWChar(), nStart, n); } - size_t find_last_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + size_t find_last_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const { return find_last_of(sz.data(), nStart, n); } - size_t find_last_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + size_t find_last_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const { return find_last_of(sz.data(), nStart, n); } size_t find_first_not_of(const wxCStrData& sz, size_t nStart = 0) const { return find_first_not_of(sz.AsString(), nStart); } - size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart = 0) const + size_t find_first_not_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const { return find_first_not_of(sz.data(), nStart); } - size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const + size_t find_first_not_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const { return find_first_not_of(sz.data(), nStart); } size_t find_first_not_of(const wxCStrData& sz, size_t nStart, size_t n) const { return find_first_not_of(sz.AsWChar(), nStart, n); } - size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + size_t find_first_not_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const { return find_first_not_of(sz.data(), nStart, n); } - size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + size_t find_first_not_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const { return find_first_not_of(sz.data(), nStart, n); } size_t find_last_not_of(const wxCStrData& sz, size_t nStart = 0) const { return find_last_not_of(sz.AsString(), nStart); } - size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart = 0) const + size_t find_last_not_of(const wxScopedCharBuffer& sz, size_t nStart = 0) const { return find_last_not_of(sz.data(), nStart); } - size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const + size_t find_last_not_of(const wxScopedWCharBuffer& sz, size_t nStart = 0) const { return find_last_not_of(sz.data(), nStart); } size_t find_last_not_of(const wxCStrData& sz, size_t nStart, size_t n) const { return find_last_not_of(sz.AsWChar(), nStart, n); } - size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + size_t find_last_not_of(const wxScopedCharBuffer& sz, size_t nStart, size_t n) const { return find_last_not_of(sz.data(), nStart, n); } - size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + size_t find_last_not_of(const wxScopedWCharBuffer& sz, size_t nStart, size_t n) const { return find_last_not_of(sz.data(), nStart, n); } // string += string @@ -3262,10 +3392,10 @@ public: m_impl += s.AsString().m_impl; return *this; } - wxString& operator+=(const wxCharBuffer& s) - { return operator+=(s.data()); } - wxString& operator+=(const wxWCharBuffer& s) - { return operator+=(s.data()); } + wxString& operator+=(const wxScopedCharBuffer& s) + { return append(s); } + wxString& operator+=(const wxScopedWCharBuffer& s) + { return append(s); } // string += char wxString& operator+=(wxUniChar ch) { @@ -3328,36 +3458,117 @@ private: wxStringImpl m_impl; // buffers for compatibility conversion from (char*)c_str() and - // (wchar_t*)c_str(): - // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers + // (wchar_t*)c_str(): the pointers returned by these functions should remain + // valid until the string itself is modified for compatibility with the + // existing code and consistency with std::string::c_str() so returning a + // temporary buffer won't do and we need to cache the conversion results + + // TODO-UTF8: benchmark various approaches to keeping compatibility buffers template struct ConvertedBuffer { - ConvertedBuffer() : m_buf(NULL) {} + // notice that there is no need to initialize m_len here as it's unused + // as long as m_str is NULL + ConvertedBuffer() : m_str(NULL) {} ~ConvertedBuffer() - { free(m_buf); } + { free(m_str); } - operator T*() const { return m_buf; } + bool Extend(size_t len) + { + // add extra 1 for the trailing NUL + void * const str = realloc(m_str, sizeof(T)*(len + 1)); + if ( !str ) + return false; + + m_str = static_cast(str); + m_len = len; + + return true; + } - ConvertedBuffer& operator=(T *str) + const wxScopedCharTypeBuffer AsScopedBuffer() const { - free(m_buf); - m_buf = str; - return *this; + return wxScopedCharTypeBuffer::CreateNonOwned(m_str, m_len); } - T *m_buf; + T *m_str; // pointer to the string data + size_t m_len; // length, not size, i.e. in chars and without last NUL }; -#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY + + +#if wxUSE_UNICODE + // common mb_str() and wxCStrData::AsChar() helper: performs the conversion + // and returns either m_convertedToChar.m_str (in which case its m_len is + // also updated) or NULL if it failed + // + // there is an important exception: in wxUSE_UNICODE_UTF8 build if conv is a + // UTF-8 one, we return m_impl.c_str() directly, without doing any conversion + // as optimization and so the caller needs to check for this before using + // m_convertedToChar + // + // NB: AsChar() returns char* in any build, unlike mb_str() + const char *AsChar(const wxMBConv& conv) const; + + // mb_str() implementation helper + wxScopedCharBuffer AsCharBuf(const wxMBConv& conv) const + { +#if wxUSE_UNICODE_UTF8 + // avoid conversion if we can + if ( conv.IsUTF8() ) + { + return wxScopedCharBuffer::CreateNonOwned(m_impl.c_str(), + m_impl.length()); + } +#endif // wxUSE_UNICODE_UTF8 + + // call this solely in order to fill in m_convertedToChar as AsChar() + // updates it as a side effect: this is a bit ugly but it's a completely + // internal function so the users of this class shouldn't care or know + // about it and doing it like this, i.e. having a separate AsChar(), + // allows us to avoid the creation and destruction of a temporary buffer + // when using wxCStrData without duplicating any code + if ( !AsChar(conv) ) + { + // although it would be probably more correct to return NULL buffer + // from here if the conversion fails, a lot of existing code doesn't + // expect mb_str() (or wc_str()) to ever return NULL so return an + // empty string otherwise to avoid crashes in it + // + // also, some existing code does check for the conversion success and + // so asserting here would be bad too -- even if it does mean that + // silently losing data is possible for badly written code + return wxScopedCharBuffer::CreateNonOwned("", 0); + } + + return m_convertedToChar.AsScopedBuffer(); + } + ConvertedBuffer m_convertedToChar; -#endif +#endif // !wxUSE_UNICODE + #if !wxUSE_UNICODE_WCHAR + // common wc_str() and wxCStrData::AsWChar() helper for both UTF-8 and ANSI + // builds: converts the string contents into m_convertedToWChar and returns + // NULL if the conversion failed (this can only happen in ANSI build) + // + // NB: AsWChar() returns wchar_t* in any build, unlike wc_str() + const wchar_t *AsWChar(const wxMBConv& conv) const; + + // wc_str() implementation helper + wxScopedWCharBuffer AsWCharBuf(const wxMBConv& conv) const + { + if ( !AsWChar(conv) ) + return wxScopedWCharBuffer::CreateNonOwned(L"", 0); + + return m_convertedToWChar.AsScopedBuffer(); + } + ConvertedBuffer m_convertedToWChar; -#endif +#endif // !wxUSE_UNICODE_WCHAR #if wxUSE_UNICODE_UTF8 // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently - // assigning to character pointer to by wxString::interator may + // assigning to character pointer to by wxString::iterator may // change the underlying wxStringImpl iterator, so we have to // keep track of all iterators and update them as necessary: struct wxStringIteratorNodeHead @@ -3367,7 +3578,7 @@ private: // copying is disallowed as it would result in more than one pointer into // the same linked list - DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead) + wxDECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead); }; wxStringIteratorNodeHead m_iterators; @@ -3382,7 +3593,7 @@ private: }; #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN - #pragma warning (default:4275) + #pragma warning (pop) #endif // string iterator operators that satisfy STL Random Access Iterator @@ -3437,9 +3648,9 @@ namespace wxPrivate template <> struct wxStringAsBufHelper { - static wxCharBuffer Get(const wxString& s, size_t *len) + static wxScopedCharBuffer Get(const wxString& s, size_t *len) { - wxCharBuffer buf(s.mb_str()); + wxScopedCharBuffer buf(s.mb_str()); if ( len ) *len = buf ? strlen(buf) : 0; return buf; @@ -3449,11 +3660,12 @@ struct wxStringAsBufHelper template <> struct wxStringAsBufHelper { - static wxWCharBuffer Get(const wxString& s, size_t *len) + static wxScopedWCharBuffer Get(const wxString& s, size_t *len) { + const size_t length = s.length(); if ( len ) - *len = s.length(); - return wxWCharBuffer::CreateNonOwned(s.wx_str()); + *len = length; + return wxScopedWCharBuffer::CreateNonOwned(s.wx_str(), length); } }; @@ -3462,20 +3674,21 @@ struct wxStringAsBufHelper template <> struct wxStringAsBufHelper { - static wxCharBuffer Get(const wxString& s, size_t *len) + static wxScopedCharBuffer Get(const wxString& s, size_t *len) { + const size_t length = s.utf8_length(); if ( len ) - *len = s.utf8_length(); - return wxCharBuffer::CreateNonOwned(s.wx_str()); + *len = length; + return wxScopedCharBuffer::CreateNonOwned(s.wx_str(), length); } }; template <> struct wxStringAsBufHelper { - static wxWCharBuffer Get(const wxString& s, size_t *len) + static wxScopedWCharBuffer Get(const wxString& s, size_t *len) { - wxWCharBuffer wbuf(s.wc_str()); + wxScopedWCharBuffer wbuf(s.wc_str()); if ( len ) *len = wxWcslen(wbuf); return wbuf; @@ -3510,7 +3723,7 @@ private: wxString& m_str; wxStringCharType *m_buf; - DECLARE_NO_COPY_CLASS(wxStringInternalBuffer) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer); }; class wxStringInternalBufferLength @@ -3540,13 +3753,13 @@ private: size_t m_len; bool m_lenSet; - DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength); }; #endif // !wxUSE_STL_BASED_WXSTRING template -class WXDLLIMPEXP_BASE wxStringTypeBufferBase +class wxStringTypeBufferBase { public: typedef T CharType; @@ -3586,8 +3799,7 @@ protected: }; template -class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase - : public wxStringTypeBufferBase +class wxStringTypeBufferLengthBase : public wxStringTypeBufferBase { public: wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024) @@ -3621,7 +3833,7 @@ public: this->m_str.assign(this->m_buf.data()); } - DECLARE_NO_COPY_CLASS(wxStringTypeBuffer) + wxDECLARE_NO_COPY_CLASS(wxStringTypeBuffer); }; template @@ -3637,7 +3849,7 @@ public: this->m_str.assign(this->m_buf.data(), this->m_len); } - DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength) + wxDECLARE_NO_COPY_CLASS(wxStringTypeBufferLength); }; #if wxUSE_STL_BASED_WXSTRING @@ -3652,7 +3864,7 @@ public: ~wxStringInternalBuffer() { m_str.m_impl.assign(m_buf.data()); } - DECLARE_NO_COPY_CLASS(wxStringInternalBuffer) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer); }; WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( @@ -3670,7 +3882,7 @@ public: m_str.m_impl.assign(m_buf.data(), m_len); } - DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength); }; #endif // wxUSE_STL_BASED_WXSTRING @@ -3691,27 +3903,59 @@ typedef wxStringInternalBufferLength wxUTF8StringBufferLength; WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase ) -class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase +// Note about inlined dtors in the classes below: this is done not for +// performance reasons but just to avoid linking errors in the MSVC DLL build +// under Windows: if a class has non-inline methods it must be declared as +// being DLL-exported but, due to an extremely interesting feature of MSVC 7 +// and later, any template class which is used as a base of a DLL-exported +// class is implicitly made DLL-exported too, as explained at the bottom of +// http://msdn.microsoft.com/en-us/library/twa2aw10.aspx (just to confirm: yes, +// _inheriting_ from a class can change whether it is being exported from DLL) +// +// But this results in link errors because the base template class is not DLL- +// exported, whether it is declared with WXDLLIMPEXP_BASE or not, because it +// does have only inline functions. So the simplest fix is to just make all the +// functions of these classes inline too. + +class wxUTF8StringBuffer : public wxStringTypeBufferBase { public: wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024) : wxStringTypeBufferBase(str, lenWanted) {} - ~wxUTF8StringBuffer(); + ~wxUTF8StringBuffer() + { + wxMBConvStrictUTF8 conv; + size_t wlen = conv.ToWChar(NULL, 0, m_buf); + wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" ); + + wxStringInternalBuffer wbuf(m_str, wlen); + conv.ToWChar(wbuf, wlen, m_buf); + } - DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer) + wxDECLARE_NO_COPY_CLASS(wxUTF8StringBuffer); }; WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase ) -class WXDLLIMPEXP_BASE wxUTF8StringBufferLength - : public wxStringTypeBufferLengthBase +class wxUTF8StringBufferLength : public wxStringTypeBufferLengthBase { public: wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024) : wxStringTypeBufferLengthBase(str, lenWanted) {} - ~wxUTF8StringBufferLength(); + ~wxUTF8StringBufferLength() + { + wxCHECK_RET(m_lenSet, "length not set"); + + wxMBConvStrictUTF8 conv; + size_t wlen = conv.ToWChar(NULL, 0, m_buf, m_len); + wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" ); + + wxStringInternalBufferLength wbuf(m_str, wlen); + conv.ToWChar(wbuf, wlen, m_buf, m_len); + wbuf.SetLength(wlen); + } - DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength) + wxDECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength); }; #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR @@ -3748,32 +3992,32 @@ inline bool operator!=(const wxString& s1, const wxCStrData& s2) inline bool operator!=(const wxCStrData& s1, const wxString& s2) { return s1.AsString() != s2; } -inline bool operator==(const wxString& s1, const wxWCharBuffer& s2) +inline bool operator==(const wxString& s1, const wxScopedWCharBuffer& s2) { return (s1.Cmp((const wchar_t *)s2) == 0); } -inline bool operator==(const wxWCharBuffer& s1, const wxString& s2) +inline bool operator==(const wxScopedWCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const wchar_t *)s1) == 0); } -inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2) +inline bool operator!=(const wxString& s1, const wxScopedWCharBuffer& s2) { return (s1.Cmp((const wchar_t *)s2) != 0); } -inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2) +inline bool operator!=(const wxScopedWCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const wchar_t *)s1) != 0); } -inline bool operator==(const wxString& s1, const wxCharBuffer& s2) +inline bool operator==(const wxString& s1, const wxScopedCharBuffer& s2) { return (s1.Cmp((const char *)s2) == 0); } -inline bool operator==(const wxCharBuffer& s1, const wxString& s2) +inline bool operator==(const wxScopedCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) == 0); } -inline bool operator!=(const wxString& s1, const wxCharBuffer& s2) +inline bool operator!=(const wxString& s1, const wxScopedCharBuffer& s2) { return (s1.Cmp((const char *)s2) != 0); } -inline bool operator!=(const wxCharBuffer& s1, const wxString& s2) +inline bool operator!=(const wxScopedCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) != 0); } -inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) +inline wxString operator+(const wxString& string, const wxScopedWCharBuffer& buf) { return string + (const wchar_t *)buf; } -inline wxString operator+(const wxWCharBuffer& buf, const wxString& string) +inline wxString operator+(const wxScopedWCharBuffer& buf, const wxString& string) { return (const wchar_t *)buf + string; } -inline wxString operator+(const wxString& string, const wxCharBuffer& buf) +inline wxString operator+(const wxString& string, const wxScopedCharBuffer& buf) { return string + (const char *)buf; } -inline wxString operator+(const wxCharBuffer& buf, const wxString& string) +inline wxString operator+(const wxScopedCharBuffer& buf, const wxString& string) { return (const char *)buf + string; } // comparison with char @@ -3831,16 +4075,16 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA) WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&); -WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&); +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxScopedCharBuffer&); #ifndef __BORLANDC__ -WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&); +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxScopedWCharBuffer&); #endif #if wxUSE_UNICODE && defined(HAVE_WOSTREAM) WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&); WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&); -WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxWCharBuffer&); +WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxScopedWCharBuffer&); #endif // wxUSE_UNICODE && defined(HAVE_WOSTREAM) @@ -3865,48 +4109,56 @@ inline wxCStrData::wxCStrData(const wxCStrData& data) inline wxCStrData::~wxCStrData() { if ( m_owned ) - delete wx_const_cast(wxString*, m_str); // cast to silence warnings + delete const_cast(m_str); // cast to silence warnings } -// simple cases for AsChar() and AsWChar(), the complicated ones are -// in string.cpp -#if wxUSE_UNICODE_WCHAR +// AsChar() and AsWChar() implementations simply forward to wxString methods + inline const wchar_t* wxCStrData::AsWChar() const { - return m_str->wx_str() + m_offset; -} -#endif // wxUSE_UNICODE_WCHAR + const wchar_t * const p = +#if wxUSE_UNICODE_WCHAR + m_str->wc_str(); +#elif wxUSE_UNICODE_UTF8 + m_str->AsWChar(wxMBConvStrictUTF8()); +#else + m_str->AsWChar(wxConvLibc); +#endif + // in Unicode build the string always has a valid Unicode representation + // and even if a conversion is needed (as in UTF8 case) it can't fail + // + // but in ANSI build the string contents might be not convertible to + // Unicode using the current locale encoding so we do need to check for + // errors #if !wxUSE_UNICODE -inline const char* wxCStrData::AsChar() const -{ - return m_str->wx_str() + m_offset; -} + if ( !p ) + { + // if conversion fails, 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 + // from its c_str() and so we shouldn't neither + // + // notice that the same is done in AsChar() below and + // wxString::wc_str() and mb_str() for the same reasons + return L""; + } #endif // !wxUSE_UNICODE -#if wxUSE_UTF8_LOCALE_ONLY -inline const char* wxCStrData::AsChar() const -{ - return wxStringOperations::AddToIter(m_str->wx_str(), m_offset); + return p + m_offset; } -#endif // wxUSE_UTF8_LOCALE_ONLY -inline const wxCharBuffer wxCStrData::AsCharBuf() const -{ -#if !wxUSE_UNICODE - return wxCharBuffer::CreateNonOwned(AsChar()); -#else - return AsString().mb_str(); -#endif -} - -inline const wxWCharBuffer wxCStrData::AsWCharBuf() const +inline const char* wxCStrData::AsChar() const { -#if wxUSE_UNICODE_WCHAR - return wxWCharBuffer::CreateNonOwned(AsWChar()); -#else - return AsString().wc_str(); -#endif +#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY + const char * const p = m_str->AsChar(wxConvLibc); + if ( !p ) + return ""; +#else // !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY + const char * const p = m_str->mb_str(); +#endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY + + return p + m_offset; } inline wxString wxCStrData::AsString() const @@ -3929,7 +4181,7 @@ inline const wxStringCharType *wxCStrData::AsInternal() const inline wxUniChar wxCStrData::operator*() const { if ( m_str->empty() ) - return wxUniChar(_T('\0')); + return wxUniChar(wxT('\0')); else return (*m_str)[m_offset]; } @@ -3988,7 +4240,7 @@ void wxStringIteratorNode::DoSet(const wxString *str, if ( str ) { m_next = str->m_iterators.ptr; - wx_const_cast(wxString*, m_str)->m_iterators.ptr = this; + const_cast(m_str)->m_iterators.ptr = this; if ( m_next ) m_next->m_prev = this; } @@ -4005,7 +4257,7 @@ void wxStringIteratorNode::clear() if ( m_prev ) m_prev->m_next = m_next; else if ( m_str ) // first in the list - wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next; + const_cast(m_str)->m_iterators.ptr = m_next; m_next = m_prev = NULL; m_citer = NULL; @@ -4022,4 +4274,19 @@ void wxStringIteratorNode::clear() #include "wx/crt.h" #endif +// ---------------------------------------------------------------------------- +// Checks on wxString characters +// ---------------------------------------------------------------------------- + +template + inline bool wxStringCheck(const wxString& val) + { + for ( wxString::const_iterator i = val.begin(); + i != val.end(); + ++i ) + if (T(*i) == 0) + return false; + return true; + } + #endif // _WX_WXSTRING_H_