cleanup after #191

README.md

@@ -390,7 +390,7 @@ I deeply appreciate the help of the following people.
 - [406345](https://github.com/406345) fixed two small warnings.
 - [Glen Fernandes](https://github.com/glenfe) noted a potential portability problem in the `has_mapped_type` function.
 - [Corbin Hughes](https://github.com/nibroc) fixed some typos in the contribution guidelines.
-- [twelsby](https://github.com/twelsby) fixed the array subscript operator and an issue that failed the MSVC build.
+- [twelsby](https://github.com/twelsby) fixed the array subscript operator, an issue that failed the MSVC build, and floating-point parsing/dumping.
 
 Thanks a lot for helping out!
 
@@ -407,7 +407,7 @@ $ make
 $ ./json_unit "*"
 
 ===============================================================================
-All tests passed (3343318 assertions in 29 test cases)
+All tests passed (3343329 assertions in 29 test cases)
 ```
 
 For more information, have a look at the file [.travis.yml](https://github.com/nlohmann/json/blob/master/.travis.yml).

src/json.hpp.re2c

@@ -5604,13 +5604,20 @@ class basic_json
 
             case value_t::number_float:
             {
-                // If the number is an integer then output as a fixed with with precision 1
+                // If the number is an integer then output as a fixed with with
-                // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
+                // precision 1 to output "0.0", "1.0" etc as expected for some
-                // 15 digits of precision allows round-trip IEEE 754 string->double->string; 
+                // round trip tests otherwise  15 digits of precision allows
-                // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
+                // round-trip IEEE 754 string->double->string; to be safe, we
-                if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
+                // read this value from
-                else {
+                // std::numeric_limits<number_float_t>::digits10
-                    o.unsetf(std::ios_base::floatfield);  // std::defaultfloat not supported in gcc version < 5
+                if (std::fmod(m_value.number_float, 1) == 0)
+                {
+                    o << std::fixed << std::setprecision(1);
+                }
+                else
+                {
+                    // std::defaultfloat not supported in gcc version < 5
+                    o.unsetf(std::ios_base::floatfield);
                     o << std::setprecision(std::numeric_limits<double>::digits10);
                 }
                 o << m_value.number_float;
@@ -7046,55 +7053,35 @@ class basic_json
         @brief parse floating point number
 
         This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
+        standard floating point number parsing function (i.e., `std::strtof`,
-        supplied via the first parameter.  Set this to 
+        `std::strtod`, or `std::strtold`) based on the type supplied via the
-        @a static_cast<number_float_t>(nullptr).
+        first parameter. Set this to @a static_cast<number_float_t>(nullptr).
 
-        @param type  the @ref number_float_t in use
+        @param[in] type  the @ref number_float_t in use
 
-        @param endptr  recieves a pointer to the first character after the number
+        @param[in,out] endptr recieves a pointer to the first character after
+        the number
 
         @return the floating point number
+
+        @warning This function uses `std::strtof`, `std::strtod`, or
+        `std::strtold` which use the current C locale to determine which
+        character is used as decimal point character. This may yield to parse
+        errors if the locale does not used `.`.
         */
         long double str_to_float_t(long double* /* type */, char** endptr) const
         {
             return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
         }
 
-        /*!
+        /// @copydoc str_to_float_t
-        @brief parse floating point number
+        double str_to_float_t(double*, char** endptr) const
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to
-        @a static_cast<number_float_t>(nullptr).
-
-        @param type  the @ref number_float_t in use
-
-        @param endptr  recieves a pointer to the first character after the number
-
-        @return the floating point number
-        */
-        double str_to_float_t(double* /* type */, char** endptr) const
         {
             return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
         }
 
-        /*!
+        /// @copydoc str_to_float_t
-        @brief parse floating point number
+        float str_to_float_t(float*, char** endptr) const
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to 
-        @a static_cast<number_float_t>(nullptr).
-
-        @param type  the @ref number_float_t in use
-
-        @param endptr  recieves a pointer to the first character after the number
-
-        @return the floating point number
-        */
-        float str_to_float_t(float* /* type */, char** endptr) const
         {
             return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
         }
@@ -7369,8 +7356,8 @@ class basic_json
 
                     // check if conversion loses precision (special case -0.0 always loses precision)
                     const auto int_val = static_cast<number_integer_t>(result.m_value.number_float);
-                    if (result.m_value.number_float == static_cast<number_float_t>(int_val) &&
+                    if (result.m_value.number_float == static_cast<number_float_t>(int_val) and
-                        result.m_value.number_integer != json_value(-0.0f).number_integer)
+                            result.m_value.number_integer != json_value(-0.0f).number_integer)
                     {
                         // we would not lose precision -> return int
                         result.m_type = value_t::number_integer;

test/unit.cpp

@@ -11602,7 +11602,8 @@ TEST_CASE("regression tests")
         CHECK(j_double.get<double>() == 1.23e45);
 
         // long double
-        nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, long double> j_long_double = 1.23e45L;
+        nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, long double> j_long_double =
+            1.23e45L;
         CHECK(j_long_double.get<long double>() == 1.23e45L);
     }
 }