check for HAVE_VISIBILITY first when setting WXIMPORT/WXEXPORT; only set it on platfo...

[wxWidgets.git] / src / common / string.cpp

diff --git a/src/common/string.cpp b/src/common/string.cpp
index 410039b0bc553e6dfcb55164f2001ffcb09411c4..d36f85bd5a2cb4259e40df65fdd87a9cc3bfb7f8 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -10,13 +10,6 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-/*
- * About ref counting:
- *  1) all empty strings use g_strEmpty, nRefs = -1 (set in Init())
- *  2) AllocBuffer() sets nRefs to 1, Lock() increments it by one
- *  3) Unlock() decrements nRefs and frees memory if it goes to 0
- */
-

 // ===========================================================================
 // headers, declarations, constants
 // ===========================================================================
 // ===========================================================================
 // headers, declarations, constants
 // ===========================================================================


@@ -30,6 +23,7 @@
 
 #ifndef WX_PRECOMP
     #include "wx/string.h"
 
 #ifndef WX_PRECOMP
     #include "wx/string.h"

+    #include "wx/wxcrtvararg.h"

 #endif
 
 #include <ctype.h>
 #endif
 
 #include <ctype.h>


@@ -45,7 +39,7 @@
     #include <clib.h>
 #endif
 
     #include <clib.h>
 #endif
 

-#include <wx/hashmap.h>
+#include "wx/hashmap.h"

 
 // string handling functions used by wxString:
 #if wxUSE_UNICODE_UTF8
 
 // string handling functions used by wxString:
 #if wxUSE_UNICODE_UTF8


@@ -80,9 +74,9 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxCStrData& str)
 {
 // FIXME-UTF8: always, not only if wxUSE_UNICODE
 #if wxUSE_UNICODE && !defined(__BORLANDC__)
 {
 // FIXME-UTF8: always, not only if wxUSE_UNICODE
 #if wxUSE_UNICODE && !defined(__BORLANDC__)

-    return os << str.AsWChar();
+    return os << (const wchar_t*)str.AsWCharBuf();

 #else
 #else

-    return os << str.AsChar();
+    return os << (const char*)str.AsCharBuf();

 #endif
 }
 
 #endif
 }
 


@@ -105,10 +99,47 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
 
 #endif // wxUSE_STD_IOSTREAM
 
 
 #endif // wxUSE_STD_IOSTREAM
 

+// ===========================================================================
+// wxString class core
+// ===========================================================================
+
+#if wxUSE_UNICODE_UTF8
+
+void wxString::PosLenToImpl(size_t pos, size_t len,
+                            size_t *implPos, size_t *implLen) const
+{
+    if ( pos == npos )
+        *implPos = npos;
+    else
+    {
+        const_iterator i = begin() + pos;
+        *implPos = wxStringImpl::const_iterator(i.impl()) - m_impl.begin();
+        if ( len == npos )
+            *implLen = npos;
+        else
+        {
+            // too large length is interpreted as "to the end of the string"
+            // FIXME-UTF8: verify this is the case in std::string, assert
+            // otherwise
+            if ( pos + len > length() )
+                len = length() - pos;
+
+            *implLen = (i + len).impl() - i.impl();
+        }
+    }
+}
+
+#endif // wxUSE_UNICODE_UTF8
+

 // ----------------------------------------------------------------------------
 // wxCStrData converted strings caching
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxCStrData converted strings caching
 // ----------------------------------------------------------------------------
 

+// FIXME-UTF8: temporarily disabled because it doesn't work with global
+//             string objects; re-enable after fixing this bug and benchmarking
+//             performance to see if using a hash is a good idea at all
+#if 0
+

 // For backward compatibility reasons, it must be possible to assign the value
 // returned by wxString::c_str() to a char* or wchar_t* variable and work with
 // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick,
 // For backward compatibility reasons, it must be possible to assign the value
 // returned by wxString::c_str() to a char* or wchar_t* variable and work with
 // it. Returning wxCharBuffer from (const char*)c_str() wouldn't do the trick,


@@ -131,7 +162,7 @@ wxSTD ostream& operator<<(wxSTD ostream& os, const wxWCharBuffer& str)
 template<typename T>
 static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
 {
 template<typename T>
 static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
 {

-    typename T::iterator i = hash.find(s);
+    typename T::iterator i = hash.find(wxConstCast(s, wxString));

     if ( i != hash.end() )
     {
         free(i->second);
     if ( i != hash.end() )
     {
         free(i->second);


@@ -140,6 +171,8 @@ static inline void DeleteStringFromConversionCache(T& hash, const wxString *s)
 }
 
 #if wxUSE_UNICODE
 }
 
 #if wxUSE_UNICODE

+// NB: non-STL implementation doesn't compile with "const wxString*" key type,
+//     so we have to use wxString* here and const-cast when used

 WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual,
                     wxStringCharConversionCache);
 static wxStringCharConversionCache gs_stringsCharCache;
 WX_DECLARE_HASH_MAP(wxString*, char*, wxPointerHash, wxPointerEqual,
                     wxStringCharConversionCache);
 static wxStringCharConversionCache gs_stringsCharCache;


@@ -150,7 +183,8 @@ const char* wxCStrData::AsChar() const
     DeleteStringFromConversionCache(gs_stringsCharCache, m_str);
 
     // convert the string and keep it:
     DeleteStringFromConversionCache(gs_stringsCharCache, m_str);
 
     // convert the string and keep it:

-    const char *s = gs_stringsCharCache[m_str] = m_str->mb_str().release();
+    const char *s = gs_stringsCharCache[wxConstCast(m_str, wxString)] =
+        m_str->mb_str().release();

 
     return s + m_offset;
 }
 
     return s + m_offset;
 }


@@ -167,20 +201,13 @@ const wchar_t* wxCStrData::AsWChar() const
     DeleteStringFromConversionCache(gs_stringsWCharCache, m_str);
 
     // convert the string and keep it:
     DeleteStringFromConversionCache(gs_stringsWCharCache, m_str);
 
     // convert the string and keep it:

-    const wchar_t *s = gs_stringsWCharCache[m_str] = m_str->wc_str().release();
+    const wchar_t *s = gs_stringsWCharCache[wxConstCast(m_str, wxString)] =
+        m_str->wc_str().release();

 
     return s + m_offset;
 }
 #endif // !wxUSE_UNICODE_WCHAR
 
 
     return s + m_offset;
 }
 #endif // !wxUSE_UNICODE_WCHAR
 

-// ===========================================================================
-// wxString class core
-// ===========================================================================
-
-// ---------------------------------------------------------------------------
-// construction and conversion
-// ---------------------------------------------------------------------------
-

 wxString::~wxString()
 {
 #if wxUSE_UNICODE
 wxString::~wxString()
 {
 #if wxUSE_UNICODE


@@ -191,15 +218,83 @@ wxString::~wxString()
     DeleteStringFromConversionCache(gs_stringsWCharCache, this);
 #endif
 }
     DeleteStringFromConversionCache(gs_stringsWCharCache, this);
 #endif
 }

+#endif

 
 

-#if wxUSE_UNICODE
+#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
+const char* wxCStrData::AsChar() const
+{
+#if wxUSE_UNICODE_UTF8
+    if ( wxLocaleIsUtf8 )
+        return AsInternal();
+#endif
+    // under non-UTF8 locales, we have to convert the internal UTF-8
+    // representation using wxConvLibc and cache the result
+
+    wxString *str = wxConstCast(m_str, wxString);
+
+    // convert the string:
+    wxCharBuffer buf(str->mb_str());
+
+    // FIXME-UTF8: do the conversion in-place in the existing buffer
+    if ( str->m_convertedToChar &&
+         strlen(buf) == strlen(str->m_convertedToChar) )
+    {
+        // keep the same buffer for as long as possible, so that several calls
+        // to c_str() in a row still work:
+        strcpy(str->m_convertedToChar, buf);
+    }
+    else
+    {
+        str->m_convertedToChar = buf.release();
+    }
+
+    // and keep it:
+    return str->m_convertedToChar + m_offset;
+}
+#endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
+
+#if !wxUSE_UNICODE_WCHAR
+const wchar_t* wxCStrData::AsWChar() const
+{
+    wxString *str = wxConstCast(m_str, wxString);
+
+    // convert the string:
+    wxWCharBuffer buf(str->wc_str());
+
+    // FIXME-UTF8: do the conversion in-place in the existing buffer
+    if ( str->m_convertedToWChar &&
+         wxWcslen(buf) == wxWcslen(str->m_convertedToWChar) )
+    {
+        // keep the same buffer for as long as possible, so that several calls
+        // to c_str() in a row still work:
+        memcpy(str->m_convertedToWChar, buf, sizeof(wchar_t) * wxWcslen(buf));
+    }
+    else
+    {
+        str->m_convertedToWChar = buf.release();
+    }
+
+    // and keep it:
+    return str->m_convertedToWChar + m_offset;
+}
+#endif // !wxUSE_UNICODE_WCHAR
+
+// ===========================================================================
+// wxString class core
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// construction and conversion
+// ---------------------------------------------------------------------------
+
+#if wxUSE_UNICODE_WCHAR

 /* static */
 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
                                                const wxMBConv& conv)
 {
     // anything to do?
     if ( !psz || nLength == 0 )
 /* static */
 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
                                                const wxMBConv& conv)
 {
     // anything to do?
     if ( !psz || nLength == 0 )

-        return SubstrBufFromMB();
+        return SubstrBufFromMB(L"", 0);

 
     if ( nLength == npos )
         nLength = wxNO_LEN;
 
     if ( nLength == npos )
         nLength = wxNO_LEN;


@@ -207,18 +302,60 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
     size_t wcLen;
     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
     if ( !wcLen )
     size_t wcLen;
     wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
     if ( !wcLen )

-        return SubstrBufFromMB();
+        return SubstrBufFromMB(_T(""), 0);

     else
         return SubstrBufFromMB(wcBuf, wcLen);
 }
     else
         return SubstrBufFromMB(wcBuf, wcLen);
 }

-#else
+#endif // wxUSE_UNICODE_WCHAR
+
+#if wxUSE_UNICODE_UTF8
+/* static */
+wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
+                                               const wxMBConv& conv)
+{
+    // anything to do?
+    if ( !psz || nLength == 0 )
+        return SubstrBufFromMB("", 0);
+
+    // if psz is already in UTF-8, we don't have to do the roundtrip to
+    // wchar_t* and back:
+    if ( conv.IsUTF8() )
+    {
+        // we need to validate the input because UTF8 iterators assume valid
+        // UTF-8 sequence and psz may be invalid:
+        if ( wxStringOperations::IsValidUtf8String(psz, nLength) )
+        {
+            return SubstrBufFromMB(wxCharBuffer::CreateNonOwned(psz), nLength);
+        }
+        // else: do the roundtrip through wchar_t*
+    }
+
+    if ( nLength == npos )
+        nLength = wxNO_LEN;
+
+    // first convert to wide string:
+    size_t wcLen;
+    wxWCharBuffer wcBuf(conv.cMB2WC(psz, nLength, &wcLen));
+    if ( !wcLen )
+        return SubstrBufFromMB("", 0);
+
+    // and then to UTF-8:
+    SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxMBConvStrictUTF8()));
+    // widechar -> UTF-8 conversion isn't supposed to ever fail:
+    wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
+
+    return buf;
+}
+#endif // wxUSE_UNICODE_UTF8
+
+#if wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE

 /* static */
 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
                                                const wxMBConv& conv)
 {
     // anything to do?
     if ( !pwz || nLength == 0 )
 /* static */
 wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLength,
                                                const wxMBConv& conv)
 {
     // anything to do?
     if ( !pwz || nLength == 0 )

-        return SubstrBufFromWC();
+        return SubstrBufFromWC("", 0);

 
     if ( nLength == npos )
         nLength = wxNO_LEN;
 
     if ( nLength == npos )
         nLength = wxNO_LEN;


@@ -226,34 +363,62 @@ wxString::SubstrBufFromWC wxString::ConvertStr(const wchar_t *pwz, size_t nLengt
     size_t mbLen;
     wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
     if ( !mbLen )
     size_t mbLen;
     wxCharBuffer mbBuf(conv.cWC2MB(pwz, nLength, &mbLen));
     if ( !mbLen )

-        return SubstrBufFromWC();
+        return SubstrBufFromWC("", 0);

     else
         return SubstrBufFromWC(mbBuf, mbLen);
 }
     else
         return SubstrBufFromWC(mbBuf, mbLen);
 }

-#endif
+#endif // wxUSE_UNICODE_UTF8 || !wxUSE_UNICODE

 
 
 
 

-#if wxUSE_UNICODE
+#if wxUSE_UNICODE_WCHAR

 
 //Convert wxString in Unicode mode to a multi-byte string
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 {
 
 //Convert wxString in Unicode mode to a multi-byte string
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 {

-    return conv.cWC2MB(c_str(), length() + 1 /* size, not length */, NULL);
+    return conv.cWC2MB(wx_str(), length() + 1 /* size, not length */, NULL);

 }
 
 }
 

-#else // ANSI
+#elif wxUSE_UNICODE_UTF8
+
+const wxWCharBuffer wxString::wc_str() const
+{
+    return wxMBConvStrictUTF8().cMB2WC
+                                (
+                                    m_impl.c_str(),
+                                    m_impl.length() + 1, // size, not length
+                                    NULL
+                                );
+}
+
+const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
+{
+    if ( conv.IsUTF8() )
+        return wxCharBuffer::CreateNonOwned(m_impl.c_str());

 
 

-#if wxUSE_WCHAR_T
+    // FIXME-UTF8: use wc_str() here once we have buffers with length
+
+    size_t wcLen;
+    wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC
+                                             (
+                                                m_impl.c_str(),
+                                                m_impl.length() + 1, // size
+                                                &wcLen
+                                             ));
+    if ( !wcLen )
+        return wxCharBuffer("");
+
+    return conv.cWC2MB(wcBuf, wcLen, NULL);
+}
+
+#else // ANSI

 
 //Converts this string to a wide character string if unicode
 //mode is not enabled and wxUSE_WCHAR_T is enabled
 const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const
 {
 
 //Converts this string to a wide character string if unicode
 //mode is not enabled and wxUSE_WCHAR_T is enabled
 const wxWCharBuffer wxString::wc_str(const wxMBConv& conv) const
 {

-    return conv.cMB2WC(c_str(), length() + 1 /* size, not length */, NULL);
+    return conv.cMB2WC(wx_str(), length() + 1 /* size, not length */, NULL);

 }
 
 }
 

-#endif // wxUSE_WCHAR_T
-

 #endif // Unicode/ANSI
 
 // shrink to minimal size (releasing extra memory)
 #endif // Unicode/ANSI
 
 // shrink to minimal size (releasing extra memory)


@@ -266,7 +431,7 @@ bool wxString::Shrink()
 
 // deprecated compatibility code:
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
 
 // deprecated compatibility code:
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8

-wxChar *wxString::GetWriteBuf(size_t nLen)
+wxStringCharType *wxString::GetWriteBuf(size_t nLen)

 {
     return DoGetWriteBuf(nLen);
 }
 {
     return DoGetWriteBuf(nLen);
 }


@@ -405,6 +570,12 @@ wxString operator+(const wchar_t *pwz, const wxString& str)
 // string comparison
 // ---------------------------------------------------------------------------
 
 // string comparison
 // ---------------------------------------------------------------------------
 

+bool wxString::IsSameAs(wxUniChar c, bool compareWithCase) const
+{
+    return (length() == 1) && (compareWithCase ? GetChar(0u) == c
+                               : wxToupper(GetChar(0u)) == wxToupper(c));
+}
+

 #ifdef HAVE_STD_STRING_COMPARE
 
 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with
 #ifdef HAVE_STD_STRING_COMPARE
 
 // NB: Comparison code (both if HAVE_STD_STRING_COMPARE and if not) works with


@@ -807,63 +978,69 @@ int wxString::CmpNoCase(const wxString& s) const
 #endif
 #endif
 
 #endif
 #endif
 

-wxString wxString::FromAscii(const char *ascii)
+wxString wxString::FromAscii(const char *ascii, size_t len)

 {
 {

-    if (!ascii)
+    if (!ascii || len == 0)

        return wxEmptyString;
 
        return wxEmptyString;
 

-    size_t len = strlen( ascii );

     wxString res;
 
     wxString res;
 

-    if ( len )

     {
     {

-        wxStringBuffer buf(res, len);
-
-        wchar_t *dest = buf;
+        wxImplStringBuffer buf(res, len);
+        wxStringCharType *dest = buf;

 
 

-        for ( ;; )
+        for ( ; len > 0; --len )

         {
         {

-           if ( (*dest++ = (wchar_t)(unsigned char)*ascii++) == L'\0' )
-               break;
+            unsigned char c = (unsigned char)*ascii++;
+            wxASSERT_MSG( c < 0x80,
+                          _T("Non-ASCII value passed to FromAscii().") );
+
+            *dest++ = (wchar_t)c;

         }
     }
 
     return res;
 }
 
         }
     }
 
     return res;
 }
 

+wxString wxString::FromAscii(const char *ascii)
+{
+    return FromAscii(ascii, wxStrlen(ascii));
+}
+

 wxString wxString::FromAscii(const char ascii)
 {
     // What do we do with '\0' ?
 
 wxString wxString::FromAscii(const char ascii)
 {
     // What do we do with '\0' ?
 

-    wxString res;
-    res += (wchar_t)(unsigned char) ascii;
+    unsigned char c = (unsigned char)ascii;

 
 

-    return res;
+    wxASSERT_MSG( c < 0x80, _T("Non-ASCII value passed to FromAscii().") );
+
+    // NB: the cast to wchar_t causes interpretation of 'ascii' as Latin1 value
+    return wxString(wxUniChar((wchar_t)c));

 }
 
 const wxCharBuffer wxString::ToAscii() const
 {
     // this will allocate enough space for the terminating NUL too
     wxCharBuffer buffer(length());
 }
 
 const wxCharBuffer wxString::ToAscii() const
 {
     // this will allocate enough space for the terminating NUL too
     wxCharBuffer buffer(length());

-
-

     char *dest = buffer.data();
 
     char *dest = buffer.data();
 

-    const wchar_t *pwc = c_str();
-    for ( ;; )
+    for ( const_iterator i = begin(); i != end(); ++i )

     {
     {

-        *dest++ = (char)(*pwc > SCHAR_MAX ? wxT('_') : *pwc);
+        wxUniChar c(*i);
+        // FIXME-UTF8: unify substituted char ('_') with wxUniChar ('?')
+        *dest++ = c.IsAscii() ? (char)c : '_';

 
         // the output string can't have embedded NULs anyhow, so we can safely
         // stop at first of them even if we do have any
 
         // the output string can't have embedded NULs anyhow, so we can safely
         // stop at first of them even if we do have any

-        if ( !*pwc++ )
+        if ( !c )

             break;
     }
 
     return buffer;
 }
 
             break;
     }
 
     return buffer;
 }
 

-#endif // Unicode
+#endif // wxUSE_UNICODE

 
 // extract string of length nCount starting at nFirst
 wxString wxString::Mid(size_t nFirst, size_t nCount) const
 
 // extract string of length nCount starting at nFirst
 wxString wxString::Mid(size_t nFirst, size_t nCount) const


@@ -899,28 +1076,15 @@ wxString wxString::Mid(size_t nFirst, size_t nCount) const
 
 // check that the string starts with prefix and return the rest of the string
 // in the provided pointer if it is not NULL, otherwise return false
 
 // check that the string starts with prefix and return the rest of the string
 // in the provided pointer if it is not NULL, otherwise return false

-bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
+bool wxString::StartsWith(const wxString& prefix, wxString *rest) const

 {
 {

-    wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
-
-    // first check if the beginning of the string matches the prefix: note
-    // that we don't have to check that we don't run out of this string as
-    // when we reach the terminating NUL, either prefix string ends too (and
-    // then it's ok) or we break out of the loop because there is no match
-    const wxChar *p = c_str();
-    while ( *prefix )
-    {
-        if ( *prefix++ != *p++ )
-        {
-            // no match
-            return false;
-        }
-    }
+    if ( compare(0, prefix.length(), prefix) != 0 )
+        return false;

 
     if ( rest )
     {
         // put the rest of the string into provided pointer
 
     if ( rest )
     {
         // put the rest of the string into provided pointer

-        *rest = p;
+        rest->assign(*this, prefix.length(), npos);

     }
 
     return true;
     }
 
     return true;


@@ -929,12 +1093,11 @@ bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
 
 // check that the string ends with suffix and return the rest of it in the
 // provided pointer if it is not NULL, otherwise return false
 
 // check that the string ends with suffix and return the rest of it in the
 // provided pointer if it is not NULL, otherwise return false

-bool wxString::EndsWith(const wxChar *suffix, wxString *rest) const
+bool wxString::EndsWith(const wxString& suffix, wxString *rest) const

 {
 {

-    wxASSERT_MSG( suffix, _T("invalid parameter in wxString::EndssWith") );
+    int start = length() - suffix.length();

 
 

-    int start = length() - wxStrlen(suffix);
-    if ( start < 0 || wxStrcmp(wx_str() + start, suffix) != 0 )
+    if ( start < 0 || compare(start, npos, suffix) != 0 )

         return false;
 
     if ( rest )
         return false;
 
     if ( rest )


@@ -1065,34 +1228,43 @@ size_t wxString::Replace(const wxString& strOld,
 
 bool wxString::IsAscii() const
 {
 
 bool wxString::IsAscii() const
 {

-  const wxChar *s = (const wxChar*) *this;
-  while(*s){
-    if(!isascii(*s)) return(false);
-    s++;
-  }
-  return(true);
+    for ( const_iterator i = begin(); i != end(); ++i )
+    {
+        if ( !(*i).IsAscii() )
+            return false;
+    }
+
+    return true;

 }
 
 bool wxString::IsWord() const
 {
 }
 
 bool wxString::IsWord() const
 {

-  const wxChar *s = (const wxChar*) *this;
-  while(*s){
-    if(!wxIsalpha(*s)) return(false);
-    s++;
-  }
-  return(true);
+    for ( const_iterator i = begin(); i != end(); ++i )
+    {
+        if ( !wxIsalpha(*i) )
+            return false;
+    }
+
+    return true;

 }
 
 bool wxString::IsNumber() const
 {
 }
 
 bool wxString::IsNumber() const
 {

-  const wxChar *s = (const wxChar*) *this;
-  if (wxStrlen(s))
-     if ((s[0] == wxT('-')) || (s[0] == wxT('+'))) s++;
-  while(*s){
-    if(!wxIsdigit(*s)) return(false);
-    s++;
-  }
-  return(true);
+    if ( empty() )
+        return true;
+
+    const_iterator i = begin();
+
+    if ( *i == _T('-') || *i == _T('+') )
+        ++i;
+
+    for ( ; i != end(); ++i )
+    {
+        if ( !wxIsdigit(*i) )
+            return false;
+    }
+
+    return true;

 }
 
 wxString wxString::Strip(stripType w) const
 }
 
 wxString wxString::Strip(stripType w) const


@@ -1215,14 +1387,15 @@ int wxString::Find(wxUniChar ch, bool bFromEnd) const
 // conversion to numbers
 // ----------------------------------------------------------------------------
 
 // conversion to numbers
 // ----------------------------------------------------------------------------
 

-// the implementation of all the functions below is exactly the same so factor
-// it out
+// The implementation of all the functions below is exactly the same so factor
+// it out. Note that number extraction works correctly on UTF-8 strings, so
+// we can use wxStringCharType and wx_str() for maximum efficiency.

 
 

-template <typename T, typename F>
-bool wxStringToIntType(const wxChar *start,
+template <typename T>
+bool wxStringToIntType(const wxStringCharType *start,

                        T *val,
                        int base,
                        T *val,
                        int base,

-                       F func)
+                       T (*func)(const wxStringCharType*, wxStringCharType**, int))

 {
     wxCHECK_MSG( val, false, _T("NULL output pointer") );
     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
 {
     wxCHECK_MSG( val, false, _T("NULL output pointer") );
     wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );


@@ -1231,7 +1404,7 @@ bool wxStringToIntType(const wxChar *start,
     errno = 0;
 #endif
 
     errno = 0;
 #endif
 

-    wxChar *end;
+    wxStringCharType *end;

     *val = (*func)(start, &end, base);
 
     // return true only if scan was stopped by the terminating NUL and if the
     *val = (*func)(start, &end, base);
 
     // return true only if scan was stopped by the terminating NUL and if the


@@ -1245,36 +1418,22 @@ bool wxStringToIntType(const wxChar *start,
 
 bool wxString::ToLong(long *val, int base) const
 {
 
 bool wxString::ToLong(long *val, int base) const
 {

-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtol);
+    return wxStringToIntType(wx_str(), val, base, wxStrtol);

 }
 
 bool wxString::ToULong(unsigned long *val, int base) const
 {
 }
 
 bool wxString::ToULong(unsigned long *val, int base) const
 {

-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoul);
+    return wxStringToIntType(wx_str(), val, base, wxStrtoul);

 }
 
 bool wxString::ToLongLong(wxLongLong_t *val, int base) const
 {
 }
 
 bool wxString::ToLongLong(wxLongLong_t *val, int base) const
 {

-#ifdef wxHAS_STRTOLL
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll);
-#else
-    // TODO: implement this ourselves
-    wxUnusedVar(val);
-    wxUnusedVar(base);
-    return false;
-#endif // wxHAS_STRTOLL
+    return wxStringToIntType(wx_str(), val, base, wxStrtoll);

 }
 
 bool wxString::ToULongLong(wxULongLong_t *val, int base) const
 {
 }
 
 bool wxString::ToULongLong(wxULongLong_t *val, int base) const
 {

-#ifdef wxHAS_STRTOLL
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull);
-#else
-    // TODO: implement this ourselves
-    wxUnusedVar(val);
-    wxUnusedVar(base);
-    return false;
-#endif
+    return wxStringToIntType(wx_str(), val, base, wxStrtoull);

 }
 
 bool wxString::ToDouble(double *val) const
 }
 
 bool wxString::ToDouble(double *val) const


@@ -1302,11 +1461,12 @@ bool wxString::ToDouble(double *val) const
 // formatted output
 // ---------------------------------------------------------------------------
 
 // formatted output
 // ---------------------------------------------------------------------------
 

+#if !wxUSE_UTF8_LOCALE_ONLY

 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN

-wxString wxStringPrintfMixinBase::DoFormat(const wxChar *format, ...)
+wxString wxStringPrintfMixinBase::DoFormatWchar(const wxChar *format, ...)

 #else
 #else

-wxString wxString::DoFormat(const wxChar *format, ...)
+wxString wxString::DoFormatWchar(const wxChar *format, ...)

 #endif
 {
     va_list argptr;
 #endif
 {
     va_list argptr;


@@ -1319,6 +1479,23 @@ wxString wxString::DoFormat(const wxChar *format, ...)
 
     return s;
 }
 
     return s;
 }

+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+/* static */
+wxString wxString::DoFormatUtf8(const char *format, ...)
+{
+    va_list argptr;
+    va_start(argptr, format);
+
+    wxString s;
+    s.PrintfV(format, argptr);
+
+    va_end(argptr);
+
+    return s;
+}
+#endif // wxUSE_UNICODE_UTF8

 
 /* static */
 wxString wxString::FormatV(const wxString& format, va_list argptr)
 
 /* static */
 wxString wxString::FormatV(const wxString& format, va_list argptr)


@@ -1328,10 +1505,11 @@ wxString wxString::FormatV(const wxString& format, va_list argptr)
     return s;
 }
 
     return s;
 }
 

+#if !wxUSE_UTF8_LOCALE_ONLY

 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN

-int wxStringPrintfMixinBase::DoPrintf(const wxChar *format, ...)
+int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...)

 #else
 #else

-int wxString::DoPrintf(const wxChar *format, ...)
+int wxString::DoPrintfWchar(const wxChar *format, ...)

 #endif
 {
     va_list argptr;
 #endif
 {
     va_list argptr;


@@ -1352,19 +1530,52 @@ int wxString::DoPrintf(const wxChar *format, ...)
 
     return iLen;
 }
 
     return iLen;
 }

+#endif // !wxUSE_UTF8_LOCALE_ONLY

 
 

-int wxString::PrintfV(const wxString& format, va_list argptr)
+#if wxUSE_UNICODE_UTF8
+int wxString::DoPrintfUtf8(const char *format, ...)
+{
+    va_list argptr;
+    va_start(argptr, format);
+
+    int iLen = PrintfV(format, argptr);
+
+    va_end(argptr);
+
+    return iLen;
+}
+#endif // wxUSE_UNICODE_UTF8
+
+#if wxUSE_UNICODE_UTF8
+template<typename BufferType>
+#else
+// we only need one version in non-UTF8 builds and at least two Windows
+// compilers have problems with this function template, so use just one
+// normal function here
+#endif
+static int DoStringPrintfV(wxString& str,
+                           const wxString& format, va_list argptr)

 {
     int size = 1024;
 
     for ( ;; )
     {
 {
     int size = 1024;
 
     for ( ;; )
     {

-        wxStringBuffer tmp(*this, size + 1);
+#if wxUSE_UNICODE_UTF8
+        BufferType tmp(str, size + 1);
+        typename BufferType::CharType *buf = tmp;
+#else
+        wxStringBuffer tmp(str, size + 1);

         wxChar *buf = tmp;
         wxChar *buf = tmp;

+#endif

 
         if ( !buf )
         {
             // out of memory
 
         if ( !buf )
         {
             // out of memory

+
+            // in UTF-8 build, leaving uninitialized junk in the buffer
+            // could result in invalid non-empty UTF-8 string, so just
+            // reset the string to empty on failure:
+            buf[0] = '\0';

             return -1;
         }
 
             return -1;
         }
 


@@ -1385,14 +1596,20 @@ int wxString::PrintfV(const wxString& format, va_list argptr)
         // buffer were large enough (newer standards such as Unix98)
         if ( len < 0 )
         {
         // buffer were large enough (newer standards such as Unix98)
         if ( len < 0 )
         {

+            // NB: wxVsnprintf() may call either wxCRT_VsnprintfW or
+            //     wxCRT_VsnprintfA in UTF-8 build; wxUSE_WXVSNPRINTF
+            //     is true if *both* of them use our own implementation,
+            //     otherwise we can't be sure

 #if wxUSE_WXVSNPRINTF
             // we know that our own implementation of wxVsnprintf() returns -1
             // only for a format error - thus there's something wrong with
             // the user's format string
 #if wxUSE_WXVSNPRINTF
             // we know that our own implementation of wxVsnprintf() returns -1
             // only for a format error - thus there's something wrong with
             // the user's format string

+            buf[0] = '\0';

             return -1;
             return -1;

-#else // assume that system version only returns error if not enough space
-            // still not enough, as we don't know how much we need, double the
-            // current size of the buffer
+#else // possibly using system version
+            // assume it only returns error if there is not enough space, but
+            // as we don't know how much we need, double the current size of
+            // the buffer

             size *= 2;
 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
         }
             size *= 2;
 #endif // wxUSE_WXVSNPRINTF/!wxUSE_WXVSNPRINTF
         }


@@ -1416,9 +1633,34 @@ int wxString::PrintfV(const wxString& format, va_list argptr)
     }
 
     // we could have overshot
     }
 
     // we could have overshot

-    Shrink();
+    str.Shrink();
+
+    return str.length();
+}
+
+int wxString::PrintfV(const wxString& format, va_list argptr)
+{
+#if wxUSE_UNICODE_UTF8
+    #if wxUSE_STL_BASED_WXSTRING
+        typedef wxStringTypeBuffer<char> Utf8Buffer;
+    #else
+        typedef wxImplStringBuffer Utf8Buffer;
+    #endif
+#endif

 
 

-    return length();
+#if wxUSE_UTF8_LOCALE_ONLY
+    return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
+#else
+    #if wxUSE_UNICODE_UTF8
+    if ( wxLocaleIsUtf8 )
+        return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);
+    else
+        // wxChar* version
+        return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);
+    #else
+        return DoStringPrintfV(*this, format, argptr);
+    #endif // UTF8/WCHAR
+#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------