Fix AppVeyor failures from the Zmij double writer

MSVC 2015 warns C4554 on the shifts with casts in the fractional part
of zmij::to_shortest despite the parentheses; with /WX every target
fails to build. Name the shift amounts as constants instead.

The shortest-digits test built the candidates with one digit fewer via
a stream with std::setprecision(digits.size() - 2); the standard library
of MSVC 2017 ignores a precision of 0, so for two-digit values the
"shorter" candidates were the value itself. Truncate the digits
instead: the value lies within half a unit of the last digit, so the
truncated digits and their successor are the closest candidates.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

include/nlohmann/detail/conversions/zmij.hpp

@@ -184,7 +184,10 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc
     const uint128_parts p10 = pow10(-dec_exp - 1);
     const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
     std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
-    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
+    // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses)
+    constexpr unsigned fractional_low_shift = static_cast<unsigned>(extra_shift);
+    constexpr unsigned fractional_high_shift = 64u - fractional_low_shift;
+    const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift);
     std::uint64_t digit = 0;
     bool round_up = false;
     bool round_down = false;

include/nlohmann/detail/input/json_sax.hpp

@@ -674,19 +674,16 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            // a single lookup: insert the placeholder, or find the existing member
-            const auto inserted = obj.emplace(val, discarded);
-            const auto it = inserted.first;
-            if (!inserted.second)
+            const auto it = obj.find(val);
+            if (it != obj.end())
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
-                it->second = discarded;
             }
-            object_element = &(it->second);
+            object_element = &(obj[val] = discarded);
         }
 
         return true;

single_include/nlohmann/json.hpp

@@ -13850,19 +13850,16 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            // a single lookup: insert the placeholder, or find the existing member
-            const auto inserted = obj.emplace(val, discarded);
-            const auto it = inserted.first;
-            if (!inserted.second)
+            const auto it = obj.find(val);
+            if (it != obj.end())
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
-                it->second = discarded;
             }
-            object_element = &(it->second);
+            object_element = &(obj[val] = discarded);
         }
 
         return true;
@@ -25877,7 +25874,10 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc
     const uint128_parts p10 = pow10(-dec_exp - 1);
     const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
     std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
-    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
+    // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses)
+    constexpr unsigned fractional_low_shift = static_cast<unsigned>(extra_shift);
+    constexpr unsigned fractional_high_shift = 64u - fractional_low_shift;
+    const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift);
     std::uint64_t digit = 0;
     bool round_up = false;
     bool round_down = false;

tests/src/unit-to_chars.cpp

@@ -21,11 +21,8 @@ using nlohmann::detail::dtoa_impl::reinterpret_bits;
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
-#include <iomanip>
 #include <limits>
-#include <locale>
 #include <random>
-#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -689,20 +686,13 @@ void check_shortest(double v)
     const std::string& digits = de.first;
     if (digits.size() > 1)
     {
-        // the decimals of one digit fewer next to the value
-        // (a stream rather than snprintf("%.*e"), whose output GCC cannot bound)
-        std::ostringstream shorter;
-        shorter.imbue(std::locale::classic());
-        shorter << std::scientific << std::setprecision(static_cast<int>(digits.size()) - 2) << v;
-        const auto near = digits_and_exponent(shorter.str());
-        // as an integer with digits.size() - 1 digits
-        std::string m = near.first;
-        int e = near.second;
-        while (m.size() < digits.size() - 1)
-        {
-            m += '0';
-            --e;
-        }
+        // the decimals of one digit fewer next to the value: v lies within
+        // half a unit of the last digit of text, so the closest ones are the
+        // truncated digits and their successor
+        // (not a stream with std::setprecision(digits.size() - 2): the
+        // standard library of MSVC 2017 ignores a precision of 0)
+        const std::string m = digits.substr(0, digits.size() - 1);
+        const int e = de.second + 1;
         const std::uint64_t mid = std::stoull(m);
         for (const std::uint64_t candidate :
                 {