projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
1. added default constructors for wxString iterators
[wxWidgets.git] / src / common / string.cpp
diff --git a/src/common/string.cpp b/src/common/string.cpp
index 3ae68d82e6786b9958b5c4d8516da8c599ceaf3c..7b9f77b28b47918eed64cac21e89ffcf4e75ef1a 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -340,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, wxMBConvUTF8()));
     // 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") );
 
@@ -382,9 +382,9 @@ 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 wxMBConvUTF8().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
@@ -396,9 +396,9 @@ const wxCharBuffer wxString::mb_str(const wxMBConv& conv) const
 
     size_t wcLen;
     wxWCharBuffer wcBuf(
 
     size_t wcLen;
     wxWCharBuffer wcBuf(
-            wxConvUTF8.cMB2WC(m_impl.c_str(),
-                              m_impl.length() + 1 /* size, not length */,
-                              &wcLen));
+            wxMBConvUTF8().cMB2WC(m_impl.c_str(),
+                                  m_impl.length() + 1 /* size, not length */,
+                                  &wcLen));
     if ( !wcLen )
         return wxCharBuffer("");
 
     if ( !wcLen )
         return wxCharBuffer("");
 
@@ -565,6 +565,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
@@ -967,35 +973,36 @@ 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);
-        wxStringCharType *dest = buf;
+    wxImplStringBuffer buf(res, len);
+    wxStringCharType *dest = buf;
 
 
-        for ( ;; )
-        {
-            unsigned char c = (unsigned char)*ascii++;
-            wxASSERT_MSG( c < 0x80,
-                          _T("Non-ASCII value passed to FromAscii().") );
+    for ( ;; )
+    {
+        unsigned char c = (unsigned char)*ascii++;
+        wxASSERT_MSG( c < 0x80,
+                      _T("Non-ASCII value passed to FromAscii().") );
 
 
-            *dest++ = (wchar_t)c;
+        *dest++ = (wchar_t)c;
 
 
-            if ( c == '\0' )
-                break;
-        }
+        if ( c == '\0' )
+            break;
     }
 
     return res;
 }
 
     }
 
     return res;
 }
 
+wxString wxString::FromAscii(const char *ascii)
+{
+    return FromAscii(ascii, strlen(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' ?
@@ -1376,14 +1383,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") );
@@ -1392,7 +1400,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
@@ -1406,22 +1414,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
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoll);
+    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
 {
-    return wxStringToIntType((const wxChar*)c_str(), val, base, wxStrtoull);
+    return wxStringToIntType(wx_str(), val, base, wxStrtoull);
 }
 
 bool wxString::ToDouble(double *val) const
 }
 
 bool wxString::ToDouble(double *val) const
@@ -1559,6 +1567,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;
         }
 
@@ -1579,14 +1592,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
         }
@@ -1617,9 +1636,6 @@ 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;
 #if wxUSE_UNICODE_UTF8
     #if wxUSE_STL_BASED_WXSTRING
         typedef wxStringTypeBuffer<char> Utf8Buffer;
@@ -1629,16 +1645,16 @@ int wxString::PrintfV(const wxString& format, va_list argptr)
 #endif
 
 #if wxUSE_UTF8_LOCALE_ONLY
 #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
 }
wxWidgets (Impactor)