grok_bin_oct_hex: Improve speed, precision

This replaces a floating multiply each loop iteration with an integer
increment, plus after the loop completes, a call to ldexp() or pow().

Most of the floating multiplies are done on integral values, so
not much precision is lost, but this gets it down to just one
precision-losing operation.

Author: khwilliamson

numeric.c

@@ -487,9 +487,13 @@ Perl_grok_bin_oct_hex(pTHX_ const char * const start,
           break;
     }
 
-    /* In overflows, this keeps track of how much to multiply the overflowed NV
-     * by as we continue to parse the remaining digits */
-    NV factor = 0.0;
+    /* The loop below accumulates the integral running total of the result,
+     * digit by digit.  If this total overflows, it adds that to an NV
+     * approximation, and starts looking at the next batch of digits, until
+     * they overflow, and so on.  This variable counts the number of digits
+     * seen in the current batch.  (The initial value is irrelevant, as the
+     * first batch will end up being multiplied by zero.) */
+    uint_fast8_t batch_digit_count = 0;
 
     bool overflowed = FALSE;
     NV value_nv = 0;
@@ -512,24 +516,29 @@ Perl_grok_bin_oct_hex(pTHX_ const char * const start,
                  * slowing those down (it does have unnecessary shifts, ANDSs,
                  * and additions for those) */
                 value = (value << shift) | XDIGIT_VALUE(*s);
-                factor *= base;
+                batch_digit_count++;
                 continue;
             }
 
             /* Bah. We are about to overflow.  Instead, add the unoverflowed
              * value to an NV that contains an approximation to the correct
-             * value.  Each time through the loop we have increased 'factor' so
-             * that it gives how much the current approximation needs to
-             * effectively be shifted to make room for this new value */
-            value_nv *= factor;
+             * value.  Each time through the loop we have incremented
+             * 'batch_digit_count' so that it gives how many digits the
+             * current approximation needs to effectively be shifted to make
+             * room for this new value */
+#ifdef Perl_ldexp
+                value_nv = Perl_ldexp(value_nv, batch_digit_count * shift);
+#else
+                value_nv *= Perl_pow(base, batch_digit_count);
+#endif
             value_nv += (NV) value;
 
             /* Then we keep accumulating digits, until all are parsed.  We
              * start over using the current input value.  This will be added to
              * 'value_nv' eventually, either when all digits are gone, or we
              * have overflowed this fresh start. */
             value = XDIGIT_VALUE(*s);
-            factor = base;
+            batch_digit_count = 1;
 
             if (! overflowed) {
                 overflowed = TRUE;
@@ -623,7 +632,11 @@ Perl_grok_bin_oct_hex(pTHX_ const char * const start,
     }
 
     /* Overflowed: Calculate the final overflow approximation */
-    value_nv *= factor;
+#ifdef Perl_ldexp
+        value_nv = Perl_ldexp(value_nv, batch_digit_count * shift);
+#else
+        value_nv *= Perl_pow(base, batch_digit_count);
+#endif
     value_nv += (NV) value;
 
     output_non_portable(base);