X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5858fe6806cd4568c05a493087951fef65e0756e..9bd25c86704221bb5cf6cbe56b1b593120902ac7:/src/common/string.cpp

diff --git a/src/common/string.cpp b/src/common/string.cpp
index 96c9c526f4..3dea38ec67 100644
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -41,9 +41,9 @@
 #include "wx/vector.h"
 #include "wx/xlocale.h"
 
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
     #include "wx/msw/wrapwin.h"
-#endif // __WXMSW__
+#endif // __WINDOWS__
 
 #if wxUSE_STD_IOSTREAM
     #include <sstream>
@@ -1169,12 +1169,6 @@ int wxString::CmpNoCase(const wxString& s) const
 
 #if wxUSE_UNICODE
 
-#ifdef __MWERKS__
-#ifndef __SCHAR_MAX__
-#define __SCHAR_MAX__ 127
-#endif
-#endif
-
 wxString wxString::FromAscii(const char *ascii, size_t len)
 {
     if (!ascii || len == 0)
@@ -1349,22 +1343,43 @@ wxString wxString::Left(size_t nCount) const
 
 // get all characters before the first occurrence of ch
 // (returns the whole string if ch not found)
-wxString wxString::BeforeFirst(wxUniChar ch) const
+wxString wxString::BeforeFirst(wxUniChar ch, wxString *rest) const
 {
   int iPos = Find(ch);
   if ( iPos == wxNOT_FOUND )
-      iPos = length();
+  {
+    iPos = length();
+    if ( rest )
+      rest->clear();
+  }
+  else
+  {
+    if ( rest )
+      rest->assign(*this, iPos + 1, npos);
+  }
+
   return wxString(*this, 0, iPos);
 }
 
 /// get all characters before the last occurrence of ch
 /// (returns empty string if ch not found)
-wxString wxString::BeforeLast(wxUniChar ch) const
+wxString wxString::BeforeLast(wxUniChar ch, wxString *rest) const
 {
   wxString str;
   int iPos = Find(ch, true);
-  if ( iPos != wxNOT_FOUND && iPos != 0 )
-    str = wxString(c_str(), iPos);
+  if ( iPos != wxNOT_FOUND )
+  {
+    if ( iPos != 0 )
+      str.assign(*this, 0, iPos);
+
+    if ( rest )
+      rest->assign(*this, iPos + 1, npos);
+  }
+  else
+  {
+    if ( rest )
+      *rest = *this;
+  }
 
   return str;
 }
@@ -1421,7 +1436,7 @@ size_t wxString::Replace(const wxString& strOld,
     }
     else if ( !bReplaceAll)
     {
-        size_t pos = m_impl.find(strOld, 0);
+        size_t pos = m_impl.find(strOld.m_impl, 0);
         if ( pos != npos )
         {
             m_impl.replace(pos, strOld.m_impl.length(), strNew.m_impl);
@@ -1818,17 +1833,43 @@ bool wxString::ToCDouble(double *pVal) const
 // ----------------------------------------------------------------------------
 
 /* static */
-wxString wxString::FromCDouble(double val)
+wxString wxString::FromDouble(double val, int precision)
 {
+    wxCHECK_MSG( precision >= -1, wxString(), "Invalid negative precision" );
+
+    wxString format;
+    if ( precision == -1 )
+    {
+        format = "%g";
+    }
+    else // Use fixed precision.
+    {
+        format.Printf("%%.%df", precision);
+    }
+
+    return wxString::Format(format, val);
+}
+
+/* static */
+wxString wxString::FromCDouble(double val, int precision)
+{
+    wxCHECK_MSG( precision >= -1, wxString(), "Invalid negative precision" );
+
 #if wxUSE_STD_IOSTREAM && wxUSE_STD_STRING
     // We assume that we can use the ostream and not wstream for numbers.
     wxSTD ostringstream os;
+    if ( precision != -1 )
+    {
+        os.precision(precision);
+        os.setf(std::ios::fixed, std::ios::floatfield);
+    }
+
     os << val;
     return os.str();
-#else // wxUSE_STD_IOSTREAM
+#else // !wxUSE_STD_IOSTREAM
     // Can't use iostream locale support, fall back to the manual method
     // instead.
-    wxString s = FromDouble(val);
+    wxString s = FromDouble(val, precision);
 #if wxUSE_INTL
     wxString sep = wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
                                      wxLOCALE_CAT_NUMBER);
@@ -1961,16 +2002,16 @@ int wxString::DoPrintfUtf8(const char *format, ...)
     Since EILSEQ and EINVAL are rather common but EOVERFLOW is not and since
     EILSEQ and EINVAL are specifically defined to mean the error is other than
     an undersized buffer and no other errno are defined we treat those two
-    as meaning hard errors and everything else gets the old behavior which
+    as meaning hard errors and everything else gets the old behaviour which
     is to keep looping and increasing buffer size until the function succeeds.
 
-    In practice it's impossible to determine before compilation which behavior
-    may be used.  The vswprintf function may have vsnprintf-like behavior or
-    vice-versa.  Behavior detected on one release can theoretically change
+    In practice it's impossible to determine before compilation which behaviour
+    may be used.  The vswprintf function may have vsnprintf-like behaviour or
+    vice-versa.  Behaviour detected on one release can theoretically change
     with an updated release.  Not to mention that configure testing for it
     would require the test to be run on the host system, not the build system
     which makes cross compilation difficult. Therefore, we make no assumptions
-    about behavior and try our best to handle every known case, including the
+    about behaviour and try our best to handle every known case, including the
     case where wxVsnprintf returns a negative number and fails to set errno.
 
     There is yet one more non-standard implementation and that is our own.
@@ -1981,9 +2022,9 @@ int wxString::DoPrintfUtf8(const char *format, ...)
     at the given buffer size minus 1.  It is supposed to do this even if it
     turns out that the buffer is sized too small.
 
-    Darwin (tested on 10.5) follows the C99 behavior exactly.
+    Darwin (tested on 10.5) follows the C99 behaviour exactly.
 
-    Glibc 2.6 almost follows the C99 behavior except vswprintf never sets
+    Glibc 2.6 almost follows the C99 behaviour except vswprintf never sets
     errno even when it fails.  However, it only seems to ever fail due
     to an undersized buffer.
 */
@@ -2012,11 +2053,6 @@ static int DoStringPrintfV(wxString& str,
         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;
         }