smarter_csv 1.17.4 → 1.18.1

data/ext/smarter_csv/smarter_csv.c

@@ -7,6 +7,14 @@
 #include <stdlib.h>
 #include <errno.h>
 
+#ifdef __ARM_NEON
+  #include <arm_neon.h>
+#elif defined(__SSE2__)
+  #include <immintrin.h>
+#endif
+
+#include "vendor/eisel_lemire.h" /* Eisel-Lemire decimal->double, correctly rounded (fast_float) */
+
 #ifndef bool
   #define bool int
   #define false ((bool)0)
@@ -41,6 +49,8 @@ static ID id_only, id_except, id_quote_boundary;
 static ID id_only_headers, id_except_headers, id_keep_cols, id_strict;
 static ID id_keep_bitmap, id_keep_extra_cols, id_early_exit_after_sym;
 static ID id_backslash, id_standard;
+static ID id_decimal_precision, id_float, id_bigdecimal;
+static ID id_BigDecimal; /* the Kernel#BigDecimal() method (require 'bigdecimal' done in Ruby) */
 
 /* ================================================================================
  * ParseContext — wraps all per-file parse options as a GC-managed TypedData object.
@@ -70,6 +80,9 @@ typedef struct {
   /* Numeric conversion: 0=off, 1=all, 2=only listed keys, 3=except listed keys */
   int  numeric_mode;
 
+  /* Decimal handling: 0=float, 1=auto (BigDecimal above 16 sig digits), 2=bigdecimal */
+  int  decimal_precision;
+
   /* Column filter bitmap (xmalloc'd; NULL when no filtering active) */
   bool *keep_bitmap;
   long  keep_bitmap_len;
@@ -133,6 +146,51 @@ static const rb_data_type_t parse_context_type = {
   RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
+/* Scan [p, end) for the first `quote` char or backslash; returns a pointer to it,
+ * or `end` if neither occurs. NEON (arm64) or SSE2 (x86-64) processes 16 bytes per
+ * iteration; scalar fallback elsewhere. Ported from smarter_json's fj_scan_str.
+ *
+ * Used by the quoted-field slow path in :backslash escaping mode, where the only bytes
+ * that can change parser state inside a quoted field are the quote char (closing /
+ * doubled) and the backslash (escape). Bulk-skipping the plain content between them
+ * keeps the byte-by-byte state machine's behavior but avoids stepping every byte.
+ * In RFC mode the slow path uses a plain memchr-to-quote instead (only one byte class
+ * matters there), so this two-class scan is reserved for backslash mode. */
+static inline const char *scan_quote_or_backslash(const char *p, const char *end, char quote) {
+#ifdef __ARM_NEON
+  const uint8x16_t vq  = vdupq_n_u8((uint8_t)quote);
+  const uint8x16_t vbs = vdupq_n_u8((uint8_t)'\\');
+  while (p + 16 <= end) {
+    uint8x16_t chunk = vld1q_u8((const uint8_t *)p);
+    uint8x16_t m     = vorrq_u8(vceqq_u8(chunk, vq), vceqq_u8(chunk, vbs));
+    /* movemask emulation (Oj's technique): pack to 4 bits/byte, then ctz/4. */
+    uint8x8_t  res   = vshrn_n_u16(vreinterpretq_u16_u8(m), 4);
+    uint64_t   mask  = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+    if (__builtin_expect(mask != 0, 0)) {  /* most 16-byte chunks contain neither */
+      mask &= 0x8888888888888888ull;
+      return p + (__builtin_ctzll(mask) >> 2);
+    }
+    p += 16;
+  }
+#elif defined(__SSE2__)
+  const __m128i vq  = _mm_set1_epi8(quote);
+  const __m128i vbs = _mm_set1_epi8('\\');
+  while (p + 16 <= end) {
+    __m128i chunk = _mm_loadu_si128((const __m128i *)p);
+    __m128i m     = _mm_or_si128(_mm_cmpeq_epi8(chunk, vq), _mm_cmpeq_epi8(chunk, vbs));
+    int     mask  = _mm_movemask_epi8(m);  /* one bit per byte that matched */
+    if (__builtin_expect(mask != 0, 0)) {  /* most 16-byte chunks contain neither */
+      return p + __builtin_ctz(mask);
+    }
+    p += 16;
+  }
+#endif
+  for (; p < end; p++) {
+    if (*p == quote || *p == '\\') return p;
+  }
+  return end;
+}
+
 static VALUE unescape_quotes(char *str, long len, char quote_char, rb_encoding *encoding) {
   // Fast path: scan for any doubled quote pair. If none present, the field has
   // nothing to unescape — emit it directly via rb_enc_str_new and skip the
@@ -386,6 +444,20 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
       backslash_count = 0;
       field_started = false;  // reset for next field
     } else {
+      /* Backslash mode: NEON scan-ahead to the next quote OR backslash (Opt #7).
+       * Inside a quoted field the only state-changing bytes are the quote char and the
+       * backslash; bulk-skip the plain content between them. Skipped bytes are plain
+       * content, which the byte-by-byte loop resets backslash_count to 0 on, so reset
+       * it here whenever we actually move p. */
+      if (allow_escaped_quotes && in_quotes) {
+        const char *hit = scan_quote_or_backslash(p, endP, quote_char_val);
+        if (hit != p) {
+          backslash_count = 0;
+          p = (char *)hit;
+          if (p == endP) continue;  /* no quote/backslash before end → unclosed */
+        }
+      }
+
       if (allow_escaped_quotes && *p == '\\') {
         backslash_count++;
         if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) field_started = true;
@@ -525,47 +597,101 @@ static inline VALUE get_key_for_index(long index, VALUE headers, long headers_le
  * Handles overflow: if strtol overflows (ERANGE), falls back to rb_cstr_to_inum
  * which produces a Ruby Bignum.
  */
-static inline VALUE try_numeric_conversion(char *trim_start, long trimmed_len) {
-  // Quick pre-check: first char must be digit, +, -, or .
-  char first = trim_start[0];
-  if (!((first >= '0' && first <= '9') || first == '+' || first == '-' || first == '.')) {
+static inline VALUE try_numeric_conversion(char *s, long n, int decimal_precision) {
+  // Quick pre-check: first char must be a digit or a sign.
+  char first = s[0];
+  if (!((first >= '0' && first <= '9') || first == '+' || first == '-')) {
     return Qundef;
   }
 
-  // Need null-terminated string for strtol/strtod; use stack buffer for typical fields
-  if (trimmed_len >= 63) return Qundef;  // very long fields are unlikely to be simple numbers
-
-  char num_buf[64];
-  memcpy(num_buf, trim_start, trimmed_len);
-  num_buf[trimmed_len] = '\0';
-
-  char *endptr;
-
-  // Try integer first (most common numeric type in CSV)
-  // Don't try integer if field starts with '.' (e.g., ".5")
-  if (first != '.') {
-    errno = 0;
-    long int_val = strtol(num_buf, &endptr, 10);
-    if (endptr == num_buf + trimmed_len) {
-      // Entire string was consumed → valid integer
-      if (errno == ERANGE) {
-        // Overflow: fall back to Ruby Bignum
-        return rb_cstr_to_inum(num_buf, 10, false);
+  /* Single pass: validate the token against the same grammar as the Ruby path's
+   * NUMERIC_REGEX = /\A[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\z/ and, in the same pass,
+   * extract everything the fast paths need:
+   *   - mantissa value m10 (exact for <= 18 digits; `overflow` flags beyond)
+   *   - significant-digit count `sig` (leading zeros excluded; matches the Ruby
+   *     significant_digits helper / Oj dec_cnt) — drives the :auto Float/BigDecimal split
+   *   - base-10 exponent e10 (from the fraction length and any explicit exponent)
+   * Anything the grammar rejects returns Qundef (stays a String), keeping the C and
+   * Ruby paths byte-identical on what does and does not convert. */
+  long i = 0;
+  int neg = 0;
+  if (s[i] == '+' || s[i] == '-') { neg = (s[i] == '-'); i++; }
+
+  uint64_t m10 = 0;
+  int  m10digits = 0;       /* mantissa digits accumulated into m10 (capped at 19) */
+  long sig = 0;             /* significant digits (leading zeros excluded) */
+  int  sig_started = 0;
+  bool overflow = false;
+  long int_digits = 0, frac_digits = 0;
+  bool seen_dot = false, seen_exp = false, any_digit = false, exp_any = false;
+  int64_t exp_val = 0; int exp_neg = 0;
+
+  for (; i < n; i++) {
+    char c = s[i];
+    if (c >= '0' && c <= '9') {
+      any_digit = true;
+      if (!seen_exp) {
+        if (seen_dot) frac_digits++; else int_digits++;
+        if (sig_started) sig++;
+        else if (c != '0') { sig_started = 1; sig = 1; }
+        if (m10digits < 19) { m10 = m10 * 10 + (uint64_t)(c - '0'); m10digits++; }
+        else overflow = true;
+      } else {
+        exp_any = true;
+        exp_val = exp_val * 10 + (c - '0');
+        if (exp_val > 1000000) overflow = true; /* extreme exponent → strtod fallback */
       }
-      return LONG2NUM(int_val);
+    } else if (c == '.' && !seen_dot && !seen_exp) {
+      seen_dot = true;
+    } else if ((c == 'e' || c == 'E') && !seen_exp && any_digit) {
+      seen_exp = true;
+      if (i + 1 < n && (s[i + 1] == '+' || s[i + 1] == '-')) { exp_neg = (s[i + 1] == '-'); i++; }
+    } else {
+      return Qundef; /* invalid char for a number → not numeric */
     }
   }
 
-  // Try float (only if contains '.')
-  if (memchr(num_buf, '.', trimmed_len)) {
-    errno = 0;
-    double float_val = strtod(num_buf, &endptr);
-    if (endptr == num_buf + trimmed_len && errno != ERANGE) {
-      return DBL2NUM(float_val);
+  /* Enforce NUMERIC_REGEX exactly: an integer part is required; a dot requires a
+   * fraction digit; an exponent requires an exponent digit. */
+  if (int_digits == 0) return Qundef;
+  if (seen_dot && frac_digits == 0) return Qundef;
+  if (seen_exp && !exp_any) return Qundef;
+
+  bool is_decimal = seen_dot || seen_exp;
+
+  if (!is_decimal) {
+    /* Integer. Fast path when it fits in a long; otherwise a Ruby Integer/Bignum. */
+    if (!overflow && m10digits <= 18) {
+      long v = (long)m10;
+      return LONG2NUM(neg ? -v : v);
     }
+    VALUE str = rb_str_new(s, n);
+    return rb_cstr_to_inum(RSTRING_PTR(str), 10, false);
   }
 
-  return Qundef;  // not numeric
+  /* Decimal (has a '.' or an exponent) — honor decimal_precision. 0=float, 1=auto, 2=bigdecimal */
+  if (decimal_precision == 2 || (decimal_precision == 1 && sig > 16)) {
+    VALUE str = rb_str_new(s, n);
+    return rb_funcall(rb_cObject, id_BigDecimal, 1, str);
+  }
+
+  /* Float. base-10 exponent = explicit exponent minus the fraction length. */
+  int64_t e10 = (exp_neg ? -exp_val : exp_val) - (int64_t)frac_digits;
+  double d;
+  if (!overflow && m10digits >= 1 && m10digits <= 19 && ((long)m10digits + e10) >= -307) {
+    /* Eisel-Lemire is correctly-rounded for any nonzero mantissa that fits exactly in a
+     * uint64 — i.e. up to 19 significant digits (the max 19-digit value ~1.0e19 is below
+     * UINT64_MAX ~1.8e19). Verified bit-for-bit vs the stdlib over 1..19-digit ties. */
+    d = (m10 == 0) ? (neg ? -0.0 : 0.0) : fj_eisel_lemire_s2d(e10, m10, neg);
+  } else {
+    /* >19 digits / extreme or subnormal exponent: fall back to Ruby's own correctly-rounded
+     * strtod (rb_cstr_to_dbl) — the exact conversion String#to_f uses — so the C path and the
+     * Ruby path produce the identical double on every platform, not just where the system
+     * strtod happens to be correctly rounded. The token is pre-validated, so badcheck=0. */
+    VALUE str = rb_str_new(s, n);
+    d = rb_cstr_to_dbl(RSTRING_PTR(str), 0);
+  }
+  return DBL2NUM(d);
 }
 
 /*
@@ -614,6 +740,7 @@ typedef struct {
   long headers_len;
   long hash_capa;           // Pre-computed capacity for lazy hash allocation
   int numeric_mode;         // 0=off, 1=all, 2=only, 3=except
+  int decimal_precision;    // 0=float, 1=auto (BigDecimal above 16 sig digits), 2=bigdecimal
   bool remove_empty_values;
   bool remove_zero_values;
 } field_transform_opts;
@@ -705,7 +832,7 @@ static inline __attribute__((always_inline)) bool insert_field_into_hash(
                       (opts->numeric_mode == 2 && rb_ary_includes(opts->numeric_keys, key) == Qtrue) ||
                       (opts->numeric_mode == 3 && rb_ary_includes(opts->numeric_keys, key) != Qtrue);
     if (do_convert) {
-      VALUE numeric = try_numeric_conversion(trim_start, trimmed_len);
+      VALUE numeric = try_numeric_conversion(trim_start, trimmed_len, opts->decimal_precision);
       if (numeric != Qundef) {
         ensure_hash_allocated(opts);
         rb_hash_aset(opts->hash, key, numeric);
@@ -752,6 +879,18 @@ void parse_numeric_option(VALUE options_hash, int *out_mode, VALUE *out_keys) {
   }
 }
 
+/* Read decimal_precision into 0=float, 1=auto, 2=bigdecimal. Default :auto (1).
+ * The option is validated and coerced to a symbol on the Ruby side before we get here. */
+static inline int parse_decimal_precision(VALUE options_hash) {
+  VALUE v = rb_hash_aref(options_hash, ID2SYM(id_decimal_precision));
+  if (RB_TYPE_P(v, T_SYMBOL)) {
+    ID s = SYM2ID(v);
+    if (s == id_float) return 0;
+    if (s == id_bigdecimal) return 2;
+  }
+  return 1; // :auto (also the default when unset)
+}
+
 /*
  * ================================================================================
  * rb_parse_line_to_hash - Parse CSV line directly into a Ruby Hash
@@ -826,6 +965,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
   int numeric_mode = 0;
   VALUE numeric_keys = Qnil;
   parse_numeric_option(options_hash, &numeric_mode, &numeric_keys);
+  int decimal_precision = parse_decimal_precision(options_hash);
 
   // quote_escaping and quote_boundary are only needed in Section 5 (quoted/slow path).
   // They are declared here as forward declarations so Section 5 can set them lazily.
@@ -990,6 +1130,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
     .headers_len = headers_len,
     .hash_capa = hash_size,
     .numeric_mode = numeric_mode,
+    .decimal_precision = decimal_precision,
     .remove_empty_values = remove_empty_values,
     .remove_zero_values = remove_zero_values,
   };
@@ -1160,6 +1301,20 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
           p = next_quote;  /* jump to quote char; fall through to quote-handling code */
         }
 
+        /* Backslash mode: NEON scan-ahead to the next quote OR backslash (Opt #7).
+         * The RFC memchr skip above only matters for one byte class; with escaping on
+         * a backslash also changes state, so scan for both. Skipped bytes are plain
+         * content (the byte-by-byte loop resets backslash_count to 0 on them), so reset
+         * it here whenever we actually move p. */
+        if (allow_escaped_quotes && in_quotes) {
+          const char *hit = scan_quote_or_backslash(p, endP, quote_char_val);
+          if (hit != p) {
+            backslash_count = 0;
+            p = (char *)hit;
+            if (p == endP) continue;  /* no quote/backslash before end → unclosed */
+          }
+        }
+
         if (allow_escaped_quotes && *p == '\\') {
           // Count consecutive backslashes for escape sequence detection
           backslash_count++;
@@ -1354,6 +1509,7 @@ __attribute__((cold)) static VALUE rb_new_parse_context(VALUE self, VALUE header
 
   /* Numeric conversion */
   parse_numeric_option(options_hash, &ctx->numeric_mode, &ctx->numeric_keys);
+  ctx->decimal_precision = parse_decimal_precision(options_hash);
 
   /* quote_escaping → allow_escaped_quotes */
   VALUE quote_escaping_val = rb_hash_aref(options_hash, ID2SYM(id_quote_escaping));
@@ -1474,6 +1630,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
   bool remove_empty_values = ctx->remove_empty_values;
   bool remove_zero_values  = ctx->remove_zero_values;
   int  numeric_mode        = ctx->numeric_mode;
+  int  decimal_precision   = ctx->decimal_precision;
   VALUE numeric_keys       = ctx->numeric_keys;
   bool *keep_bitmap         = ctx->keep_bitmap;
   /* keep_bitmap is cached in the context (xmalloc'd once at construction, sized to the header count
@@ -1525,6 +1682,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
     .headers_len       = headers_len,
     .hash_capa         = hash_size,
     .numeric_mode      = numeric_mode,
+    .decimal_precision = decimal_precision,
     .remove_empty_values = remove_empty_values,
     .remove_zero_values  = remove_zero_values,
   };
@@ -1654,6 +1812,16 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
           p = next_quote;  /* fall through to quote-handling code */
         }
 
+        /* Backslash mode: NEON scan-ahead to the next quote OR backslash (Opt #7). */
+        if (allow_escaped_quotes && in_quotes) {
+          const char *hit = scan_quote_or_backslash(p, endP, quote_char_val);
+          if (hit != p) {
+            backslash_count = 0;
+            p = (char *)hit;
+            if (p == endP) continue;  /* no quote/backslash before end → unclosed */
+          }
+        }
+
         if (allow_escaped_quotes && *p == '\\') {
           backslash_count++;
           if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) field_started = true;
@@ -1878,6 +2046,10 @@ void Init_smarter_csv(void) {
   id_strict             = rb_intern("strict");
   id_backslash      = rb_intern("backslash");
   id_standard       = rb_intern("standard");
+  id_decimal_precision = rb_intern("decimal_precision");
+  id_float          = rb_intern("float");
+  id_bigdecimal     = rb_intern("bigdecimal");
+  id_BigDecimal     = rb_intern("BigDecimal"); /* Kernel#BigDecimal(); 'bigdecimal' is required in lib/smarter_csv.rb */
 
   rb_define_module_function(Parser, "parse_csv_line_c", rb_parse_csv_line, 9);
   rb_define_module_function(Parser, "count_quote_chars_c", rb_count_quote_chars, 4);

data/ext/smarter_csv/vendor/LICENSE-fast_float-MIT

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2021 The fast_float authors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/ext/smarter_csv/vendor/eisel_lemire.h

@@ -0,0 +1,117 @@
+/* Eisel-Lemire decimal->double, ported from fast_float:
+ * include/fast_float/decimal_to_binary.h, the compute_float<binary_format<double>>
+ * + compute_product_approximation routines.
+ *
+ * Algorithm authors: Michael Eisel (original approach) and Daniel Lemire
+ * (formalization, proof, and the fast_float implementation) — hence "Eisel-Lemire".
+ *
+ * Copyright (c) 2021 The fast_float authors. Tri-licensed Apache-2.0 / MIT / BSL-1.0;
+ * used here under MIT — see LICENSE-fast_float-MIT in this directory.
+ *
+ * This is the "without fallback" variant (Noble Mushtak & Daniel Lemire, "Fast
+ * Number Parsing Without Fallback"): for ANY nonzero mantissa w that fits exactly
+ * in a uint64 (i.e. <= 19 significant digits, not truncated) and decimal exponent
+ * q, it returns the correctly-rounded binary64 with no slow-path needed.
+ *
+ * smarter_json uses it as THE decimal->double path for mantissas up to 18 digits
+ * (everything wider / overflowed / with an extreme exponent goes to the strtod
+ * round-to-odd fallback). It is correctly-rounded across that whole range, with no
+ * round-to-even tie loss, and is fast on the common short-mantissa case.
+ * Verified bit-for-bit vs JSON.parse. See eisel_lemire.md for provenance. */
+#ifndef FJ_EISEL_LEMIRE_H
+#define FJ_EISEL_LEMIRE_H
+
+#include <stdint.h>
+#include <string.h>
+#include "eisel_lemire_powers.h"
+
+/* binary_format<double> constants from fast_float. */
+#define FJ_EL_MANTISSA_BITS   52
+#define FJ_EL_MIN_EXPONENT   (-1023)
+#define FJ_EL_INFINITE_POWER  0x7FF
+#define FJ_EL_SMALLEST_POW10 (-342)
+#define FJ_EL_LARGEST_POW10   308
+#define FJ_EL_MIN_RTE        (-4)   /* min_exponent_round_to_even */
+#define FJ_EL_MAX_RTE         23    /* max_exponent_round_to_even */
+
+/* (((152170 + 65536) * q) >> 16) + 63 == floor(log2(10^q)) + q + 63, see paper. */
+static inline int32_t fj_el_power(int32_t q) {
+  return (((152170 + 65536) * q) >> 16) + 63;
+}
+
+static inline void fj_el_mul128(uint64_t a, uint64_t b, uint64_t *hi, uint64_t *lo) {
+#if defined(__SIZEOF_INT128__)
+  __uint128_t p = (__uint128_t)a * (__uint128_t)b;
+  *lo = (uint64_t)p;
+  *hi = (uint64_t)(p >> 64);
+#else
+  uint64_t a0 = (uint32_t)a, a1 = a >> 32, b0 = (uint32_t)b, b1 = b >> 32;
+  uint64_t p00 = a0 * b0, p01 = a0 * b1, p10 = a1 * b0, p11 = a1 * b1;
+  uint64_t mid = p10 + (p00 >> 32) + (uint32_t)p01;
+  *hi = p11 + (mid >> 32) + (p01 >> 32);
+  *lo = (mid << 32) | (uint32_t)p00;
+#endif
+}
+
+static inline double fj_el_bits2double(uint64_t bits) {
+  double d;
+  memcpy(&d, &bits, sizeof(d));
+  return d;
+}
+
+/* q = power of ten, w = mantissa (NONZERO, exact, fits in uint64). neg = sign. */
+static inline double fj_eisel_lemire_s2d(int64_t q, uint64_t w, int neg) {
+  const uint64_t sign = (uint64_t)(neg != 0) << 63;
+  uint64_t mantissa, prod_hi, prod_lo, sp_hi, sp_lo;
+  int32_t  power2;
+  int      lz, upperbit, shift, index;
+
+  if (q < FJ_EL_SMALLEST_POW10) return fj_el_bits2double(sign); /* underflow -> 0 */
+  if (q > FJ_EL_LARGEST_POW10)
+    return fj_el_bits2double(sign | ((uint64_t)FJ_EL_INFINITE_POWER << FJ_EL_MANTISSA_BITS));
+
+  lz = __builtin_clzll(w);
+  w <<= lz;
+
+  /* compute_product_approximation<mantissa_bits + 3 = 55>: precision_mask = 0x1FF. */
+  index = 2 * (int)(q - FJ_EL_SMALLEST_POWER_OF_FIVE);
+  fj_el_mul128(w, fj_power_of_five_128[index], &prod_hi, &prod_lo);
+  if ((prod_hi & 0x1FF) == 0x1FF) {
+    fj_el_mul128(w, fj_power_of_five_128[index + 1], &sp_hi, &sp_lo);
+    prod_lo += sp_hi;
+    if (sp_hi > prod_lo) prod_hi++;
+  }
+
+  upperbit = (int)(prod_hi >> 63);
+  shift = upperbit + 64 - FJ_EL_MANTISSA_BITS - 3; /* upperbit + 9 */
+  mantissa = prod_hi >> shift;
+  power2 = (int32_t)(fj_el_power((int32_t)q) + upperbit - lz - FJ_EL_MIN_EXPONENT);
+
+  if (power2 <= 0) { /* subnormal */
+    if (-power2 + 1 >= 64) return fj_el_bits2double(sign); /* far below min -> 0 */
+    mantissa >>= (-power2 + 1);
+    mantissa += (mantissa & 1);
+    mantissa >>= 1;
+    power2 = (mantissa < ((uint64_t)1 << FJ_EL_MANTISSA_BITS)) ? 0 : 1;
+    return fj_el_bits2double(sign | ((uint64_t)power2 << FJ_EL_MANTISSA_BITS) | mantissa);
+  }
+
+  /* round-to-even: if we land exactly between two doubles, round down. */
+  if ((prod_lo <= 1) && (q >= FJ_EL_MIN_RTE) && (q <= FJ_EL_MAX_RTE) &&
+      ((mantissa & 3) == 1) && ((mantissa << shift) == prod_hi)) {
+    mantissa &= ~(uint64_t)1;
+  }
+
+  mantissa += (mantissa & 1);
+  mantissa >>= 1;
+  if (mantissa >= ((uint64_t)2 << FJ_EL_MANTISSA_BITS)) {
+    mantissa = (uint64_t)1 << FJ_EL_MANTISSA_BITS;
+    power2++;
+  }
+  mantissa &= ~((uint64_t)1 << FJ_EL_MANTISSA_BITS); /* drop implicit bit */
+  if (power2 >= FJ_EL_INFINITE_POWER)
+    return fj_el_bits2double(sign | ((uint64_t)FJ_EL_INFINITE_POWER << FJ_EL_MANTISSA_BITS));
+  return fj_el_bits2double(sign | ((uint64_t)power2 << FJ_EL_MANTISSA_BITS) | mantissa);
+}
+
+#endif

data/ext/smarter_csv/vendor/eisel_lemire.md

@@ -0,0 +1,29 @@
+# Eisel-Lemire decimal→double, from fast_float
+
+- The algorithm is **Eisel-Lemire**, named for **Michael Eisel** (who proposed/motivated the original approach) and **Daniel Lemire** (who formalized it, proved its bounds, and wrote the fast_float implementation). We use the later "without fallback" form proven by **Noble Mushtak & Daniel Lemire, _Fast Number Parsing Without Fallback_**. It converts a decimal mantissa+exponent to a correctly-rounded binary64 with no slow path, for any nonzero mantissa that fits exactly in a `uint64` (≤ 19 significant digits).
+- Vendored from **fastfloat/fast_float** — https://github.com/fastfloat/fast_float — license Apache-2.0 / MIT / Boost-1.0 (your choice).
+
+## What smarter_json uses it for
+
+`try_numeric_conversion` (in `smarter_csv.c`) routes decimal tokens with `m10digits ≤ 19 → fj_eisel_lemire_s2d`, and `> 19 / overflow / extreme exponent → strtod`. Eisel-Lemire is correctly-rounded across the whole ≤19-digit range — every mantissa that fits exactly in a uint64, no round-to-even tie loss — **and** fast on the common short-mantissa case. (smarter_json uses it the same way via `fj_float_from_parts`.)
+
+## These two files are DERIVED, not verbatim copies
+
+- **`eisel_lemire_powers.h`** — the `power_of_five_128` table (1302 × `uint64`), extracted **verbatim** (the constants are byte-for-byte) from fast_float `include/fast_float/fast_table.h`, but **rewrapped**: a plain C `static const uint64_t fj_power_of_five_128[...]` array instead of fast_float's C++ `powers_template` struct. `FJ_EL_SMALLEST_POWER_OF_FIVE` / `FJ_EL_LARGEST_POWER_OF_FIVE` are the `-342` / `308` bounds.
+- **`eisel_lemire.h`** — a C **port** of `compute_float<binary_format<double>>` + `compute_product_approximation` from fast_float `include/fast_float/decimal_to_binary.h`. Adapted to: (a) plain C (no templates), (b) take our already-extracted `(q, w)` = `(e10, m10)` instead of re-parsing a string, (c) the binary64 constants inlined as `FJ_EL_*` macros, (d) a portable `fj_el_mul128` (`__uint128_t` when available, else a 32×32 split). The control flow — `compute_product_approximation<55>`, the `0x1FF` precision mask, `upperbit`/`shift`, the subnormal branch, and the round-to-even "land exactly between two doubles → round down" check — mirrors the source.
+
+Because they're derived (rewrapped table, ported algorithm), they're named after the **algorithm** (Eisel-Lemire) rather than their upstream source (`fast_float`). The verification that they faithfully reproduce upstream is the bit-for-bit stress vs `JSON.parse` (8–10M random numbers incl. ties / subnormals / near-overflow, 0 mismatches).
+
+## To refresh from upstream
+
+Re-pull the two source files and re-derive:
+
+- table: `curl -L https://raw.githubusercontent.com/fastfloat/fast_float/main/include/fast_float/fast_table.h` — copy the `power_of_five_128[...] = { ... };` body into `eisel_lemire_powers.h`'s array (constants only).
+- algorithm: `curl -L https://raw.githubusercontent.com/fastfloat/fast_float/main/include/fast_float/decimal_to_binary.h` — re-check `compute_float` / `compute_product_approximation` against the port in `eisel_lemire.h`.
+
+Then re-run the bit-exact stress (≥ several million random 1–19-digit numbers, with forced round-to-even ties and exponents spanning subnormal → overflow) vs `JSON.parse` before trusting it.
+
+- origin: Eisel-Lemire (`fastfloat/fast_float`)
+- vendored from: fast_float (upstream `main`)
+- copyright: (c) 2021 The fast_float authors
+- license: tri-licensed Apache-2.0 / MIT / BSL-1.0; vendored here under **MIT**, full text in `LICENSE-fast_float-MIT` (this directory)