Fix for bug 908824

Author: ras0219-msft

Release/src/json/json_parsing.cpp

@@ -26,6 +26,7 @@
 ****/
 
 #include "stdafx.h"
+#include <vector>
 
 #pragma warning(disable : 4127) // allow expressions like while(true) pass 
 using namespace web;
@@ -367,6 +368,34 @@ inline bool JSON_Parser<CharType>::ParseInt64(CharType first, uint64_t& value)
     return true;
 }
 
+// This namespace hides the x-plat helper functions
+namespace
+{
+#ifdef _MS_WINDOWS
+    static int print_llu(char* ptr, size_t n, uint64_t val64)
+    {
+        return _snprintf_s(ptr, n, _TRUNCATE, "%I64u", val64);
+    }
+
+    static int print_llu(wchar_t* ptr, size_t n, uint64_t val64)
+    {
+        return _snwprintf_s(ptr, n, _TRUNCATE, L"%I64u", val64);
+    }
+#else
+    static int print_llu(char* ptr, size_t n, unsigned long long val64)
+    {
+        return snprintf(ptr, n, "%llu", val64);
+    }
+    static int print_llu(char* ptr, size_t n, unsigned long val64)
+    {
+        return snprintf(ptr, n, "%lu", val64);
+    }
+#endif
+
+    static double anystod(const char* str) { return strtod(str, nullptr); }
+    static double anystod(const wchar_t* str) { return wcstod(str, nullptr); }
+}
+
 template <typename CharType>
 bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
 {
@@ -424,25 +453,22 @@ bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
         return true;
     }
 
-    double value = static_cast<double>(val64);
-    bool decimal = false;
-    int after_decimal = 0;    // counts digits after the decimal
+    // Magic number 5 leaves room for decimal point, null terminator, etc (in most cases)
+    ::std::vector<CharType> buf(::std::numeric_limits<uint64_t>::digits10 + 5);
+    int count = print_llu(buf.data(), buf.size(), val64);
+    _ASSERTE(count >= 0);
+    _ASSERTE((size_t)count < buf.size());
+    // Resize to cut off the null terminator
+    buf.resize(count);
 
-    // Exponent and related flags
-    int exponent = 0;
-    bool has_exponent = false;
-    bool exponent_minus = false;
+    bool decimal = false;
 
     while (ch != this->m_eof)
     {
         // Digit encountered?
         if (ch >= '0' && ch <= '9')
         {
-            value *= 10;
-            value += ch - '0';
-            if (decimal)
-                after_decimal++;
-
+            buf.push_back(ch);
             NextCharacter();
             ch = PeekCharacter();
         }
@@ -454,6 +480,7 @@ bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
                 return false;
 
             decimal = true;
+            buf.push_back(ch);
 
             NextCharacter();
             ch = PeekCharacter();
@@ -462,40 +489,36 @@ bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
             if (ch < '0' || ch > '9')
             return false;
 
-            // Parse it
-            value *= 10;
-            value += ch - '0';
-            after_decimal = 1;
-
+            buf.push_back(ch);
             NextCharacter();
             ch = PeekCharacter();
         }
 
         // Exponent?
         else if (ch == 'E' || ch == 'e')
         {
-            has_exponent = true;
+            buf.push_back(ch);
             NextCharacter();
             ch = PeekCharacter();
 
             // Check for the exponent sign
             if (ch == '+')
             {
+                buf.push_back(ch);
                 NextCharacter();
                 ch = PeekCharacter();
             }
             else if (ch == '-')
             {
-                exponent_minus = true;
+                buf.push_back(ch);
                 NextCharacter();
                 ch = PeekCharacter();
             }
 
             // First number of the exponent
             if (ch >= '0' && ch <= '9')
             {
-                exponent = ch - '0';
-
+                buf.push_back(ch);
                 NextCharacter();
                 ch = PeekCharacter();
             }
@@ -504,9 +527,7 @@ bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
             // The rest of the exponent
             while (ch >= '0' && ch <= '9')
             {
-                exponent *= 10;
-                exponent += ch - '0';
-
+                buf.push_back(ch);
                 NextCharacter();
                 ch = PeekCharacter();
             }
@@ -521,24 +542,12 @@ bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)
         }
     };
 
+    buf.push_back('\0');
+    token.double_val = anystod(buf.data());
     if (minus_sign)
-        value = -value;
-
-    if (has_exponent)
     {
-        if (exponent_minus)
-            exponent = -exponent;
-
-        if (decimal)
-            exponent -= after_decimal;
-
-        token.double_val = value * pow(double(10), exponent);
+        token.double_val = -token.double_val;
     }
-    else
-    {
-        token.double_val = value / pow(double(10), after_decimal);
-    }
-
     token.kind = (JSON_Parser<CharType>::Token::TKN_NumberLiteral);
 
     return true;

Release/tests/Functional/json/json_numbers_tests.cpp

@@ -25,6 +25,7 @@
 
 #include "stdafx.h"
 #include <iomanip>
+#include <clocale>
 
 using namespace web; using namespace utility;
 
@@ -124,12 +125,12 @@ TEST(parse_uint64)
     test_int64(uint64_t(ULLONG_MAX)-1);
 }
 
-void test_double(double number)
+const int DOUBLE_DIGITS = std::numeric_limits<double>::digits10 + 7;  //7 = length of "1." and "e+123" which is the begining and the end of the double representation
+
+void test_double(double number, string_t str_rep)
 {
-    int precision = std::numeric_limits<double>::digits10 + 7;  //7 = length of "1." and "e+123" which is the begining and the end of the double representation
     stringstream_t ss;
-    ss << std::setprecision(precision);
-    ss << number;
+    ss << str_rep;
 
     json::value num = json::value::parse(ss);
     VERIFY_ARE_EQUAL(number, num.as_double());
@@ -140,41 +141,73 @@ void test_double(double number)
 
     // If it is outside the range, these methods should return false.
     // Note that at this point there is no guarantee that the number was stored as double.
-
+    
     if (number < INT_MIN || number > INT_MAX || number!=floor(number))
         VERIFY_IS_FALSE(num.as_number().is_int32());
-
+    
     if (number < 0 || number > UINT_MAX || number!=floor(number))
         VERIFY_IS_FALSE(num.as_number().is_uint32());
-
+    
     if (number < LLONG_MIN || number > LLONG_MAX || number!=floor(number))
         VERIFY_IS_FALSE(num.as_number().is_int64());
 
     if (number < 0 || number > ULLONG_MAX || number!=floor(number))
         VERIFY_IS_FALSE(num.as_number().is_uint64());
 }
 
-TEST(parsing_doubles)
+void test_double(double d)
+{
+    ::std::basic_stringstream<string_t::value_type> ss;
+    ss << ::std::setprecision(DOUBLE_DIGITS);
+    ss << d;
+    test_double(d, ss.str());
+}
+
+TEST(parsing_doubles_into_longs)
 {
     test_double(2.0);
+    test_double(pow(2.0, 10.0));
+    test_double(pow(2.0, 20.0));
+    test_double(pow(2.0, 60.0));
+    test_double(pow(2.0, 63.0));
+}
+
+TEST(parsing_doubles)
+{
     test_double(3.14);
     test_double(-9.81);
+
+    // Note: this should not parse to a ullong because of rounding
     test_double(static_cast<double>(ULLONG_MAX));
+
     test_double(0 - static_cast<double>(ULLONG_MAX));
     test_double(static_cast<double>(ULLONG_MAX)+(2<<(64-52)));  // the lowest number that will be represented as double due to overflowing unsigned int64 (52bits fraction in double-precision)
-    test_double(pow(2.0, 10.0));
-    test_double(pow(2.0, 20.0));
-    test_double(pow(2.0, 60.0));
-    test_double(pow(2.0, 63.0));
     test_double(0 - pow(2.0, 63.0) * 1.5);  // between 0-ULLONG_MAX and LLONGMIN
 }
 
-TEST(parsing_very_large_doubles, "Ignore:Linux", "Bug 908824")
+TEST(parsing_doubles_setlocale, "Ignore", "Bug 912803")
+{
+    // JSON uses the C locale always and should therefore not be impacted by the process locale
+    setlocale(LC_ALL, "fr-FR");
+    test_double(1.91563, U("1.91563"));
+    test_double(2.0e93, U("2.0e93"));
+    setlocale(LC_ALL, "C");
+}
+
+TEST(parsing_very_large_doubles)
 {
     test_double(pow(2.0, 64.0));
     test_double(pow(2.0, 70.0));
     test_double(pow(2.0, 80.0));
     test_double(pow(2.0, 120.0));
+    test_double(pow(2.0, 240.0));
+    test_double(pow(2.0, 300.0));
+}
+
+TEST(parsing_very_small_doubles)
+{
+    test_double(2.34e-308);
+    test_double(1e-308);
 }
 
 void test_integral(int number)
@@ -267,4 +300,4 @@ TEST(compare_numbers)
 
 } // SUITE(json_numbers_tests)
 
-}}}
+}}}