From a1c6f16bd3c90b77fb22c723edaf2dce7dfb1e7d Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Sun, 24 Jan 2016 17:00:11 +1000
Subject: [PATCH 01/10] Fix Issue #186 - add overload wrappers for
strto(f|d|ld)
---
src/json.hpp | 85 +++++++++++++++++++++++++++++++++++++++--------
src/json.hpp.re2c | 85 +++++++++++++++++++++++++++++++++++++++--------
test/unit.cpp | 48 ++++++++++++++++++++++++--
3 files changed, 190 insertions(+), 28 deletions(-)
diff --git a/src/json.hpp b/src/json.hpp
index ac362dcf..44848553 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -5539,10 +5539,13 @@ class basic_json
case value_t::number_float:
{
- // 15 digits of precision allows round-trip IEEE 754
- // string->double->string; to be safe, we read this value from
- // std::numeric_limits<number_float_t>::digits10
- o << std::setprecision(std::numeric_limits<number_float_t>::digits10) << m_value.number_float;
+ // If the number is an integer then output as a fixed with with precision 1
+ // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
+ // 15 digits of precision allows round-trip IEEE 754 string->double->string;
+ // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
+ if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
+ else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
+ o << m_value.number_float;
return;
}
@@ -7289,6 +7292,63 @@ basic_json_parser_64:
return result;
}
+ /*!
+ @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
+ 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
+ */
+ 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);
+ }
+
+ /*!
+ @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
+ 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);
+ }
+
+ /*!
+ @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
+ 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);
+ }
+
/*!
@brief return number value for number tokens
@@ -7306,13 +7366,12 @@ basic_json_parser_64:
@throw std::range_error if passed value is out of range
*/
- long double get_number() const
+ number_float_t get_number() const
{
// conversion
typename string_t::value_type* endptr;
assert(m_start != nullptr);
- const auto float_val = std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start),
- &endptr);
+ number_float_t float_val = str_to_float_t(static_cast<number_float_t*>(nullptr), &endptr);
// return float_val if the whole number was translated and NAN
// otherwise
@@ -7546,11 +7605,11 @@ basic_json_parser_64:
case lexer::token_type::value_number:
{
- auto float_val = m_lexer.get_number();
+ result.m_value = m_lexer.get_number();
// NAN is returned if token could not be translated
// completely
- if (std::isnan(float_val))
+ if (std::isnan(result.m_value.number_float))
{
throw std::invalid_argument(std::string("parse error - ") +
m_lexer.get_token() + " is not a number");
@@ -7558,9 +7617,10 @@ basic_json_parser_64:
get_token();
- // check if conversion loses precision
- const auto int_val = static_cast<number_integer_t>(float_val);
- if (approx(float_val, static_cast<long double>(int_val)))
+ // 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 (approx(result.m_value.number_float, static_cast<number_float_t>(int_val)) &&
+ 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;
@@ -7570,7 +7630,6 @@ basic_json_parser_64:
{
// we would lose precision -> return float
result.m_type = value_t::number_float;
- result.m_value = static_cast<number_float_t>(float_val);
}
break;
}
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index c7ee44f5..1d7e4a03 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -5539,10 +5539,13 @@ class basic_json
case value_t::number_float:
{
- // 15 digits of precision allows round-trip IEEE 754
- // string->double->string; to be safe, we read this value from
- // std::numeric_limits<number_float_t>::digits10
- o << std::setprecision(std::numeric_limits<number_float_t>::digits10) << m_value.number_float;
+ // If the number is an integer then output as a fixed with with precision 1
+ // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
+ // 15 digits of precision allows round-trip IEEE 754 string->double->string;
+ // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
+ if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
+ else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
+ o << m_value.number_float;
return;
}
@@ -6971,6 +6974,63 @@ class basic_json
return result;
}
+ /*!
+ @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
+ 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
+ */
+ 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);
+ }
+
+ /*!
+ @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
+ 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);
+ }
+
+ /*!
+ @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
+ 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);
+ }
+
/*!
@brief return number value for number tokens
@@ -6988,13 +7048,12 @@ class basic_json
@throw std::range_error if passed value is out of range
*/
- long double get_number() const
+ number_float_t get_number() const
{
// conversion
typename string_t::value_type* endptr;
assert(m_start != nullptr);
- const auto float_val = std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start),
- &endptr);
+ number_float_t float_val = str_to_float_t(static_cast<number_float_t*>(nullptr), &endptr);
// return float_val if the whole number was translated and NAN
// otherwise
@@ -7228,11 +7287,11 @@ class basic_json
case lexer::token_type::value_number:
{
- auto float_val = m_lexer.get_number();
+ result.m_value = m_lexer.get_number();
// NAN is returned if token could not be translated
// completely
- if (std::isnan(float_val))
+ if (std::isnan(result.m_value.number_float))
{
throw std::invalid_argument(std::string("parse error - ") +
m_lexer.get_token() + " is not a number");
@@ -7240,9 +7299,10 @@ class basic_json
get_token();
- // check if conversion loses precision
- const auto int_val = static_cast<number_integer_t>(float_val);
- if (approx(float_val, static_cast<long double>(int_val)))
+ // 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 (approx(result.m_value.number_float, static_cast<number_float_t>(int_val)) &&
+ 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;
@@ -7252,7 +7312,6 @@ class basic_json
{
// we would lose precision -> return float
result.m_type = value_t::number_float;
- result.m_value = static_cast<number_float_t>(float_val);
}
break;
}
diff --git a/test/unit.cpp b/test/unit.cpp
index 8b3bc19b..05c36acc 100644
--- a/test/unit.cpp
+++ b/test/unit.cpp
@@ -11085,7 +11085,7 @@ TEST_CASE("compliance tests from nativejson-benchmark")
//"test/json_roundtrip/roundtrip18.json",
//"test/json_roundtrip/roundtrip19.json",
//"test/json_roundtrip/roundtrip20.json",
- //"test/json_roundtrip/roundtrip21.json",
+ "test/json_roundtrip/roundtrip21.json",
"test/json_roundtrip/roundtrip22.json",
"test/json_roundtrip/roundtrip23.json",
//"test/json_roundtrip/roundtrip24.json",
@@ -11402,7 +11402,8 @@ TEST_CASE("regression tests")
SECTION("issue #89 - nonstandard integer type")
{
// create JSON class with nonstandard integer number type
- nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, float> j;
+ using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, float>;
+ custom_json j;
j["int_1"] = 1;
// we need to cast to int to compile with Catch - the value is int32_t
CHECK(static_cast<int>(j["int_1"]) == 1);
@@ -11504,4 +11505,47 @@ TEST_CASE("regression tests")
{
CHECK(json::parse("\"\\ud80c\\udc60abc\"").get<json::string_t>() == u8"\U00013060abc");
}
+
+ SECTION("issue #186 miloyip/nativejson-benchmark: floating-point parsing")
+ {
+ json j;
+
+ j = json::parse("-0.0");
+ CHECK(j.get<double>() == -0.0);
+
+ j = json::parse("2.22507385850720113605740979670913197593481954635164564e-308");
+ CHECK(j.get<double>() == 2.2250738585072009e-308);
+
+ j = json::parse("0.999999999999999944488848768742172978818416595458984374");
+ CHECK(j.get<double>() == 0.99999999999999989);
+
+ j = json::parse("1.00000000000000011102230246251565404236316680908203126");
+ CHECK(j.get<double>() == 1.00000000000000022);
+
+ j = json::parse("7205759403792793199999e-5");
+ CHECK(j.get<double>() == 72057594037927928.0);
+
+ j = json::parse("922337203685477529599999e-5");
+ CHECK(j.get<double>() == 9223372036854774784.0);
+
+ j = json::parse("1014120480182583464902367222169599999e-5");
+ CHECK(j.get<double>() == 10141204801825834086073718800384.0);
+
+ j = json::parse("5708990770823839207320493820740630171355185151999e-3");
+ CHECK(j.get<double>() == 5708990770823838890407843763683279797179383808.0);
+
+ // create JSON class with nonstandard float number type
+
+ // float
+ nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, float> j_float = 1.23e25f;
+ CHECK(j_float.get<float>() == 1.23e25f);
+
+ // double
+ nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, double> j_double = 1.23e45;
+ 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;
+ CHECK(j_long_double.get<long double>() == 1.23e45L);
+ }
}
From bd8db5d40e438ef501f003369e9be87aad7db2bd Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Sun, 24 Jan 2016 17:15:44 +1000
Subject: [PATCH 02/10] Remove VS induced tabs
---
src/json.hpp | 6 +++---
src/json.hpp.re2c | 6 +++---
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/json.hpp b/src/json.hpp
index 44848553..1b1939c4 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -5539,10 +5539,10 @@ class basic_json
case value_t::number_float:
{
- // If the number is an integer then output as a fixed with with precision 1
- // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
+ // If the number is an integer then output as a fixed with with precision 1
+ // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
// 15 digits of precision allows round-trip IEEE 754 string->double->string;
- // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
+ // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
o << m_value.number_float;
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index 1d7e4a03..873f9be8 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -5539,10 +5539,10 @@ class basic_json
case value_t::number_float:
{
- // If the number is an integer then output as a fixed with with precision 1
- // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
+ // If the number is an integer then output as a fixed with with precision 1
+ // to output "0.0", "1.0" etc as expected for some round trip tests otherwise
// 15 digits of precision allows round-trip IEEE 754 string->double->string;
- // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
+ // to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
o << m_value.number_float;
From c1f5f0451d098263d00cfb8c71b3dd74f1327e80 Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Sun, 24 Jan 2016 17:54:50 +1000
Subject: [PATCH 03/10] Add workaround for gcc < 5 not supporting
std::defaultfloat
---
src/json.hpp | 5 ++++-
src/json.hpp.re2c | 5 ++++-
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/json.hpp b/src/json.hpp
index 1b1939c4..cf69dff6 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -5544,7 +5544,10 @@ class basic_json
// 15 digits of precision allows round-trip IEEE 754 string->double->string;
// to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
- else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
+ else {
+ o.unsetf(std::ios_base::floatfield); // std::defaultfloat not supported in gcc version < 5
+ o << std::setprecision(std::numeric_limits<double>::digits10);
+ }
o << m_value.number_float;
return;
}
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index 873f9be8..c6046d15 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -5544,7 +5544,10 @@ class basic_json
// 15 digits of precision allows round-trip IEEE 754 string->double->string;
// to be safe, we read this value from std::numeric_limits<number_float_t>::digits10
if (std::fmod(m_value.number_float, 1) == 0) o << std::fixed << std::setprecision(1);
- else o << std::defaultfloat << std::setprecision(std::numeric_limits<double>::digits10);
+ else {
+ o.unsetf(std::ios_base::floatfield); // std::defaultfloat not supported in gcc version < 5
+ o << std::setprecision(std::numeric_limits<double>::digits10);
+ }
o << m_value.number_float;
return;
}
From f79d52b973f30250d5b7734c327786ca27fbdb65 Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Sun, 24 Jan 2016 19:15:30 +1000
Subject: [PATCH 04/10] DEBUG ONLY: DUMP INFO FROM TRAVIS
---
test/unit.cpp | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/test/unit.cpp b/test/unit.cpp
index 05c36acc..a1362fc4 100644
--- a/test/unit.cpp
+++ b/test/unit.cpp
@@ -11521,6 +11521,13 @@ TEST_CASE("regression tests")
j = json::parse("1.00000000000000011102230246251565404236316680908203126");
CHECK(j.get<double>() == 1.00000000000000022);
+ union double_union { double _double; uint64_t _uint64_t; };
+ double_union A, B;
+ A._double = 1.00000000000000022;
+ B._double = j.get<double>();
+ std::cout << "Literal -> " << std::hex << A._uint64_t << std::endl;
+ std::cout << "Parsed -> " << std::hex << B._uint64_t << std::endl;
+ std::cout << "Type == " << std::dec << static_cast<int>(j.type()) << std::endl;
j = json::parse("7205759403792793199999e-5");
CHECK(j.get<double>() == 72057594037927928.0);
From 3245a0dc06b02cf267521d90f7290f813ec7775e Mon Sep 17 00:00:00 2001
From: Niels <niels.lohmann@gmail.com>
Date: Sun, 24 Jan 2016 16:42:13 +0100
Subject: [PATCH 05/10] fixed #194
---
src/json.hpp | 2 +-
src/json.hpp.re2c | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/json.hpp b/src/json.hpp
index 36280c16..5ca6fd81 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -4862,7 +4862,7 @@ class basic_json
}
else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
{
- return static_cast<number_float_t>(lhs.m_value.number_integer == rhs.m_value.number_float);
+ return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
}
else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
{
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index b88d8fb0..1b65a095 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -4862,7 +4862,7 @@ class basic_json
}
else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
{
- return static_cast<number_float_t>(lhs.m_value.number_integer == rhs.m_value.number_float);
+ return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
}
else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
{
From dfb01c659b945b5d1401b049ddfdfc18d92116ca Mon Sep 17 00:00:00 2001
From: Niels <niels.lohmann@gmail.com>
Date: Sun, 24 Jan 2016 16:42:45 +0100
Subject: [PATCH 06/10] added more comments
---
CONTRIBUTING.md | 3 ++-
README.md | 2 ++
2 files changed, 4 insertions(+), 1 deletion(-)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0171a244..5d8ef7b5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -72,4 +72,5 @@ The following areas really need contribution:
- Extending the **continuous integration** beyond Linux running some versions of GCC and Clang on [Travis](https://travis-ci.org/nlohmann/json) and Microsoft Visual Studio on [AppVeyor](https://ci.appveyor.com/project/nlohmann/json). We have found a lot of bugs just because several compilers behave in a slightly different manner.
- Improving the efficiency of the **JSON parser**. The current parser is implemented as a naive recursive descent parser with hand coded string handling. More sophisticated approaches like LALR parsers would be really appreciated. That said, parser generators like Bison or ANTLR do not play nice with single-header files -- I really would like to keep the parser inside the `json.hpp` header, and I am not aware of approaches similar to [`re2c`](http://re2c.org) for parsing.
- Extending and updating existing **benchmarks** to include (the most recent version of) this library. Though efficiency is not everything, speed and memory consumption are very important characteristics for C++ developers, so having proper comparisons would be interesting.
-- Check the code with [Coverity](https://scan.coverity.com).
+- Check the code with [**Coverity**](https://scan.coverity.com).
+- Make the code **locale-independent**. The library currently only works for a locale where `.` is the decimal point character.
diff --git a/README.md b/README.md
index 6d45c2a2..93b4395a 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,8 @@ Other aspects were not so important to us:
- **Speed**. We currently implement the parser as naive [recursive descent parser](http://en.wikipedia.org/wiki/Recursive_descent_parser) with hand coded string handling. It is fast enough, but a [LALR-parser](http://en.wikipedia.org/wiki/LALR_parser) with a decent regular expression processor should be even faster (but would consist of more files which makes the integration harder).
+See the [https://github.com/nlohmann/json/blob/master/CONTRIBUTING.md#please-dont](contribution guidelines) for more information.
+
## Integration
The single required source, file `json.hpp` is in the `src` directory or [released here](https://github.com/nlohmann/json/releases). All you need to do is add
From 4d6985d4e2cd1f9ce4f1c3491d9cf33e97fb352f Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Mon, 25 Jan 2016 01:53:32 +1000
Subject: [PATCH 07/10] Disable problematic test for GCC/clang, remove debug
dump from unit.cpp
---
test/unit.cpp | 11 ++++-------
1 file changed, 4 insertions(+), 7 deletions(-)
diff --git a/test/unit.cpp b/test/unit.cpp
index a1362fc4..487632bf 100644
--- a/test/unit.cpp
+++ b/test/unit.cpp
@@ -11519,15 +11519,12 @@ TEST_CASE("regression tests")
j = json::parse("0.999999999999999944488848768742172978818416595458984374");
CHECK(j.get<double>() == 0.99999999999999989);
+ // Test fails under GCC/clang due to strtod() error (may originate in libstdc++
+ // but seems to have been fixed in the most current versions)
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
j = json::parse("1.00000000000000011102230246251565404236316680908203126");
CHECK(j.get<double>() == 1.00000000000000022);
- union double_union { double _double; uint64_t _uint64_t; };
- double_union A, B;
- A._double = 1.00000000000000022;
- B._double = j.get<double>();
- std::cout << "Literal -> " << std::hex << A._uint64_t << std::endl;
- std::cout << "Parsed -> " << std::hex << B._uint64_t << std::endl;
- std::cout << "Type == " << std::dec << static_cast<int>(j.type()) << std::endl;
+#endif
j = json::parse("7205759403792793199999e-5");
CHECK(j.get<double>() == 72057594037927928.0);
From 9584a99a43751aea124c9b24d3cd9f56a04ab1e2 Mon Sep 17 00:00:00 2001
From: Niels <niels.lohmann@gmail.com>
Date: Sun, 24 Jan 2016 17:06:36 +0100
Subject: [PATCH 08/10] added issue stats
---
CONTRIBUTING.md | 2 ++
1 file changed, 2 insertions(+)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5d8ef7b5..ea57e650 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,3 +1,5 @@
+[](http://issuestats.com/github/nlohmann/json) [](http://issuestats.com/github/nlohmann/json)
+
# How to contribute
This project started as a little excuse to exercise some of the cool new C++11 features. Over time, people actually started to use the JSON library (yey!) and started to help improve it by proposing features, finding bugs, or even fixing my mistakes. I am really [thankful](https://github.com/nlohmann/json/blob/master/README.md#thanks) for this and try to keep track of all the helpers.
From 19918b948d5909bc9dae9fc6e92668f2b56e363f Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Mon, 25 Jan 2016 02:07:49 +1000
Subject: [PATCH 09/10] Fix typo in preprocessor defined/!defined
---
test/unit.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/test/unit.cpp b/test/unit.cpp
index 9185c205..f098170d 100644
--- a/test/unit.cpp
+++ b/test/unit.cpp
@@ -11574,7 +11574,7 @@ TEST_CASE("regression tests")
// Test fails under GCC/clang due to strtod() error (may originate in libstdc++
// but seems to have been fixed in the most current versions - just not on Travis)
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+#if !defined(__clang__) && !defined(__GNUC__) && !defined(__GNUG__)
j = json::parse("1.00000000000000011102230246251565404236316680908203126");
CHECK(j.get<double>() == 1.00000000000000022);
#endif
From 81b70792559ee5db8c6e0de2d1ac3c59ccab66d2 Mon Sep 17 00:00:00 2001
From: Trevor Welsby <welsby.trevorr@gmail.com>
Date: Mon, 25 Jan 2016 02:13:39 +1000
Subject: [PATCH 10/10] Kill unused argument warnings in GCC/clang
---
src/json.hpp | 6 +++---
src/json.hpp.re2c | 6 +++---
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/json.hpp b/src/json.hpp
index ad4c65f6..1a81a3e4 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -7374,7 +7374,7 @@ basic_json_parser_64:
@return the floating point number
*/
- long double str_to_float_t(long double* type, char** endptr) const
+ 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);
}
@@ -7393,7 +7393,7 @@ basic_json_parser_64:
@return the floating point number
*/
- double str_to_float_t(double* type, char** endptr) const
+ double str_to_float_t(double* /* type */, char** endptr) const
{
return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
}
@@ -7412,7 +7412,7 @@ basic_json_parser_64:
@return the floating point number
*/
- float str_to_float_t(float* type, char** endptr) const
+ float str_to_float_t(float* /* type */, char** endptr) const
{
return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
}
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index 28f7d498..243e9d36 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -7056,7 +7056,7 @@ class basic_json
@return the floating point number
*/
- long double str_to_float_t(long double* type, char** endptr) const
+ 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);
}
@@ -7075,7 +7075,7 @@ class basic_json
@return the floating point number
*/
- double str_to_float_t(double* type, char** endptr) const
+ double str_to_float_t(double* /* type */, char** endptr) const
{
return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
}
@@ -7094,7 +7094,7 @@ class basic_json
@return the floating point number
*/
- float str_to_float_t(float* type, char** endptr) const
+ float str_to_float_t(float* /* type */, char** endptr) const
{
return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
}