carray 3.0.3 → 3.0.5

data/ext/ca_obj_refer.c

@@ -74,10 +74,10 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca_size_t s;
   int8_t i;
 
-  CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(ndim);
-  CA_CHECK_DIM(ndim, dim);
-  CA_CHECK_BYTES(data_type, bytes);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
+  CA_CHECK_RANK_GIVEN(ndim);
+  CA_CHECK_DIM_GIVEN(ndim, dim);
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
 
   /* An object cell is a VALUE the GC marks: reading other bytes as one
      marks garbage, and reading one as bytes exposes an address. */
@@ -89,6 +89,14 @@ ca_refer_setup (CARefer *ca, CArray *parent,
     rb_raise(rb_eCADataTypeError,
              "non-object array can't be referred as object data type");
   }
+  /* A boolean cell holds 0 or 1, and a view that reads other bytes as
+     boolean cannot keep them so: the parent is written as what it is. */
+  if (data_type == CA_BOOLEAN && parent->data_type != CA_BOOLEAN) {
+    rb_raise(rb_eCADataTypeError,
+             "%s: a %s array can't be referred as boolean (its bytes need not "
+             "be 0 or 1); compare it instead, e.g. ne(0)",
+             ca_calling_method_name(), ca_type_name[parent->data_type]);
+  }
   if (parent->elements && bytes > parent_bytes * parent->elements) {
     rb_raise(rb_eArgError, "bytes exceeds the data size of referent");
   }
@@ -129,16 +137,17 @@ ca_refer_setup (CARefer *ca, CArray *parent,
     return 0;
   }
 
-  /* CAREFUL: initialise mask0 before ca_stride_setup — the setup
-     may dispatch to ca_refer_func_create_mask, which writes to
-     mask0.  Leaving it uninitialised risks freeing a garbage
-     pointer during error unwind. */
+  /* mask0 is written by ca_refer_func_create_mask when the constructor
+     takes the parent's mask, and freed on error unwind, so it starts
+     NULL. */
   ca->mask0 = NULL;
 
-  ca_stride_setup((CAStride *) ca, CA_OBJ_REFER, parent,
-                  data_type, bytes, ndim, dim, strides, base_offset);
+  ca_stride_setup_view((CAStride *) ca, CA_OBJ_REFER, parent,
+                       data_type, bytes, ndim, dim, strides, base_offset);
 
-  if (ca_is_scalar(parent)) {
+  /* A refer of a scalar stays one only while it has the one cell: read as
+     narrower elements it is an array of several. */
+  if (ca_is_scalar(parent) && ca->elements == 1) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
   return 0;
@@ -153,6 +162,7 @@ ca_refer_new (CArray *parent,
   ca_refer_setup(NULL, parent, data_type, ndim, dim, bytes, offset);
   ca = (CARefer *) ca_array_alloc(CA_OBJ_REFER, ndim);
   ca_refer_setup(ca, parent, data_type, ndim, dim, bytes, offset);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -203,16 +213,20 @@ ca_refer_func_create_mask (void *ap)
   else if (ca->bytes < parent_bytes) {
     /* Divided reinterpret: one parent element splits into
        ratio = parent_bytes / bytes view elements.  Build a
-       CARepeat that broadcasts each parent mask bit across the
-       ratio sub-positions, then refer-reshape it to the view's
-       actual shape. */
+       repeat of two axes, (parent elements, ratio), that broadcasts
+       each parent mask bit across the ratio sub-positions, then
+       refer-reshape it to the view's actual shape.  Two axes whatever
+       the parent's rank, so a parent at CA_RANK_MAX needs no extra
+       one. */
     ca_size_t ratio = parent_bytes / ca->bytes;
-    ca_size_t count[CA_RANK_MAX];
-    int8_t i;
-    for (i = 0; i < ca->parent->ndim; i++) count[i] = 0;
-    count[ca->parent->ndim] = ratio;
+    ca_size_t mdim[2], mstrides[2];
+    mdim[0]     = ca->parent->elements;
+    mdim[1]     = ratio;
+    mstrides[0] = 1;
+    mstrides[1] = 0;
     ca->mask0 =
-      (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim + 1, count);
+      (CArray *) ca_stride_new(CA_OBJ_REPEAT, ca->parent->mask, CA_BOOLEAN, 1,
+                               2, mdim, mstrides, 0);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
     /* mask0 has ratio cells per parent element, so the offset is counted
        in those. */
@@ -260,6 +274,7 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
      unusual mod-bytes alignments. */
   ca_refer_setup(ca, cs->parent, cs->data_type, cs->ndim, cs->dim,
                  cs->bytes, cs->base_offset / cs->parent->bytes);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -488,7 +503,7 @@ rb_ca_refer_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
       }
     }
     Check_Type(rdim, T_ARRAY);
-    CA_CHECK_RANK(RARRAY_LEN(rdim));   /* before dim[] is filled */
+    CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));   /* before dim[] is filled */
     ndim = RARRAY_LEN(rdim);
     for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
     if (! NIL_P(roffset)) offset = NUM2SIZE(roffset);
@@ -610,9 +625,10 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if (argc < 0 || argc > CA_RANK_MAX) {
-    rb_raise(rb_eArgError, "reshape: invalid number of dims (%d)", argc);
+  if ( argc == 0 ) {
+    rb_raise(rb_eArgError, "reshape: give at least one axis");
   }
+  ca_check_rank_fits(argc, "reshape");
 
   /* Locate the (at most one) auto-infer placeholder.  `-1` is the
      conventional spelling; `:~` is the unified auto-fill sigil
@@ -775,7 +791,7 @@ rb_ca_flatten (VALUE self)
      before axis 0 twice              -> [1, 1, 2, 3]
 
    Returns a CARefer view (zero-copy alias to +self+'s data, via reshape).
-   Bound to the internal name __insert_axis_size1__; the user-facing
+   Bound to the private method insert_size_one_axes; the user-facing
    insert_axis (with the repeat: keyword) is the Ruby method in
    lib/carray/basics.rb, which builds on this primitive.
 
@@ -795,11 +811,7 @@ rb_ca_insert_axis (int argc, VALUE *argv, VALUE self)
 
   ndim     = (int) ca->ndim;
   new_ndim = ndim + argc;
-  if (new_ndim > CA_RANK_MAX) {
-    rb_raise(rb_eArgError,
-             "insert_axis: resulting ndim %d exceeds CA_RANK_MAX %d",
-             new_ndim, CA_RANK_MAX);
-  }
+  ca_check_rank_fits(new_ndim, "insert_axis");
 
   ngap = ndim + 1;   /* gaps live in [0, ndim] (ndim = the end gap) */
 
@@ -809,12 +821,7 @@ rb_ca_insert_axis (int argc, VALUE *argv, VALUE self)
     gap_count[i] = 0;
   }
   for (i = 0; i < argc; i++) {
-    int raw = (int) ca_axis_integer(argv[i], "insert_axis");
-    int g   = (raw < 0) ? raw + ngap : raw;
-    if (g < 0 || g >= ngap) {
-      rb_raise(rb_eArgError,
-               "insert_axis: axis %d out of range for ndim %d", raw, ndim);
-    }
+    int g = ca_normalize_axis_arg(argv[i], ngap, "insert_axis");
     gap_count[g]++;
   }
 
@@ -858,7 +865,7 @@ Init_ca_obj_refer (void)
   /* The bare size-1 primitive.  The user-facing `insert_axis` (with its
      `repeat:` keyword) is the Ruby method in lib/carray/basics.rb, which
      owns the name and calls this primitive. */
-  rb_define_method(rb_cCArray, "__insert_axis_size1__", rb_ca_insert_axis, -1);
+  rb_define_private_method(rb_cCArray, "insert_size_one_axes", rb_ca_insert_axis, -1);
   rb_define_alloc_func(rb_cCARefer, rb_ca_refer_s_allocate);
   rb_define_method(rb_cCARefer, "initialize_copy",
                                        rb_ca_refer_initialize_copy, 1);

data/ext/ca_obj_remap.c

@@ -129,6 +129,12 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
 {
   ca_remap_check_constraints(ref, idx);
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_REMAP;
   ca->data_type = ref->data_type;
   ca->flags     = 0;
@@ -147,9 +153,6 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
   ca->nosync    = 0;
   ca->idx       = idx;
 
-  if ( ca_has_mask(ref) ) {
-    ca_create_mask(ca);
-  }
 
   if ( ca_is_scalar(ref) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -161,8 +164,11 @@ ca_remap_setup (CARemap *ca, CArray *ref, CArray *idx)
 CARemap *
 ca_remap_new (CArray *ref, CArray *idx)
 {
-  CARemap *ca = (CARemap *) ca_array_alloc(CA_OBJ_REMAP, ref->ndim);
+  CARemap *ca;
+  ca_remap_setup(NULL, ref, idx);
+  ca = (CARemap *) ca_array_alloc(CA_OBJ_REMAP, ref->ndim);
   ca_remap_setup(ca, ref, idx);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -211,7 +217,7 @@ static void
 ca_remap_func_allocate (void *ap)
 {
   CARemap *ca = (CARemap *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -435,8 +441,9 @@ rb_ca_remap_new (VALUE cary, VALUE rmapper)
 }
 
 /* Read-only accessor for the per-cell index CArray that defines this
-   CARemap's mapping.  Returns the same CArray VALUE the caller passed
-   to ca[mapper] (= shared reference, not a copy).  Companion to
+   CARemap's mapping: the array the view reads.  For ca[mapper] it is a
+   copy of mapper taken at the call, so a later change to mapper does
+   not reach the view.  Companion to
    CABlock#start / CAStride#strides / CAWindow#count etc. — the view
    hierarchy is preserved so each named view class exposes its own
    defining semantic state. */
@@ -453,8 +460,22 @@ rb_ca_remap_mapper (VALUE self)
 static VALUE
 rb_ca_remap_dup (VALUE self)
 {
-  return rb_ca_remap_new(rb_ca_parent(self),
-                         rb_ivar_get(self, rb_intern("remap_idx")));
+  volatile VALUE rmapper = rb_ivar_get(self, rb_intern("remap_idx"));
+  if ( NIL_P(rmapper) ) {
+    /* The mask of a CARemap (it holds no index array of its own): another
+       remap over the same parent mask and index.  The array it is the mask
+       of keeps both alive, so the copy holds that array too. */
+    volatile VALUE obj;
+    CArray *ca, *cp;
+    TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+    cp = (CArray *) ca_remap_func_clone(ca);
+    ca_keep_chain_flags(cp, ca);
+    obj = TypedData_Wrap_Struct(rb_obj_class(self), &caremap_data_type, cp);
+    rb_ivar_set(obj, rb_intern("masked_array"),
+                rb_ivar_get(self, rb_intern("masked_array")));
+    return obj;
+  }
+  return rb_ca_remap_new(rb_ca_parent(self), rmapper);
 }
 
 static VALUE

data/ext/ca_obj_repeat.c

@@ -39,9 +39,7 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
   int8_t data_ndim = 0;
   int8_t i, j;
 
-  if ( ndim < 0 || ndim > CA_RANK_MAX ) {
-    rb_raise(rb_eArgError, "invalid ndim %d", (int) ndim);
-  }
+  ca_check_rank_fits(ndim, NULL);
   for (i = 0; i < ndim; i++) {
     if (count[i] < 0) {
       rb_raise(rb_eArgError,
@@ -86,9 +84,9 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
     return 0;
   }
 
-  ca_stride_setup(ca, CA_OBJ_REPEAT, parent,
-                  parent->data_type, parent->bytes,
-                  ndim, newdim, strides, 0);
+  ca_stride_setup_view(ca, CA_OBJ_REPEAT, parent,
+                       parent->data_type, parent->bytes,
+                       ndim, newdim, strides, 0);
 
   ca_set_flag(ca, CA_FLAG_READ_ONLY);
   if (ca->mask) {
@@ -104,6 +102,7 @@ ca_repeat_new (CArray *parent, int8_t ndim, ca_size_t *count)
   ca_repeat_setup(NULL, parent, ndim, count);
   ca = (CAStride *) ca_array_alloc(CA_OBJ_REPEAT, ndim);
   ca_repeat_setup(ca, parent, ndim, count);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -216,12 +215,12 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
         self = rb_ca_refer_new(self, ca->data_type, ndim, dim, ca->bytes, 0);
       }
     }
-    return rb_ca_repeat((int)RARRAY_LEN(args), (VALUE *)RARRAY_CONST_PTR(args), self);
+    self = rb_ca_repeat((int)RARRAY_LEN(args), (VALUE *)RARRAY_CONST_PTR(args), self);
+    RB_GC_GUARD(args);   /* the repeat reads its arguments out of args */
+    return self;
   }
 
-  if ( argc > CA_RANK_MAX ) {         /* count[] and dim[] hold CA_RANK_MAX */
-    rb_raise(rb_eArgError, "invalid ndim %d", argc);
-  }
+  ca_check_rank_fits(argc, NULL);     /* count[] and dim[] hold CA_RANK_MAX */
 
   repeat = 1;
   for (i=0; i<argc; i++) {

data/ext/ca_obj_roll.c

@@ -112,6 +112,8 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->reps      = NULL;               /* set before either allocation can raise */
+  ca->dim       = NULL;
   ca->reps      = ALLOC_N(ca_size_t, ndim);  /* repurposed as shift[] */
   ca->dim       = ALLOC_N(ca_size_t, ndim);
 
@@ -126,21 +128,37 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
     ca->reps[i] = s;
   }
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
 
   return 0;
 }
 
+typedef struct {
+  CARoll    *ca;
+  CArray    *parent;
+  ca_size_t *shift;
+} ca_roll_new_arg;
+
+static VALUE
+ca_roll_new_setup (VALUE varg)
+{
+  ca_roll_new_arg *a = (ca_roll_new_arg *) varg;
+  ca_roll_setup(a->ca, a->parent, a->shift);
+  return Qnil;
+}
+
+/* The setup allocates reps and dim after the struct: when either fails,
+   the struct goes too. */
 CARoll *
 ca_roll_new (CArray *parent, ca_size_t *shift)
 {
-  CARoll *ca;
+  ca_roll_new_arg a;
   ca_roll_setup(NULL, parent, shift);
-  ca = ALLOC(CARoll);
-  ca_roll_setup(ca, parent, shift);
-  return ca;
+  a.ca     = ALLOC(CARoll);
+  a.parent = parent;
+  a.shift = shift;
+  ca_fill_or_free((CArray *) a.ca, ca_roll_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_view_inherit_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -261,6 +279,7 @@ ca_roll_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_size_t idx[CA_RANK_MAX], doff = 0, base = 0;
     for (k = 0; k < ndim; k++) base += starts[k] * rnative[k];
     for (k = 0; k < ndim; k++) idx[k] = 0;
+    /* empty: the slot returns on an empty region at its entry */
     while (1) {
       ca_size_t roff = base, ridx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) roff += idx[k] * strides[k];
@@ -364,6 +383,7 @@ ca_roll_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   }
 
   for (k = 0; k < ndim; k++) o[k] = 0;
+  /* empty: the slot returns on an empty region at its entry */
   while (1) {
     ca_size_t pbase = 0, doff = 0, i;
     for (k = 0; k < inner; k++) {
@@ -506,7 +526,7 @@ ca_roll_func_allocate (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -514,7 +534,7 @@ ca_roll_func_attach (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_roll_iterate_regions(ca, ca->ptr, 0);
 }
 
@@ -629,7 +649,7 @@ rb_ca_roll (int argc, VALUE *argv, VALUE self)
   }
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( i < argc ) {
-      shift[i] = NUM2SIZE(argv[i]);
+      shift[i] = ca_integer_arg(argv[i], "a shift", NULL);
     } else {
       shift[i] = 0;
     }
@@ -659,6 +679,7 @@ rb_ca_roll_initialize_copy (VALUE self, VALUE other)
   ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CARoll, &caroll_data_type, cs);
   ca_roll_setup(ca, cs->parent, cs->reps);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 

data/ext/ca_obj_select.c

@@ -130,7 +130,8 @@ ca_select_snapshot (CArray *select)
 
 /* Set up the view over `parent` from an owned selector snapshot (see
    ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
-   parent order).  Does not raise. */
+   parent order).  Raises only when the indices cannot be allocated, after
+   every field free_ca_select reads is set. */
 static int
 ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
 {
@@ -162,15 +163,19 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
       if ( s[i] ) count++;
     }
     ca->elements = count;
-    /* Placeholder 1-element allocation when count == 0 to avoid
-       malloc(0) implementation variance; the engine treats
-       elements==0 as a no-op so the contents are irrelevant. */
-    ca->indices  = (ca_size_t *) xmalloc(
-                     sizeof(ca_size_t) * (count > 0 ? count : 1));
+    /* One slot more than count: the loop below writes every position
+       and advances only on TRUE, so a run of FALSE after the last TRUE
+       writes slot `count`.  Writing without a branch keeps a selector
+       with TRUE and FALSE mixed at random from mispredicting on most
+       cells.  The extra slot also keeps count == 0 from malloc(0). */
+    ca->indices  = (ca_size_t *) xmalloc(sizeof(ca_size_t) * (count + 1));
     {
-      ca_size_t j = 0;
-      for (i = 0; i < ca->select->elements; i++) {
-        if ( s[i] ) ca->indices[j++] = i;
+      ca_size_t *ix = ca->indices;
+      ca_size_t n   = ca->select->elements;
+      ca_size_t j   = 0;
+      for (i = 0; i < n; i++) {
+        ix[j] = i;
+        j += ( s[i] != 0 );
       }
     }
     /* Constant-step detection: promotes to STRIDE descriptor kind
@@ -207,13 +212,42 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
   return 0;
 }
 
+typedef struct {
+  CASelect *ca;
+  CArray   *parent;
+  CArray   *snapshot;
+} ca_select_new_arg;
+
+static VALUE
+ca_select_new_alloc (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  a->ca = ALLOC(CASelect);
+  return Qnil;
+}
+
+static VALUE
+ca_select_new_setup (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  ca_select_setup(a->ca, a->parent, a->snapshot);
+  return Qnil;
+}
+
+/* The struct and the indices are allocated after the snapshot.  When the
+   struct cannot be allocated the snapshot goes; when the indices cannot,
+   the struct goes and takes the snapshot with it (the setup stores the
+   snapshot before it allocates the indices). */
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
-  CArray *snapshot = ca_select_snapshot(select);
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, snapshot);
-  return (CArray*) ca;
+  ca_select_new_arg a;
+  a.parent   = parent;
+  a.snapshot = ca_select_snapshot(select);
+  /* check: the setup checks nothing */
+  ca_fill_or_free(a.snapshot, ca_select_new_alloc, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_select_new_setup, (VALUE) &a);
+  return (CArray*) a.ca;
 }
 
 /* Alias for source compatibility.  Both constructors produce a
@@ -431,7 +465,7 @@ ca_select_func_allocate (void *ap)
   if ( ! ca_parent_lends_no_memory(ca->parent) ) {
     ca_attach(ca->parent);
   }
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void

data/ext/ca_obj_select_axis.c

@@ -311,6 +311,7 @@ ca_select_axis_new (CArray *parent, int8_t indirect_axis,
                     CArray *selector,
                     ca_size_t *ap_start, ca_size_t *ap_count, ca_size_t *ap_step)
 {
+  /* check: the callers (clone, create_mask) pass an existing view's checked selector */
   CASelectAxis *ca = (CASelectAxis *) ca_array_alloc(CA_OBJ_SELECT_AXIS, parent->ndim);
   ca_select_axis_setup(ca, parent, indirect_axis, selector,
                        ap_start, ap_count, ap_step);
@@ -590,6 +591,7 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_size_t idx[CA_RANK_MAX], doff = 0, base = 0;
     for (k = 0; k < ndim; k++) base += starts[k] * cnative[k];
     for (k = 0; k < ndim; k++) idx[k] = 0;
+    /* empty: the slot returns on an empty region at its entry */
     while (1) {
       ca_size_t coff = base, cidx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) coff += idx[k] * strides[k];
@@ -673,6 +675,7 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
      ca_xfer_stride/ca_xfer_addrs. */
   for (k = 0; k < ndim; k++) o[k] = 0;
 
+  /* empty: the slot returns on an empty region at its entry */
   while (1) {
     ca_size_t pbase = 0, doff = 0;
     for (k = 0; k < inner; k++) {
@@ -725,7 +728,7 @@ ca_select_axis_func_allocate (void *ap)
   if ( ! ca_parent_lends_no_memory(ca->parent) ) {
     ca_attach(ca->parent);
   }
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -895,6 +898,7 @@ rb_ca_select_axis_s_new_debug (VALUE klass, VALUE rparent, VALUE rindirect,
                                 VALUE rap_count, VALUE rap_step)
 {
   CArray *parent, *selector;
+  /* fits: an axis number from the view that made it */
   int8_t indirect_axis = (int8_t) NUM2INT(rindirect);
   int8_t ndim;
   int8_t k;
@@ -966,15 +970,15 @@ rb_ca_select_axis_eligible_p (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   if ( argc != ca->ndim ) return 0;
 
-  /* axis 0 is the boolean (indirect).  Walk rest; require nil/Integer/Range. */
+  /* axis 0 is the boolean (indirect).  The rest are read as the indexer
+     reads them; a run of more than one step, or of no cells, goes to
+     CAGrid. */
   for ( i = 1; i < argc; i++ ) {
     VALUE arg = argv[i];
-    if ( NIL_P(arg) ) continue;
-    if ( FIXNUM_P(arg) ) continue;
-    if ( TYPE(arg) == T_DATA ) return 0;   /* CArray at axis > 0 → bail */
-    if ( rb_obj_is_kind_of(arg, rb_cRange) ) continue;
-    if ( rb_obj_is_kind_of(arg, rb_cInteger) ) continue;
-    return 0;
+    ca_size_t start, count, step;
+    if ( rb_obj_is_carray(arg) ) return 0;   /* CArray at axis > 0 → bail */
+    ca_index_axis_key(arg, ca->dim[i], i, &start, &count, &step);
+    if ( step != 1 || count < 1 ) return 0;
   }
 
   return 1;
@@ -1006,45 +1010,9 @@ rb_ca_select_axis (int argc, VALUE *argv, VALUE self)
   for ( i = 0; i < argc; i++ ) {
     VALUE arg = argv[i];
 
-    if ( NIL_P(arg) ) {
-      ap_start[i] = 0;
-      ap_count[i] = parent->dim[i];
-      ap_step[i]  = 1;
-    }
-    else if ( FIXNUM_P(arg) || rb_obj_is_kind_of(arg, rb_cInteger) ) {
-      ca_size_t n = NUM2LL(arg);
-      if ( n < 0 ) n += parent->dim[i];
-      if ( n < 0 || n >= parent->dim[i] ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: index %lld out of range at axis %d",
-                 (long long) n, i);
-      }
-      ap_start[i] = n;
-      ap_count[i] = 1;
-      ap_step[i]  = 1;
-    }
-    else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
-      VALUE rfirst = rb_funcall(arg, rb_intern("first"), 0);
-      VALUE rlast  = rb_funcall(arg, rb_intern("last"),  0);
-      int exclusive = RTEST(rb_funcall(arg, rb_intern("exclude_end?"), 0));
-      ca_size_t a = NUM2LL(rfirst);
-      ca_size_t b = NUM2LL(rlast);
-      if ( a < 0 ) a += parent->dim[i];
-      if ( b < 0 ) b += parent->dim[i];
-      ca_size_t cnt = exclusive ? (b - a) : (b - a + 1);
-      if ( cnt <= 0 ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: empty range at axis %d", i);
-      }
-      if ( a < 0 || a >= parent->dim[i] ||
-           (a + cnt - 1) < 0 || (a + cnt - 1) >= parent->dim[i] ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: range [%lld..%lld] out of bounds at axis %d",
-                 (long long) a, (long long) (a + cnt - 1), i);
-      }
-      ap_start[i] = a;
-      ap_count[i] = cnt;
-      ap_step[i]  = 1;
+    if ( ! rb_obj_is_carray(arg) ) {
+      ca_index_axis_key(arg, parent->dim[i], i,
+                        &ap_start[i], &ap_count[i], &ap_step[i]);
     }
     else if ( rb_obj_is_carray(arg) && rb_ca_is_boolean_type(arg) ) {
       TypedData_Get_Struct(arg, CArray, &carray_data_type, selector);