carray 3.0.4 → 3.0.5

data/ext/ca_obj_array.c

@@ -144,7 +144,6 @@ carray_setup_i (CArray *ca,
                 CArray *mask, int allocate, int use_calloc, char *adopt_ptr)
 {
   ca_size_t elements;
-  int8_t i;
   ca_size_t k;
 
   /* check arguments */
@@ -295,26 +294,54 @@ carray_new_with_mask (CArray *ca, CArray *mask)
   return ca;
 }
 
+typedef struct {
+  CArray    *ca;
+  int8_t     data_type;
+  int8_t     ndim;
+  ca_size_t *dim;
+  ca_size_t  bytes;
+  int        use_calloc;
+} carray_new_arg;
+
+static VALUE
+carray_new_setup (VALUE varg)
+{
+  carray_new_arg *a = (carray_new_arg *) varg;
+  carray_setup_i(a->ca, a->data_type, a->ndim, a->dim, a->bytes, NULL,
+                 1, a->use_calloc, NULL);
+  return Qnil;
+}
+
+/* The setup allocates the cells, after the struct: when that fails, the
+   struct goes too. */
+static CArray *
+carray_new_i (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
+              CArray *mask, int use_calloc)
+{
+  carray_new_arg a;
+  carray_setup_i(NULL, data_type, ndim, dim, bytes, NULL, 1, use_calloc, NULL);
+  a.ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
+  a.data_type = data_type;
+  a.ndim = ndim;
+  a.dim = dim;
+  a.bytes = bytes;
+  a.use_calloc = use_calloc;
+  ca_fill_or_free(a.ca, carray_new_setup, (VALUE) &a);
+  return carray_new_with_mask(a.ca, mask);
+}
+
 CArray *
 carray_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
-  CArray *ca;
-  carray_setup(NULL, data_type, ndim, dim, bytes, NULL);
-  ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_setup(ca, data_type, ndim, dim, bytes, NULL);
-  return carray_new_with_mask(ca, mask);
+  return carray_new_i(data_type, ndim, dim, bytes, mask, 0);
 }
 
 CArray *
 carray_new_safe (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
-  CArray *ca;
-  carray_safe_setup(NULL, data_type, ndim, dim, bytes, NULL);
-  ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_safe_setup(ca, data_type, ndim, dim, bytes, NULL);
-  return carray_new_with_mask(ca, mask);
+  return carray_new_i(data_type, ndim, dim, bytes, mask, 1);
 }
 
 /* Create an entity that adopts a caller-provided data buffer instead of
@@ -440,13 +467,39 @@ cscalar_setup (CScalar *ca,
  * constructs a CScalar struct without initialization
  */
 
+typedef struct {
+  CScalar  *ca;
+  int8_t    data_type;
+  ca_size_t bytes;
+} cscalar_new_arg;
+
+static VALUE
+cscalar_new_setup (VALUE varg)
+{
+  cscalar_new_arg *a = (cscalar_new_arg *) varg;
+  cscalar_setup(a->ca, a->data_type, a->bytes, NULL);
+  return Qnil;
+}
+
+/* The setup allocates the cell after the struct: when that fails, the
+   struct goes too.  It goes by xfree, not ca_free, because its ptr was
+   never set. */
+static CScalar *
+cscalar_new_i (int8_t data_type, ca_size_t bytes)
+{
+  cscalar_new_arg a;
+  cscalar_setup(NULL, data_type, bytes, NULL);
+  a.ca        = ALLOC(CScalar);
+  a.data_type = data_type;
+  a.bytes     = bytes;
+  ca_fill_or_xfree(a.ca, cscalar_new_setup, (VALUE) &a);
+  return a.ca;
+}
+
 CScalar *
 cscalar_new (int8_t data_type, ca_size_t bytes, CArray *mask)
 {
-  CScalar *ca;
-  cscalar_setup(NULL, data_type, bytes, NULL);
-  ca = ALLOC(CScalar);
-  cscalar_setup(ca, data_type, bytes, NULL);
+  CScalar *ca = cscalar_new_i(data_type, bytes);
   return (CScalar *) carray_new_with_mask((CArray *) ca, mask);
 }
 
@@ -457,10 +510,7 @@ cscalar_new (int8_t data_type, ca_size_t bytes, CArray *mask)
 CScalar *
 cscalar_new2 (int8_t data_type, ca_size_t bytes, char *val)
 {
-  CScalar *ca;
-  cscalar_setup(NULL, data_type, bytes, NULL);
-  ca = ALLOC(CScalar);
-  cscalar_setup(ca, data_type, bytes, NULL);
+  CScalar *ca = cscalar_new_i(data_type, bytes);
   memcpy(ca->ptr, val, ca->bytes);
   return ca;
 }

data/ext/ca_obj_bincmp.c

@@ -647,6 +647,7 @@ rb_ca_bincmp_build (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
     r_resolved = ca_lazy_settle_scalar(r_resolved, r_scalar);
   }
 
+  ca_refuse_without_common_type(l_resolved, r_resolved);
   TypedData_Get_Struct(l_resolved, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_resolved, CArray, &carray_data_type, r);
 

data/ext/ca_obj_binop.c

@@ -569,6 +569,7 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
     r_resolved = ca_lazy_settle_scalar(r_resolved, r_scalar);
   }
 
+  ca_refuse_without_common_type(l_resolved, r_resolved);
   TypedData_Get_Struct(l_resolved, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_resolved, CArray, &carray_data_type, r);
 

data/ext/ca_obj_bitarray.c

@@ -93,7 +93,8 @@ ca_bitarray_setup (CABitarray *ca, CArray *parent)
   ca_size_t bitlen, elements;
 
   if ( ca_is_complex_type(parent) || ( ca_is_object_type(parent) ) ) {
-    rb_raise(rb_eCADataTypeError, "invalid data_type for bitarray");
+    rb_raise(rb_eCADataTypeError, "%s: can't view the bits of a cell of %s",
+             ca_calling_method_name(), ca_type_name[parent->data_type]);
   }
 
   /* The bits of one byte would share that byte's one mask cell, so a bit
@@ -106,6 +107,9 @@ ca_bitarray_setup (CABitarray *ca, CArray *parent)
              "use .value.bitarray to read the bits without it");
   }
 
+  /* The bits add an axis to the parent's. */
+  ca_check_rank_fits(parent->ndim + 1, "bitarray");
+
   /* ca == NULL asks for the checks above only, so that a constructor can
      run them before it allocates. */
   if ( ca == NULL ) {

data/ext/ca_obj_bitfield.c

@@ -4,10 +4,11 @@
   cell, exposing it as an unsigned-integer (or boolean, when
   bitlen == 1) CArray of the same shape as the parent.
 
-  Byte-straddling fields are handled by loading up to 8 bytes from
-  the parent starting at `byte_offset`, masking with `bit_mask`, and
-  shifting by `bit_offset`.  Big-endian hosts adjust byte_offset /
-  bit_offset so the field selection is invariant to host byte order.
+  Bits are counted from the least significant bit of the parent cell
+  read as a host-order integer.  Byte-straddling fields are handled
+  by loading up to 8 bytes, the least significant first, starting
+  `byte_offset` bytes above the least significant byte, masking with
+  `bit_mask`, and shifting by `bit_offset`.
 
 ---------------------------------------------------------------------------- */
 
@@ -32,7 +33,7 @@ typedef struct {
   ca_size_t   byte_offset;
   ca_size_t   bit_offset;
   uint64_t  bit_mask;
-  ca_size_t   bit_start;  /* original offset before endian adjustment */
+  ca_size_t   bit_start;  /* the offset of the field's lowest bit */
   ca_size_t   bit_length; /* width of the field in bits */
   int8_t      sign_extend; /* the field is read as a signed integer */
 } CABitfield;
@@ -85,6 +86,40 @@ static VALUE rb_cCABitfield;
  * 8-bit field starting at bit 4 of a 2-byte parent) sees the full
  * bit_mask.  A dbytes-typed cast would silently truncate bit_mask
  * to `1 << (dbytes * 8)`, dropping the upper bits of the field. */
+/* The `span` bytes of a cell from `lo` bytes above its least
+   significant byte, as an integer.  On a big-endian host the least
+   significant byte is the last one. */
+static inline uint64_t
+bitfield_load (const char *cell, ca_size_t cbytes, ca_size_t lo, ca_size_t span)
+{
+  uint64_t v = 0;
+#ifdef WORDS_BIGENDIAN
+  ca_size_t j;
+  for (j = 0; j < span; j++) {
+    v |= (uint64_t) (uint8_t) cell[cbytes - 1 - lo - j] << (8 * j);
+  }
+#else
+  (void) cbytes;
+  memcpy(&v, cell + lo, (size_t) span);
+#endif
+  return v;
+}
+
+static inline void
+bitfield_save (char *cell, ca_size_t cbytes, ca_size_t lo, ca_size_t span,
+               uint64_t v)
+{
+#ifdef WORDS_BIGENDIAN
+  ca_size_t j;
+  for (j = 0; j < span; j++) {
+    cell[cbytes - 1 - lo - j] = (char) (v >> (8 * j));
+  }
+#else
+  (void) cbytes;
+  memcpy(cell + lo, &v, (size_t) span);
+#endif
+}
+
 static void
 bitfield_fetch(char *dst, ca_size_t dbytes,
                    char *src, ca_size_t sbytes,
@@ -98,13 +133,12 @@ bitfield_fetch(char *dst, ca_size_t dbytes,
   if (span > 8) span = 8;
   ca_size_t dwrite = (dbytes > 8) ? 8 : dbytes;
   for (k = 0; k < elements; k++) {
-    uint64_t tmp = 0;
-    memcpy(&tmp, src + k * sbytes + byte_offset, (size_t) span);
+    uint64_t tmp = bitfield_load(src + k * sbytes, sbytes, byte_offset, span);
     uint64_t result = (tmp & bit_mask) >> bit_offset;
     if ( result & sign ) {
       result |= ~( ( sign << 1 ) - 1 );   /* the field's top bit is its sign */
     }
-    memcpy(dst + k * dbytes, &result, (size_t) dwrite);
+    bitfield_save(dst + k * dbytes, dwrite, 0, dwrite, result);
   }
 }
 
@@ -124,12 +158,10 @@ bitfield_store(char *src, ca_size_t sbytes,
   if (span > 8) span = 8;
   ca_size_t sread = (sbytes > 8) ? 8 : sbytes;
   for (k = 0; k < elements; k++) {
-    uint64_t srcv = 0;
-    memcpy(&srcv, src + k * sbytes, (size_t) sread);
-    uint64_t tmp = 0;
-    memcpy(&tmp, dst + k * dbytes + byte_offset, (size_t) span);
+    uint64_t srcv = bitfield_load(src + k * sbytes, sread, 0, sread);
+    uint64_t tmp = bitfield_load(dst + k * dbytes, dbytes, byte_offset, span);
     tmp = (tmp & ~bit_mask) | ((srcv << bit_offset) & bit_mask);
-    memcpy(dst + k * dbytes + byte_offset, &tmp, (size_t) span);
+    bitfield_save(dst + k * dbytes, dbytes, byte_offset, span, tmp);
   }
 }
 
@@ -160,14 +192,16 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   }
 
   if ( offset < 0 || offset + bitlen -1 >= bitsize ) {
-    rb_raise(rb_eIndexError, "invalid offset for bit field");
+    rb_raise(rb_eIndexError, "%s: bits out of range for a cell of %d bits",
+             ca_calling_method_name(), (int) bitsize);
   }
 
   /* The bits of an object cell are a reference: writing them would leave
      the cell pointing nowhere.  A complex cell is refused as bitarray
      refuses it. */
   if ( ca_is_object_type(parent) || ca_is_complex_type(parent) ) {
-    rb_raise(rb_eCADataTypeError, "invalid data_type for bitfield");
+    rb_raise(rb_eCADataTypeError, "%s: can't view the bits of a cell of %s",
+             ca_calling_method_name(), ca_type_name[parent->data_type]);
   }
 
   /* A field is read with one 8-byte load from the byte it starts in. */
@@ -213,32 +247,11 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
              (long long) bitlen, ca_type_name[data_type]);
   }
 
-  if ( ca_endian == CA_BIG_ENDIAN ) {
-    /* The window is placed by the narrowest width that holds the field,
-       not by the type it is read as, which may be wider. */
-    ca_size_t window = ( bitlen <= 8 ) ? 1 : ( bitlen <= 16 ) ? 2 :
-                       ( bitlen <= 32 ) ? 4 : 8;
-    byte_offset = parent->bytes - offset/8 - window;
-    bit_offset  = offset % 8;
-    bit_mask    = 0;
-    for (i=0; i<bitlen; i++) {
-      bit_mask += 1ULL << ( bit_offset + i );
-    }
-    if ( byte_offset < 0 ) {
-      for (i=0; i<-byte_offset; i++) {
-        bit_mask = bit_mask << 8;
-        bit_offset += 8;
-      }
-      byte_offset = 0;
-    }
-  }
-  else {
-    byte_offset = offset / 8;
-    bit_offset  = offset % 8;
-    bit_mask    = 0;
-    for (i=0; i<bitlen; i++) {
-      bit_mask += 1ULL << ( bit_offset + i );
-    }
+  byte_offset = offset / 8;
+  bit_offset  = offset % 8;
+  bit_mask    = 0;
+  for (i=0; i<bitlen; i++) {
+    bit_mask += 1ULL << ( bit_offset + i );
   }
 
   /* ca == NULL asks for the checks above only, so that a constructor can
@@ -666,8 +679,10 @@ rb_ca_bitfield (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if ( TYPE(rrange) == T_FIXNUM ) {
-    offset = NUM2INT(rrange);
+  if ( RB_INTEGER_TYPE_P(rrange) ) {
+    /* A bit of a cell: negative from the last.  One beyond any cell is
+       refused by the setup's range check, as an offset past the cell is. */
+    offset = RB_FIXNUM_P(rrange) ? FIX2LONG(rrange) : CA_LENGTH_MAX;
     if ( offset < 0 ) {
       offset += ca->bytes * 8;
     }

data/ext/ca_obj_byte_swap.c

@@ -196,7 +196,8 @@ ca_byte_swap_setup (CAByteSwap *ca, CArray *parent, VALUE data_class)
   CA_CHECK_DATA_TYPE_GIVEN(parent->data_type);
 
   if ( parent->data_type == CA_OBJECT ) {
-    rb_raise(rb_eCADataTypeError, "object array can't be byte-swapped");
+    rb_raise(rb_eCADataTypeError, "%s: an object array can't be byte-swapped",
+             ca_calling_method_name());
   }
 
   /* ca == NULL asks for the checks above only, so that a constructor can

data/ext/ca_obj_const_string.c

@@ -837,19 +837,31 @@ rb_ca_const_string_eq (VALUE self, VALUE other)
     ca_const_string_scan_end(&b);
     return vout;
   }
+  /* Another array is compared cell by cell as Strings, where a CAString
+     reconciles it (an object array of Strings, a fixlen or a CAString). */
+  if ( rb_obj_is_carray(other) ) {
+    return rb_funcall(rb_ca_const_string_to_string(self), rb_intern("eq"), 1,
+                      other);
+  }
   return ca_const_string_predicate(self, other, CA_TEXT_EQ);
 }
 
-/* CAConstString#count(value): number of (non-masked) elements byte-equal to value. */
+/* CAConstString#count(value): number of (non-masked) elements byte-equal to
+   value.  With no value, the number of non-masked elements, as CArray#count
+   answers. */
 static VALUE
-rb_ca_const_string_count (VALUE self, VALUE query)
+rb_ca_const_string_count (int argc, VALUE *argv, VALUE self)
 {
   ca_const_string_scan_t s;
   const char *qp, *p;
   long qlen;
   int64_t len;
   ca_size_t i, c = 0;
+  VALUE query;
 
+  if ( rb_scan_args(argc, argv, "01", &query) == 0 ) {
+    return rb_funcall(self, rb_intern("count_not_masked"), 0);
+  }
   if ( TYPE(query) != T_STRING ) {
     query = rb_obj_as_string(query);
   }
@@ -1216,7 +1228,7 @@ Init_ca_obj_const_string (void)
   /* native byte ops (§3.7) */
   rb_define_method(rb_cCAConstString, "byte_length", rb_ca_const_string_byte_length, 0);
   rb_define_method(rb_cCAConstString, "eq",          rb_ca_const_string_eq, 1);
-  rb_define_method(rb_cCAConstString, "count",       rb_ca_const_string_count, 1);
+  rb_define_method(rb_cCAConstString, "count",       rb_ca_const_string_count, -1);
   rb_define_method(rb_cCAConstString, "start_with?", rb_ca_const_string_start_with, 1);
   rb_define_method(rb_cCAConstString, "end_with?",   rb_ca_const_string_end_with, 1);
   rb_define_method(rb_cCAConstString, "include?",    rb_ca_const_string_include, 1);

data/ext/ca_obj_face.c

@@ -281,7 +281,8 @@ ca_face_lift (VALUE view, VALUE face_parent)
        handled by builder-side pre-strip.  data_type above stays a full strip
        (surface concern, §8 #7) — the parent pointer is the structural concern
        (§8.3); the two axes are deliberately separate. */
-    if ( ((CAView *) view_ca)->parent == fp
+    if ( ca_is_view(view_ca)                /* an entity (a copy) has no parent field */
+         && ((CAView *) view_ca)->parent == fp
          && ! ca_test_flag(view_ca, CA_FLAG_MULTI_PARENTS) ) {
       ((CAView *) view_ca)->parent = ((CAView *) fp)->parent;   /* C pointer: one level */
       rb_ca_set_parent(view, rb_ca_parent(face_parent));        /* @parent ivar: lockstep */
@@ -1233,6 +1234,25 @@ ca_face_reconcile_comparison (volatile VALUE *pself, volatile VALUE *pother)
     return;
   }
 
+  /* Two string arrays of different kinds (CAString, CAFixlenString,
+     CAConstString) or of different cell widths hold their strings in
+     different storage: the padded bytes of one are not the bytes of the
+     other.  They are compared by their strings. */
+  if ( RTEST(rb_obj_is_carray(other)) ) {
+    static ID id_to_string = 0;
+    CArray *oc;
+    if ( id_to_string == 0 ) id_to_string = rb_intern("to_string");
+    TypedData_Get_Struct(other, CArray, &carray_data_type, oc);
+    if ( ca_is_face(oc) && rb_respond_to(self, id_to_string)
+         && rb_respond_to(other, id_to_string)
+         && ( rb_obj_class(self) != rb_obj_class(other)
+              || sc->bytes != oc->bytes ) ) {
+      *pself  = rb_ca_strip_face_value(rb_funcall(self, id_to_string, 0));
+      *pother = rb_ca_strip_face_value(rb_funcall(other, id_to_string, 0));
+      return;
+    }
+  }
+
   storage = ca_strip_face(sc);
   if ( storage->data_type == CA_FIXLEN ) {
     /* genuine fixlen semantics: memcmp is the correct comparison, so self
@@ -1262,6 +1282,26 @@ ca_face_reconcile_comparison (volatile VALUE *pself, volatile VALUE *pother)
   }
 }
 
+/* A Face's parent, the array its values are stored in, is handed out as a
+   read-only view: a write through it would change the Face's values
+   without the Face's conversion (a tick count stored into a time, bytes
+   into a record).  The storage is written through the Face's own named
+   methods (CATime#ticks), which take it with face_storage. */
+static VALUE
+rb_ca_face_parent (VALUE self)
+{
+  volatile VALUE st = rb_ca_parent(self), view;
+  CArray *cs, *cv;
+  if ( NIL_P(st) ) {
+    return st;
+  }
+  TypedData_Get_Struct(st, CArray, &carray_data_type, cs);
+  view = rb_ca_refer_new(st, cs->data_type, cs->ndim, cs->dim, cs->bytes, 0);
+  TypedData_Get_Struct(view, CArray, &carray_data_type, cv);
+  ca_set_flag(cv, CA_FLAG_READ_ONLY);
+  return view;
+}
+
 void
 Init_ca_face (void)
 {
@@ -1271,6 +1311,7 @@ Init_ca_face (void)
      ahead of this Init) — CAFace inherits from it. */
   rb_cCAFace = rb_define_class("CAFace", rb_cCAView);
   rb_define_alloc_func(rb_cCAFace, rb_ca_face_s_allocate_forbidden);
+  rb_define_method(rb_cCAFace, "parent", rb_ca_face_parent, 0);
 
   /* Initialise the portable table to -1 for every slot so dispatch
      can distinguish "explicitly registered 0" (CAConstString) from

data/ext/ca_obj_field.c

@@ -40,11 +40,12 @@ ca_field_setup (CAStride *ca, CArray *parent,
   }
   if ( data_type == CA_OBJECT ) {
     rb_raise(rb_eCADataTypeError,
-             "CA_OBJECT can not to be a data_type for CAField");
+             "%s: a field can't be read as object", ca_calling_method_name());
   }
   if ( ca_is_object_type(parent) ) {
     rb_raise(rb_eCADataTypeError,
-             "a field can not be taken from an object array");
+             "%s: a field can't be taken from an object array",
+             ca_calling_method_name());
   }
   /* A boolean cell holds 0 or 1, and a field of a numeric array is
      written as that number.  A record's boolean member is a field of a
@@ -105,6 +106,14 @@ rb_ca_field_new (VALUE cary, ca_size_t offset, int8_t data_type, ca_size_t bytes
   CAStride *ca;
   rb_check_carray_object(cary);
   TypedData_Get_Struct(cary, CArray, &carray_data_type, parent);
+  /* A record's boolean member is a byte of a fixlen array that other
+     fields (a uint8 one, a String store of the record) can write as any
+     byte.  It is read through a cast to boolean, which refuses a byte
+     that is not 0 or 1, as fake(:boolean) does. */
+  if ( data_type == CA_BOOLEAN && parent->data_type == CA_FIXLEN ) {
+    obj = rb_ca_field_new(cary, offset, CA_UINT8, 1);
+    return rb_ca_fake_new(obj, CA_BOOLEAN, 1);
+  }
   ca  = ca_field_new(parent, offset, data_type, bytes);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
@@ -139,7 +148,7 @@ rb_ca_field (int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "21", (VALUE *) &voffset, (VALUE *) &rtype, (VALUE *) &ropt);
   rb_scan_options(ropt, "bytes", &rbytes);
 
-  offset = NUM2SIZE(voffset);
+  offset = ca_integer_arg(voffset, "offset", NULL);
 
   if ( rb_obj_is_carray(rtype) ) {
     CArray *ct;
@@ -149,6 +158,7 @@ rb_ca_field (int argc, VALUE *argv, VALUE self)
     TypedData_Get_Struct(rtype, CArray, &carray_data_type, ct);
     data_type = CA_FIXLEN;
     bytes     = ct->bytes * ct->elements;
+    ca_check_rank_fits((long) ca->ndim + ct->ndim, "field");
     obj = rb_ca_field_new(self, offset, data_type, bytes);
     ndim = ca->ndim + ct->ndim;
     for (i=0; i<ca->ndim; i++) {

data/ext/ca_obj_grid.c

@@ -242,7 +242,9 @@ ca_grid_setup (CAGrid *ca, CArray *parent, int8_t ndim,
     ca_set_flag(ca, CA_FLAG_SHARE_INDEX);
     ca->axes = protos;
   } else {
-    ca->axes = ALLOC_N(cag_axis_t, ndim);
+    /* Zeroed: an axis's indices or holes that cannot be allocated raises
+       with the later axes not yet copied, and free_ca_grid reads them. */
+    ca->axes = ZALLOC_N(cag_axis_t, ndim);
     for (k = 0; k < ndim; k++) {
       ca->axes[k].kind  = protos[k].kind;
       ca->axes[k].count = protos[k].count;
@@ -319,16 +321,38 @@ ca_grid_inherit_mask (VALUE view)
   return ca_view_inherit_mask(view);
 }
 
-/* holes_read_masked is the copied grid's: a copy of a mask grid is one. */
+typedef struct {
+  CAGrid     *ca;
+  CArray     *parent;
+  int8_t      ndim;
+  cag_axis_t *protos;
+} ca_grid_new_arg;
+
+static VALUE
+ca_grid_new_setup (VALUE varg)
+{
+  ca_grid_new_arg *a = (ca_grid_new_arg *) varg;
+  ca_grid_setup(a->ca, a->parent, a->ndim, a->protos, 0);
+  return Qnil;
+}
+
+/* holes_read_masked is the copied grid's: a copy of a mask grid is one.
+   The setup allocates the axes after the struct and its pool: when that
+   fails, the struct goes too. */
 static CAGrid *
 ca_grid_new_as (CArray *parent, int8_t ndim, cag_axis_t *protos,
                 int8_t holes_read_masked, CAGrid *mask_owner)
 {
   CAGrid *ca;
+  ca_grid_new_arg a;
   ca_grid_check_protos(parent, ndim, protos);
   /* check: ca_grid_check_protos above */
   ca = (CAGrid *) ca_array_alloc(CA_OBJ_GRID, ndim);
-  ca_grid_setup(ca, parent, ndim, protos, 0);
+  a.ca     = ca;
+  a.parent = parent;
+  a.ndim   = ndim;
+  a.protos = protos;
+  ca_fill_or_free((CArray *) ca, ca_grid_new_setup, (VALUE) &a);
   ca->holes_read_masked = holes_read_masked;
   ca->mask_owner        = mask_owner;
   ca_fill_or_free((CArray *) ca, ca_grid_inherit_mask, (VALUE) ca);
@@ -358,7 +382,7 @@ free_ca_grid (void *ap)
   if ( ca != NULL ) {
     ca_free(ca->mask);
     ca_free(ca->mask_standin);
-    if ( ! (ca->flags & CA_FLAG_SHARE_INDEX) ) {
+    if ( ! (ca->flags & CA_FLAG_SHARE_INDEX) && ca->axes ) {
       int8_t k;
       for (k = 0; k < ca->ndim; k++) {
         if ( ca->axes[k].kind == CAG_AXIS_INDEX && ca->axes[k].indices ) {
@@ -1226,7 +1250,15 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
       rb_raise(rb_eArgError, "invalid total ndim of args");
     }
     ref = rb_ca_refer_new(self, ca->data_type, rndim, rdim, ca->bytes, 0);
-    return rb_ca_grid(argc, argv, ref);
+    /* An index array that spans several axes picks along the one axis
+       they are joined into, so it is read flat there. */
+    {
+      VALUE flat[CA_RANK_MAX];
+      for (i=0; i<rndim; i++) {
+        flat[i] = rb_obj_is_carray(argv[i]) ? rb_ca_flatten(argv[i]) : argv[i];
+      }
+      return rb_ca_grid(argc, flat, ref);
+    }
   }
 
   /* Dispatch hook: route a boolean on axis 0 with plain keys elsewhere to
@@ -1256,6 +1288,21 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
       protos[i].holes   = NULL;
       continue;
     }
+    {
+      /* An index array picks cells along its one axis.  One of more axes
+         states a shape the axis does not have. */
+      CArray *cs;
+      TypedData_Get_Struct(rval, CArray, &carray_data_type, cs);
+      if ( cs->ndim > 1 ) {
+        volatile VALUE sshape = rb_ary_new();
+        int k;
+        for (k = 0; k < cs->ndim; k++) rb_ary_push(sshape, SIZE2NUM(cs->dim[k]));
+        rb_raise(rb_eArgError,
+                 "%s: index array of shape %"PRIsVALUE" on axis %d (an index "
+                 "array picks along one axis; use .flatten)",
+                 ca_calling_method_name(), sshape, (int) i);
+      }
+    }
     if ( rb_ca_is_boolean_type(rval) ) {
       CArray *cb;
       TypedData_Get_Struct(rval, CArray, &carray_data_type, cb);