strtod.c: new public domain implementation of `strtod`; ref #5448

Instead of using copyrighted `strtod`, now use the public domain
implementation of `strtod` by Yasuhiro Matsumoto (@mattn). The function
has been renamed to `mrb_float_read()`; ref #5460 as well.

2 files changed, 120 insertions, 247 deletions

diff --git a/src/string.c b/src/string.c
index f87471e5d..2258dce2c 100644
--- a/src/string.c
+++ b/src/string.c
@@ -2922,250 +2922,3 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "setbyte",         mrb_str_setbyte,         MRB_ARGS_REQ(2));
   mrb_define_method(mrb, s, "byteslice",       mrb_str_byteslice,       MRB_ARGS_ARG(1,1));
 }
-
-#ifndef MRB_NO_FLOAT
-/*
- * Source code for the "strtod" library procedure.
- *
- * Copyright (c) 1988-1993 The Regents of the University of California.
- * Copyright (c) 1994 Sun Microsystems, Inc.
- *
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- *
- * RCS: @(#) $Id: strtod.c 11708 2007-02-12 23:01:19Z shyouhei $
- */
-
-#include <ctype.h>
-#include <errno.h>
-
-static const int maxExponent = 511; /* Largest possible base 10 exponent.  Any
-                                     * exponent larger than this will already
-                                     * produce underflow or overflow, so there's
-                                     * no need to worry about additional digits.
-                                     */
-static const double powersOf10[] = {/* Table giving binary powers of 10.  Entry */
-    10.,                            /* is 10^2^i.  Used to convert decimal */
-    100.,                           /* exponents into floating-point numbers. */
-    1.0e4,
-    1.0e8,
-    1.0e16,
-    1.0e32,
-    1.0e64,
-    1.0e128,
-    1.0e256
-};
-
-MRB_API double
-mrb_float_read(const char *string, char **endPtr)
-/*  const char *string;            A decimal ASCII floating-point number,
-                                 * optionally preceded by white space.
-                                 * Must have form "-I.FE-X", where I is the
-                                 * integer part of the mantissa, F is the
-                                 * fractional part of the mantissa, and X
-                                 * is the exponent.  Either of the signs
-                                 * may be "+", "-", or omitted.  Either I
-                                 * or F may be omitted, or both.  The decimal
-                                 * point isn't necessary unless F is present.
-                                 * The "E" may actually be an "e".  E and X
-                                 * may both be omitted (but not just one).
-                                 */
-/*  char **endPtr;                 If non-NULL, store terminating character's
-                                 * address here. */
-{
-    int sign, expSign = FALSE;
-    double fraction, dblExp;
-    const double *d;
-    const char *p;
-    int c;
-    int exp = 0;                /* Exponent read from "EX" field. */
-    int fracExp = 0;            /* Exponent that derives from the fractional
-                                 * part.  Under normal circumstances, it is
-                                 * the negative of the number of digits in F.
-                                 * However, if I is very long, the last digits
-                                 * of I get dropped (otherwise a long I with a
-                                 * large negative exponent could cause an
-                                 * unnecessary overflow on I alone).  In this
-                                 * case, fracExp is incremented one for each
-                                 * dropped digit. */
-    int mantSize;               /* Number of digits in mantissa. */
-    int decPt;                  /* Number of mantissa digits BEFORE decimal
-                                 * point. */
-    const char *pExp;           /* Temporarily holds location of exponent
-                                 * in string. */
-
-    /*
-     * Strip off leading blanks and check for a sign.
-     */
-
-    p = string;
-    while (ISSPACE(*p)) {
-      p += 1;
-    }
-    if (*p == '-') {
-      sign = TRUE;
-      p += 1;
-    }
-    else {
-      if (*p == '+') {
-        p += 1;
-      }
-      sign = FALSE;
-    }
-
-    /*
-     * Count the number of digits in the mantissa (including the decimal
-     * point), and also locate the decimal point.
-     */
-
-    decPt = -1;
-    for (mantSize = 0; ; mantSize += 1)
-    {
-      c = *p;
-      if (!ISDIGIT(c)) {
-        if ((c != '.') || (decPt >= 0)) {
-          break;
-        }
-        decPt = mantSize;
-      }
-      p += 1;
-    }
-
-    /*
-     * Now suck up the digits in the mantissa.  Use two integers to
-     * collect 9 digits each (this is faster than using floating-point).
-     * If the mantissa has more than 18 digits, ignore the extras, since
-     * they can't affect the value anyway.
-     */
-
-    pExp  = p;
-    p -= mantSize;
-    if (decPt < 0) {
-      decPt = mantSize;
-    }
-    else {
-      mantSize -= 1; /* One of the digits was the point. */
-    }
-    if (mantSize > 18) {
-      if (decPt - 18 > 29999) {
-        fracExp = 29999;
-      }
-      else {
-        fracExp = decPt - 18;
-      }
-      mantSize = 18;
-    }
-    else {
-      fracExp = decPt - mantSize;
-    }
-    if (mantSize == 0) {
-      fraction = 0.0;
-      p = string;
-      goto done;
-    }
-    else {
-      int frac1, frac2;
-      frac1 = 0;
-      for ( ; mantSize > 9; mantSize -= 1)
-      {
-        c = *p;
-        p += 1;
-        if (c == '.') {
-          c = *p;
-          p += 1;
-        }
-        frac1 = 10*frac1 + (c - '0');
-      }
-      frac2 = 0;
-      for (; mantSize > 0; mantSize -= 1)
-      {
-        c = *p;
-        p += 1;
-        if (c == '.') {
-          c = *p;
-          p += 1;
-        }
-        frac2 = 10*frac2 + (c - '0');
-      }
-      fraction = (1.0e9 * frac1) + frac2;
-    }
-
-    /*
-     * Skim off the exponent.
-     */
-
-    p = pExp;
-    if ((*p == 'E') || (*p == 'e')) {
-      p += 1;
-      if (*p == '-') {
-        expSign = TRUE;
-        p += 1;
-      }
-      else {
-        if (*p == '+') {
-          p += 1;
-        }
-        expSign = FALSE;
-      }
-      while (ISDIGIT(*p)) {
-        exp = exp * 10 + (*p - '0');
-        if (exp > 19999) {
-          exp = 19999;
-        }
-        p += 1;
-      }
-    }
-    if (expSign) {
-      exp = fracExp - exp;
-    }
-    else {
-      exp = fracExp + exp;
-    }
-
-    /*
-     * Generate a floating-point number that represents the exponent.
-     * Do this by processing the exponent one bit at a time to combine
-     * many powers of 2 of 10. Then combine the exponent with the
-     * fraction.
-     */
-
-    if (exp < 0) {
-      expSign = TRUE;
-      exp = -exp;
-    }
-    else {
-      expSign = FALSE;
-    }
-    if (exp > maxExponent) {
-      exp = maxExponent;
-      errno = ERANGE;
-    }
-    dblExp = 1.0;
-    for (d = powersOf10; exp != 0; exp >>= 1, d += 1) {
-      if (exp & 01) {
-        dblExp *= *d;
-      }
-    }
-    if (expSign) {
-      fraction /= dblExp;
-    }
-    else {
-      fraction *= dblExp;
-    }
-
-done:
-    if (endPtr != NULL) {
-      *endPtr = (char *) p;
-    }
-
-    if (sign) {
-      return -fraction;
-    }
-    return fraction;
-}
-#endif
diff --git a/src/strtod.c b/src/strtod.c
new file mode 100644
index 000000000..19a8e8dc6
--- /dev/null
+++ b/src/strtod.c
@@ -0,0 +1,120 @@
+#include <mruby.h>
+
+#ifndef MRB_NO_FLOAT
+/*
+ * strtod implementation.
+ * author: Yasuhiro Matsumoto (@mattn)
+ * license: public domain
+ */
+
+/*
+The original code can be found in https://github.com/mattn/strtod
+
+I modified the routine for mruby:
+
+ * renamed the function `vim_strtod` -> `mrb_float_read`
+ * simplified the code
+
+My modifications in this file are also placed in the public domain.
+
+Matz (Yukihiro Matsumoto)
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <errno.h>
+
+MRB_API double
+mrb_float_read(const char *str, char **end)
+{
+  double d = 0.0;
+  int sign;
+  int n = 0;
+  const char *p, *a;
+
+  a = p = str;
+  while (ISSPACE(*p))
+    ++p;
+
+  /* decimal part */
+  sign = 1;
+  if (*p == '-') {
+    sign = -1;
+    ++p;
+  } else if (*p == '+')
+    ++p;
+  if (ISDIGIT(*p)) {
+    d = (double)(*p++ - '0');
+    while (*p && ISDIGIT(*p)) {
+      d = d * 10.0 + (double)(*p - '0');
+      ++p;
+      ++n;
+    }
+    a = p;
+  } else if (*p != '.')
+    goto done;
+  d *= sign;
+
+  /* fraction part */
+  if (*p == '.') {
+    double f = 0.0;
+    double base = 0.1;
+    ++p;
+
+    if (ISDIGIT(*p))
+      {
+        while (*p && ISDIGIT(*p)) {
+          f += base * (*p - '0') ;
+          base /= 10.0;
+          ++p;
+          ++n;
+        }
+      }
+    d += f * sign;
+    a = p;
+  }
+
+  /* exponential part */
+  if ((*p == 'E') || (*p == 'e')) {
+    int e = 0;
+    ++p;
+
+    sign = 1;
+    if (*p == '-') {
+      sign = -1;
+      ++p;
+    } else if (*p == '+')
+      ++p;
+
+    if (ISDIGIT(*p)) {
+      while (*p == '0')
+        ++p;
+      if (*p == '\0') --p;
+      e = (int)(*p++ - '0');
+      for (; *p && ISDIGIT(*p); p++) {
+        if (e < 10000)
+          e = e * 10 + (*p - '0');
+      }
+      e *= sign;
+    }
+    else if (!ISDIGIT(*(a-1))) {
+      a = str;
+      goto done;
+    }
+    else if (*p == 0)
+      goto done;
+    d *= pow(10.0, (double) e);
+    a = p;
+  }
+  else if (p > str && !ISDIGIT(*(p-1))) {
+    a = str;
+    goto done;
+  }
+
+done:
+  if (end)
+    *end = (char*)a;
+  return d;
+}
+#endif