JavaScriptExpert
diff --git a/‎README.md‎
Lines changed: 1 addition & 1 deletion b/‎README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎benchmark/parseandstatcompetition.cpp‎
Lines changed: 31 additions & 0 deletions b/‎benchmark/parseandstatcompetition.cpp‎
Lines changed: 31 additions & 0 deletions
diff --git a/‎benchmark/parsingcompetition.cpp‎
Lines changed: 13 additions & 0 deletions b/‎benchmark/parsingcompetition.cpp‎
Lines changed: 13 additions & 0 deletions
@@ -402,7 +402,7 @@ _We do not aim to provide a general-purpose JSON library._ A library like RapidJ
 - The input string is unmodified. (Parsers like sajson and RapidJSON use the input string as a buffer.)
 - We parse integers and floating-point numbers as separate types which allows us to support large signed 64-bit integers in [-9223372036854775808,9223372036854775808), like a Java `long` or a C/C++ `long long` and large unsigned integers up to the value 18446744073709551615. Among the parsers that differentiate between integers and floating-point numbers, not all support 64-bit integers. (For example, sajson rejects JSON files with integers larger than or equal to 2147483648. RapidJSON will parse a file containing an overly long integer like 18446744073709551616 as a floating-point number.) When we cannot represent exactly an integer as a signed or unsigned 64-bit value, we reject the JSON document.
 - We support the full range of 64-bit floating-point numbers (binary64). The values range from ` std::numeric_limits<double>::lowest()`  to `std::numeric_limits<double>::max()`, so from -1.7976e308 all the way to 1.7975e308. Extreme values (less or equal to -1e308, greater or equal to 1e308) are rejected: we refuse to parse the input document.
-- We test for accurate float parsing with a bound on the [unit of least precision (ULP)](https://en.wikipedia.org/wiki/Unit_in_the_last_place) of one. Practically speaking, this implies 15 digits of accuracy or better.
+- We test for accurate float parsing with a perfect (ULP 0) accuracy. Many parsers offer only approximate floating parsing. RapidJSON also offers the option of accurate float parsing (`kParseFullPrecisionFlag`) but it comes at a significant performance penalty compared to the default settings.
 - We do full UTF-8 validation as part of the parsing. (Parsers like fastjson, gason and dropbox json11 do not do UTF-8 validation. The sajson parser does incomplete UTF-8 validation, accepting code point
 sequences like 0xb1 0x87.)
 - We fully validate the numbers. (Parsers like gason and ultranjson will accept `[0e+]` as valid JSON.)
 
@@ -238,6 +238,32 @@ rapid_compute_stats(const simdjson::padded_string &p) {
   return answer;
 }
 
+__attribute__((noinline)) stat_t
+rapid_accurate_compute_stats(const simdjson::padded_string &p) {
+  stat_t answer;
+  char *buffer = (char *)malloc(p.size() + 1);
+  if(buffer == nullptr) {
+    return answer;
+  }
+  memcpy(buffer, p.data(), p.size());
+  buffer[p.size()] = '\0';
+  rapidjson::Document d;
+  d.ParseInsitu<kParseValidateEncodingFlag|kParseFullPrecisionFlag>(buffer);
+  answer.valid = !d.HasParseError();
+  if (!answer.valid) {
+    free(buffer);
+    return answer;
+  }
+  answer.number_count = 0;
+  answer.object_count = 0;
+  answer.array_count = 0;
+  answer.null_count = 0;
+  answer.true_count = 0;
+  answer.false_count = 0;
+  rapid_traverse(answer, d);
+  free(buffer);
+  return answer;
+}
 int main(int argc, char *argv[]) {
   bool verbose = false;
   bool just_data = false;
@@ -294,6 +320,11 @@ int main(int argc, char *argv[]) {
     printf("rapid:    ");
     print_stat(s2);
   }
+  stat_t s2a = rapid_accurate_compute_stats(p);
+  if (verbose) {
+    printf("rapid full:    ");
+    print_stat(s2);
+  }
   stat_t s3 = sasjon_compute_stats(p);
   if (verbose) {
     printf("sasjon:   ");
 
@@ -130,11 +130,24 @@ bool bench(const char *filename, bool verbose, bool just_data, int repeat_multip
                   .HasParseError(),
               false, memcpy(buffer, p.data(), p.size()), repeat, volume,
               !just_data);
+#ifndef ALLPARSER
+  if (!just_data)
+#endif
+    BEST_TIME("RapidJSON (accurate number parsing)  ",
+              d.Parse<kParseValidateEncodingFlag|kParseFullPrecisionFlag>((const char *)buffer)
+                  .HasParseError(),
+              false, memcpy(buffer, p.data(), p.size()), repeat, volume,
+              !just_data);
   BEST_TIME("RapidJSON (insitu)",
             d.ParseInsitu<kParseValidateEncodingFlag>(buffer).HasParseError(),
             false,
             memcpy(buffer, p.data(), p.size()) && (buffer[p.size()] = '\0'),
             repeat, volume, !just_data);
+  BEST_TIME("RapidJSON (insitu, accurate number parsing)",
+            d.ParseInsitu<kParseValidateEncodingFlag|kParseFullPrecisionFlag>(buffer).HasParseError(),
+            false,
+            memcpy(buffer, p.data(), p.size()) && (buffer[p.size()] = '\0'),
+            repeat, volume, !just_data);
 #ifndef ALLPARSER
   if (!just_data)
 #endif