smarter_csv 1.17.1 → 1.17.3

data/ext/smarter_csv/smarter_csv.c

@@ -169,16 +169,107 @@ needs_unescape:
 /* Helper: build the 2-element [elements, data_size] tuple returned by rb_parse_csv_line.
  * Aligns this function's return shape with parse_csv_line_ruby and rb_parse_line_to_hash_ctx:
  * data_size = -1 signals "unclosed quoted field — needs more data". */
-static inline VALUE make_parse_result(VALUE elements, long data_size) {
+static inline __attribute__((always_inline))
+VALUE return_parser_result(VALUE elements, long data_size) {
   VALUE result = rb_ary_new_capa(2);
   rb_ary_push(result, elements);
   rb_ary_push(result, LONG2FIX(data_size));
   return result;
 }
 
+/* Helper: trim leading/trailing spaces and tabs from a field when strip_ws is set.
+ * Sets *out_start to the first kept byte and returns the trimmed length (0 when the
+ * field is empty or all whitespace). This is the trim performed at every field
+ * boundary in all three parsers; kept always_inline so each call site compiles to
+ * the same code as the hand-written loops it replaces (no performance cost). */
+static inline __attribute__((always_inline))
+long trim_field(char *field, long field_len, bool strip_ws, char **out_start) {
+  char *trim_start = field;
+  char *trim_end   = field + field_len - 1;
+  if (strip_ws) {
+    while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
+    while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
+  }
+  *out_start = trim_start;
+  return (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+}
+
+/* A field after quote-stripping and trimming: where its content starts, how long it
+ * is, and whether it still contains quote characters that need unescaping. */
+typedef struct {
+  char *start;
+  long  len;
+  bool  has_quotes;
+} extracted_field;
+
+/* Helper: turn a raw field slice into the values every extraction site needs.
+ * Strips a surrounding pair of quote chars (if present), trims whitespace via
+ * trim_field, and reports whether the result still has embedded quotes (true for a
+ * quoted field, or any field containing the quote char). This is the common prefix
+ * before each field is pushed/inserted, in all three parsers' slow paths.
+ * always_inline + return-by-value so the struct is dissolved into registers and each
+ * call site compiles to the same code as the old inline block (no performance cost). */
+static inline __attribute__((always_inline))
+extracted_field extract_field(char *raw_field, long field_len, bool strip_ws, char quote_char_val) {
+  bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
+  if (quoted) {
+    raw_field++;       // Skip opening quote
+    field_len -= 2;    // Exclude both quotes from length
+  }
+  char *trim_start;
+  long trimmed_len = trim_field(raw_field, field_len, strip_ws, &trim_start);
+  extracted_field result = {
+    trim_start,
+    trimmed_len,
+    quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len))
+  };
+  return result;
+}
+
+/* Helper: is a closing quote at p actually a field close? Valid only when followed by
+ * the column separator, the row separator, or end of line. Pure read — touches none of
+ * the quote loop's state (in_quotes/field_started/etc). Mirrors the inline lookahead
+ * copied into all three parsers' quote machines; always_inline so it compiles to the
+ * same code as the hand-written block. */
+static inline __attribute__((always_inline))
+bool is_valid_close(const char *p, const char *endP,
+                    const char *col_sepP, long col_sep_len,
+                    const char *row_sepP, long row_sep_len) {
+  bool valid_close = (p + 1 >= endP);
+  if (!valid_close) {
+    valid_close = true;
+    for (long j = 0; j < col_sep_len; j++) {
+      if (*(p + 1 + j) != *(col_sepP + j)) { valid_close = false; break; }
+    }
+  }
+  if (!valid_close && row_sep_len > 0) {
+    valid_close = true;
+    for (long j = 0; j < row_sep_len; j++) {
+      if (*(p + 1 + j) != *(row_sepP + j)) { valid_close = false; break; }
+    }
+  }
+  return valid_close;
+}
+
+/* Helper: strip a trailing row separator from the line (pointer adjustment, no string
+ * mutation). If the last row_sep_len bytes at endP match row_sepP, move endP back past
+ * them; otherwise leave endP untouched. The row_sep_len > 0 guard means callers can
+ * pass (NULL, 0) for "no separator known yet" without an outer if. Shared by
+ * rb_parse_line_to_hash and rb_parse_line_to_hash_ctx; always_inline keeps the chomp
+ * site as cheap as the hand-written check it replaces. */
+static inline __attribute__((always_inline))
+char *chomp_row_sep(char *endP, long line_len, const char *row_sepP, long row_sep_len) {
+  if (row_sep_len > 0
+      && line_len >= row_sep_len
+      && memcmp(endP - row_sep_len, row_sepP, (size_t)row_sep_len) == 0) {
+    endP -= row_sep_len;
+  }
+  return endP;
+}
+
 static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quote_char, VALUE max_size, VALUE has_quotes_val, VALUE strip_ws_val, VALUE allow_escaped_quotes_val, VALUE quote_boundary_standard_val, VALUE row_sep_val) {
   if (RB_TYPE_P(line, T_NIL) == 1) {
-    return make_parse_result(rb_ary_new(), 0);
+    return return_parser_result(rb_ary_new(), 0);
   }
 
   if (RB_TYPE_P(line, T_STRING) != 1) {
@@ -205,7 +296,7 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
   if (max_size != Qnil) {
     max_fields = NUM2INT(max_size);
     if (max_fields < 0) {
-      return make_parse_result(rb_ary_new(), 0);
+      return return_parser_result(rb_ary_new(), 0);
     }
   }
 
@@ -229,15 +320,8 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
 
       long field_len = sep_pos - startP;
       char *raw_field = startP;
-      char *trim_start = raw_field;
-      char *trim_end = raw_field + field_len - 1;
-
-      if (strip_ws) {
-        while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-        while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-      }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+      char *trim_start;
+      long trimmed_len = trim_field(raw_field, field_len, strip_ws, &trim_start);
 
       field = (trimmed_len > 0) ? rb_enc_str_new(trim_start, trimmed_len, encoding) : Qempty_string;
       rb_ary_push(elements, field);
@@ -250,21 +334,14 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
     if ((max_fields < 0) || (element_count < max_fields)) {
       long field_len = endP - startP;
       char *raw_field = startP;
-      char *trim_start = raw_field;
-      char *trim_end = raw_field + field_len - 1;
-
-      if (strip_ws) {
-        while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-        while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-      }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+      char *trim_start;
+      long trimmed_len = trim_field(raw_field, field_len, strip_ws, &trim_start);
 
       field = (trimmed_len > 0) ? rb_enc_str_new(trim_start, trimmed_len, encoding) : Qempty_string;
       rb_ary_push(elements, field);
     }
 
-    return make_parse_result(elements, RARRAY_LEN(elements));
+    return return_parser_result(elements, RARRAY_LEN(elements));
   }
 
   // === SLOW PATH: Quoted fields or multi-char separator ===
@@ -291,28 +368,14 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
       long field_len = p - startP;
       char *raw_field = startP;
 
-      bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-      if (quoted) {
-        raw_field++;
-        field_len -= 2;
-      }
-
-      char *trim_start = raw_field;
-      char *trim_end = raw_field + field_len - 1;
+      extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
-      if (strip_ws) {
-        while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-        while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-      }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-      if (trimmed_len == 0) {
+      if (f.len == 0) {
         field = Qempty_string;
-      } else if (quoted || memchr(trim_start, quote_char_val, trimmed_len)) {
-        field = unescape_quotes(trim_start, trimmed_len, quote_char_val, encoding);
+      } else if (f.has_quotes) {
+        field = unescape_quotes(f.start, f.len, quote_char_val, encoding);
       } else {
-        field = rb_enc_str_new(trim_start, trimmed_len, encoding);
+        field = rb_enc_str_new(f.start, f.len, encoding);
       }
 
       rb_ary_push(elements, field);
@@ -331,25 +394,27 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
           if (!allow_escaped_quotes || backslash_count % 2 == 0) {
             if (__builtin_expect(quote_boundary_standard, 1)) {
               if (in_quotes) {
-                // closing quote: only valid if followed by col_sep, row_sep, or end of line
-                bool valid_close = (p + 1 >= endP);
-                if (!valid_close) {
-                  valid_close = true;
-                  for (long j = 0; j < col_sep_len; j++) {
-                    if (*(p + 1 + j) != *(col_sepP + j)) { valid_close = false; break; }
-                  }
-                }
-                if (!valid_close && row_sep_len > 0) {
-                  valid_close = true;
-                  for (long j = 0; j < row_sep_len; j++) {
-                    if (*(p + 1 + j) != *(row_sepP + j)) { valid_close = false; break; }
+                if (p + 2 < endP && *(p + 1) == quote_char_val) {
+                  /* RFC doubled quote inside a quoted field ("" → ").
+                   * Give this precedence over the closing-quote check, but only
+                   * when another byte follows the doubled pair.
+                   *
+                   * Compatibility note: we intentionally do NOT force terminal
+                   * "" to be consumed here. SmarterCSV has a long-standing lenient
+                   * behavior for malformed tails like ...\"" in :double_quotes mode:
+                   * the final quote may still close the field instead of turning the
+                   * row into an unclosed-quote error. Issue #334 needs doubled-quote
+                   * precedence for ..."",... (more content follows), but we keep the
+                   * historical leniency for terminal ..."". */
+                  p++;
+                } else {
+                  // closing quote: only valid if followed by col_sep, row_sep, or end of line
+                  if (is_valid_close(p, endP, col_sepP, col_sep_len, row_sepP, row_sep_len)) {
+                    in_quotes = false;
+                    field_started = true;
                   }
+                  // else: quote inside quoted field → literal
                 }
-                if (valid_close) {
-                  in_quotes = false;
-                  field_started = true;
-                }
-                // else: quote inside quoted field → literal (handles "" doubling)
               } else if (!field_started) {
                 in_quotes = true;     // opening quote at field boundary
                 field_started = true;
@@ -383,41 +448,27 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
      * the signal: append the next physical line and re-parse, or raise MalformedCSV
      * at EOF if the field never closes. The parser does not decide "ultimately
      * malformed"; the caller does. */
-    return make_parse_result(rb_ary_new(), -1);
+    return return_parser_result(rb_ary_new(), -1);
   }
 
   if ((max_fields < 0) || (element_count < max_fields)) {
     long field_len = endP - startP;
     char *raw_field = startP;
 
-    bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-    if (quoted) {
-      raw_field++;
-      field_len -= 2;
-    }
+    extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
-    char *trim_start = raw_field;
-    char *trim_end = raw_field + field_len - 1;
-
-    if (strip_ws) {
-      while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-      while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-    }
-
-    long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-    if (trimmed_len == 0) {
+    if (f.len == 0) {
       field = Qempty_string;
-    } else if (quoted || memchr(trim_start, quote_char_val, trimmed_len)) {
-      field = unescape_quotes(trim_start, trimmed_len, quote_char_val, encoding);
+    } else if (f.has_quotes) {
+      field = unescape_quotes(f.start, f.len, quote_char_val, encoding);
     } else {
-      field = rb_enc_str_new(trim_start, trimmed_len, encoding);
+      field = rb_enc_str_new(f.start, f.len, encoding);
     }
 
     rb_ary_push(elements, field);
   }
 
-  return make_parse_result(elements, RARRAY_LEN(elements));
+  return return_parser_result(elements, RARRAY_LEN(elements));
 }
 
 // Efficiently combine two arrays into a hash (replaces headers.zip(values).to_h)
@@ -675,6 +726,32 @@ static inline __attribute__((always_inline)) bool insert_field_into_hash(
   return true;
 }
 
+/* Helper: parse the convert_values_to_numeric option into a mode + key list.
+ * mode: 0=off, 1=all, 2=only listed keys, 3=except listed keys.
+ * Writes through the out-params only when the option is set, so callers must
+ * pre-initialize *out_mode = 0 and *out_keys = Qnil. Shared by rb_parse_line_to_hash
+ * and rb_new_parse_context — identical logic, different storage (locals vs ctx fields).
+ * always_inline so each call site compiles to the same code as the old inline block. */
+static inline __attribute__((always_inline))
+void parse_numeric_option(VALUE options_hash, int *out_mode, VALUE *out_keys) {
+  VALUE convert_opt = rb_hash_aref(options_hash, ID2SYM(id_convert_values_to_numeric));
+  if (RTEST(convert_opt)) {
+    if (RB_TYPE_P(convert_opt, T_HASH)) {
+      VALUE only_keys = rb_hash_aref(convert_opt, ID2SYM(id_only));
+      VALUE except_keys = rb_hash_aref(convert_opt, ID2SYM(id_except));
+      if (RTEST(only_keys)) {
+        *out_mode = 2;
+        *out_keys = rb_Array(only_keys);   // wrap single value in array if needed
+      } else if (RTEST(except_keys)) {
+        *out_mode = 3;
+        *out_keys = rb_Array(except_keys); // wrap single value in array if needed
+      }
+    } else {
+      *out_mode = 1;  // convert all
+    }
+  }
+}
+
 /*
  * ================================================================================
  * rb_parse_line_to_hash - Parse CSV line directly into a Ruby Hash
@@ -723,10 +800,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
    * SECTION 1: Handle nil/invalid input
    * ---------------------------------------- */
   if (NIL_P(line)) {
-    VALUE result = rb_ary_new_capa(2);
-    rb_ary_push(result, Qnil);
-    rb_ary_push(result, INT2FIX(0));
-    return result;
+    return return_parser_result(Qnil, 0);
   }
 
   if (RB_TYPE_P(line, T_STRING) != 1) {
@@ -751,22 +825,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
   // numeric_mode: 0=off, 1=all, 2=only listed keys, 3=except listed keys
   int numeric_mode = 0;
   VALUE numeric_keys = Qnil;
-  VALUE convert_opt = rb_hash_aref(options_hash, ID2SYM(id_convert_values_to_numeric));
-  if (RTEST(convert_opt)) {
-    if (RB_TYPE_P(convert_opt, T_HASH)) {
-      VALUE only_keys = rb_hash_aref(convert_opt, ID2SYM(id_only));
-      VALUE except_keys = rb_hash_aref(convert_opt, ID2SYM(id_except));
-      if (RTEST(only_keys)) {
-        numeric_mode = 2;
-        numeric_keys = rb_Array(only_keys);   // wrap single value in array if needed
-      } else if (RTEST(except_keys)) {
-        numeric_mode = 3;
-        numeric_keys = rb_Array(except_keys); // wrap single value in array if needed
-      }
-    } else {
-      numeric_mode = 1;  // convert all
-    }
-  }
+  parse_numeric_option(options_hash, &numeric_mode, &numeric_keys);
 
   // 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.
@@ -783,11 +842,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
   // row_sep is also reused in Section 5 for the closing-quote boundary check.
   VALUE row_sep = rb_hash_aref(options_hash, ID2SYM(id_row_sep));
   if (!NIL_P(row_sep) && RB_TYPE_P(row_sep, T_STRING)) {
-    char *row_sepP = RSTRING_PTR(row_sep);
-    long row_sep_len = RSTRING_LEN(row_sep);
-    if (line_len >= row_sep_len && memcmp(endP - row_sep_len, row_sepP, row_sep_len) == 0) {
-      endP -= row_sep_len;
-    }
+    endP = chomp_row_sep(endP, line_len, RSTRING_PTR(row_sep), RSTRING_LEN(row_sep));
   }
 
   char *col_sepP = RSTRING_PTR(col_sep);
@@ -829,6 +884,11 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
    * the frame stays well below 4 KB and ___chkstk_darwin never fires on ARM64 macOS.
    */
   bool *keep_bitmap = NULL;
+  /* In THIS (non-ctx) function the bitmap is alloca'd to headers_len on every call (see the alloca
+   * sites below), so keep_bitmap[] is exactly headers_len long and headers_len is the correct bound
+   * at all access sites. Do NOT mirror rb_parse_line_to_hash_ctx's keep_bitmap_len here: that variant
+   * caches its bitmap across rows (where @headers can grow), so it must use the captured length; this
+   * one rebuilds per call and does not. */
   bool keep_extra_columns = true; /* extra cols (> headers_len): keep by default */
   bool has_only = false;          /* true when only_headers: filtering is active */
   long early_exit_after = -1;     /* column index after which we stop; -1 = no early exit */
@@ -955,13 +1015,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
       /* --- (a) Common path: no column filter, no early exit --- */
       while ((sep_pos = memchr(p, sep, endP - p))) {
         long field_len   = sep_pos - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
           all_blank = false;
         element_count++;
@@ -970,13 +1025,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
       /* Process last field */
       {
         long field_len   = endP - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
           all_blank = false;
         element_count++;
@@ -985,13 +1035,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
       /* --- (b) Filter path: column bitmap and/or early exit active --- */
       while ((sep_pos = memchr(p, sep, endP - p))) {
         long field_len   = sep_pos - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
           if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
             all_blank = false;
@@ -1006,13 +1051,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
       /* Process last field — skip on early exit */
       if (!did_early_exit) {
         long field_len   = endP - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
           if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
             all_blank = false;
@@ -1087,28 +1127,10 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
         long field_len = p - startP;
         char *raw_field = startP;
 
-        // Check if field is wrapped in quotes: "value"
-        bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-        if (quoted) {
-          raw_field++;       // Skip opening quote
-          field_len -= 2;    // Exclude both quotes from length
-        }
-
-        char *trim_start = raw_field;
-        char *trim_end = raw_field + field_len - 1;
-
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-        // Determine if field contains embedded quotes (need unescape)
-        bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
+        extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
         if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
-          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
+          if (insert_field_into_hash(&xform, f.start, f.len, element_count, f.has_quotes, quote_char_val, encoding))
             all_blank = false;
         }
         element_count++;
@@ -1147,25 +1169,27 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
             if (!allow_escaped_quotes || backslash_count % 2 == 0) {
               if (__builtin_expect(quote_boundary_standard, 1)) {
                 if (in_quotes) {
-                  // closing quote: only valid if followed by col_sep, row_sep, or end of line
-                  bool valid_close = (p + 1 >= endP);
-                  if (!valid_close) {
-                    valid_close = true;
-                    for (long j = 0; j < col_sep_len; j++) {
-                      if (*(p + 1 + j) != *(col_sepP + j)) { valid_close = false; break; }
-                    }
-                  }
-                  if (!valid_close && row_sep_len2 > 0) {
-                    valid_close = true;
-                    for (long j = 0; j < row_sep_len2; j++) {
-                      if (*(p + 1 + j) != *(row_sepP2 + j)) { valid_close = false; break; }
+                  if (p + 2 < endP && *(p + 1) == quote_char_val) {
+                    /* RFC doubled quote inside a quoted field ("" → ").
+                     * Give this precedence over the closing-quote check, but only
+                     * when another byte follows the doubled pair.
+                     *
+                     * Compatibility note: we intentionally do NOT force terminal
+                     * "" to be consumed here. SmarterCSV has a long-standing lenient
+                     * behavior for malformed tails like ...\"" in :double_quotes mode:
+                     * the final quote may still close the field instead of turning the
+                     * row into an unclosed-quote error. Issue #334 needs doubled-quote
+                     * precedence for ..."",... (more content follows), but we keep the
+                     * historical leniency for terminal ..."". */
+                    p++;
+                  } else {
+                    // closing quote: only valid if followed by col_sep, row_sep, or end of line
+                    if (is_valid_close(p, endP, col_sepP, col_sep_len, row_sepP2, row_sep_len2)) {
+                      in_quotes = false;
+                      field_started = true;
                     }
+                    // else: quote inside quoted field → literal
                   }
-                  if (valid_close) {
-                    in_quotes = false;
-                    field_started = true;
-                  }
-                  // else: quote inside quoted field → literal (handles "" doubling)
                 } else if (!field_started) {
                   in_quotes = true;     // opening quote at field boundary
                   field_started = true;
@@ -1198,10 +1222,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
      * We return [nil, -1] rather than raising so the read loop can handle multiline fields
      * without a separate pre-scan pass (detect_multiline). */
     if (!did_early_exit && in_quotes) {
-      VALUE result = rb_ary_new_capa(2);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, LONG2FIX(-1));
-      return result;
+      return return_parser_result(Qnil, -1);
     }
 
     /* Process the last field (same logic as above) — skip on early exit */
@@ -1209,26 +1230,10 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
       long field_len = endP - startP;
       char *raw_field = startP;
 
-      bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-      if (quoted) {
-        raw_field++;
-        field_len -= 2;
-      }
-
-      char *trim_start = raw_field;
-      char *trim_end = raw_field + field_len - 1;
-
-      if (strip_ws) {
-        while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-        while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-      }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-      bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
+      extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
       if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
-        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
+        if (insert_field_into_hash(&xform, f.start, f.len, element_count, f.has_quotes, quote_char_val, encoding))
           all_blank = false;
       }
       element_count++;
@@ -1249,10 +1254,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
    */
   if (all_blank) {
     if (remove_empty) {
-      VALUE result = rb_ary_new_capa(2);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, LONG2FIX(element_count));
-      return result;
+      return return_parser_result(Qnil, element_count);
     }
 
     ensure_hash_allocated(&xform);
@@ -1280,10 +1282,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line,
    * Return [hash, element_count] so caller can detect extra columns
    * (when element_count > headers_len) and extend headers if needed.
    */
-  VALUE result = rb_ary_new_capa(2);
-  rb_ary_push(result, xform.hash);
-  rb_ary_push(result, LONG2FIX(element_count));
-  return result;
+  return return_parser_result(xform.hash, element_count);
 }
 
 /* ================================================================================
@@ -1354,22 +1353,7 @@ __attribute__((cold)) static VALUE rb_new_parse_context(VALUE self, VALUE header
   ctx->remove_zero_values  = RTEST(rb_hash_aref(options_hash, ID2SYM(id_remove_zero_values)));
 
   /* Numeric conversion */
-  VALUE convert_opt = rb_hash_aref(options_hash, ID2SYM(id_convert_values_to_numeric));
-  if (RTEST(convert_opt)) {
-    if (RB_TYPE_P(convert_opt, T_HASH)) {
-      VALUE only_keys  = rb_hash_aref(convert_opt, ID2SYM(id_only));
-      VALUE except_keys = rb_hash_aref(convert_opt, ID2SYM(id_except));
-      if (RTEST(only_keys)) {
-        ctx->numeric_mode = 2;
-        ctx->numeric_keys = rb_Array(only_keys);
-      } else if (RTEST(except_keys)) {
-        ctx->numeric_mode = 3;
-        ctx->numeric_keys = rb_Array(except_keys);
-      }
-    } else {
-      ctx->numeric_mode = 1;
-    }
-  }
+  parse_numeric_option(options_hash, &ctx->numeric_mode, &ctx->numeric_keys);
 
   /* quote_escaping → allow_escaped_quotes */
   VALUE quote_escaping_val = rb_hash_aref(options_hash, ID2SYM(id_quote_escaping));
@@ -1468,10 +1452,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
    * SECTION 1: Handle nil/invalid input
    * ---------------------------------------- */
   if (NIL_P(line)) {
-    VALUE result = rb_ary_new_capa(2);
-    rb_ary_push(result, Qnil);
-    rb_ary_push(result, INT2FIX(0));
-    return result;
+    return return_parser_result(Qnil, 0);
   }
 
   if (RB_TYPE_P(line, T_STRING) != 1) {
@@ -1495,6 +1476,14 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
   int  numeric_mode        = ctx->numeric_mode;
   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
+   * THEN). @headers can grow in place as undeclared extra columns appear, so the live headers_len
+   * (re-read each call below) may exceed the bitmap's length. Every keep_bitmap[] access in this
+   * function MUST be bounded by keep_bitmap_len, never headers_len — indices past the bitmap are
+   * extra columns and follow keep_extra_columns. Bounding by the grown headers_len was an
+   * out-of-bounds heap read (the bug). The sibling rb_parse_line_to_hash safely uses headers_len
+   * because it re-allocs its bitmap to headers_len on every call. */
+  long  keep_bitmap_len     = ctx->keep_bitmap_len;
   bool  keep_extra_columns  = ctx->keep_extra_columns;
   long  early_exit_after    = ctx->early_exit_after;
 
@@ -1509,12 +1498,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
   char *p       = startP;
 
   /* Chomp: strip trailing row separator (pointer adjustment, no string mutation) */
-  if (ctx->row_sep_len > 0) {
-    long rsl = (long)ctx->row_sep_len;
-    if (line_len >= rsl && memcmp(endP - rsl, ctx->row_sep_buf, (size_t)rsl) == 0) {
-      endP -= rsl;
-    }
-  }
+  endP = chomp_row_sep(endP, line_len, ctx->row_sep_buf, (long)ctx->row_sep_len);
 
   /* Re-read headers_len each call to handle extra-column growth */
   long headers_len = NIL_P(ctx->headers) ? 0 : RARRAY_LEN(ctx->headers);
@@ -1559,13 +1543,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
       /* --- (a) Common path: no column filter, no early exit --- */
       while ((sep_pos = memchr(p, sep, endP - p))) {
         long  field_len  = sep_pos - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
           all_blank = false;
         element_count++;
@@ -1574,13 +1553,8 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
       /* Process last field */
       {
         long  field_len  = endP - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
         if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
           all_blank = false;
         element_count++;
@@ -1589,14 +1563,9 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
       /* --- (b) Filter path: column bitmap and/or early exit active --- */
       while ((sep_pos = memchr(p, sep, endP - p))) {
         long  field_len  = sep_pos - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-        if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
+        if (!keep_bitmap || (element_count < keep_bitmap_len ? keep_bitmap[element_count] : keep_extra_columns)) {
           if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
             all_blank = false;
         }
@@ -1610,14 +1579,9 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
       /* Process last field — skip on early exit */
       if (!did_early_exit) {
         long  field_len  = endP - startP;
-        char *trim_start = startP;
-        char *trim_end   = startP + field_len - 1;
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-        if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
+        char *trim_start;
+        long trimmed_len = trim_field(startP, field_len, strip_ws, &trim_start);
+        if (!keep_bitmap || (element_count < keep_bitmap_len ? keep_bitmap[element_count] : keep_extra_columns)) {
           if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
             all_blank = false;
         }
@@ -1662,26 +1626,10 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
         long  field_len  = p - startP;
         char *raw_field  = startP;
 
-        bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-        if (quoted) {
-          raw_field++;
-          field_len -= 2;
-        }
-
-        char *trim_start = raw_field;
-        char *trim_end   = raw_field + field_len - 1;
-
-        if (strip_ws) {
-          while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-          while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-        }
-
-        long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
+        extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
-        bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
-
-        if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
-          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
+        if (!keep_bitmap || (element_count < keep_bitmap_len ? keep_bitmap[element_count] : keep_extra_columns)) {
+          if (insert_field_into_hash(&xform, f.start, f.len, element_count, f.has_quotes, quote_char_val, encoding))
             all_blank = false;
         }
         element_count++;
@@ -1714,25 +1662,27 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
             if (!allow_escaped_quotes || backslash_count % 2 == 0) {
               if (__builtin_expect(quote_boundary_standard, 1)) {
                 if (in_quotes) {
-                  /* closing quote: only valid if followed by col_sep, row_sep, or end */
-                  bool valid_close = (p + 1 >= endP);
-                  if (!valid_close) {
-                    valid_close = true;
-                    for (long j = 0; j < col_sep_len; j++) {
-                      if (*(p + 1 + j) != *(col_sepP + j)) { valid_close = false; break; }
-                    }
-                  }
-                  if (!valid_close && row_sep_len2 > 0) {
-                    valid_close = true;
-                    for (long j = 0; j < row_sep_len2; j++) {
-                      if (*(p + 1 + j) != *(row_sepP2 + j)) { valid_close = false; break; }
+                  if (p + 2 < endP && *(p + 1) == quote_char_val) {
+                    /* RFC doubled quote inside a quoted field ("" → ").
+                     * Give this precedence over the closing-quote check, but only
+                     * when another byte follows the doubled pair.
+                     *
+                     * Compatibility note: we intentionally do NOT force terminal
+                     * "" to be consumed here. SmarterCSV has a long-standing lenient
+                     * behavior for malformed tails like ...\"" in :double_quotes mode:
+                     * the final quote may still close the field instead of turning the
+                     * row into an unclosed-quote error. Issue #334 needs doubled-quote
+                     * precedence for ..."",... (more content follows), but we keep the
+                     * historical leniency for terminal ..."". */
+                    p++;
+                  } else {
+                    /* closing quote: only valid if followed by col_sep, row_sep, or end */
+                    if (is_valid_close(p, endP, col_sepP, col_sep_len, row_sepP2, row_sep_len2)) {
+                      in_quotes     = false;
+                      field_started = true;
                     }
+                    /* else: quote inside quoted field → literal */
                   }
-                  if (valid_close) {
-                    in_quotes     = false;
-                    field_started = true;
-                  }
-                  /* else: quote inside quoted field → literal (handles "" doubling) */
                 } else if (!field_started) {
                   in_quotes     = true;   /* opening quote at field boundary */
                   field_started = true;
@@ -1762,10 +1712,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
     section5_done_ctx:;
     /* Unclosed quote at end of line — signal multiline continuation */
     if (!did_early_exit && in_quotes) {
-      VALUE result = rb_ary_new_capa(2);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, LONG2FIX(-1));
-      return result;
+      return return_parser_result(Qnil, -1);
     }
 
     /* Process the last field — skip on early exit */
@@ -1773,26 +1720,10 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
       long  field_len  = endP - startP;
       char *raw_field  = startP;
 
-      bool quoted = (field_len >= 2 && raw_field[0] == quote_char_val && raw_field[field_len - 1] == quote_char_val);
-      if (quoted) {
-        raw_field++;
-        field_len -= 2;
-      }
-
-      char *trim_start = raw_field;
-      char *trim_end   = raw_field + field_len - 1;
+      extracted_field f = extract_field(raw_field, field_len, strip_ws, quote_char_val);
 
-      if (strip_ws) {
-        while (trim_start <= trim_end && (*trim_start == ' ' || *trim_start == '\t')) trim_start++;
-        while (trim_end >= trim_start && (*trim_end == ' ' || *trim_end == '\t')) trim_end--;
-      }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-      bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
-
-      if (!keep_bitmap || (element_count < headers_len ? keep_bitmap[element_count] : keep_extra_columns)) {
-        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
+      if (!keep_bitmap || (element_count < keep_bitmap_len ? keep_bitmap[element_count] : keep_extra_columns)) {
+        if (insert_field_into_hash(&xform, f.start, f.len, element_count, f.has_quotes, quote_char_val, encoding))
           all_blank = false;
       }
       element_count++;
@@ -1804,10 +1735,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
    * ---------------------------------------- */
   if (all_blank) {
     if (remove_empty) {
-      VALUE result = rb_ary_new_capa(2);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, LONG2FIX(element_count));
-      return result;
+      return return_parser_result(Qnil, element_count);
     }
 
     ensure_hash_allocated(&xform);
@@ -1819,7 +1747,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
   if (!remove_empty_values) {
     ensure_hash_allocated(&xform);
     for (long i = element_count; i < headers_len; i++) {
-      if (!keep_bitmap || keep_bitmap[i]) {
+      if (!keep_bitmap || (i < keep_bitmap_len ? keep_bitmap[i] : keep_extra_columns)) {
         rb_hash_aset(xform.hash, rb_ary_entry(headers, i), Qnil);
       }
     }
@@ -1828,10 +1756,7 @@ __attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE li
   /* ----------------------------------------
    * SECTION 8: Return result
    * ---------------------------------------- */
-  VALUE result = rb_ary_new_capa(2);
-  rb_ary_push(result, xform.hash);
-  rb_ary_push(result, LONG2FIX(element_count));
-  return result;
+  return return_parser_result(xform.hash, element_count);
 }
 
 // Count quote characters in a line, optionally respecting backslash escapes.