carray 3.0.1 → 3.0.3

data/ext/ca_sweep_engine.h

@@ -5,15 +5,14 @@
  *  Established in PROPOSAL_L0_AUTHOR_SURFACE L0.1 (2026-06-11).  Extracts
  *  the xfer_all-aware lifecycle template previously duplicated 7-times in
  *  ext/carray_call_cfunc.c (= one body per arity 1..7) into a single shared
- *  helper.  Same helper will back the forthcoming CA_FOR_EACH_ELEMENT macro
- *  family (L0.2a) and the WHOLE_BUFFER family (L0.2c).
+ *  helper, also used by the chunked slab family (ca_call_cslab_*).
  *
  *  Lifecycle template:
  *    (1) per-operand acquire
  *          OUTPUT (fsync=='1') -> ca_attach + use ca->ptr (sync on release)
  *          INPUT  (fsync=='0') alias-able -> ca_attach + use ca->ptr
  *          INPUT  (fsync=='0') non-alias  -> xmalloc + ca_xfer_all(GET)
- *    (2) broadcast shape check (scalar collapse + n_kernel agreement)
+ *    (2) operand pairing (scalar collapse; arrays must agree in shape)
  *    (3) mask OR across INPUT operands -> m0 (xmalloc, NULL if none)
  *    (4) mask propagate to OUTPUT operands (overwrite output->mask)
  *    (5) caller runs the per-cell loop using base[] + stride[]
@@ -64,15 +63,10 @@ typedef struct ca_sweep_state {
   boolean8_t     *m0;
   ca_size_t       n_kernel;
   const char     *src_label;
-  /* no_mask: if non-zero, ca_sweep_acquire raises when any INPUT operand has
-   * a mask.  Used by the NO_MASK macro forms (CA_FOR_EACH_ELEMENT etc.) to
-   * implement Q3=(ii) runtime error policy.  Default 0 (= masked INPUT OK,
-   * m0 built as usual).  Caller sets before calling ca_sweep_acquire. */
-  int             no_mask;
 
   /* === chunked path fields (L0.1 chunk, PROPOSAL_L0_AUTHOR_SURFACE) === */
   /* Used by ca_sweep_acquire_chunked / ca_sweep_next_chunk / ca_sweep_release_chunked
-   * (= the sweep ELEMENT macro family).  Unused by the whole-materialise path
+   * (= the chunked slab family, ca_call_cslab_*).  Unused by the whole-materialise path
    * (ca_sweep_acquire / ca_sweep_release) — cfunc and other whole-buffer callers
    * leave these zero. */
   char          **base_orig;     /* per-op original ptr (= ca->ptr for
@@ -84,14 +78,20 @@ typedef struct ca_sweep_state {
   ca_size_t       chunk_n_max;   /* max chunk size from ca_chunk_compute_n */
   ca_size_t       inner;         /* product of dims except outermost (= row
                                     size in elements for outer-axis chunking) */
-  int             chunked_state; /* 0=pre-init, 1=active, 2=done */
+  int             chunked_state; /* 0=pre-init, 1=active, 2=done,
+                                    3=aborted (a read raised; resources
+                                    already given back) */
   boolean8_t     *mask_scratch;  /* chunk-sized staging for the per-chunk
                                     mask OR; NULL when no INPUT is masked */
 } ca_sweep_state_t;
 
-/* Validate fsync length, acquire per-op buffers, compute broadcast shape +
- * strides, build mask m0, propagate mask to OUTPUTs.  May raise (fsync
- * length mismatch, shape mismatch). */
+/* Validate fsync length, pair the operands (shape), acquire per-op
+ * buffers, build mask m0, propagate mask to OUTPUTs.  May raise: refusals
+ * (fsync length, shape mismatch) before
+ * anything is held, and a raising operand read after -- in which case
+ * everything acquired so far is detached / freed before the raise
+ * propagates, so the caller must not call release.  The chunked path
+ * does the same for acquire_chunked and each ca_sweep_next_chunk. */
 void ca_sweep_acquire (ca_sweep_state_t *st);
 
 /* Reverse-order release: sync OUTPUTs, detach attached / xfree owned_buf,
@@ -99,13 +99,22 @@ void ca_sweep_acquire (ca_sweep_state_t *st);
  * state without re-initializing the caller-owned arrays. */
 void ca_sweep_release (ca_sweep_state_t *st);
 
-/* Strict full-shape equality check used by INOUT macros (AC5: silent-
- * corruption seam prevention).  Raises if ndim differs or any dim[k]
- * differs.  Returns void; raises on mismatch. */
-void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
-                             const char *src_label);
+/* Run walk(arg) -- the caller's loop over the acquired state -- and then
+ * release.  If walk raises (a callback refusing a value), everything the
+ * engine holds is detached / freed without syncing before the raise
+ * propagates.  Use in place of calling ca_sweep_release /
+ * ca_sweep_release_chunked yourself whenever the loop can raise.  The
+ * chunked walk calls ca_sweep_next_chunk itself. */
+void ca_sweep_run         (ca_sweep_state_t *st, VALUE (*walk)(VALUE), VALUE arg);
+void ca_sweep_run_chunked (ca_sweep_state_t *st, VALUE (*walk)(VALUE), VALUE arg);
 
-/* ===== Chunked path API (sweep ELEMENT macro family, L0.1 chunk) =====
+/* Shape pairing shared with rb_ca_template_n: non-zero when a and b have
+ * the same ndim and dims; the refusal raises ArgumentError naming both
+ * shapes. */
+int  ca_sweep_same_shape (CArray *a, CArray *b);
+NORETURN(void ca_sweep_refuse_shapes (CArray *a, CArray *b));
+
+/* ===== Chunked path API (ca_call_cslab_*) =====
  *
  * Unlike ca_sweep_acquire / ca_sweep_release (= whole-buffer materialise used
  * by cfunc), the chunked path keeps INPUT memory peak bounded to chunk
@@ -113,7 +122,7 @@ void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
  * memory peak guarantee: shrinking views materialise into chunk scratch
  * sized to inner-axis multiples, not full operand size.
  *
- * Usage shape (inside a macro):
+ * Usage shape:
  *   ca_sweep_acquire_chunked(&st);
  *   while (ca_sweep_next_chunk(&st)) {
  *     for (k = 0; k < st.chunk_n; k++) {
@@ -141,9 +150,8 @@ void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
  *   indexed within the chunk, NOT by the flat cell index.  (This differs
  *   from the whole-buffer path, where m0 spans n_kernel.)
  *
- *   An author may WRITE m0[k] during the chunk loop (= the INOUT_MASKED
- *   forms' m_out).  Those writes are flushed into the OUTPUT operands'
- *   masks when the chunk finishes -- at the top of the following
+ *   The chunk's m0 is flushed into the OUTPUT operands' masks when the
+ *   chunk finishes -- at the top of the following
  *   ca_sweep_next_chunk, and once more in ca_sweep_release_chunked for
  *   the last chunk -- so the OUTPUT masks are created up front in
  *   acquire_chunked rather than propagated in one go at release.

data/ext/ca_triop_dispatch.c

@@ -27,6 +27,7 @@ ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt)
     case CA_TRIOP_FMA:  return ca_triop_fma  [common_dt];
     case CA_TRIOP_FMS:  return ca_triop_fms  [common_dt];
     case CA_TRIOP_CLIP: return ca_triop_clip [common_dt];
+    case CA_TRIOP_SELECT: return ca_triop_select [common_dt];
     default:            return NULL;
   }
 }
@@ -38,7 +39,9 @@ ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt)
 int8_t
 ca_lazy_promote_triop (uint16_t op_id, int8_t dt1, int8_t dt2, int8_t dt3)
 {
-  (void) op_id;   /* uniform 3-way promote across all currently-defined triops */
+  if ( op_id == CA_TRIOP_SELECT ) {
+    return (int8_t) ca_promote_type(dt2, dt3);
+  }
   return (int8_t) ca_promote_type(ca_promote_type(dt1, dt2), dt3);
 }
 

data/ext/ca_triop_dispatch.h

@@ -11,7 +11,7 @@
   runs (cast-before invariant, mirrors CABinOp).  Output data_type is
   always the common data_type (preserve).
 
-  Scope: fma / fms / clip (see ext/mkkernel.rb :fma / :fms / :clip).
+  Scope: fma / fms / clip / select (see ext/mkkernel.rb).
   None of the currently-defined triops trap on integer zero divisor.
 
 ---------------------------------------------------------------------------- */
@@ -29,6 +29,7 @@ enum {
   CA_TRIOP_FMA  = 0,   /* a * b + c  (single-rounding on float)     */
   CA_TRIOP_FMS  = 1,   /* a * b - c  (single-rounding on float)     */
   CA_TRIOP_CLIP = 2,   /* min(max(a, lo), hi), NaN-preserving        */
+  CA_TRIOP_SELECT = 3, /* a ? b : c  (lazy then_else)                 */
 
   CA_TRIOP_COUNT
 };
@@ -40,6 +41,7 @@ enum {
 extern ca_triop_func_t ca_triop_fma        [CA_NTYPE];
 extern ca_triop_func_t ca_triop_fms        [CA_NTYPE];
 extern ca_triop_func_t ca_triop_clip       [CA_NTYPE];
+extern ca_triop_func_t ca_triop_select     [CA_NTYPE];
 
 /* ------------------------------------------------------------------- */
 /* Dispatch API                                                         */
@@ -49,7 +51,8 @@ extern ca_triop_func_t ca_triop_clip       [CA_NTYPE];
    not implemented at the requested data_type. */
 ca_triop_func_t ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt);
 
-/* 3-way promotion: common data_type of (dt1, dt2, dt3).                 */
+/* 3-way promotion: common data_type of (dt1, dt2, dt3).  For select it is
+   that of the two branches (dt2, dt3); the condition is converted to it. */
 int8_t ca_lazy_promote_triop (uint16_t op_id, int8_t dt1, int8_t dt2, int8_t dt3);
 
 /* Each operand's cast-target data_type (= common data_type for all three,

data/ext/caframe_csv_reader.c

@@ -0,0 +1,463 @@
+/* CSV body reader for CAFrame.from_csv.
+
+   CArray.__csv_read_body_as_string_cells__(text, sep, quote, ncol, keep)
+     -> [ncol, cells, records]
+   reads every record of text into one flat Array of nrow * ncol cells, row
+   after row: a String for a field, UNDEF for a missing one (an unquoted
+   empty field, or a cell a short row never reached).  keep, when not nil,
+   is the ascending Array of the indexes of the columns to read: a row then
+   has a cell for each of them only, and the fields of the others are passed
+   over without being copied out of the text.  records counts the
+   records read, blank lines included, as the Ruby tokenizer numbers them.
+   With ncol 0 the column count is the first record's, as for a file with no
+   header; a later record that is longer is then one this reader declines.
+
+   CArray.__csv_read_body_as_const_string_columns__(text, sep, quote, ncol, keep)
+     -> [ncol, buffer, [pairs, ...], records]
+   reads the same records into one fixlen-16 (start, end) pair entity per
+   column read, the layout CAConstString.wrap takes, with missing cells masked.
+   The pairs index buffer, which is text itself when no field held a doubled
+   quote, and text followed by those fields' unescaped bytes otherwise, so
+   the cells are not copied out of the text.
+
+   Both follow the rules of the Ruby tokenizer in
+   lib/carray/frame/csv_parser.rb, which stays the reference: a quoted field
+   may hold the separator, doubled quotes and line breaks; a line that is
+   empty, or only spaces and tabs with no separator, is not a row unless the
+   file has one column.  They answer nil, for the Ruby tokenizer to read the
+   text and say what is wrong, when the text is not UTF-8 or US-ASCII or has
+   an invalid byte, when a record is malformed or longer than ncol, and when
+   keep names no column or one past the last. */
+
+#include "carray.h"
+#include "carray_internal.h"
+#include "ruby/encoding.h"
+
+static int
+ca_csv_at (const char *s, long n, long p, const char *t, long tlen)
+{
+  return p + tlen <= n && memcmp(s + p, t, tlen) == 0;
+}
+
+/* The end of the line content that starts at p: the position of its "\n",
+   or n; *next is where the following line starts.  A "\r" before the "\n",
+   or at the end of the text, is not content. */
+static long
+ca_csv_line_end (const char *s, long n, long p, long *next)
+{
+  const char *nl = memchr(s + p, '\n', n - p);
+  long e = nl ? nl - s : n;
+  *next = nl ? e + 1 : n;
+  if ( e > p && s[e - 1] == '\r' ) {
+    e -= 1;
+  }
+  return e;
+}
+
+/* A growing list of (start, end) pairs.  A pair at or past the length of
+   the text indexes the unescaped tail; a missing cell is (-1, -1). */
+typedef struct {
+  int64_t *v;
+  long len, cap;           /* in pairs */
+} ca_csv_cell_ranges;
+
+static void
+ca_csv_push_cell_range (ca_csv_cell_ranges *a, int64_t start, int64_t end)
+{
+  if ( a->len == a->cap ) {
+    a->cap = a->cap ? 2 * a->cap : 4096;
+    REALLOC_N(a->v, int64_t, 2 * a->cap);
+  }
+  a->v[2 * a->len]     = start;
+  a->v[2 * a->len + 1] = end;
+  a->len++;
+}
+
+typedef struct {
+  ca_csv_cell_ranges cells;      /* row after row */
+  ca_csv_cell_ranges pending;    /* blank lines before the first record */
+  VALUE tail;              /* unescaped quoted fields, or Qnil */
+  VALUE keep;              /* the indexes of the columns to read, or Qnil */
+  char *kept;              /* keep as a byte per column, 1 for one read;
+                              NULL for every column, or before ncol is known */
+  long ncol;
+  long width;              /* the cells of a row: those of the columns read */
+  long records;
+} ca_csv_walk_t;
+
+/* Set w->kept and w->width from w->keep for w->ncol columns.  Returns 0 when
+   keep names no column or one past the last. */
+static int
+ca_csv_set_kept_columns (ca_csv_walk_t *w)
+{
+  long i;
+  w->kept = ALLOC_N(char, w->ncol);
+  memset(w->kept, 0, w->ncol);
+  for (i = 0; i < RARRAY_LEN(w->keep); i++) {
+    long j = NUM2LONG(rb_ary_entry(w->keep, i));
+    if ( j < 0 || j >= w->ncol ) {
+      return 0;
+    }
+    if ( ! w->kept[j] ) {
+      w->kept[j] = 1;
+      w->width++;
+    }
+  }
+  return w->width > 0;
+}
+
+/* Read every record of s into w.  Returns 0 when the text is one this
+   reader declines (see the header comment).  The cell ranges it grows are
+   the caller's to free, whether it returns or raises. */
+static int
+ca_csv_walk_records (const char *s, long n, const char *sp, long slen,
+             const char *qp, long qlen, ca_csv_walk_t *w)
+{
+  long ncol = w->ncol, p = 0;
+
+  if ( ! NIL_P(w->keep) && ncol > 0 && ! ca_csv_set_kept_columns(w) ) {
+    return 0;
+  }
+  while ( p < n ) {
+    long next, e = ca_csv_line_end(s, n, p, &next), k, fields = 0;
+    int blank = 1;
+
+    w->records += 1;
+
+    /* A blank line: empty, or only spaces and tabs with no separator. */
+    for (k = p; k < e; k++) {
+      if ( s[k] != ' ' && s[k] != '\t' ) {
+        blank = 0;
+        break;
+      }
+    }
+    if ( blank ) {
+      for (k = p; k + slen <= e; k++) {
+        if ( memcmp(s + k, sp, slen) == 0 ) {
+          blank = 0;
+          break;
+        }
+      }
+    }
+    if ( blank ) {
+      int64_t a = e > p ? p : -1, b = e > p ? e : -1;
+      if ( ncol == 1 ) {
+        if ( w->kept == NULL || w->kept[0] ) {
+          ca_csv_push_cell_range(&w->cells, a, b);
+        }
+      }
+      else if ( ncol == 0 ) {
+        /* Before the first record the column count is not known: keep the
+           line, a row if that record turns out to have one column. */
+        ca_csv_push_cell_range(&w->pending, a, b);
+      }
+      p = next;
+      continue;
+    }
+
+    for (;;) {
+      int64_t a = -1, b = -1;
+      /* The field of a column not read is passed over, its text not
+         unescaped. */
+      int read = w->kept == NULL || ( fields < ncol && w->kept[fields] );
+      if ( ca_csv_at(s, n, p, qp, qlen) ) {
+        /* A quoted field, which may run onto later lines. */
+        long q = p + qlen, start = q, tail0 = -1;
+        for (;;) {
+          const char *hit = NULL;
+          long r = q;
+          while ( r + qlen <= n ) {
+            const char *c = memchr(s + r, qp[0], n - r);
+            if ( c == NULL ) {
+              break;
+            }
+            r = c - s;
+            if ( ca_csv_at(s, n, r, qp, qlen) ) {
+              hit = c;
+              break;
+            }
+            r++;
+          }
+          if ( hit == NULL ) {
+            return 0;                           /* unterminated */
+          }
+          if ( ca_csv_at(s, n, r + qlen, qp, qlen) ) {
+            /* a doubled quote is a literal one */
+            if ( ! read ) {
+              q = r + 2 * qlen;
+              continue;
+            }
+            if ( NIL_P(w->tail) ) {
+              w->tail = rb_str_buf_new(256);
+            }
+            if ( tail0 < 0 ) {
+              tail0 = RSTRING_LEN(w->tail);
+              rb_str_cat(w->tail, s + start, r + qlen - start);
+            }
+            else {
+              rb_str_cat(w->tail, s + q, r + qlen - q);
+            }
+            q = r + 2 * qlen;
+            continue;
+          }
+          if ( tail0 < 0 ) {
+            a = start;
+            b = r;
+          }
+          else {
+            rb_str_cat(w->tail, s + q, r - q);
+            a = n + tail0;
+            b = n + RSTRING_LEN(w->tail);
+          }
+          p = r + qlen;
+          break;
+        }
+        e = ca_csv_line_end(s, n, p, &next);
+        if ( p != e && ! ca_csv_at(s, n, p, sp, slen) ) {
+          return 0;                             /* text after the closing quote */
+        }
+      }
+      else {
+        long r = p;
+        if ( slen == 1 && qlen == 1 ) {
+          const char sc = sp[0], qc = qp[0];
+          while ( r < e && s[r] != sc ) {
+            if ( s[r] == qc ) {
+              return 0;                         /* a quote in an unquoted field */
+            }
+            r++;
+          }
+        }
+        else {
+          while ( r < e && ! ca_csv_at(s, n, r, sp, slen) ) {
+            if ( ca_csv_at(s, n, r, qp, qlen) ) {
+              return 0;                         /* a quote in an unquoted field */
+            }
+            r++;
+          }
+        }
+        a = r > p ? p : -1;
+        b = r > p ? r : -1;
+        p = r;
+      }
+      if ( ++fields > ncol && ncol > 0 ) {
+        return 0;                               /* a row too long */
+      }
+      if ( read ) {
+        ca_csv_push_cell_range(&w->cells, a, b);
+      }
+      if ( p < e && ca_csv_at(s, n, p, sp, slen) ) {
+        p += slen;
+        continue;
+      }
+      break;
+    }
+    if ( ncol == 0 ) {
+      /* The first record sets the column count; the blank lines before it
+         are rows of a one-column file and nothing otherwise. */
+      ncol = fields;
+      if ( ! NIL_P(w->keep) ) {
+        /* Its fields were all read, the columns being unknown until now:
+           keep those of the columns read. */
+        long j, k = 0;
+        w->ncol = ncol;
+        if ( ! ca_csv_set_kept_columns(w) ) {
+          return 0;
+        }
+        for (j = 0; j < ncol; j++) {
+          if ( w->kept[j] ) {
+            w->cells.v[2 * k]     = w->cells.v[2 * j];
+            w->cells.v[2 * k + 1] = w->cells.v[2 * j + 1];
+            k++;
+          }
+        }
+        w->cells.len = k;
+      }
+      if ( ncol == 1 && w->pending.len > 0 ) {
+        long i;
+        for (i = 0; i < w->cells.len; i++) {
+          ca_csv_push_cell_range(&w->pending, w->cells.v[2 * i], w->cells.v[2 * i + 1]);
+        }
+        { ca_csv_cell_ranges t = w->cells; w->cells = w->pending; w->pending = t; }
+        w->pending.len = 0;
+      }
+    }
+    for (; fields < ncol; fields++) {
+      if ( w->kept == NULL || w->kept[fields] ) {
+        ca_csv_push_cell_range(&w->cells, -1, -1);
+      }
+    }
+    p = next;
+  }
+  w->ncol = ncol;
+  if ( NIL_P(w->keep) ) {
+    w->width = ncol;
+  }
+  return ncol > 0;                              /* 0: no record */
+}
+
+/* The arguments both readers take, checked; 0 for text they decline. */
+static int
+ca_csv_check_reader_args (VALUE text, VALUE vsep, VALUE vquote, VALUE vncol,
+                          VALUE keep, long *ncol)
+{
+  rb_encoding *enc;
+  Check_Type(text, T_STRING);
+  Check_Type(vsep, T_STRING);
+  Check_Type(vquote, T_STRING);
+  if ( ! NIL_P(keep) ) {
+    Check_Type(keep, T_ARRAY);
+  }
+  *ncol = NUM2LONG(vncol);
+  enc = rb_enc_get(text);
+  if ( ( enc != rb_utf8_encoding() && enc != rb_usascii_encoding() )
+       || rb_enc_str_coderange(text) == ENC_CODERANGE_BROKEN || *ncol < 0 ) {
+    return 0;
+  }
+  return RSTRING_LEN(vsep) >= 1 && RSTRING_LEN(vquote) >= 1;
+}
+
+/* What a reader makes of the walked records: the Ruby value it answers. */
+typedef VALUE (*ca_csv_build_result) (VALUE text, ca_csv_walk_t *w);
+
+typedef struct {
+  VALUE text, vsep, vquote, vncol;
+  ca_csv_walk_t w;
+  ca_csv_build_result build;
+} ca_csv_read_body_context;
+
+static VALUE
+ca_csv_read_body_walk_and_build (VALUE varg)
+{
+  ca_csv_read_body_context *c = (ca_csv_read_body_context *) varg;
+  if ( ! ca_csv_check_reader_args(c->text, c->vsep, c->vquote, c->vncol, c->w.keep,
+                                  &c->w.ncol) ) {
+    return Qnil;
+  }
+  if ( ! ca_csv_walk_records(RSTRING_PTR(c->text), RSTRING_LEN(c->text),
+                             RSTRING_PTR(c->vsep), RSTRING_LEN(c->vsep),
+                             RSTRING_PTR(c->vquote), RSTRING_LEN(c->vquote), &c->w) ) {
+    return Qnil;
+  }
+  return c->build(c->text, &c->w);
+}
+
+static VALUE
+ca_csv_read_body_free_cell_ranges (VALUE varg)
+{
+  ca_csv_read_body_context *c = (ca_csv_read_body_context *) varg;
+  xfree(c->w.cells.v);
+  xfree(c->w.pending.v);
+  xfree(c->w.kept);
+  return Qnil;
+}
+
+/* Walk the records of text and build the answer from them, with the cell
+   ranges freed however that ends: the walk and the build both allocate,
+   and so may raise. */
+static VALUE
+ca_csv_read_body (VALUE text, VALUE vsep, VALUE vquote, VALUE vncol, VALUE keep,
+                  ca_csv_build_result build)
+{
+  ca_csv_read_body_context c = {
+    text, vsep, vquote, vncol,
+    { { NULL, 0, 0 }, { NULL, 0, 0 }, Qnil, keep, NULL, 0, 0, 0 }, build
+  };
+  VALUE out = rb_ensure(ca_csv_read_body_walk_and_build, (VALUE) &c,
+                        ca_csv_read_body_free_cell_ranges, (VALUE) &c);
+  RB_GC_GUARD(c.w.tail);
+  return out;
+}
+
+static VALUE
+ca_csv_build_string_cells (VALUE text, ca_csv_walk_t *w)
+{
+  volatile VALUE out;
+  rb_encoding *enc = rb_enc_get(text);
+  const char *s = RSTRING_PTR(text);
+  long n = RSTRING_LEN(text), i;
+
+  out = rb_ary_new_capa(w->cells.len);
+  for (i = 0; i < w->cells.len; i++) {
+    int64_t a = w->cells.v[2 * i], b = w->cells.v[2 * i + 1];
+    VALUE cell;
+    if ( a < 0 ) {
+      cell = CA_UNDEF;
+    }
+    else if ( a < n ) {
+      cell = rb_enc_str_new(s + a, b - a, enc);
+    }
+    else {
+      cell = rb_enc_str_new(RSTRING_PTR(w->tail) + (a - n), b - a, enc);
+    }
+    rb_ary_push(out, cell);
+  }
+  return rb_ary_new3(3, LONG2NUM(w->ncol), out, LONG2NUM(w->records));
+}
+
+static VALUE
+ca_csv_build_const_string_columns (VALUE text, ca_csv_walk_t *w)
+{
+  volatile VALUE buffer, cols;
+  ca_size_t dim[1];
+  long nrow, i, j;
+
+  if ( NIL_P(w->tail) ) {
+    buffer = text;
+  }
+  else {
+    buffer = rb_str_buf_new(RSTRING_LEN(text) + RSTRING_LEN(w->tail));
+    rb_str_cat(buffer, RSTRING_PTR(text), RSTRING_LEN(text));
+    rb_str_cat(buffer, RSTRING_PTR(w->tail), RSTRING_LEN(w->tail));
+    rb_enc_copy(buffer, text);
+  }
+
+  nrow = w->cells.len / w->width;
+  dim[0] = (ca_size_t) nrow;
+  cols = rb_ary_new_capa(w->width);
+  for (j = 0; j < w->width; j++) {
+    CArray *pe;
+    int64_t *range;
+    boolean8_t *m = NULL;
+    VALUE col = rb_carray_new(CA_FIXLEN, 1, dim, 2 * sizeof(int64_t), NULL);
+    rb_ary_push(cols, col);
+    TypedData_Get_Struct(col, CArray, &carray_data_type, pe);
+    range = (int64_t *) pe->ptr;
+    for (i = 0; i < nrow; i++) {
+      int64_t a = w->cells.v[2 * (i * w->width + j)];
+      int64_t b = w->cells.v[2 * (i * w->width + j) + 1];
+      if ( a < 0 ) {
+        if ( m == NULL ) {
+          ca_create_mask(pe);
+          m = (boolean8_t *) pe->mask->ptr;
+        }
+        m[i] = 1;
+        a = b = 0;
+      }
+      range[2 * i]     = a;
+      range[2 * i + 1] = b;
+    }
+  }
+  return rb_ary_new3(4, LONG2NUM(w->ncol), buffer, cols, LONG2NUM(w->records));
+}
+
+static VALUE
+rb_ca_s_csv_read_body_as_string_cells (VALUE klass, VALUE text, VALUE vsep, VALUE vquote,
+                                       VALUE vncol, VALUE keep)
+{
+  return ca_csv_read_body(text, vsep, vquote, vncol, keep, ca_csv_build_string_cells);
+}
+
+static VALUE
+rb_ca_s_csv_read_body_as_const_string_columns (VALUE klass, VALUE text, VALUE vsep, VALUE vquote,
+                                               VALUE vncol, VALUE keep)
+{
+  return ca_csv_read_body(text, vsep, vquote, vncol, keep, ca_csv_build_const_string_columns);
+}
+
+void
+Init_caframe_csv_reader (void)
+{
+  rb_define_singleton_method(rb_cCArray, "__csv_read_body_as_string_cells__", rb_ca_s_csv_read_body_as_string_cells, 5);
+  rb_define_singleton_method(rb_cCArray, "__csv_read_body_as_const_string_columns__", rb_ca_s_csv_read_body_as_const_string_columns, 5);
+}