Remove use of global locale in JSON parsing and serialization.

Author: ras0219-msft

Release/include/cpprest/asyncrt_utils.h

@@ -230,35 +230,6 @@ namespace conversions
 
 namespace details
 {
-    /// <summary>
-    /// Cross platform RAII container for setting thread local locale.
-    /// </summary>
-    class scoped_c_thread_locale
-    {
-    public:
-        _ASYNCRTIMP scoped_c_thread_locale();
-        _ASYNCRTIMP ~scoped_c_thread_locale();
-
-#if !defined(ANDROID) && !defined(__ANDROID__) // CodePlex 269
-#ifdef _WIN32
-        typedef _locale_t xplat_locale;
-#else
-        typedef locale_t xplat_locale;
-#endif
-
-        static _ASYNCRTIMP xplat_locale __cdecl c_locale();
-#endif
-    private:
-#ifdef _WIN32
-        std::string m_prevLocale;
-        int m_prevThreadSetting;
-#elif !(defined(ANDROID) || defined(__ANDROID__))
-        locale_t m_prevLocale;
-#endif
-        scoped_c_thread_locale(const scoped_c_thread_locale &);
-        scoped_c_thread_locale & operator=(const scoped_c_thread_locale &);
-    };
-
     /// <summary>
     /// Our own implementation of alpha numeric instead of std::isalnum to avoid
     /// taking global lock for performance reasons.

Release/include/cpprest/json.h

@@ -562,9 +562,6 @@ namespace json
         /// <param name="stream">The stream that the JSON string representation should be written to.</param>
         inline void serialize(std::ostream& stream) const
         {
-#ifndef _WIN32
-            utility::details::scoped_c_thread_locale locale;
-#endif
             stream << serialize();
         }
 #if !defined(_LIBCPP_VERSION)

Release/src/json/json_parsing.cpp

@@ -126,10 +126,6 @@ class JSON_Parser
 
     web::json::value ParseValue(Token &first)
     {
-#ifndef _WIN32
-        utility::details::scoped_c_thread_locale locale;
-#endif
-
         return ParseValue_inner(first);
     }
 
@@ -447,30 +443,6 @@ inline bool JSON_Parser::ParseInt64(char first, uint64_t& value)
     return true;
 }
 
-#if defined(_WIN32)
-    int print_llu(char* ptr, size_t n, uint64_t val64)
-    {
-        return _snprintf_s_l(ptr, n, _TRUNCATE, "%I64u", utility::details::scoped_c_thread_locale::c_locale(), val64);
-    }
-    double anystod(const char* str)
-    {
-        return _strtod_l(str, nullptr, utility::details::scoped_c_thread_locale::c_locale());
-    }
-#else
-    int __attribute__((__unused__)) print_llu(char* ptr, size_t n, unsigned long long val64)
-    {
-        return snprintf(ptr, n, "%llu", val64);
-    }
-    int __attribute__((__unused__)) print_llu(char* ptr, size_t n, unsigned long val64)
-    {
-        return snprintf(ptr, n, "%lu", val64);
-    }
-    double __attribute__((__unused__)) anystod(const char* str)
-    {
-        return strtod(str, nullptr);
-    }
-#endif
-
 bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
 {
     bool minus_sign;
@@ -528,13 +500,22 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
         return true;
     }
 
-    // Magic number 5 leaves room for decimal point, null terminator, etc (in most cases)
-    ::std::vector<char> buf(::std::numeric_limits<uint64_t>::digits10 + 5);
-    int count = print_llu(buf.data(), buf.size(), val64);
+    // digits10 is the number of digits _from text_ that are guaranteed to round-trip.
+    // We must +1 to get the the amount of text needed to round trip any number
+    // Also, +1 for null terminator
+    std::array<char, ::std::numeric_limits<uint64_t>::digits10 + 2> longbuf;
+
+#ifdef WIN32
+    int count = _snprintf_s(longbuf.data(), longbuf.size(), _TRUNCATE, "%I64u", val64);
+#else
+    int count = std::snprintf(longbuf.data(), longbuf.size(), "%llu", val64);
+#endif
     _ASSERTE(count >= 0);
-    _ASSERTE((size_t)count < buf.size());
-    // Resize to cut off the null terminator
-    buf.resize(count);
+    _ASSERTE((size_t)count < longbuf.size());
+
+    ::std::stringstream buf;
+    buf.imbue(std::locale::classic());
+    buf.write(longbuf.data(), count);
 
     bool decimal = false;
 
@@ -543,7 +524,7 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
         // Digit encountered?
         if (ch >= '0' && ch <= '9')
         {
-            buf.push_back(static_cast<char>(ch));
+            buf.put(static_cast<char>(ch));
             NextCharacter();
             ch = PeekCharacter();
         }
@@ -555,7 +536,7 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
                 return false;
 
             decimal = true;
-            buf.push_back(static_cast<char>(ch));
+            buf.put('.');
 
             NextCharacter();
             ch = PeekCharacter();
@@ -564,36 +545,30 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
             if (ch < '0' || ch > '9')
             return false;
 
-            buf.push_back(static_cast<char>(ch));
+            buf.put(static_cast<char>(ch));
             NextCharacter();
             ch = PeekCharacter();
         }
 
         // Exponent?
         else if (ch == 'E' || ch == 'e')
         {
-            buf.push_back(static_cast<char>(ch));
+            buf.put(static_cast<char>(ch));
             NextCharacter();
             ch = PeekCharacter();
 
             // Check for the exponent sign
-            if (ch == '+')
+            if (ch == '+' || ch == '-')
             {
-                buf.push_back(static_cast<char>(ch));
-                NextCharacter();
-                ch = PeekCharacter();
-            }
-            else if (ch == '-')
-            {
-                buf.push_back(static_cast<char>(ch));
+                buf.put(static_cast<char>(ch));
                 NextCharacter();
                 ch = PeekCharacter();
             }
 
             // First number of the exponent
             if (ch >= '0' && ch <= '9')
             {
-                buf.push_back(static_cast<char>(ch));
+                buf.put(static_cast<char>(ch));
                 NextCharacter();
                 ch = PeekCharacter();
             }
@@ -602,7 +577,7 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
             // The rest of the exponent
             while (ch >= '0' && ch <= '9')
             {
-                buf.push_back(static_cast<char>(ch));
+                buf.put(static_cast<char>(ch));
                 NextCharacter();
                 ch = PeekCharacter();
             }
@@ -616,9 +591,8 @@ bool JSON_Parser::CompleteNumberLiteral(char first, Token &token)
             break;
         }
     };
+    buf >> token.double_val;
 
-    buf.push_back('\0');
-    token.double_val = anystod(buf.data());
     if (minus_sign)
     {
         token.double_val = -token.double_val;
@@ -789,11 +763,12 @@ inline bool JSON_Parser::handle_unescape_char(Token &token)
                         ec = json_error::malformed_string_literal;
                         return 0;
                     }
-#ifdef _WIN32
-                    const int isxdigitResult = _isxdigit_l(ch_int, utility::details::scoped_c_thread_locale::c_locale());
-#else
-                    const int isxdigitResult = isxdigit(ch_int);
-#endif
+
+                    const bool isxdigitResult =
+                        (ch_int >= '0' && ch_int <= '9')
+                        || (ch_int >= 'a' && ch_int <= 'f')
+                        || (ch_int >= 'A' && ch_int <= 'F');
+
                     if (!isxdigitResult)
                     {
                         ec = json_error::malformed_string_literal;

Release/src/json/json_serialization.cpp

@@ -25,6 +25,7 @@
 
 #include "stdafx.h"
 #include <stdio.h>
+#include <iomanip>
 
 #ifndef _WIN32
 #define __STDC_FORMAT_MACROS
@@ -145,21 +146,12 @@ void web::json::details::_Number::serialize_impl(std::string& stream) const
     }
     else
     {
-        // #digits + 2 to avoid loss + 1 for the sign + 1 for decimal point + 5 for exponent (e+xxx) + 1 for null terminator
-        const size_t tempSize = std::numeric_limits<double>::digits10 + 10;
-        char tempBuffer[tempSize];
-#ifdef _WIN32
-        const auto numChars = _sprintf_s_l(
-            tempBuffer,
-            tempSize,
-            "%.*g",
-            utility::details::scoped_c_thread_locale::c_locale(),
-            std::numeric_limits<double>::digits10 + 2,
-            m_number.m_value);
-#else
-        const auto numChars = snprintf(tempBuffer, tempSize, "%.*g", std::numeric_limits<double>::digits10 + 2, m_number.m_value);
-#endif
-        stream.append(tempBuffer, numChars);
+        std::stringstream sbuf;
+        sbuf.imbue(std::locale::classic());
+        sbuf.precision(std::numeric_limits<double>::max_digits10);
+        sbuf << m_number.m_value;
+
+        stream.append(sbuf.str());
     }
 }
 
@@ -172,10 +164,6 @@ const std::string& web::json::value::as_string() const
 
 std::string json::value::serialize() const
 {
-#ifndef _WIN32
-    utility::details::scoped_c_thread_locale locale;
-#endif
-
     std::string ret;
     ret.reserve(serialize_size());
     serialize(ret);

Release/src/utilities/asyncrt_utils.cpp

@@ -53,113 +53,6 @@ namespace utility
 namespace details
 {
 
-#if !defined(ANDROID) && !defined(__ANDROID__)
-std::once_flag g_c_localeFlag;
-std::unique_ptr<scoped_c_thread_locale::xplat_locale, void(*)(scoped_c_thread_locale::xplat_locale *)> g_c_locale(nullptr, [](scoped_c_thread_locale::xplat_locale *){});
-scoped_c_thread_locale::xplat_locale scoped_c_thread_locale::c_locale()
-{
-    std::call_once(g_c_localeFlag, [&]()
-    {
-        scoped_c_thread_locale::xplat_locale *clocale = new scoped_c_thread_locale::xplat_locale();
-#ifdef _WIN32
-        *clocale = _create_locale(LC_ALL, "C");
-        if (*clocale == nullptr)
-        {
-            throw std::runtime_error("Unable to create 'C' locale.");
-        }
-        auto deleter = [](scoped_c_thread_locale::xplat_locale *clocale)
-        {
-            _free_locale(*clocale);
-            delete clocale;
-        };
-#else
-        *clocale = newlocale(LC_ALL, "C", nullptr);
-        if (*clocale == nullptr)
-        {
-            throw std::runtime_error("Unable to create 'C' locale.");
-        }
-        auto deleter = [](scoped_c_thread_locale::xplat_locale *clocale)
-        {
-            freelocale(*clocale);
-            delete clocale;
-        };
-#endif
-        g_c_locale = std::unique_ptr<scoped_c_thread_locale::xplat_locale, void(*)(scoped_c_thread_locale::xplat_locale *)>(clocale, deleter);
-    });
-    return *g_c_locale;
-}
-#endif
-
-#ifdef _WIN32
-scoped_c_thread_locale::scoped_c_thread_locale()
-    : m_prevLocale(), m_prevThreadSetting(-1)
-{
-    char *prevLocale = setlocale(LC_ALL, nullptr);
-    if (prevLocale == nullptr)
-    {
-        throw std::runtime_error("Unable to retrieve current locale.");
-    }
-
-    if (std::strcmp(prevLocale, "C") != 0)
-    {
-        m_prevLocale = prevLocale;
-        m_prevThreadSetting = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
-        if (m_prevThreadSetting == -1)
-        {
-            throw std::runtime_error("Unable to enable per thread locale.");
-        }
-        if (setlocale(LC_ALL, "C") == nullptr)
-        {
-             _configthreadlocale(m_prevThreadSetting);
-             throw std::runtime_error("Unable to set locale");
-        }
-    }
-}
-
-scoped_c_thread_locale::~scoped_c_thread_locale()
-{
-    if (m_prevThreadSetting != -1)
-    {
-        setlocale(LC_ALL, m_prevLocale.c_str());
-        _configthreadlocale(m_prevThreadSetting);
-    }
-}
-#elif (defined(ANDROID) || defined(__ANDROID__))
-scoped_c_thread_locale::scoped_c_thread_locale() {}
-scoped_c_thread_locale::~scoped_c_thread_locale() {}
-#else
-scoped_c_thread_locale::scoped_c_thread_locale()
-    : m_prevLocale(nullptr)
-{
-    char *prevLocale = setlocale(LC_ALL, nullptr);
-    if (prevLocale == nullptr)
-    {
-        throw std::runtime_error("Unable to retrieve current locale.");
-    }
-
-    if (std::strcmp(prevLocale, "C") != 0)
-    {
-        m_prevLocale = uselocale(c_locale());
-        if (m_prevLocale == nullptr)
-        {
-            throw std::runtime_error("Unable to set locale");
-        }
-    }
-}
-
-scoped_c_thread_locale::~scoped_c_thread_locale()
-{
-    if (m_prevLocale != nullptr)
-    {
-        uselocale(m_prevLocale);
-    }
-}
-#endif
-}
-
-namespace details
-{
-
 const std::error_category & __cdecl platform_category()
 {
 #ifdef _WIN32

Release/tests/functional/json/parsing_tests.cpp

@@ -664,7 +664,7 @@ TEST(non_default_locale, "Ignore:Android", "Locale unsupported on Android")
     if(setlocale(LC_ALL, changedLocale.c_str()) != nullptr)
     {
         // string serialize
-        std::string str("[true,false,-1.55,5,null,{\"abc\":5555}]");
+        std::string str("[true,false,-1.125,5,null,{\"abc\":5555}]");
         json::value v = json::value::parse(str);
         VERIFY_ARE_EQUAL(changedLocale, setlocale(LC_ALL, nullptr));
         VERIFY_ARE_EQUAL(str, v.serialize());