don't modify the output variable if ToXXX() fails to convert (modified patch 1849041)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@50710 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/docs/latex/wx/wxstring.tex b/docs/latex/wx/wxstring.tex
index a4dcdaf4c74b581a265fedb2797af315db7d62a3..cdd13d86b7b9ceec9e32ed6f9aa6bc72a6c81e70 100644 (file)
--- a/docs/latex/wx/wxstring.tex
+++ b/docs/latex/wx/wxstring.tex
@@ -1205,8 +1205,8 @@ powerful means of converting wxString to C string.
 
 Attempts to convert the string to a floating point number. Returns \true on
 success (the number is stored in the location pointed to by \arg{val}) or \false
-if the string does not represent such number (the value of \arg{val} shouldn't
-be used in this case).
+if the string does not represent such number (the value of \arg{val} is not
+modified in this case).
 
 \wxheading{See also}
 
@@ -1221,8 +1221,8 @@ be used in this case).
 Attempts to convert the string to a signed integer in base {\it base}. Returns
 \true on success in which case the number is stored in the location
 pointed to by \arg{val} or \false if the string does not represent a
-valid number in the given base (the value of \arg{val} shouldn't
-be used in this case).
+valid number in the given base (the value of \arg{val} is not modified
+in this case).
 
 The value of {\it base} must be comprised between $2$ and $36$, inclusive, or
 be a special value $0$ which means that the usual rules of {\tt C} numbers are
@@ -1262,8 +1262,8 @@ with C99 support and Microsoft Visual C++ version 7 and higher do support this.
 Attempts to convert the string to an unsigned integer in base {\it base}.
 Returns \true on success in which case the number is stored in the
 location pointed to by \arg{val} or \false if the string does not
-represent a valid number in the given base (the value of \arg{val} shouldn't
-be used in this case). Please notice that this function
+represent a valid number in the given base (the value of \arg{val} is not
+modified in this case). Please notice that this function
 behaves in the same way as the standard \texttt{strtoul()} and so it simply
 converts negative numbers to unsigned representation instead of rejecting them
 (e.g. $-1$ is returned as \texttt{ULONG\_MAX}).

diff --git a/src/common/string.cpp b/src/common/string.cpp
index e401661db80bd78982742e51d23610cd84ab584c..f413b031fd79c9c1b92e58e28794f5d40a26fe38 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -1348,7 +1348,7 @@ wxString& wxString::MakeLower()
 
 // some compilers (VC++ 6.0 not to name them) return true for a call to
 // isspace('\xEA') in the C locale which seems to be broken to me, but we have
-// to live with this by checking that the character is a 7 bit one - even if 
+// to live with this by checking that the character is a 7 bit one - even if
 // this may fail to detect some spaces (I don't know if Unicode doesn't have
 // space-like symbols somewhere except in the first 128 chars), it is arguably
 // still better than trimming away accented letters
@@ -1444,61 +1444,62 @@ int wxString::Find(wxUniChar ch, bool bFromEnd) const
     #define DO_IF_NOT_WINCE(x)
 #endif
 
-#define WX_STRING_TO_INT_TYPE(val, base, func)                              \
-    wxCHECK_MSG( val, false, _T("NULL output pointer") );                   \
+#define WX_STRING_TO_INT_TYPE(out, base, func, T)                           \
+    wxCHECK_MSG( out, 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);                                         \
+    T 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) )
+    if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) )         \
+        return false;                                                       \
+    *out = val;                                                             \
+    return true
 
-bool wxString::ToLong(long *val, int base) const
+bool wxString::ToLong(long *pVal, int base) const
 {
-    WX_STRING_TO_INT_TYPE(val, base, wxStrtol);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtol, long);
 }
 
-bool wxString::ToULong(unsigned long *val, int base) const
+bool wxString::ToULong(unsigned long *pVal, int base) const
 {
-    WX_STRING_TO_INT_TYPE(val, base, wxStrtoul);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoul, unsigned long);
 }
 
-bool wxString::ToLongLong(wxLongLong_t *val, int base) const
+bool wxString::ToLongLong(wxLongLong_t *pVal, int base) const
 {
-    WX_STRING_TO_INT_TYPE(val, base, wxStrtoll);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoll, wxLongLong_t);
 }
 
-bool wxString::ToULongLong(wxULongLong_t *val, int base) const
+bool wxString::ToULongLong(wxULongLong_t *pVal, int base) const
 {
-    WX_STRING_TO_INT_TYPE(val, base, wxStrtoull);
+    WX_STRING_TO_INT_TYPE(pVal, base, wxStrtoull, wxULongLong_t);
 }
 
-bool wxString::ToDouble(double *val) const
+bool wxString::ToDouble(double *pVal) const
 {
-    wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") );
+    wxCHECK_MSG( pVal, false, _T("NULL output pointer") );
 
-#ifndef __WXWINCE__
-    errno = 0;
-#endif
+    DO_IF_NOT_WINCE( errno = 0; )
 
     const wxChar *start = c_str();
     wxChar *end;
-    *val = wxStrtod(start, &end);
+    double val = wxStrtod(start, &end);
 
     // 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
-    ;
+    if ( *end || end == start DO_IF_NOT_WINCE(|| errno == ERANGE) )
+        return false;
+
+    *pVal = val;
+
+    return true;
 }
 
 // ---------------------------------------------------------------------------
@@ -1620,7 +1621,7 @@ int wxString::DoPrintfUtf8(const char *format, ...)
     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
     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
@@ -1730,7 +1731,7 @@ static int DoStringPrintfV(wxString& str,
         else if ( len >= size )
         {
 #if wxUSE_WXVSNPRINTF
-            // we know that our own implementation of wxVsnprintf() returns 
+            // we know that our own implementation of wxVsnprintf() returns
             // size+1 when there's not enough space but that's not the size
             // of the required buffer!
             size *= 2;      // so we just double the current size of the buffer