Merge pull request #91 from pitrou/issue90-decimal-point

Issue #90: accept custom decimal point

Author: lemire

include/fast_float/ascii_number.h

@@ -81,7 +81,10 @@ struct parsed_number_string {
 // Assuming that you use no more than 19 digits, this will
 // parse an ASCII string.
 fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
   parsed_number_string answer;
   answer.valid = false;
   answer.too_many_digits = false;
@@ -91,7 +94,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     if (p == pend) {
       return answer;
     }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
       return answer;
     }
   }
@@ -109,7 +112,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
   const char *const end_of_integer_part = p;
   int64_t digit_count = int64_t(end_of_integer_part - start_digits);
   int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_point)) {
     ++p;
   // Fast approach only tested under little endian systems
   if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
@@ -179,7 +182,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     // We need to be mindful of the case where we only have zeroes...
     // E.g., 0.000000000...000.
     const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
       if(*start == '0') { digit_count --; }
       start++;
     }
@@ -196,7 +199,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
       if (i >= minimal_nineteen_digit_integer) { // We have a big integers
         exponent = end_of_integer_part - p + exp_number;
       } else { // We have a value with a fractional component.
-          p++; // skip the '.'
+          p++; // skip the dot
           const char *first_after_period = p;
           while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
             i = i * 10 + uint64_t(*p - '0');
@@ -217,7 +220,9 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
 // This function could be optimized. In particular, we could stop after 19 digits
 // and try to bail out. Furthermore, we should be able to recover the computed
 // exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
+fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend, parse_options options) noexcept {
+  const char decimal_point = options.decimal_point;
+
   decimal answer;
   answer.num_digits = 0;
   answer.decimal_point = 0;
@@ -237,7 +242,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     answer.num_digits++;
     ++p;
   }
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_point)) {
     ++p;
     const char *first_after_period = p;
     // if we have not yet encountered a zero, we have to skip it as well
@@ -276,7 +281,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     // we have at least one non-zero digit.
     const char *preverse = p - 1;
     int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
+    while ((*preverse == '0') || (*preverse == decimal_point)) {
       if(*preverse == '0') { trailing_zeros++; };
       --preverse;
     }

include/fast_float/fast_float.h

@@ -17,6 +17,17 @@ struct from_chars_result {
   std::errc ec;
 };
 
+struct parse_options {
+  explicit parse_options(chars_format fmt = chars_format::general,
+                         char dot = '.')
+    : format(fmt), decimal_point(dot) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  char decimal_point;
+};
+
 /**
  * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
  * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
@@ -40,6 +51,13 @@ template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
                              T &value, chars_format fmt = chars_format::general)  noexcept;
 
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept;
+
 }
 #include "parse_number.h"
-#endif // FASTFLOAT_FAST_FLOAT_H
+#endif // FASTFLOAT_FAST_FLOAT_H

include/fast_float/parse_number.h

@@ -85,6 +85,13 @@ fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &va
 template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
                              T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
+  return from_chars_advanced(first, last, value, parse_options{fmt});
+}
+
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept  {
+
   static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
 
 
@@ -94,7 +101,7 @@ from_chars_result from_chars(const char *first, const char *last,
     answer.ptr = first;
     return answer;
   }
-  parsed_number_string pns = parse_number_string(first, last, fmt);
+  parsed_number_string pns = parse_number_string(first, last, options);
   if (!pns.valid) {
     return detail::parse_infnan(first, last, value);
   }
@@ -116,7 +123,7 @@ from_chars_result from_chars(const char *first, const char *last,
   }
   // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
   // then we need to go the long way around again. This is very uncommon.
-  if(am.power2 < 0) { am = parse_long_mantissa<binary_format<T>>(first,last); }
+  if(am.power2 < 0) { am = parse_long_mantissa<binary_format<T>>(first, last, options); }
   detail::to_float(pns.negative, am, value);
   return answer;
 }

include/fast_float/simple_decimal_conversion.h

@@ -351,8 +351,8 @@ adjusted_mantissa compute_float(decimal &d) {
 }
 
 template <typename binary>
-adjusted_mantissa parse_long_mantissa(const char *first, const char* last) {
-    decimal d = parse_decimal(first, last);
+adjusted_mantissa parse_long_mantissa(const char *first, const char* last, parse_options options) {
+    decimal d = parse_decimal(first, last, options);
     return compute_float<binary>(d);
 }