Minor API changes

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

diff --git a/src/common/string.cpp b/src/common/string.cpp
index f9f389cfa209b8a722cd905e2a109f1708a61aa2..a791562d7e25fd40ebda91a5289debf9bc56c8b2 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -220,9 +220,16 @@ wxString::~wxString()
 }
 #endif
 
 }
 #endif
 

-#if wxUSE_UNICODE
+#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY

 const char* wxCStrData::AsChar() const
 {
 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:
     wxString *str = wxConstCast(m_str, wxString);
 
     // convert the string:


@@ -244,7 +251,7 @@ const char* wxCStrData::AsChar() const
     // and keep it:
     return str->m_convertedToChar + m_offset;
 }
     // and keep it:
     return str->m_convertedToChar + m_offset;
 }

-#endif // wxUSE_UNICODE
+#endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY

 
 #if !wxUSE_UNICODE_WCHAR
 const wchar_t* wxCStrData::AsWChar() const
 
 #if !wxUSE_UNICODE_WCHAR
 const wchar_t* wxCStrData::AsWChar() const


@@ -306,14 +313,23 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
                                                const wxMBConv& conv)
 {
 wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
                                                const wxMBConv& conv)
 {

-    // FIXME-UTF8: return as-is without copying under UTF8 locale, return
-    //             converted string under other locales - needs wxCharBuffer
-    //             changes
-

     // anything to do?
     if ( !psz || nLength == 0 )
         return SubstrBufFromMB("", 0);
 
     // 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;
 
     if ( nLength == npos )
         nLength = wxNO_LEN;
 


@@ -324,7 +340,7 @@ wxString::SubstrBufFromMB wxString::ConvertStr(const char *psz, size_t nLength,
         return SubstrBufFromMB("", 0);
 
     // and then to UTF-8:
         return SubstrBufFromMB("", 0);
 
     // and then to UTF-8:

-    SubstrBufFromMB buf(ConvertStr(wcBuf, wcLen, wxConvUTF8));
+    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") );
 
     // widechar -> UTF-8 conversion isn't supposed to ever fail:
     wxASSERT_MSG( buf.data, _T("conversion to UTF-8 failed") );
 


@@ -366,22 +382,28 @@ const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 
 const wxWCharBuffer wxString::wc_str() const
 {
 
 const wxWCharBuffer wxString::wc_str() const
 {

-    return wxConvUTF8.cMB2WC(m_impl.c_str(),
-                             m_impl.length() + 1 /* size, not length */,
-                             NULL);
+    return wxMBConvStrictUTF8().cMB2WC
+                                (
+                                    m_impl.c_str(),
+                                    m_impl.length() + 1, // size, not length
+                                    NULL
+                                );

 }
 
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 {
 }
 
 const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 {

-    // FIXME-UTF8: optimize the case when conv==wxConvUTF8 or wxConvLibc
-    //             under UTF8 locale
+    if ( conv.IsUTF8() )
+        return wxCharBuffer::CreateNonOwned(m_impl.c_str());
+

     // FIXME-UTF8: use wc_str() here once we have buffers with length
 
     size_t wcLen;
     // FIXME-UTF8: use wc_str() here once we have buffers with length
 
     size_t wcLen;

-    wxWCharBuffer wcBuf(
-            wxConvUTF8.cMB2WC(m_impl.c_str(),
-                              m_impl.length() + 1 /* size, not length */,
-                              &wcLen));
+    wxWCharBuffer wcBuf(wxMBConvStrictUTF8().cMB2WC
+                                             (
+                                                m_impl.c_str(),
+                                                m_impl.length() + 1, // size
+                                                &wcLen
+                                             ));

     if ( !wcLen )
         return wxCharBuffer("");
 
     if ( !wcLen )
         return wxCharBuffer("");
 


@@ -548,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


@@ -950,35 +978,35 @@ 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 )

     {
     {

-        wxImplStringBuffer buf(res, len);
+        wxStringInternalBuffer buf(res, len);

         wxStringCharType *dest = buf;
 
         wxStringCharType *dest = buf;
 

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

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

-
-            if ( c == '\0' )
-                break;

         }
     }
 
     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' ?


@@ -1048,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;


@@ -1078,11 +1093,9 @@ 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() - wxStrlen(suffix);
+    int start = length() - suffix.length();

 
     if ( start < 0 || compare(start, npos, suffix) != 0 )
         return false;
 
     if ( start < 0 || compare(start, npos, suffix) != 0 )
         return false;


@@ -1374,52 +1387,50 @@ 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
-
-template <typename T, typename F>
-bool wxStringToIntType(const wxChar *start,
-                       T *val,
-                       int base,
-                       F func)
-{
-    wxCHECK_MSG( val, false, _T("NULL output pointer") );
-    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
+// 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.

 
 #ifndef __WXWINCE__
 
 #ifndef __WXWINCE__

-    errno = 0;
+    #define DO_IF_NOT_WINCE(x) x
+#else
+    #define DO_IF_NOT_WINCE(x)

 #endif
 
 #endif
 

-    wxChar *end;
-    *val = (*func)(start, &end, base);
-
-    // return true only if scan was stopped by the terminating NUL and if the
-    // string was not empty to start with and no under/overflow occurred
-    return !*end && (end != start)
-#ifndef __WXWINCE__
-        && (errno != ERANGE)
-#endif
-    ;
-}
+#define WX_STRING_TO_INT_TYPE(val, base, func)                              \
+    wxCHECK_MSG( val, false, _T("NULL output pointer") );                   \
+    wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );  \
+                                                                            \
+    DO_IF_NOT_WINCE( errno = 0; )                                           \
+                                                                            \
+    const wxStringCharType *start = wx_str();                               \
+    wxStringCharType *end;                                                  \
+    *val = func(start, &end, base);                                         \
+                                                                            \
+    /* return true only if scan was stopped by the terminating NUL and */   \
+    /* if the string was not empty to start with and no under/overflow */   \
+    /* occurred: */                                                         \
+    return !*end && (end != start)                                          \
+        DO_IF_NOT_WINCE( && (errno != ERANGE) )

 
 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);
+    WX_STRING_TO_INT_TYPE(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);
+    WX_STRING_TO_INT_TYPE(val, base, wxStrtoul);

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

-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll);
+    WX_STRING_TO_INT_TYPE(val, base, wxStrtoll);

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

-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull);
+    WX_STRING_TO_INT_TYPE(val, base, wxStrtoull);

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


@@ -1450,7 +1461,7 @@ bool wxString::ToDouble(double *val) const
 #if !wxUSE_UTF8_LOCALE_ONLY
 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 #if !wxUSE_UTF8_LOCALE_ONLY
 /* static */
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN

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

 #else
 wxString wxString::DoFormatWchar(const wxChar *format, ...)
 #endif
 #else
 wxString wxString::DoFormatWchar(const wxChar *format, ...)
 #endif


@@ -1557,6 +1568,11 @@ static int DoStringPrintfV(wxString& str,
         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;
         }
 


@@ -1577,14 +1593,20 @@ static int DoStringPrintfV(wxString& str,
         // 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
         }


@@ -1615,28 +1637,25 @@ static int DoStringPrintfV(wxString& str,
 
 int wxString::PrintfV(const wxString& format, va_list argptr)
 {
 
 int wxString::PrintfV(const wxString& format, va_list argptr)
 {

-    va_list argcopy;
-    wxVaCopy(argcopy, argptr);
-

 #if wxUSE_UNICODE_UTF8
     #if wxUSE_STL_BASED_WXSTRING
         typedef wxStringTypeBuffer<char> Utf8Buffer;
     #else
 #if wxUSE_UNICODE_UTF8
     #if wxUSE_STL_BASED_WXSTRING
         typedef wxStringTypeBuffer<char> Utf8Buffer;
     #else

-        typedef wxImplStringBuffer Utf8Buffer;
+        typedef wxStringInternalBuffer Utf8Buffer;

     #endif
 #endif
 
 #if wxUSE_UTF8_LOCALE_ONLY
     #endif
 #endif
 
 #if wxUSE_UTF8_LOCALE_ONLY

-    return DoStringPrintfV<Utf8Buffer>(*this, format, argcopy);
+    return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);

 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )
 #else
     #if wxUSE_UNICODE_UTF8
     if ( wxLocaleIsUtf8 )

-        return DoStringPrintfV<Utf8Buffer>(*this, format, argcopy);
+        return DoStringPrintfV<Utf8Buffer>(*this, format, argptr);

     else
         // wxChar* version
     else
         // wxChar* version

-        return DoStringPrintfV<wxStringBuffer>(*this, format, argcopy);
+        return DoStringPrintfV<wxStringBuffer>(*this, format, argptr);

     #else
     #else

-        return DoStringPrintfV(*this, format, argcopy);
+        return DoStringPrintfV(*this, format, argptr);

     #endif // UTF8/WCHAR
 #endif
 }
     #endif // UTF8/WCHAR
 #endif
 }


@@ -1810,3 +1829,32 @@ wxString wxString::Upper() const
 
 // convert to lower case, return the copy of the string
 wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }
 
 // convert to lower case, return the copy of the string
 wxString wxString::Lower() const { wxString s(*this); return s.MakeLower(); }

+
+// ----------------------------------------------------------------------------
+// wxUTF8StringBuffer
+// ----------------------------------------------------------------------------
+
+#if wxUSE_UNICODE_WCHAR
+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);
+}
+
+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);
+}
+#endif // wxUSE_UNICODE_WCHAR