fix: accept subnormal and underflowing doubles when parsing (#1427)

decodeDouble parsed numbers via `istringstream >> double`. For a
subnormal value such as `3.2114e-312`, operator>> sets failbit even
though it consumed the whole token and produced the correctly-rounded
value. The failure path only special-cased overflow (value ==
max/lowest), so subnormals were rejected as "not a number" -- meaning a
value jsoncpp had just serialized could fail to parse back.

In the failure path, distinguish a complete-but-out-of-range parse from
genuine junk by whether the entire token was consumed (is.eof()): on a
full parse keep the value operator>> produced (the correctly-rounded
subnormal, zero on underflow, or infinity on overflow); only a partial
parse (e.g. "1abc") is still rejected. eof() is used instead of errno
because it is a fundamental streambuf signal that behaves consistently
across libstdc++, libc++, and MSVC. Applied to both Reader and OurReader.

Adds CharReaderTest/parseSubnormalAndUnderflow covering subnormals, a
writer round-trip, underflow-to-zero, and continued rejection of junk.

Author: baylesj

src/lib_json/json_reader.cpp

@@ -584,7 +584,12 @@ bool Reader::decodeDouble(Token& token, Value& decoded) {
       value = std::numeric_limits<double>::infinity();
     else if (value == std::numeric_limits<double>::lowest())
       value = -std::numeric_limits<double>::infinity();
-    else if (!std::isinf(value))
+    // operator>> sets failbit for a value that overflows to infinity or
+    // underflows to a subnormal/zero, even though it consumed the entire token
+    // and produced the correctly-rounded result. Distinguish that from genuine
+    // junk by whether the whole token was consumed: on a complete parse (eof)
+    // keep the value, only reject a partial one. See issue #1427.
+    else if (!is.eof())
       return addError(
           "'" + String(token.start_, token.end_) + "' is not a number.", token);
   }
@@ -1637,7 +1642,12 @@ bool OurReader::decodeDouble(Token& token, Value& decoded) {
       value = std::numeric_limits<double>::infinity();
     else if (value == std::numeric_limits<double>::lowest())
       value = -std::numeric_limits<double>::infinity();
-    else if (!std::isinf(value))
+    // operator>> sets failbit for a value that overflows to infinity or
+    // underflows to a subnormal/zero, even though it consumed the entire token
+    // and produced the correctly-rounded result. Distinguish that from genuine
+    // junk by whether the whole token was consumed: on a complete parse (eof)
+    // keep the value, only reject a partial one. See issue #1427.
+    else if (!is.eof())
       return addError(
           "'" + String(token.start_, token.end_) + "' is not a number.", token);
   }

src/test_lib_json/main.cpp

@@ -3212,6 +3212,49 @@ JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseNumber) {
   }
 }
 
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseSubnormalAndUnderflow) {
+  // Regression test for #1427: subnormal doubles make operator>> set failbit
+  // (errno == ERANGE) even though it produced the correctly-rounded value, so
+  // they used to fail to parse. They should now parse to that value.
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+
+  const struct {
+    const char* doc;
+    double expected;
+  } cases[] = {
+      {"[3.2114e-312]", 3.2114e-312}, // subnormal
+      {"[-1e-320]", -1e-320},         // negative subnormal
+      {"[4.9e-324]", 4.9e-324},       // smallest positive subnormal
+      {"[1e-400]", 0.0},              // underflow all the way to zero
+  };
+  for (const auto& c : cases) {
+    Json::Value root;
+    bool ok = reader->parse(c.doc, c.doc + std::strlen(c.doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL(c.expected, root[0].asDouble());
+  }
+
+  // A subnormal also round-trips through the writer.
+  {
+    const Json::String doc = Json::writeString(Json::StreamWriterBuilder(),
+                                               Json::Value(3.2114e-312));
+    Json::Value root;
+    bool ok = reader->parse(doc.data(), doc.data() + doc.size(), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_EQUAL(3.2114e-312, root.asDouble());
+  }
+
+  // Genuine non-numbers are still rejected.
+  {
+    char const doc[] = "[1abc]";
+    Json::Value root;
+    JSONTEST_ASSERT(!reader->parse(doc, doc + std::strlen(doc), &root, &errs));
+  }
+}
+
 JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseString) {
   Json::CharReaderBuilder b;
   CharReaderPtr reader(b.newCharReader());