X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cbec0f401afa51ec852d599e0119f4a8966aec19..aadbdd1699e512735a6e63798530192b1f9cb09b:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 22e0ec6f5e..e1cc80ae33 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -209,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 @@ -225,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(); } @@ -245,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; @@ -262,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 @@ -278,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); } @@ -287,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; @@ -350,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) @@ -372,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) @@ -390,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 @@ -426,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 @@ -476,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 @@ -512,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) @@ -525,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); } @@ -550,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()); } @@ -985,9 +1004,19 @@ public: iterator operator-(ptrdiff_t n) const { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } + // Normal iterators need to be comparable with the const_iterators so + // declare the comparison operators and implement them below after the + // full const_iterator declaration. + bool operator==(const const_iterator& i) const; + bool operator!=(const const_iterator& i) const; + bool operator<(const const_iterator& i) const; + bool operator>(const const_iterator& i) const; + bool operator<=(const const_iterator& i) const; + bool operator>=(const const_iterator& i) const; + 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 const_cast(m_node.m_str); } @@ -1029,10 +1058,15 @@ public: const_iterator operator-(ptrdiff_t n) const { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } + // Notice that comparison operators taking non-const iterator are not + // needed here because of the implicit conversion from non-const iterator + // to const ones ensure that the versions for const_iterator declared + // inside WX_STR_ITERATOR_IMPL can be used. + 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; } @@ -1064,6 +1098,15 @@ public: iterator operator-(ptrdiff_t n) const { return iterator(wxStringOperations::AddToIter(m_cur, -n)); } + // As in UTF-8 case above, define comparison operators taking + // const_iterator too. + bool operator==(const const_iterator& i) const; + bool operator!=(const const_iterator& i) const; + bool operator<(const const_iterator& i) const; + bool operator>(const const_iterator& i) const; + bool operator<=(const const_iterator& i) const; + bool operator>=(const const_iterator& i) const; + private: // for internal wxString use only: iterator(underlying_iterator ptr) : m_cur(ptr) {} @@ -1091,6 +1134,11 @@ public: const_iterator operator-(ptrdiff_t n) const { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); } + // As in UTF-8 case above, we don't need comparison operators taking + // iterator because we have an implicit conversion from iterator to + // const_iterator so the operators declared by WX_STR_ITERATOR_IMPL will + // be used. + private: // for internal wxString use only: const_iterator(underlying_iterator ptr) : m_cur(ptr) {} @@ -1265,10 +1313,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 @@ -1297,12 +1345,13 @@ public: } #endif // wxUSE_STRING_POS_CACHE - // even if we're not built with wxUSE_STL == 1 it is very convenient to allow - // implicit conversions from std::string to wxString and vice verse as this - // allows to use the same strings in non-GUI and GUI code, however we don't - // want to unconditionally add this ctor as it would make wx lib dependent on - // libstdc++ on some Linux versions which is bad, so instead we ask the - // client code to define this wxUSE_STD_STRING symbol if they need it + // even if we're not built with wxUSE_STD_STRING_CONV_IN_WXSTRING == 1 it is + // very convenient to allow implicit conversions from std::string to wxString + // and vice verse as this allows to use the same strings in non-GUI and GUI + // code, however we don't want to unconditionally add this ctor as it would + // make wx lib dependent on libstdc++ on some Linux versions which is bad, so + // instead we ask the client code to define this wxUSE_STD_STRING symbol if + // they need it #if wxUSE_STD_STRING #if wxUSE_UNICODE_WCHAR wxString(const wxStdWideString& str) : m_impl(str) {} @@ -1320,30 +1369,57 @@ public: #endif #endif // wxUSE_STD_STRING - // 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 + // Also always provide explicit conversions to std::[w]string in any case, + // see below for the implicit ones. +#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 + { +#if wxUSE_UNICODE_WCHAR + wxScopedWCharBuffer buf = + wxScopedWCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length()); +#else // !wxUSE_UNICODE_WCHAR + wxScopedWCharBuffer buf(wc_str()); +#endif + + 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 -#endif // wxUSE_STL + +#if wxUSE_STD_STRING_CONV_IN_WXSTRING + // Implicit conversions to std::[w]string are not provided by default as + // they conflict with the implicit conversions to "const char/wchar_t *" + // which we use for backwards compatibility but do provide them if + // explicitly requested. + operator wxStringToStdStringRetType() const { return ToStdString(); } + operator wxStringToStdWstringRetType() const { return ToStdWstring(); } +#endif // wxUSE_STD_STRING_CONV_IN_WXSTRING + +#undef wxStringToStdStringRetType +#undef wxStringToStdWstringRetType + +#endif // wxUSE_STD_STRING wxString Clone() const { @@ -1490,14 +1566,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(); } @@ -1578,11 +1654,12 @@ public: operator wxCStrData() const { return c_str(); } // the first two operators conflict with operators for conversion to - // std::string and they must be disabled in STL build; the next one only - // makes sense if conversions to char* are also defined and not defining it - // in STL build also helps us to get more clear error messages for the code - // which relies on implicit conversion to char* in STL build -#if !wxUSE_STL + // std::string and they must be disabled if those conversions are enabled; + // the next one only makes sense if conversions to char* are also defined + // and not defining it in STL build also helps us to get more clear error + // messages for the code which relies on implicit conversion to char* in + // STL build +#if !wxUSE_STD_STRING_CONV_IN_WXSTRING operator const char*() const { return c_str(); } operator const wchar_t*() const { return c_str(); } @@ -1590,7 +1667,7 @@ public: // wxWidgets versions: this is the same as conversion to const char * so it // may fail! operator const void*() const { return c_str(); } -#endif // wxUSE_STL +#endif // !wxUSE_STD_STRING_CONV_IN_WXSTRING // identical to c_str(), for MFC compatibility const wxCStrData GetData() const { return c_str(); } @@ -1626,7 +1703,7 @@ public: if ( len ) *len = length(); - return wxCharTypeBuffer::CreateNonOwned(wx_str()); + return wxCharTypeBuffer::CreateNonOwned(wx_str(), length()); #endif // Unicode build kind } @@ -1640,7 +1717,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) @@ -1695,8 +1772,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 @@ -1711,33 +1788,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) @@ -1745,14 +1828,16 @@ 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); } // version for NUL-terminated data: static wxString From8BitData(const char *data) { return wxString(data); } - const char *To8BitData() const { return c_str(); } + const wxScopedCharBuffer To8BitData() const + { return wxScopedCharBuffer::CreateNonOwned(wx_str(), length()); } #endif // Unicode/ANSI // conversions with (possible) format conversions: have to return a @@ -1764,48 +1849,62 @@ 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 @@ -1900,12 +1999,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 @@ -1919,7 +2018,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); @@ -1940,10 +2039,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) @@ -1961,9 +2060,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; } @@ -1971,9 +2070,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) @@ -2013,36 +2112,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); } -#if defined wxLongLong_t && !defined wxLongLongIsLong + { return (*this) << Format(wxT("%lu"), ul); } +#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG // 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 +#endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG // 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) @@ -2054,9 +2151,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; @@ -2079,9 +2176,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; @@ -2120,11 +2217,13 @@ public: // get last nCount characters wxString Right(size_t nCount) const; // get all characters before the first occurrence of ch - // (returns the whole string if ch not found) - wxString BeforeFirst(wxUniChar ch) const; + // (returns the whole string if ch not found) and also put everything + // following the first occurrence of ch into rest if it's non-NULL + wxString BeforeFirst(wxUniChar ch, wxString *rest = NULL) const; // get all characters before the last occurrence of ch - // (returns empty string if ch not found) - wxString BeforeLast(wxUniChar ch) const; + // (returns empty string if ch not found) and also put everything + // following the last occurrence of ch into rest if it's non-NULL + wxString BeforeLast(wxUniChar ch, wxString *rest = NULL) const; // get all characters after the first occurrence of ch // (returns empty string if ch not found) wxString AfterFirst(wxUniChar ch) const; @@ -2188,9 +2287,9 @@ 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) occurrences of substring with @@ -2202,24 +2301,38 @@ 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; + + // 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; + + // create a string representing the given floating point number with the + // default (like %g) or fixed (if precision >=0) precision + // in the current locale + static wxString FromDouble(double val, int precision = -1); + // in C locale + static wxString FromCDouble(double val, int precision = -1); #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // formatted input/output @@ -2245,7 +2358,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__ @@ -2294,7 +2407,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__ @@ -2375,7 +2488,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 @@ -2435,15 +2548,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 @@ -2567,15 +2680,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' @@ -2626,9 +2739,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; @@ -3009,9 +3122,9 @@ 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); } @@ -3055,9 +3168,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); } @@ -3243,54 +3356,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 @@ -3323,10 +3436,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) { @@ -3389,36 +3502,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 @@ -3428,7 +3622,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; @@ -3443,7 +3637,7 @@ private: }; #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN - #pragma warning (default:4275) + #pragma warning (pop) #endif // string iterator operators that satisfy STL Random Access Iterator @@ -3498,9 +3692,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; @@ -3510,11 +3704,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); } }; @@ -3523,20 +3718,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; @@ -3571,7 +3767,7 @@ private: wxString& m_str; wxStringCharType *m_buf; - DECLARE_NO_COPY_CLASS(wxStringInternalBuffer) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer); }; class wxStringInternalBufferLength @@ -3601,7 +3797,7 @@ private: size_t m_len; bool m_lenSet; - DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength) + wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength); }; #endif // !wxUSE_STL_BASED_WXSTRING @@ -3681,7 +3877,7 @@ public: this->m_str.assign(this->m_buf.data()); } - DECLARE_NO_COPY_CLASS(wxStringTypeBuffer) + wxDECLARE_NO_COPY_CLASS(wxStringTypeBuffer); }; template @@ -3697,7 +3893,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 @@ -3712,7 +3908,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( @@ -3730,7 +3926,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 @@ -3780,7 +3976,7 @@ public: conv.ToWChar(wbuf, wlen, m_buf); } - DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer) + wxDECLARE_NO_COPY_CLASS(wxUTF8StringBuffer); }; WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase ) @@ -3803,7 +3999,7 @@ public: wbuf.SetLength(wlen); } - DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength) + wxDECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength); }; #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR @@ -3840,32 +4036,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 @@ -3888,6 +4084,21 @@ inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsS inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); } inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); } + +// wxString iterators comparisons +inline bool wxString::iterator::operator==(const const_iterator& i) const + { return i == *this; } +inline bool wxString::iterator::operator!=(const const_iterator& i) const + { return i != *this; } +inline bool wxString::iterator::operator<(const const_iterator& i) const + { return i > *this; } +inline bool wxString::iterator::operator>(const const_iterator& i) const + { return i < *this; } +inline bool wxString::iterator::operator<=(const const_iterator& i) const + { return i >= *this; } +inline bool wxString::iterator::operator>=(const const_iterator& i) const + { return i <= *this; } + // comparison with C string in Unicode build #if wxUSE_UNICODE @@ -3923,16 +4134,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) @@ -3960,45 +4171,53 @@ inline wxCStrData::~wxCStrData() 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); -} -#endif // wxUSE_UTF8_LOCALE_ONLY - -inline const wxCharBuffer wxCStrData::AsCharBuf() const -{ -#if !wxUSE_UNICODE - return wxCharBuffer::CreateNonOwned(AsChar()); -#else - return AsString().mb_str(); -#endif + return p + m_offset; } -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 @@ -4021,7 +4240,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]; }