carray 3.0.6 → 3.0.7

data/ext/carray_conversion.c

@@ -195,6 +195,23 @@ ca_to_a_universal (VALUE arg)
   return Qnil;
 }
 
+/* An array with no cells still has the nesting of its axes up to the first
+   zero-length one: (3, 0) is three empty rows, (2, 0, 4) two empty rows. */
+static VALUE
+ca_to_a_empty_nesting (CArray *ca, int32_t level)
+{
+  volatile VALUE ary;
+  ca_size_t i;
+
+  ary = rb_ary_new2(ca->dim[level]);
+  if ( level < ca->ndim - 1 ) {
+    for (i=0; i<ca->dim[level]; i++) {
+      rb_ary_store(ary, i, ca_to_a_empty_nesting(ca, level + 1));
+    }
+  }
+  return ary;
+}
+
 VALUE
 rb_ca_to_a (VALUE self)
 {
@@ -203,6 +220,9 @@ rb_ca_to_a (VALUE self)
   int data_type, fast_eligible;
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ca->elements == 0 && ca->ndim > 0 ) {
+    return ca_to_a_empty_nesting(ca, 0);
+  }
   ary = rb_ca_is_empty(self) ? rb_ary_new() : rb_ary_new2(ca->dim[0]);
 
   /* Once attached, ca->ptr is a contig row-major buffer (alias for
@@ -375,6 +395,28 @@ rb_ca_convert (int argc, VALUE *argv, VALUE self)
   return obj;
 }
 
+/* The transfer of dump_binary into a String.  The String is locked while
+   the bytes go in: a view that runs Ruby to make its cells (a CAObject)
+   could otherwise resize it under the pointer being written. */
+typedef struct {
+  CArray *ca;
+  VALUE   io;
+} ca_dump_into_string_t;
+
+static VALUE
+ca_dump_into_string_body (VALUE arg)
+{
+  ca_dump_into_string_t *d = (ca_dump_into_string_t *) arg;
+  ca_copy_data(d->ca, RSTRING_PTR(d->io));
+  return Qnil;
+}
+
+static VALUE
+ca_dump_into_string_unlock (VALUE io)
+{
+  return rb_str_unlocktmp(io);
+}
+
 /* CArray#dump_binary([io]) — write self's raw element bytes to io in
  * row-major order.
  *
@@ -411,7 +453,17 @@ rb_ca_dump_binary (int argc, VALUE *argv, VALUE self)
     if ( ca_length(ca) != RSTRING_LEN(io) ) {
       rb_str_resize(io, ca_length(ca));
     }
-    ca_copy_data(ca, RSTRING_PTR(io));
+    /* the bytes are written behind Ruby's back: drop the cached code
+       range, or the string keeps answering 7-bit for any contents */
+    rb_str_modify(io);
+    {
+      ca_dump_into_string_t d;
+      d.ca = ca;
+      d.io = io;
+      rb_str_locktmp(io);
+      rb_ensure(ca_dump_into_string_body, (VALUE) &d,
+                ca_dump_into_string_unlock, io);
+    }
     break;
   case T_FILE: {
     rb_io_t *iop;
@@ -487,8 +539,10 @@ rb_ca_load_binary (VALUE self, VALUE io)
                "%s: data size mismatch (got %" PRId64 " bytes, expected %" PRId64 ")",
                ca_calling_method_name(), (ca_size_t) RSTRING_LEN(io), (ca_size_t) ca_length(ca));
     }
+    /* A copy shares the bytes until either side changes: a view that runs
+       Ruby while it stores (a CAObject) cannot then move them. */
+    io = rb_str_dup(io);
     if ( ca->data_type == CA_BOOLEAN ) {
-      io = rb_str_dup(io);
       rb_str_modify(io);
       ca_boolean_normalize_bytes(RSTRING_PTR(io), ca->elements);
     }

data/ext/carray_copy.c

@@ -61,6 +61,30 @@ ca_fill_or_detach (int n, CArray **list, VALUE (*fill)(VALUE), VALUE arg)
   }
 }
 
+typedef struct {
+  CArray **list;
+  int32_t  n;
+} ca_attach_list_arg;
+
+static VALUE
+ca_attach_list_fill (VALUE arg)
+{
+  ca_attach_list_arg *a = (ca_attach_list_arg *) arg;
+  ca_attach_all(a->list, a->n);
+  return Qnil;
+}
+
+char *
+ca_alloc_cells_then_attach (CArray *ca, int32_t n, CArray **parents)
+{
+  char *buf = ca_alloc_cells(ca);
+  ca_attach_list_arg a;
+  a.list = parents;
+  a.n    = n;
+  ca_fill_or_xfree(buf, ca_attach_list_fill, (VALUE) &a);
+  return buf;
+}
+
 VALUE
 ca_view_inherit_mask (VALUE view)
 {

data/ext/carray_core.c

@@ -954,15 +954,29 @@ ca_refuse_cells_reaching_evaluation (ca_size_t n, const VALUE *cells)
   }
 }
 
+static VALUE
+ca_computing_start (VALUE arg)
+{
+  return ca_computing_next((ca_computing_t *) arg);
+}
+
 /* Runs body(arg), a computation over ops[0..n), with each object array
    among them recorded as computed over.  Raises when one of them is
    already being computed over by the same method: a cell's value, or an
-   element's operation, led the computation back into it. */
+   element's operation, led the computation back into it.  A computation
+   over object cells calls methods of the cells, so it counts as a walk into
+   them (ca_cell_walk_run). */
 VALUE
 ca_computing_run (int n, CArray **ops, VALUE (*body)(VALUE), VALUE arg)
 {
   ca_computing_t c;
+  int k;
   c.n = n; c.ops = ops; c.kind = CA_RECURSION_COMPUTE; c.k = 0; c.body = body; c.arg = arg;
+  for (k=0; k<n; k++) {
+    if ( ops[k] && ca_is_object_type(ops[k]) ) {
+      return ca_cell_walk_run(ca_computing_start, (VALUE) &c);
+    }
+  }
   return ca_computing_next(&c);
 }
 
@@ -985,6 +999,55 @@ ca_recursion_probe (VALUE key, VALUE arg, int recursive)
   return recursive ? Qtrue : Qfalse;
 }
 
+/* A walk into the cells of an object array (#hash, #==, a nested dump) goes
+   on into any array it finds there.  An array holding itself is found by
+   the records above, but a cell can also give a new array each time it is
+   opened (a lazy expression over an array that holds it), and then the walk
+   never meets an array it has seen.  So the depth of these walks is
+   limited.  It is counted for each fiber, not in the arrays. */
+
+#define CA_CELL_NESTING_MAX 256
+
+typedef struct {
+  VALUE thread;
+  VALUE before;
+} ca_cell_nesting_t;
+
+static VALUE
+ca_cell_nesting_leave (VALUE varg)
+{
+  ca_cell_nesting_t *t = (ca_cell_nesting_t *) varg;
+  rb_thread_local_aset(t->thread, rb_intern("carray_cell_nesting"), t->before);
+  return Qnil;
+}
+
+VALUE
+ca_cell_walk_run (VALUE (*body)(VALUE), VALUE arg)
+{
+  ca_cell_nesting_t t;
+  long depth;
+
+  t.thread = rb_thread_current();
+  if ( OBJ_FROZEN(t.thread) ) {       /* it can not hold the count */
+    return body(arg);
+  }
+  t.before = rb_thread_local_aref(t.thread, rb_intern("carray_cell_nesting"));
+  depth    = NIL_P(t.before) ? 0 : FIX2LONG(t.before);
+  if ( depth >= CA_CELL_NESTING_MAX ) {
+    rb_raise(rb_eArgError, "%s: object cells nested too deep: more than %d levels",
+             ca_calling_method_name(), CA_CELL_NESTING_MAX);
+  }
+  rb_thread_local_aset(t.thread, rb_intern("carray_cell_nesting"), LONG2FIX(depth + 1));
+  return rb_ensure(body, arg, ca_cell_nesting_leave, (VALUE) &t);
+}
+
+static VALUE
+ca_yield_nil (VALUE arg)
+{
+  (void) arg;
+  return rb_yield(Qnil);
+}
+
 static VALUE
 ca_refuse_reentry_step (VALUE self, VALUE name, int recursive)
 {
@@ -993,14 +1056,14 @@ ca_refuse_reentry_step (VALUE self, VALUE name, int recursive)
     rb_raise(rb_eArgError, "%" PRIsVALUE ": cyclic reference is not allowed in CArray",
              name);
   }
-  return rb_yield(Qnil);
+  return ca_cell_walk_run(ca_yield_nil, Qnil);
 }
 
 /* refuse_reentry(name) { ... } -- runs the block, refusing as cyclic a
    second call for the same array from inside it (rb_exec_recursive, by
-   the receiver).  Ruby code that walks the cells of an object array and
-   comes back to the array through a cell, such as the nested dump of a
-   view, goes through this. */
+   the receiver), and counting it as a walk into cells.  Ruby code that
+   walks the cells of an object array and comes back to the array through a
+   cell, such as the nested dump of a view, goes through this. */
 static VALUE
 rb_ca_refuse_reentry (VALUE self, VALUE name)
 {
@@ -1015,7 +1078,7 @@ ca_test_cyclic_check (void *ap, void *ptr)
 {
   CArray *ca = (CArray *) ap;
   if ( ca_is_object_type(ca) ) {
-    VALUE rval = *(VALUE *) ptr;
+    volatile VALUE rval = *(VALUE *) ptr;
     if ( rb_obj_is_carray(rval) ) {
       CArray *cv;
       TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);

data/ext/carray_count.c

@@ -82,7 +82,7 @@ ca_count_each_body (VALUE arg)
     /* Extract vk as a scalar VALUE via flat addr.  rb_ca_fetch_addr
        takes a ca_size_t addr (not a Ruby VALUE). */
     VALUE vk = rb_ca_fetch_addr(c->rval, k);
-    VALUE sub;
+    volatile VALUE sub;
     /* A masked query cell asks nothing: its count is masked.  Passing it
        on would ask count(UNDEF), the count of self's masked cells. */
     if ( vk == CA_UNDEF ) {
@@ -154,7 +154,14 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     }
   }
 
-  volatile VALUE rval = argv[0];
+  /* true and false count the cells holding 1 and 0 of a numeric array */
+  volatile VALUE rval = ca_truth_as_number(src, argv[0]);
+  if ( rval != argv[0] ) {
+    VALUE *nargv = ALLOCA_N(VALUE, argc);
+    MEMCPY(nargv, argv, VALUE, argc);
+    nargv[0] = rval;
+    argv = nargv;
+  }
 
   /* count(UNDEF) == count_masked: UNDEF is mask-state vocabulary, not a
      value to compare against.  Forward, dropping the UNDEF from argv. */
@@ -162,6 +169,17 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     return rb_ca_count_masked(argc - 1, argv + 1, self);
   }
 
+  /* An array that can not hold the value (nil, a String) counts no cell
+     for it: the cells that matched, none, are counted the way count(true)
+     counts a mask. */
+  if ( ca_query_matches_nothing(src, rval) && ! ca_is_complex_type(src) ) {
+    VALUE *nargv = ALLOCA_N(VALUE, argc);
+    MEMCPY(nargv, argv, VALUE, argc);
+    nargv[0] = Qtrue;
+    return rb_ca_count(argc, nargv,
+                       rb_funcall(self, rb_intern("eq"), 1, rval));
+  }
+
   /* Face gate, mirroring the search / linear family (ext/carray_order.c):
      descend an ORDERABLE Face to its storage so the equality runs on the
      numeric storage, and let the reference reconcile the query into its own
@@ -284,7 +302,7 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     }
 
     /* Allocate output i64 CArray. */
-    VALUE vout = rb_funcall(rb_cCArray, rb_intern("new"), 2,
+    volatile VALUE vout = rb_funcall(rb_cCArray, rb_intern("new"), 2,
                             INT2NUM(CA_INT64),
                             rb_ary_new4(out_ndim,
                                         ({ VALUE *tmp = ALLOCA_N(VALUE, out_ndim);
@@ -348,16 +366,17 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
                iv);
     } else {
       rb_raise(rb_eTypeError,
-               "count(v) on boolean array: v must be true / false / 1 / 0, got %s",
-               rb_obj_classname(rval));
+               "count(v) on boolean array: v must be true / false / 1 / 0, got %"PRIsVALUE"",
+               rb_obj_class(rval));
     }
   } else {
-    /* true / false are the boolean array's own domain, not a number --
-       except in an object array, where they are ordinary stored values. */
+    /* An integer, float or complex array has read true / false as 1 / 0
+       above (ca_truth_as_number); an object array stores them as values.
+       Any other array that reaches here can not count them. */
     if ( ( rval == Qtrue || rval == Qfalse ) && src->data_type != CA_OBJECT ) {
       rb_raise(rb_eTypeError,
-               "count(v) on numeric array: v must be numeric, got %s",
-               rb_obj_classname(rval));
+               "count(v) on numeric array: v must be numeric, got %"PRIsVALUE"",
+               rb_obj_class(rval));
     }
     /* The query is compared in the type it and the array match in, as `eq`
        compares (ca_query_match_type): 1.5 does not match 1, and an Integer

data/ext/carray_element.c

@@ -38,22 +38,28 @@ elem_index_value (VALUE v)
   }
 }
 
+ca_size_t
+ca_index_key_value (VALUE v)
+{
+  return elem_index_value(v);
+}
+
 /* T_ARRAY index parser.  ridx is assumed already known to be T_ARRAY.
    Direct VALUE * access + FIXNUM_P fast path eliminates rb_ary_entry
    bounds check and NUM2SIZE Bignum branching for the common case. */
 static inline void
 elem_parse_idx_array (CArray *ca, VALUE rary, ca_size_t *idx)
 {
-  const VALUE *iarr;
   int8_t ndim = ca->ndim;
   int8_t i;
   if ( RARRAY_LEN(rary) != ndim ) {
     rb_raise(rb_eIndexError, "%ld indices given for a carray of ndim %i",
              (long) RARRAY_LEN(rary), (int) ndim);
   }
-  iarr = RARRAY_CONST_PTR(rary);
   for (i=0; i<ndim; i++) {
-    ca_size_t k = elem_index_value(iarr[i]);
+    /* Read each entry afresh: converting one can run Ruby that changes the
+       Array (an entry gone reads as nil, which is refused). */
+    ca_size_t k = elem_index_value(rb_ary_entry(rary, i));
     CA_CHECK_INDEX(k, ca->dim[i]);
     idx[i] = k;
   }

data/ext/carray_factorize.c

@@ -818,7 +818,7 @@ static VALUE
 fz_factorize_appearance_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
   fr->self = self = fz_face_descend(self, &face, "categorize");
@@ -843,7 +843,7 @@ fz_factorize_appearance_body (VALUE arg)
   ca_size_t N = ca->elements;
 
   /* uint32 code scratch, same shape as self; narrowed once k is known. */
-  VALUE vu32 = rb_carray_new(CA_UINT32, ca->ndim, ca->dim, 0, NULL);
+  volatile VALUE vu32 = rb_carray_new(CA_UINT32, ca->ndim, ca->dim, 0, NULL);
   CArray *cu32;
   TypedData_Get_Struct(vu32, CArray, &carray_data_type, cu32);
 
@@ -1028,7 +1028,7 @@ static VALUE
 fz_mask_duplicates_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE vaxis = fr->a;
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
@@ -1189,7 +1189,7 @@ static VALUE
 fz_unique_flat_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
   fr->self = self = fz_face_descend(self, &face, "unique");
@@ -1429,7 +1429,7 @@ static VALUE
 fz_is_in_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE rvalues = fr->a;
   CArray *ca, *cv;
   volatile VALUE face;
@@ -1592,7 +1592,7 @@ static VALUE
 fz_locate_addr_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE rref = fr->a;
   CArray *ca, *cr;
   /* Here the *reference* is the argument (self is the query being placed on
@@ -1859,7 +1859,7 @@ static VALUE
 fz_set_relation_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE rother = fr->a;
   int keep_when_hit = fr->i;
   CArray *ca, *co;
@@ -2055,7 +2055,7 @@ static VALUE
 fz_set_union_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE rother = fr->a;
   CArray *ca, *co;
   volatile VALUE face;
@@ -2149,7 +2149,7 @@ static VALUE
 fz_value_counts_flat_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
   fr->self = self = fz_face_descend(self, &face, "value_counts");
@@ -2325,7 +2325,7 @@ static VALUE
 fz_nunique_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE vaxis = fr->a;
   VALUE vkeep = fr->b;
   CArray *ca;
@@ -2472,7 +2472,7 @@ static VALUE
 fz_is_mode_body (VALUE arg)
 {
   fz_frame *fr = (fz_frame *) arg;
-  VALUE self = fr->self;
+  volatile VALUE self = fr->self;
   VALUE vaxis = fr->a;
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);

data/ext/carray_histogram.c

@@ -437,7 +437,7 @@ rb_ca_histogram_scatter_ki (VALUE self, VALUE rcounts, VALUE redges,
   }
 
   for ( k = 0; k < M; k++ ) {
-    VALUE e = RARRAY_AREF(redges, k);
+    volatile VALUE e = RARRAY_AREF(redges, k);
     GetCArray(e, edge_ca[k]);
     histbin_check_edge_mask(edge_ca[k], "histogram");
   }
@@ -528,7 +528,7 @@ bincount_nd_label_u64 (uint64_t x)
   } while (0)
 
 static VALUE
-rb_ca_bincount_nd_count_ki (VALUE self, VALUE rcounts, VALUE rweights)
+rb_ca_bincount_nd_count_ki (VALUE self, VALUE rcounts, volatile VALUE rweights)
 {
   CArray   *ca, *cc, *cw = NULL;
   long      M, nf, k;

data/ext/carray_index_classifier.c

@@ -322,15 +322,15 @@ ca_classifier_check_reserved_symbol (VALUE sym)
 {
   const char *name;
   if ( ! SYMBOL_P(sym) ) return;
-  name = rb_id2name(SYM2ID(sym));
+  name = rb_id2name(SYM2ID(sym));   /* name: its first two bytes are read at once */
   if ( name != NULL
        && name[0] != '\0' && name[1] == '\0'
        && ( ( name[0] >= 'a' && name[0] <= 'z' )
             || ( name[0] >= 'A' && name[0] <= 'Z' ) )
        && name[0] != '_' /* :_ is iterator marker, handled separately */ ) {
     rb_raise(rb_eIndexError,
-             "symbol :%s is reserved",
-             name);
+             "symbol :%"PRIsVALUE" is reserved",
+             rb_sym2str(sym));
   }
 }
 
@@ -1005,7 +1005,7 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
      also fall through here and are raised later by the per-axis
      dispatcher's SYMBOL_P branch. */
   if ( SYMBOL_P(argv[0]) ) {
-    const char *name = rb_id2name(SYM2ID(argv[0]));
+    const char *name = rb_id2name(SYM2ID(argv[0]));   /* name: read at once by strlen */
     if ( name != NULL && strlen(name) > 1 ) {
       info->type   = CA_REG_METHOD_CALL;
       info->symbol = argv[0];
@@ -1069,7 +1069,7 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
    downstream introspection. */
 
 static VALUE
-rb_ca_s_scan_index_v2 (VALUE self, VALUE rdim, VALUE ridx)
+rb_ca_s_scan_index_v2 (VALUE self, VALUE rdim, volatile VALUE ridx)
 {
   CAIndexInfo info;
   ca_size_t   dim[CA_RANK_MAX];
@@ -1079,6 +1079,8 @@ rb_ca_s_scan_index_v2 (VALUE self, VALUE rdim, VALUE ridx)
 
   Check_Type(rdim, T_ARRAY);
   Check_Type(ridx, T_ARRAY);
+  /* Converting an entry can run Ruby that changes the Array: read a copy. */
+  ridx = rb_ary_dup(ridx);
 
   ndim = (int) RARRAY_LEN(rdim);
   elements = 1;

data/ext/carray_internal.h

@@ -24,6 +24,8 @@
 #ifndef CARRAY_INTERNAL_H
 #define CARRAY_INTERNAL_H
 
+#include "ruby/thread_native.h"   /* rb_nativethread_lock_t */
+
 #include "carray.h"
 #include <math.h>     /* isnan, for CA_OBJ_ISNAN */
 
@@ -85,6 +87,7 @@ void    ca_lazy_arena_enter   (void);
 void    ca_lazy_arena_exit    (void);
 void   *ca_lazy_arena_acquire (ca_size_t bytes);
 void   *ca_lazy_arena_acquire_object (ca_size_t n_elements);
+void         ca_lazy_arena_untag_objects (void *ptr);
 void    ca_lazy_arena_release (void *ptr);
 VALUE   ca_lazy_arena_protect (VALUE (*body)(VALUE),
                                VALUE (*cleanup)(VALUE), VALUE arg);
@@ -145,6 +148,18 @@ ca_boolean_normalize_bytes (void *ptr, ca_size_t n)
   }
 }
 
+/* A buffer for n cells of data_type, each bytes long: object cells start
+   as nil. */
+static inline char *
+ca_alloc_cells_of (int8_t data_type, ca_size_t elements, ca_size_t bytes)
+{
+  char *p = (char *) xmalloc(elements > 0 ? elements * bytes : 1);
+  if ( data_type == CA_OBJECT ) {
+    ca_object_cells_clear(p, elements);
+  }
+  return p;
+}
+
 static inline char *
 ca_alloc_cells (const CArray *ca)
 {
@@ -237,6 +252,17 @@ void    ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg);
 void    ca_fill_or_xfree  (void *buf, VALUE (*fill)(VALUE), VALUE arg);
 void    ca_fill_or_detach (int n, CArray **list, VALUE (*fill)(VALUE), VALUE arg);
 
+/* The buffer of a view's own cells, for an attach or allocate slot that
+   attaches parents[0..n-1] and then works in a buffer of its own.  The
+   buffer is allocated before the parents are attached, and freed if
+   attaching them raises: a slot that raises before it publishes ca->ptr
+   gives ca_attach no detach slot to call, and a parent left attached keeps
+   reading and writing the copy it materialised instead of its root.  The
+   caller publishes the result as ca->ptr.  utils/check_attach_then_alloc.rb
+   finds a slot that allocates after attaching. */
+
+char   *ca_alloc_cells_then_attach (CArray *ca, int32_t n, CArray **parents);
+
 /* A view takes its parent's mask by asking the parent whether it has one,
    and a parent that is a CAObject answers in Ruby and can raise.  A view's
    setup therefore does not ask: its constructor calls this under
@@ -360,6 +386,7 @@ VALUE   ca_lazy_settle_scalar (VALUE operand, int was_scalar);
    of one view all take the same branch. */
 
 int     ca_parent_lends_no_memory (void *ap);
+void    rb_ca_cast_three (volatile VALUE *v1, volatile VALUE *v2, volatile VALUE *v3);
 
 /* Transfers of the descriptor views (CAGrid, CASelect, CASelectAxis,
    CAWindow) whose parent holds no ptr (ca_axis_dispatch.c).
@@ -433,6 +460,13 @@ CAReduce *ca_reduce_new (CArray *carray, ca_size_t count, ca_size_t offset);
 void     ca_broadcast_to_destination (VALUE dst, volatile VALUE *src);
 VALUE    rb_ary_flatten_for_elements (VALUE ary, ca_size_t elements, void *ap);
 
+/* carray_access.c */
+void ca_refuse_complex_into_real (CArray *ca, CArray *cv);
+
+/* carray_cast.c */
+void ca_cast_block_skip_masked (ca_size_t n, void *ap1, void *ptr1,
+                                void *ap2, void *ptr2, boolean8_t *m);
+
 /* carray_utils.c */
 const char *ca_calling_method_name (void);
 VALUE       ca_answer_as_caller (VALUE (*body)(VALUE), VALUE arg);
@@ -440,13 +474,26 @@ long        ca_integer_arg (VALUE v, const char *arg, const char *name);
 /* 1 with the position of an index key (an Integer, or a Float with no
    fraction while exact), 2 for an Integer past int64, 0 otherwise. */
 int         ca_index_key_position (VALUE v, ca_size_t *out);
+ca_size_t   ca_index_key_value (VALUE v);
 void        ca_refuse_without_common_type (VALUE self, VALUE other);
 ca_size_t   ca_shape_elements (int8_t ndim, const ca_size_t *dim, ca_size_t bytes);
 void        ca_check_index_array (VALUE v);
 VALUE       ca_order_key (VALUE v, const char *name);
 void        ca_check_integer_fits (VALUE v, int8_t data_type);
 VALUE       ca_obj2integer_fitting (VALUE v, int8_t data_type);
+/* A Ruby value stored into an integer cell of `dst`: refused when it does
+   not fit (ca_obj2integer_fitting), except into the cells of a bit field
+   view (ca_bitfield_beneath), which keep it modulo 2 ** bits
+   (ca_integer_wrap_bits). */
+VALUE       ca_obj2integer_store (CArray *dst, VALUE v, int8_t data_type);
+CArray     *ca_bitfield_beneath (CArray *ca);
+VALUE       ca_bitfield_wrap_integer (CArray *ca, VALUE v);
+/* v as an Integer modulo 2 ** bits; with sign_extend, in
+   -2 ** (bits - 1) ... 2 ** (bits - 1) - 1.  A String is read as a
+   decimal integer, any other value through Integer() (1.5 is 1). */
+VALUE       ca_integer_wrap_bits (VALUE v, int bits, int sign_extend);
 int         ca_integer_range_side (VALUE v, int8_t data_type);
+int         ca_obj_number_fits_integer (VALUE v, int8_t data_type);
 int         ca_bincmp_integer_prepare (volatile VALUE *self, volatile VALUE *other,
                                        int op_id, int *signed_side);
 int         ca_bincmp_answer_when_negative (int op_id, int signed_side);
@@ -481,6 +528,11 @@ VALUE ca_computing_run_nodes (int n, CArray **ops, VALUE (*body)(VALUE), VALUE a
 /* Refuses as cyclic a cell among cells[0..n) that is an array reaching a
    lazy node being evaluated: computing it would come back into the node. */
 void  ca_refuse_cells_reaching_evaluation (ca_size_t n, const VALUE *cells);
+/* Runs body(arg), a walk into the cells of an object array, one level deeper
+   in this fiber; past the limit it raises ArgumentError.  A cell can give a
+   new array each time it is opened, which the records above never meet
+   twice. */
+VALUE ca_cell_walk_run (VALUE (*body)(VALUE), VALUE arg);
 
 /* Registers a view type whose transfers only move cells between its parents
    and the caller (an index view: CAGrid, CASelect, CAWindow, CAStack, ...),
@@ -845,6 +897,40 @@ ca_query_match_applies (CArray *ref, VALUE query)
   return 1;
 }
 
+/* A Ruby value an integer, float, complex or boolean array can not hold:
+   anything but a Numeric, true, false and UNDEF that does not make an
+   array (an Array, a #to_ca, a memory view).  nil, a String, a Symbol and
+   other objects are foreign.  An object or fixlen array and a Face hold or
+   read such values, so nothing is foreign to them (ca_cast.c). */
+int     ca_value_foreign_to (CArray *ca, VALUE v);
+
+/* An operator refuses a foreign value as Float#+ does (TypeError), and an
+   ordering refuses it as Float#< does (ArgumentError).  `array` is the
+   CArray operand (ca_cast.c). */
+void    ca_refuse_foreign_operand (VALUE v, VALUE array);
+void    ca_refuse_foreign_order (VALUE v, VALUE array);
+
+/* true and false as the numbers 1 and 0 for a value query on an integer,
+   float or complex array; any other value, or array, is returned as is
+   (ca_cast.c). */
+VALUE   ca_truth_as_number (CArray *ca, VALUE v);
+
+/* eq / ne when no cell can match (carray_operator.c). */
+VALUE   ca_bincmp_no_match (VALUE self, int ne);
+
+/* A value an array can not hold matches no cell as a value query: eq, ne,
+   count and search answer as they do for an Integer outside the array's
+   type.  nil is such a value for every array but an object one, which
+   holds nil and is asked. */
+static inline int
+ca_query_matches_nothing (CArray *ca, VALUE query)
+{
+  if ( NIL_P(query) ) {
+    return ca->data_type != CA_OBJECT;
+  }
+  return ca_value_foreign_to(ca, query);
+}
+
 /* Equality of two object cells, as the float lanes answer it: Ruby's `==`,
    except that a Float NaN equals nothing, itself included.  rb_equal alone
    answers true for the same object, so whether two NaN cells matched would
@@ -986,4 +1072,12 @@ int  ca_index_key_is_scalar (VALUE arg);
 /* Whether this runs in the main Ractor (carray_utils.c). */
 int ca_in_main_ractor (void);
 
+/* Take a native lock that guards a table shared by every Ractor, waiting
+   without the GVL (carray_utils.c).  A Ractor that waits for the lock while
+   it holds its GVL cannot stop for a GC, so one that holds the lock and
+   allocates (a GC) would wait for it, and it for the lock.  The lock is only
+   ever taken outside the wait, so an interrupt that raises there leaves it
+   free.  The lock must not be held across a call that can raise. */
+void ca_native_lock_without_gvl (rb_nativethread_lock_t *lock);
+
 #endif /* CARRAY_INTERNAL_H */