smarter_csv 1.15.2 → 1.16.0

data/ext/smarter_csv/smarter_csv.c

@@ -37,7 +37,101 @@ VALUE Qempty_string = Qnil;
 static ID id_col_sep, id_quote_char, id_row_sep, id_missing_header_prefix;
 static ID id_strip_whitespace, id_remove_empty_hashes, id_remove_empty_values;
 static ID id_quote_escaping, id_convert_values_to_numeric, id_remove_zero_values;
-static ID id_only, id_except;
+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;
+
+/* ================================================================================
+ * ParseContext — wraps all per-file parse options as a GC-managed TypedData object.
+ *
+ * Building a context once after headers are loaded eliminates the ~10 rb_hash_aref
+ * calls that rb_parse_line_to_hash performs on every row.  The hot path calls
+ * parse_line_to_hash_ctx_c(line, ctx) instead of parse_line_to_hash_c(line, headers, opts).
+ * ================================================================================ */
+typedef struct {
+  /* Separator and quoting config — copied into C buffers, no Ruby GC tracking needed */
+  char  col_sep_buf[8];
+  int   col_sep_len;
+  char  quote_char_val;
+  char  row_sep_buf[16];
+  int   row_sep_len;
+  char  prefix_buf[64];
+  const char *prefix_str;      /* "column_" literal or points into prefix_buf */
+
+  /* Boolean parse flags */
+  bool strip_ws;
+  bool remove_empty;
+  bool remove_empty_values;
+  bool remove_zero_values;
+  bool allow_escaped_quotes;   /* quote_escaping == :backslash */
+  bool quote_boundary_standard;
+
+  /* Numeric conversion: 0=off, 1=all, 2=only listed keys, 3=except listed keys */
+  int  numeric_mode;
+
+  /* Column filter bitmap (xmalloc'd; NULL when no filtering active) */
+  bool *keep_bitmap;
+  long  keep_bitmap_len;
+  bool  keep_extra_columns;
+  bool  has_only;
+  long  early_exit_after;      /* column index after which we stop; -1 = no early exit */
+
+  /* Hash allocation hint (set once at context creation) */
+  long  hash_capa;
+
+  /* GC-tracked Ruby values — must be marked in the mark callback */
+  VALUE headers;
+  VALUE numeric_keys;          /* Qnil when not used */
+} parse_context_t;
+
+__attribute__((cold)) static void parse_context_mark(void *ptr) {
+  parse_context_t *ctx = (parse_context_t *)ptr;
+#if defined(RUBY_API_VERSION_MAJOR) && (RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 7))
+  rb_gc_mark_movable(ctx->headers);
+  rb_gc_mark_movable(ctx->numeric_keys);
+#else
+  rb_gc_mark(ctx->headers);
+  if (!NIL_P(ctx->numeric_keys)) rb_gc_mark(ctx->numeric_keys);
+#endif
+}
+
+#if defined(RUBY_API_VERSION_MAJOR) && (RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 7))
+__attribute__((cold)) static void parse_context_compact(void *ptr) {
+  parse_context_t *ctx = (parse_context_t *)ptr;
+  ctx->headers      = rb_gc_location(ctx->headers);
+  ctx->numeric_keys = rb_gc_location(ctx->numeric_keys);
+}
+#endif
+
+__attribute__((cold)) static void parse_context_free(void *ptr) {
+  parse_context_t *ctx = (parse_context_t *)ptr;
+  if (ctx->keep_bitmap) xfree(ctx->keep_bitmap);
+  xfree(ctx);
+}
+
+__attribute__((cold)) static size_t parse_context_memsize(const void *ptr) {
+  const parse_context_t *ctx = (const parse_context_t *)ptr;
+  size_t sz = sizeof(parse_context_t);
+  if (ctx->keep_bitmap) sz += (size_t)ctx->keep_bitmap_len * sizeof(bool);
+  return sz;
+}
+
+static const rb_data_type_t parse_context_type = {
+  "SmarterCSV::ParseContext",
+  {
+    parse_context_mark,
+    parse_context_free,
+    parse_context_memsize,
+#if defined(RUBY_API_VERSION_MAJOR) && (RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 7))
+    parse_context_compact,
+#else
+    0,
+#endif
+  },
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
 
 static VALUE unescape_quotes(char *str, long len, char quote_char, rb_encoding *encoding) {
   char *buf = ALLOC_N(char, len);
@@ -55,7 +149,7 @@ static VALUE unescape_quotes(char *str, long len, char quote_char, rb_encoding *
   return out;
 }
 
-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) {
+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 rb_ary_new();
   }
@@ -91,6 +185,10 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
   bool has_quotes = RTEST(has_quotes_val);
   bool strip_ws = RTEST(strip_ws_val);
   bool allow_escaped_quotes = RTEST(allow_escaped_quotes_val);
+  bool quote_boundary_standard = RTEST(quote_boundary_standard_val);
+
+  char *row_sepP = (RB_TYPE_P(row_sep_val, T_STRING)) ? RSTRING_PTR(row_sep_val) : NULL;
+  long row_sep_len = (row_sepP) ? RSTRING_LEN(row_sep_val) : 0;
 
   // === FAST PATH: No quotes and single-character separator ===
   if (__builtin_expect(!has_quotes && col_sep_len == 1, 1)) {
@@ -147,6 +245,7 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
   long backslash_count = 0;
   bool in_quotes = false;
   bool col_sep_found = true;
+  bool field_started = false;  // for quote_boundary_standard: true once field has non-boundary content
 
   while (p < endP) {
     col_sep_found = true;
@@ -195,13 +294,53 @@ static VALUE rb_parse_csv_line(VALUE self, VALUE line, VALUE col_sep, VALUE quot
       p += col_sep_len;
       startP = p;
       backslash_count = 0;
+      field_started = false;  // reset for next field
     } else {
       if (allow_escaped_quotes && *p == '\\') {
         backslash_count++;
+        if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) field_started = true;
       } else {
         if (*p == quote_char_val) {
           if (!allow_escaped_quotes || backslash_count % 2 == 0) {
-            in_quotes = !in_quotes;
+            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 (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;
+              }
+              // else: mid-field quote → treat as literal
+            } else {
+              in_quotes = !in_quotes;
+            }
+          }
+        } else if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) {
+          if (strip_ws) {
+            if (*p != ' ' && *p != '\t') {
+              field_started = true;
+            } else if (!field_started) {
+              startP = p + 1; /* advance past leading whitespace so quote-detection at extraction sees the quote */
+            }
+          } else {
+            field_started = true;
           }
         }
         backslash_count = 0;
@@ -393,7 +532,7 @@ static inline void ensure_hash_allocated(field_transform_opts *opts) {
  * Returns: true if a non-blank value was inserted, false otherwise.
  *          (Used to track all_blank for remove_empty_hashes.)
  */
-static inline bool insert_field_into_hash(
+static inline __attribute__((always_inline)) bool insert_field_into_hash(
     field_transform_opts *opts,
     char *trim_start, long trimmed_len,
     long element_count, bool is_quoted,
@@ -513,7 +652,7 @@ static inline bool insert_field_into_hash(
  * Input:  line = "john,25,boston,extra" (more fields than headers)
  * Output: [{name: "john", age: "25", city: "boston", column_4: "extra"}, 4]
  */
-static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE options_hash) {
+__attribute__((hot)) static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE options_hash) {
 
   /* ----------------------------------------
    * SECTION 1: Handle nil/invalid input
@@ -538,7 +677,6 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
   VALUE col_sep = rb_hash_aref(options_hash, ID2SYM(id_col_sep));
   VALUE quote_char = rb_hash_aref(options_hash, ID2SYM(id_quote_char));
   VALUE header_prefix = rb_hash_aref(options_hash, ID2SYM(id_missing_header_prefix));
-  VALUE quote_escaping_val = rb_hash_aref(options_hash, ID2SYM(id_quote_escaping));
   bool strip_ws = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strip_whitespace)));
   bool remove_empty = RTEST(rb_hash_aref(options_hash, ID2SYM(id_remove_empty_hashes)));
   bool remove_empty_values = RTEST(rb_hash_aref(options_hash, ID2SYM(id_remove_empty_values)));
@@ -565,11 +703,10 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
     }
   }
 
-  // Determine if backslash-escaped quotes are allowed
-  bool allow_escaped_quotes = false;
-  if (RB_TYPE_P(quote_escaping_val, T_SYMBOL)) {
-    allow_escaped_quotes = (SYM2ID(quote_escaping_val) == rb_intern("backslash"));
-  }
+  // 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.
+  bool allow_escaped_quotes = false;   // set in Section 5 on first entry
+  bool quote_boundary_standard = false; // set in Section 5 on first entry
 
   rb_encoding *encoding = rb_enc_get(line);      // Preserve string encoding
   char *startP = RSTRING_PTR(line);              // Pointer to start of current field
@@ -577,7 +714,8 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
   char *endP = startP + line_len;                // End of line marker
   char *p = startP;                              // Current parsing position
 
-  // Chomp: strip trailing row separator (pointer adjustment, no string mutation)
+  // Chomp: strip trailing row separator (pointer adjustment, no string mutation).
+  // 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);
@@ -600,6 +738,112 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
   // Optimization hint: check if line contains quote characters
   bool has_quotes = (memchr(startP, quote_char_val, line_len) != NULL);
 
+  /* ----------------------------------------
+   * Column-filter bitmap for only_headers: / except_headers:
+   * ----------------------------------------
+   * keep_bitmap[i] = true  → include column i in the output hash
+   * keep_bitmap[i] = false → skip column i (no Ruby allocation at all)
+   * NULL when no filter is active — zero overhead on common path.
+   *
+   * Preferred source: options[:_keep_cols] — a Ruby Array of true/false values
+   * precomputed once in reader.rb after headers are loaded (O(1) Set lookups).
+   * Copying it here is O(headers_len) with O(1) per element — no rb_ary_includes.
+   *
+   * Fallback: build from only_headers/except_headers via rb_ary_includes (O(k)
+   * per column, k = filter list length). Used only when _keep_cols is absent.
+   *
+   * Capped at 4096 columns; wider CSVs fall back to the Ruby-side
+   * hash.select!/hash.reject! filter applied after return.
+   *
+   * The bitmap is a loop invariant: headers and filter settings never change between rows.
+   * reader.rb precomputes it once as a packed binary String (_keep_bitmap) and also
+   * pre-stores keep_extra_cols and early_exit_after, so C just does 3 hash lookups +
+   * one memcpy instead of N rb_ary_entry calls on every row.
+   *
+   * alloca() keeps the allocation conditional: no-filter path never calls alloca(), so
+   * the frame stays well below 4 KB and ___chkstk_darwin never fires on ARM64 macOS.
+   */
+  bool *keep_bitmap = NULL;
+  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 */
+
+  /* Column-filter bitmap setup.
+   *
+   * _keep_cols is the gate key — checked with a single rb_hash_aref on every row:
+   *   false (default) → no filtering; skip everything instantly.  ← COMMON CASE, zero overhead
+   *   nil             → filter active (reader.rb path): check _keep_bitmap for the fast bitmap.
+   *   Array           → backward-compat: direct C API callers passing _keep_cols as an Array.
+   *
+   * When _keep_cols is absent from the hash (nil from rb_hash_aref), it falls through to
+   * deriving the bitmap from only_headers/except_headers directly (manual options hashes).
+   *
+   * only_headers: / except_headers: are RARELY used options.  The common path (no filtering)
+   * pays exactly one rb_hash_aref and nothing else.
+   */
+  VALUE keep_cols_val = rb_hash_aref(options_hash, ID2SYM(id_keep_cols));
+  if (keep_cols_val != Qfalse) {
+    /* Not false: either nil (filter active / absent) or Array (backward-compat). */
+    if (NIL_P(keep_cols_val)) {
+      /* nil: reader.rb filter path — check _keep_bitmap, or fall back to deriving it. */
+      VALUE prebuilt_bitmap = rb_hash_aref(options_hash, ID2SYM(id_keep_bitmap));
+      if (RB_TYPE_P(prebuilt_bitmap, T_STRING)
+          && headers_len > 0 && RSTRING_LEN(prebuilt_bitmap) >= headers_len) {
+        /* Precomputed binary bitmap from reader.rb — one memcpy replaces N rb_ary_entry calls.
+         * Copy before any Ruby API calls that could trigger GC compaction. */
+        keep_bitmap = (bool *)alloca((size_t)headers_len * sizeof(bool));
+        memcpy(keep_bitmap, RSTRING_PTR(prebuilt_bitmap), (size_t)headers_len * sizeof(bool));
+        VALUE kec = rb_hash_aref(options_hash, ID2SYM(id_keep_extra_cols));
+        keep_extra_columns = NIL_P(kec) ? true : RTEST(kec);
+        VALUE exa = rb_hash_aref(options_hash, ID2SYM(id_early_exit_after_sym));
+        early_exit_after = RB_INTEGER_TYPE_P(exa) ? NUM2LONG(exa) : -1;
+        has_only = !keep_extra_columns;
+      } else if (headers_len > 0 && headers_len <= 4096) {
+        /* Last resort: derive from only_headers/except_headers directly.
+         * Only reached when options hash is built manually without any _keep_* keys. */
+        VALUE only_hdrs  = rb_hash_aref(options_hash, ID2SYM(id_only_headers));
+        VALUE except_hdrs = rb_hash_aref(options_hash, ID2SYM(id_except_headers));
+        bool has_except  = RB_TYPE_P(except_hdrs, T_ARRAY) && RARRAY_LEN(except_hdrs) > 0;
+        has_only         = RB_TYPE_P(only_hdrs,  T_ARRAY) && RARRAY_LEN(only_hdrs)  > 0;
+        if (has_only || has_except) {
+          keep_bitmap = (bool *)alloca((size_t)headers_len * sizeof(bool));
+          for (long bi = 0; bi < headers_len; bi++) {
+            VALUE hdr = rb_ary_entry(headers, bi);
+            keep_bitmap[bi] = has_only
+              ? (rb_ary_includes(only_hdrs,   hdr) == Qtrue)
+              : (rb_ary_includes(except_hdrs, hdr) != Qtrue);
+          }
+          keep_extra_columns = !has_only;
+          bool strict = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strict)));
+          if (has_only && !strict) {
+            for (long bi = headers_len - 1; bi >= 0; bi--) {
+              if (keep_bitmap[bi]) { early_exit_after = bi; break; }
+            }
+          }
+        }
+      }
+    } else if (RB_TYPE_P(keep_cols_val, T_ARRAY) && headers_len > 0 && headers_len <= 4096) {
+      /* Backward-compat: _keep_cols Array from direct C API callers — O(headers_len) Ruby calls */
+      keep_bitmap = (bool *)alloca((size_t)headers_len * sizeof(bool));
+      long prebuilt_len = RARRAY_LEN(keep_cols_val);
+      for (long bi = 0; bi < headers_len; bi++) {
+        keep_bitmap[bi] = bi < prebuilt_len ? RTEST(rb_ary_entry(keep_cols_val, bi)) : false;
+      }
+      VALUE only_hdrs = rb_hash_aref(options_hash, ID2SYM(id_only_headers));
+      has_only = RB_TYPE_P(only_hdrs, T_ARRAY) && RARRAY_LEN(only_hdrs) > 0;
+      keep_extra_columns = !has_only;
+      bool strict = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strict)));
+      if (has_only && !strict) {
+        for (long bi = headers_len - 1; bi >= 0; bi--) {
+          if (keep_bitmap[bi]) { early_exit_after = bi; break; }
+        }
+      }
+    }
+  }
+  /* else: _keep_cols is false — no filtering, keep_bitmap stays NULL. COMMON CASE. */
+
+  bool did_early_exit = false; /* set to true when early exit fires */
+
   /* ----------------------------------------
    * SECTION 3: Initialize hash and tracking variables
    * ----------------------------------------
@@ -637,46 +881,79 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
     char sep = *col_sepP;
     char *sep_pos = NULL;
 
-    /* Loop through each field by finding separator positions */
-    while ((sep_pos = memchr(p, sep, endP - p))) {
-      // Extract field boundaries
-      long field_len = sep_pos - startP;
-      char *trim_start = startP;
-      char *trim_end = startP + field_len - 1;
-
-      // Optional whitespace trimming (spaces and tabs only)
-      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--;
+    /* Loop through each field by finding separator positions.
+     * Two sub-paths to avoid per-field overhead in the common case:
+     *   (a) no filter + no early exit → pure memchr loop, zero extra branches
+     *   (b) filter active             → bitmap/early-exit checks per field
+     */
+    if (__builtin_expect(keep_bitmap == NULL && early_exit_after < 0, 1)) {
+      /* --- (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;
+        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+          all_blank = false;
+        element_count++;
+        p = sep_pos + 1; startP = p;
       }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-      if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
-        all_blank = false;
-      element_count++;
-
-      // Move to next field
-      p = sep_pos + 1;
-      startP = p;
-    }
-
-    /* Process the last field (no separator after it) */
-    {
-      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--;
+      /* 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;
+        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+          all_blank = false;
+        element_count++;
+      }
+    } else {
+      /* --- (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)) {
+          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+            all_blank = false;
+        }
+        element_count++;
+        if (early_exit_after >= 0 && element_count > early_exit_after) {
+          did_early_exit = true;
+          break;
+        }
+        p = sep_pos + 1; startP = p;
+      }
+      /* 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)) {
+          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+            all_blank = false;
+        }
+        element_count++;
       }
-
-      long trimmed_len = (trim_end >= trim_start) ? (trim_end - trim_start + 1) : 0;
-
-      if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
-        all_blank = false;
-      element_count++;
     }
 
   } else {
@@ -689,25 +966,59 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
      * - Escaped quotes using backslash: \"
      *
      * We must scan character-by-character to track quote state.
+     *
+     * quote_escaping and quote_boundary options are only needed here (Section 4
+     * fast path never touches them), so we extract them lazily on first Section 5 entry.
      */
+    VALUE quote_escaping_val = rb_hash_aref(options_hash, ID2SYM(id_quote_escaping));
+    if (RB_TYPE_P(quote_escaping_val, T_SYMBOL)) {
+      allow_escaped_quotes = (SYM2ID(quote_escaping_val) == id_backslash);
+    }
+    VALUE quote_boundary_val = rb_hash_aref(options_hash, ID2SYM(id_quote_boundary));
+    quote_boundary_standard = (RB_TYPE_P(quote_boundary_val, T_SYMBOL) &&
+                               SYM2ID(quote_boundary_val) == id_standard);
+    /* row_sep reused from chomp above for the closing-quote boundary check */
+    char *row_sepP2 = (RB_TYPE_P(row_sep, T_STRING)) ? RSTRING_PTR(row_sep) : NULL;
+    long row_sep_len2 = (row_sepP2) ? RSTRING_LEN(row_sep) : 0;
+
+    /* Opt #5 (C-side): if backslash mode is requested but the (chomped) line contains
+     * no backslash character, backslash escaping cannot possibly affect parsing — a
+     * backslash only matters immediately before a quote char. Downgrade to RFC mode
+     * so the memchr-inside-quotes optimisation fires unconditionally for such lines.
+     * This replaces the Ruby-side line.include?('\\') pre-scan that was on the hot
+     * path: now the check happens here in C (one fast memchr), and only for lines
+     * that actually reach Section 5 (i.e. lines that contain quote characters).
+     * Unquoted lines never enter Section 5, so they pay zero cost for this check. */
+    if (allow_escaped_quotes && !memchr(startP, '\\', endP - startP)) {
+      allow_escaped_quotes = false;
+    }
+
     long i;
     long backslash_count = 0;    // Track consecutive backslashes for escape detection
     bool in_quotes = false;      // Are we inside a quoted field?
     bool col_sep_found = true;
+    bool field_started = false;  // for quote_boundary_standard: true once field has non-boundary content
+
+    /* Cache first separator byte for fast pre-filtering */
+    char sep_char_slow = *col_sepP;
 
     /* Scan through the line character by character */
     while (p < endP) {
-      // Check if current position matches the column separator
-      col_sep_found = true;
-      for (i = 0; (i < col_sep_len) && (p + i < endP); i++) {
-        if (*(p + i) != *(col_sepP + i)) {
-          col_sep_found = false;
-          break;
+      // Separator check: when in_quotes we can never be at a field boundary,
+      // so skip the comparison entirely.
+      // For single-char separator: direct byte compare.
+      // For multi-char separator: pre-filter on first byte, then check the rest.
+      if (!in_quotes && *p == sep_char_slow) {
+        col_sep_found = true;
+        for (i = 1; (i < col_sep_len) && (p + i < endP); i++) {
+          if (*(p + i) != *(col_sepP + i)) { col_sep_found = false; break; }
         }
+      } else {
+        col_sep_found = false;
       }
 
-      // Found separator and not inside quotes = end of field
-      if (col_sep_found && !in_quotes) {
+      // Found separator — !in_quotes is guaranteed by the block above
+      if (col_sep_found) {
         long field_len = p - startP;
         char *raw_field = startP;
 
@@ -731,25 +1042,83 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
         // Determine if field contains embedded quotes (need unescape)
         bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
 
-        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
-          all_blank = false;
+        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))
+            all_blank = false;
+        }
         element_count++;
 
+        /* Early exit: all required columns already collected — stop scanning */
+        if (early_exit_after >= 0 && element_count > early_exit_after) {
+          did_early_exit = true;
+          goto section5_done;
+        }
+
         // Move past the separator to start of next field
         p += col_sep_len;
         startP = p;
         backslash_count = 0;
+        field_started = false;   // reset for next field
 
       } else {
         /* Not at a separator (or inside quotes) - track quote state */
 
+        /* RFC mode: inside quoted field, skip ahead to the next quote char.
+         * Everything between here and the next quote is plain field content — no
+         * separators or backslashes can appear (allow_escaped_quotes is false).
+         * memchr() is SIMD-accelerated and handles typical field lengths in 1 call. */
+        if (!allow_escaped_quotes && in_quotes) {
+          char *next_quote = (char *)memchr(p, quote_char_val, endP - p);
+          if (!next_quote) { p = endP; continue; }  /* no closing quote → unclosed */
+          p = next_quote;  /* jump to quote char; fall through to quote-handling code */
+        }
+
         if (allow_escaped_quotes && *p == '\\') {
           // Count consecutive backslashes for escape sequence detection
           backslash_count++;
+          if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) field_started = true;
         } else {
           if (*p == quote_char_val) {
             if (!allow_escaped_quotes || backslash_count % 2 == 0) {
-              in_quotes = !in_quotes;
+              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 (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;
+                }
+                // else: mid-field quote → treat as literal
+              } else {
+                in_quotes = !in_quotes;
+              }
+            }
+          } else if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) {
+            if (strip_ws) {
+              if (*p != ' ' && *p != '\t') {
+                field_started = true;
+              } else if (!field_started) {
+                startP = p + 1; /* advance past leading whitespace so quote-detection at extraction sees the quote */
+              }
+            } else {
+              field_started = true;
             }
           }
           backslash_count = 0;
@@ -758,13 +1127,20 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
       }
     }
 
-    // Error: unclosed quote at end of line
-    if (in_quotes) {
-      rb_raise(eMalformedCSVError, "Unclosed quoted field detected in line: %s", StringValueCStr(line));
+    section5_done:;
+    /* Unclosed quote at end of line (skip check on early exit):
+     * Signal "needs more data" — the caller stitches the next physical line and re-parses.
+     * 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;
     }
 
-    /* Process the last field (same logic as above) */
-    {
+    /* Process the last field (same logic as above) — skip on early exit */
+    if (!did_early_exit) {
       long field_len = endP - startP;
       char *raw_field = startP;
 
@@ -786,8 +1162,10 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
 
       bool has_embedded_quotes = quoted || (trimmed_len > 0 && memchr(trim_start, quote_char_val, trimmed_len));
 
-      if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, has_embedded_quotes, quote_char_val, encoding))
-        all_blank = false;
+      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))
+          all_blank = false;
+      }
       element_count++;
     }
   }
@@ -817,7 +1195,9 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
   if (!remove_empty_values) {
     ensure_hash_allocated(&xform);
     for (long i = element_count; i < headers_len; i++) {
-      rb_hash_aset(xform.hash, rb_ary_entry(headers, i), Qnil);
+      if (!keep_bitmap || keep_bitmap[i]) {
+        rb_hash_aset(xform.hash, rb_ary_entry(headers, i), Qnil);
+      }
     }
   }
 
@@ -833,6 +1213,550 @@ static VALUE rb_parse_line_to_hash(VALUE self, VALUE line, VALUE headers, VALUE
   return result;
 }
 
+/* ================================================================================
+ * new_parse_context_c(headers, options_hash) → ParseContext
+ *
+ * Extracts all loop-invariant options from the options_hash once and stores them
+ * in a C struct wrapped as a TypedData Ruby object.  Called once per file after
+ * headers are known.  The returned context is passed to parse_line_to_hash_ctx_c
+ * on every row, eliminating ~10 rb_hash_aref calls per row.
+ * ================================================================================ */
+__attribute__((cold)) static VALUE rb_new_parse_context(VALUE self, VALUE headers, VALUE options_hash) {
+  parse_context_t *ctx;
+  VALUE ctx_obj = TypedData_Make_Struct(rb_cObject, parse_context_t, &parse_context_type, ctx);
+
+  /* Initialize all fields to safe defaults */
+  memset(ctx, 0, sizeof(parse_context_t));
+  ctx->headers          = headers;
+  ctx->numeric_keys     = Qnil;
+  ctx->keep_bitmap      = NULL;
+  ctx->early_exit_after = -1;
+  ctx->keep_extra_columns = true;
+
+  /* col_sep */
+  VALUE col_sep_val = rb_hash_aref(options_hash, ID2SYM(id_col_sep));
+  if (RB_TYPE_P(col_sep_val, T_STRING)) {
+    long len = RSTRING_LEN(col_sep_val);
+    if (len > (long)(sizeof(ctx->col_sep_buf) - 1)) len = (long)(sizeof(ctx->col_sep_buf) - 1);
+    memcpy(ctx->col_sep_buf, RSTRING_PTR(col_sep_val), (size_t)len);
+    ctx->col_sep_buf[len] = '\0';
+    ctx->col_sep_len = (int)len;
+  } else {
+    ctx->col_sep_buf[0] = ',';
+    ctx->col_sep_buf[1] = '\0';
+    ctx->col_sep_len    = 1;
+  }
+
+  /* quote_char */
+  VALUE quote_char_v = rb_hash_aref(options_hash, ID2SYM(id_quote_char));
+  ctx->quote_char_val = (RB_TYPE_P(quote_char_v, T_STRING) && RSTRING_LEN(quote_char_v) > 0)
+                         ? RSTRING_PTR(quote_char_v)[0] : '"';
+
+  /* row_sep */
+  VALUE row_sep_v = rb_hash_aref(options_hash, ID2SYM(id_row_sep));
+  if (RB_TYPE_P(row_sep_v, T_STRING)) {
+    long len = RSTRING_LEN(row_sep_v);
+    if (len > (long)(sizeof(ctx->row_sep_buf) - 1)) len = (long)(sizeof(ctx->row_sep_buf) - 1);
+    memcpy(ctx->row_sep_buf, RSTRING_PTR(row_sep_v), (size_t)len);
+    ctx->row_sep_buf[len] = '\0';
+    ctx->row_sep_len = (int)len;
+  }
+
+  /* missing_header_prefix */
+  VALUE header_prefix = rb_hash_aref(options_hash, ID2SYM(id_missing_header_prefix));
+  if (NIL_P(header_prefix)) {
+    ctx->prefix_str = "column_";
+  } else {
+    long len = RSTRING_LEN(header_prefix);
+    if (len > (long)(sizeof(ctx->prefix_buf) - 1)) len = (long)(sizeof(ctx->prefix_buf) - 1);
+    memcpy(ctx->prefix_buf, RSTRING_PTR(header_prefix), (size_t)len);
+    ctx->prefix_buf[len] = '\0';
+    ctx->prefix_str = ctx->prefix_buf;
+  }
+
+  /* Boolean flags */
+  ctx->strip_ws            = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strip_whitespace)));
+  ctx->remove_empty        = RTEST(rb_hash_aref(options_hash, ID2SYM(id_remove_empty_hashes)));
+  ctx->remove_empty_values = RTEST(rb_hash_aref(options_hash, ID2SYM(id_remove_empty_values)));
+  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;
+    }
+  }
+
+  /* quote_escaping → allow_escaped_quotes */
+  VALUE quote_escaping_val = rb_hash_aref(options_hash, ID2SYM(id_quote_escaping));
+  if (RB_TYPE_P(quote_escaping_val, T_SYMBOL)) {
+    ctx->allow_escaped_quotes = (SYM2ID(quote_escaping_val) == id_backslash);
+  }
+
+  /* quote_boundary */
+  VALUE quote_boundary_val = rb_hash_aref(options_hash, ID2SYM(id_quote_boundary));
+  ctx->quote_boundary_standard = (RB_TYPE_P(quote_boundary_val, T_SYMBOL) &&
+                                   SYM2ID(quote_boundary_val) == id_standard);
+
+  /* Column filter bitmap */
+  long headers_len = NIL_P(headers) ? 0 : RARRAY_LEN(headers);
+  ctx->hash_capa = headers_len > 0 ? headers_len : 16;
+
+  VALUE keep_cols_val = rb_hash_aref(options_hash, ID2SYM(id_keep_cols));
+  if (keep_cols_val != Qfalse) {
+    if (NIL_P(keep_cols_val)) {
+      /* nil: reader.rb filter path — check _keep_bitmap, or fall back to deriving it. */
+      VALUE prebuilt_bitmap = rb_hash_aref(options_hash, ID2SYM(id_keep_bitmap));
+      if (RB_TYPE_P(prebuilt_bitmap, T_STRING)
+          && headers_len > 0 && RSTRING_LEN(prebuilt_bitmap) >= headers_len) {
+        ctx->keep_bitmap = (bool *)xmalloc((size_t)headers_len * sizeof(bool));
+        ctx->keep_bitmap_len = headers_len;
+        memcpy(ctx->keep_bitmap, RSTRING_PTR(prebuilt_bitmap), (size_t)headers_len * sizeof(bool));
+        VALUE kec = rb_hash_aref(options_hash, ID2SYM(id_keep_extra_cols));
+        ctx->keep_extra_columns = NIL_P(kec) ? true : RTEST(kec);
+        VALUE exa = rb_hash_aref(options_hash, ID2SYM(id_early_exit_after_sym));
+        ctx->early_exit_after = RB_INTEGER_TYPE_P(exa) ? NUM2LONG(exa) : -1;
+        ctx->has_only = !ctx->keep_extra_columns;
+      } else if (headers_len > 0 && headers_len <= 4096) {
+        /* Last resort: derive from only_headers/except_headers directly. */
+        VALUE only_hdrs  = rb_hash_aref(options_hash, ID2SYM(id_only_headers));
+        VALUE except_hdrs = rb_hash_aref(options_hash, ID2SYM(id_except_headers));
+        bool has_except  = RB_TYPE_P(except_hdrs, T_ARRAY) && RARRAY_LEN(except_hdrs) > 0;
+        ctx->has_only    = RB_TYPE_P(only_hdrs,  T_ARRAY) && RARRAY_LEN(only_hdrs)  > 0;
+        if (ctx->has_only || has_except) {
+          ctx->keep_bitmap = (bool *)xmalloc((size_t)headers_len * sizeof(bool));
+          ctx->keep_bitmap_len = headers_len;
+          for (long bi = 0; bi < headers_len; bi++) {
+            VALUE hdr = rb_ary_entry(headers, bi);
+            ctx->keep_bitmap[bi] = ctx->has_only
+              ? (rb_ary_includes(only_hdrs,  hdr) == Qtrue)
+              : (rb_ary_includes(except_hdrs, hdr) != Qtrue);
+          }
+          ctx->keep_extra_columns = !ctx->has_only;
+          bool strict = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strict)));
+          if (ctx->has_only && !strict) {
+            for (long bi = headers_len - 1; bi >= 0; bi--) {
+              if (ctx->keep_bitmap[bi]) { ctx->early_exit_after = bi; break; }
+            }
+          }
+        }
+      }
+    } else if (RB_TYPE_P(keep_cols_val, T_ARRAY) && headers_len > 0 && headers_len <= 4096) {
+      /* Backward-compat: _keep_cols Array from direct C API callers */
+      ctx->keep_bitmap = (bool *)xmalloc((size_t)headers_len * sizeof(bool));
+      ctx->keep_bitmap_len = headers_len;
+      long prebuilt_len = RARRAY_LEN(keep_cols_val);
+      for (long bi = 0; bi < headers_len; bi++) {
+        ctx->keep_bitmap[bi] = bi < prebuilt_len ? RTEST(rb_ary_entry(keep_cols_val, bi)) : false;
+      }
+      VALUE only_hdrs = rb_hash_aref(options_hash, ID2SYM(id_only_headers));
+      ctx->has_only = RB_TYPE_P(only_hdrs, T_ARRAY) && RARRAY_LEN(only_hdrs) > 0;
+      ctx->keep_extra_columns = !ctx->has_only;
+      bool strict = RTEST(rb_hash_aref(options_hash, ID2SYM(id_strict)));
+      if (ctx->has_only && !strict) {
+        for (long bi = headers_len - 1; bi >= 0; bi--) {
+          if (ctx->keep_bitmap[bi]) { ctx->early_exit_after = bi; break; }
+        }
+      }
+    }
+  }
+  /* else: _keep_cols == false — no filtering; keep_bitmap stays NULL */
+
+  return ctx_obj;
+}
+
+/* ================================================================================
+ * parse_line_to_hash_ctx_c(line, ctx) → [hash, data_size]
+ *
+ * High-performance variant of parse_line_to_hash_c that reads all loop-invariant
+ * options from a pre-built ParseContext object instead of calling rb_hash_aref on
+ * every row.  Eliminates ~10 rb_hash_aref calls per row from the critical path.
+ *
+ * ctx must be a ParseContext built by new_parse_context_c(headers, options_hash).
+ * headers_len is re-read each call from RARRAY_LEN(ctx->headers) to handle extra
+ * column growth without requiring a context rebuild.
+ * ================================================================================ */
+__attribute__((hot)) static VALUE rb_parse_line_to_hash_ctx(VALUE self, VALUE line, VALUE ctx_obj) {
+  parse_context_t *ctx;
+  TypedData_Get_Struct(ctx_obj, parse_context_t, &parse_context_type, ctx);
+
+  /* ----------------------------------------
+   * 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;
+  }
+
+  if (RB_TYPE_P(line, T_STRING) != 1) {
+    rb_raise(rb_eTypeError, "ERROR in SmarterCSV.parse_line_to_hash: line has to be a string or nil");
+  }
+
+  /* ----------------------------------------
+   * SECTION 2: Read options from context (zero rb_hash_aref calls)
+   * ----------------------------------------
+   * All loop-invariant options are read directly from the pre-built struct.
+   * No Hash lookups.  No Ruby object allocation.  Pure C struct field reads.
+   */
+  char *col_sepP          = ctx->col_sep_buf;
+  long  col_sep_len       = (long)ctx->col_sep_len;
+  char  quote_char_val    = ctx->quote_char_val;
+  const char *prefix_str  = ctx->prefix_str;
+  bool strip_ws            = ctx->strip_ws;
+  bool remove_empty        = ctx->remove_empty;
+  bool remove_empty_values = ctx->remove_empty_values;
+  bool remove_zero_values  = ctx->remove_zero_values;
+  int  numeric_mode        = ctx->numeric_mode;
+  VALUE numeric_keys       = ctx->numeric_keys;
+  bool *keep_bitmap         = ctx->keep_bitmap;
+  bool  keep_extra_columns  = ctx->keep_extra_columns;
+  long  early_exit_after    = ctx->early_exit_after;
+
+  /* allow_escaped_quotes starts from context; per-line Opt #5 may downgrade it */
+  bool allow_escaped_quotes    = ctx->allow_escaped_quotes;
+  bool quote_boundary_standard = ctx->quote_boundary_standard;
+
+  rb_encoding *encoding = rb_enc_get(line);
+  char *startP = RSTRING_PTR(line);
+  long  line_len = RSTRING_LEN(line);
+  char *endP    = startP + line_len;
+  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;
+    }
+  }
+
+  /* Re-read headers_len each call to handle extra-column growth */
+  long headers_len = NIL_P(ctx->headers) ? 0 : RARRAY_LEN(ctx->headers);
+  VALUE headers    = ctx->headers;
+
+  /* Check if line contains quote characters (per-line; cannot be precomputed) */
+  bool has_quotes = (memchr(startP, quote_char_val, line_len) != NULL);
+
+  bool did_early_exit = false;
+
+  /* ----------------------------------------
+   * SECTION 3: Initialize hash and tracking variables
+   * ---------------------------------------- */
+  long hash_size     = headers_len > 0 ? headers_len : 16;
+  long element_count = 0;
+  bool all_blank     = true;
+
+  field_transform_opts xform = {
+    .hash              = Qnil,
+    .headers           = headers,
+    .numeric_keys      = numeric_keys,
+    .encoding          = encoding,
+    .prefix_str        = prefix_str,
+    .headers_len       = headers_len,
+    .hash_capa         = hash_size,
+    .numeric_mode      = numeric_mode,
+    .remove_empty_values = remove_empty_values,
+    .remove_zero_values  = remove_zero_values,
+  };
+
+  /* ========================================
+   * SECTION 4: FAST PATH - No quotes, single-char separator
+   * Two sub-paths to avoid per-field overhead in the common case:
+   *   (a) no filter + no early exit → pure memchr loop, zero extra branches
+   *   (b) filter active             → bitmap/early-exit checks per field
+   * ======================================== */
+  if (__builtin_expect(!has_quotes && col_sep_len == 1, 1)) {
+    char sep      = *col_sepP;
+    char *sep_pos = NULL;
+
+    if (__builtin_expect(keep_bitmap == NULL && early_exit_after < 0, 1)) {
+      /* --- (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;
+        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+          all_blank = false;
+        element_count++;
+        p = sep_pos + 1; startP = p;
+      }
+      /* 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;
+        if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+          all_blank = false;
+        element_count++;
+      }
+    } else {
+      /* --- (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)) {
+          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+            all_blank = false;
+        }
+        element_count++;
+        if (early_exit_after >= 0 && element_count > early_exit_after) {
+          did_early_exit = true;
+          break;
+        }
+        p = sep_pos + 1; startP = p;
+      }
+      /* 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)) {
+          if (insert_field_into_hash(&xform, trim_start, trimmed_len, element_count, false, quote_char_val, encoding))
+            all_blank = false;
+        }
+        element_count++;
+      }
+    }
+
+  } else {
+    /* ========================================
+     * SECTION 5: SLOW PATH - Quoted fields or multi-char separator
+     * ========================================
+     * Quote escaping options are read from the context (no rb_hash_aref).
+     * Opt #5: downgrade to RFC mode if backslash mode is requested but this
+     * specific line contains no backslash — allows memchr skip-ahead inside quotes.
+     */
+    if (allow_escaped_quotes && !memchr(startP, '\\', endP - startP)) {
+      allow_escaped_quotes = false;
+    }
+
+    char *row_sepP2    = (ctx->row_sep_len > 0) ? ctx->row_sep_buf : NULL;
+    long  row_sep_len2 = (long)ctx->row_sep_len;
+
+    long i;
+    long backslash_count = 0;
+    bool in_quotes     = false;
+    bool col_sep_found = true;
+    bool field_started = false;
+
+    char sep_char_slow = *col_sepP;
+
+    while (p < endP) {
+      if (!in_quotes && *p == sep_char_slow) {
+        col_sep_found = true;
+        for (i = 1; (i < col_sep_len) && (p + i < endP); i++) {
+          if (*(p + i) != *(col_sepP + i)) { col_sep_found = false; break; }
+        }
+      } else {
+        col_sep_found = false;
+      }
+
+      if (col_sep_found) {
+        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;
+
+        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))
+            all_blank = false;
+        }
+        element_count++;
+
+        if (early_exit_after >= 0 && element_count > early_exit_after) {
+          did_early_exit = true;
+          goto section5_done_ctx;
+        }
+
+        p += col_sep_len;
+        startP = p;
+        backslash_count = 0;
+        field_started   = false;
+
+      } else {
+        /* Not at a separator (or inside quotes) — track quote state */
+
+        /* RFC mode: memchr skip-ahead inside quoted fields (Opt #6) */
+        if (!allow_escaped_quotes && in_quotes) {
+          char *next_quote = (char *)memchr(p, quote_char_val, endP - p);
+          if (!next_quote) { p = endP; continue; }
+          p = next_quote;  /* fall through to quote-handling code */
+        }
+
+        if (allow_escaped_quotes && *p == '\\') {
+          backslash_count++;
+          if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) field_started = true;
+        } else {
+          if (*p == quote_char_val) {
+            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 (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;
+                }
+                /* else: mid-field quote → treat as literal */
+              } else {
+                in_quotes = !in_quotes;
+              }
+            }
+          } else if (__builtin_expect(quote_boundary_standard, 1) && !in_quotes) {
+            if (strip_ws) {
+              if (*p != ' ' && *p != '\t') {
+                field_started = true;
+              } else if (!field_started) {
+                startP = p + 1;
+              }
+            } else {
+              field_started = true;
+            }
+          }
+          backslash_count = 0;
+        }
+        p++;
+      }
+    }
+
+    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;
+    }
+
+    /* Process the last field — skip on early exit */
+    if (!did_early_exit) {
+      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));
+
+      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))
+          all_blank = false;
+      }
+      element_count++;
+    }
+  }
+
+  /* ----------------------------------------
+   * SECTION 6: Handle blank rows
+   * ---------------------------------------- */
+  if (remove_empty && all_blank) {
+    VALUE result = rb_ary_new_capa(2);
+    rb_ary_push(result, Qnil);
+    rb_ary_push(result, LONG2FIX(element_count));
+    return result;
+  }
+
+  /* ----------------------------------------
+   * SECTION 7: Pad hash with nil for missing columns (conditional)
+   * ---------------------------------------- */
+  if (!remove_empty_values) {
+    ensure_hash_allocated(&xform);
+    for (long i = element_count; i < headers_len; i++) {
+      if (!keep_bitmap || keep_bitmap[i]) {
+        rb_hash_aset(xform.hash, rb_ary_entry(headers, i), Qnil);
+      }
+    }
+  }
+
+  /* ----------------------------------------
+   * 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;
+}
+
 // Count quote characters in a line, optionally respecting backslash escapes.
 // This is a performance optimization that replaces the Ruby each_char implementation
 // which creates a new String object for every character in the line.
@@ -942,10 +1866,22 @@ void Init_smarter_csv(void) {
   id_remove_zero_values = rb_intern("remove_zero_values");
   id_only = rb_intern("only");
   id_except = rb_intern("except");
-
-  rb_define_module_function(Parser, "parse_csv_line_c", rb_parse_csv_line, 7);
+  id_quote_boundary = rb_intern("quote_boundary");
+  id_only_headers   = rb_intern("only_headers");
+  id_except_headers = rb_intern("except_headers");
+  id_keep_cols          = rb_intern("_keep_cols");
+  id_keep_bitmap        = rb_intern("_keep_bitmap");
+  id_keep_extra_cols    = rb_intern("_keep_extra_cols");
+  id_early_exit_after_sym = rb_intern("_early_exit_after");
+  id_strict             = rb_intern("strict");
+  id_backslash      = rb_intern("backslash");
+  id_standard       = rb_intern("standard");
+
+  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);
   rb_define_module_function(Parser, "count_quote_chars_auto_c", rb_count_quote_chars_auto, 3);
   rb_define_module_function(Parser, "zip_to_hash_c", rb_zip_to_hash, 2);
   rb_define_module_function(Parser, "parse_line_to_hash_c", rb_parse_line_to_hash, 3);
+  rb_define_module_function(Parser, "new_parse_context_c", rb_new_parse_context, 2);
+  rb_define_module_function(Parser, "parse_line_to_hash_ctx_c", rb_parse_line_to_hash_ctx, 2);
 }