carray 3.0.3 → 3.0.5

data/ext/ca_obj_bincmp.c

@@ -74,10 +74,7 @@ typedef struct CABinCmp {
                                 target of both left & right, also the
                                 kernel lookup key) */
   double    eps;             /* Runtime tolerance slot for IS_CLOSE /
-                                IS_EQUIV; ignored for other ops.  The
-                                `eps` name is retained to keep the
-                                `__eps__` Ruby accessor stable across
-                                the dual purpose. */
+                                IS_EQUIV; ignored for other ops. */
   int8_t    sign_fix;        /* 0, or the side (1 left, 2 right) of an
                                 int64 operand compared with a uint64 one:
                                 the kernel compares both as uint64 and
@@ -179,6 +176,7 @@ ca_bincmp_setup (CABinCmp *ca, CArray *left, CArray *right, uint16_t op_id,
 CABinCmp *
 ca_bincmp_new (CArray *left, CArray *right, uint16_t op_id, double eps)
 {
+  /* check: the setup checks nothing */
   CABinCmp *ca = (CABinCmp *) ca_array_alloc(CA_OBJ_BINCMP, left->ndim);
   ca_bincmp_setup(ca, left, right, op_id, eps);
   return ca;
@@ -226,7 +224,7 @@ ca_bincmp_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
   int8_t    k;
 
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_index PUT)");
+    ca_refuse_read_only();
   }
 
   for ( k = ca->ndim - 1; k >= 0; k-- ) {
@@ -412,7 +410,7 @@ ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
                "CABinCmp: kernel not implemented (op_id=%u data_type=%d)",
                (unsigned) bc->op_id, (int) bc->common_dt);
     }
-    if ( bc->common_dt == CA_OBJECT ) {
+    if ( ca_op_raises_on_cell(CA_OP_KIND_BINCMP, bc->op_id, bc->common_dt) ) {
       slab_mask = ca_lazy_req_mask(req, 2, bc->operands);
     }
     fn(slab_n, slab_mask,
@@ -446,7 +444,7 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_stride PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_region(&req, ap, starts, counts, strides);
   ca_bincmp_eval((CABinCmp *) ap, &req, data);
@@ -459,7 +457,7 @@ ca_bincmp_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 {
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_addrs PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_addrs(&req, n, addrs);
   ca_bincmp_eval((CABinCmp *) ap, &req, data);
@@ -482,7 +480,7 @@ static void
 ca_bincmp_func_allocate (void *ap)
 {
   CABinCmp *ca = (CABinCmp *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -499,7 +497,7 @@ ca_bincmp_func_attach (void *ap)
   int8_t    k;
   ca_size_t s;
 
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
@@ -525,7 +523,7 @@ NORETURN(static void ca_bincmp_func_fill_data (void *ap, void *ptr));
 static void
 ca_bincmp_func_fill_data (void *ap, void *ptr)
 {
-  rb_raise(rb_eRuntimeError, "CABinCmp is read-only (fill_data)");
+  ca_refuse_read_only();
 }
 
 /* mask = left.mask | right.mask, computed on each read (CAMaskOfOperands). */
@@ -580,6 +578,14 @@ rb_ca_bincmp_new (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
   rb_check_carray_object(r_cary);
   TypedData_Get_Struct(l_cary, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_cary, CArray, &carray_data_type, r);
+  /* No kernel for the type the builder cast to: refuse as the eager
+     comparison does, before anything is allocated. */
+  {
+    ca_bincmp_func_t fn = ca_bincmp_kernel_lookup(op_id, l->data_type);
+    if ( fn == NULL || fn == ca_bincmp_not_implement ) {
+      ca_op_refuse_unimplemented(l_cary, l->data_type, rb_eTypeError);
+    }
+  }
   ca  = ca_bincmp_new(l, r, op_id, eps);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, l_cary);
@@ -641,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);
 
@@ -711,6 +718,7 @@ rb_ca_bincmp_s_build (int argc, VALUE *argv, VALUE klass)
   double eps = 0.0;
   (void) klass;
   rb_scan_args(argc, argv, "31", &l_cary, &r_cary, &op_id_val, &eps_val);
+  /* fits: an operation number from the library's own table */
   op_id = (uint16_t) NUM2UINT(op_id_val);
   if ( argc >= 4 ) eps = NUM2DBL(eps_val);
   return rb_ca_bincmp_build(l_cary, r_cary, op_id, eps);
@@ -724,7 +732,8 @@ rb_ca_bincmp_trapping (VALUE self)
 {
   CABinCmp *bc;
   TypedData_Get_Struct(self, CABinCmp, &cabincmp_data_type, bc);
-  return ( bc->common_dt == CA_OBJECT ) ? Qtrue : Qfalse;
+  return ca_op_raises_on_cell(CA_OP_KIND_BINCMP, bc->op_id, bc->common_dt)
+         ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -741,14 +750,7 @@ rb_ca_bincmp_right (VALUE self)
   return rb_ivar_get(self, rb_intern("__bincmp_right__"));
 }
 
-static VALUE
-rb_ca_bincmp_eps (VALUE self)
-{
-  CABinCmp *bc;
-  TypedData_Get_Struct(self, CABinCmp, &cabincmp_data_type, bc);
-  return rb_float_new(bc->eps);
-}
-
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_bincmp_s_reset_scratch_counter (VALUE klass)
 {
@@ -793,6 +795,7 @@ rb_ca_bincmp_s_leaf_inplace_count (VALUE klass)
   (void) klass;
   return SIZE2NUM(ca_bincmp_leaf_inplace_count);
 }
+#endif /* CARRAY_DEV_BUILD */
 
 static VALUE
 rb_ca_bincmp_s_allocate (VALUE klass)
@@ -853,8 +856,8 @@ Init_ca_obj_bincmp (void)
   rb_define_method(rb_cCABinCmp, "__trapping__", rb_ca_bincmp_trapping, 0);
   rb_define_method(rb_cCABinCmp, "__bincmp_right__",
                                   rb_ca_bincmp_right, 0);
-  rb_define_method(rb_cCABinCmp, "__eps__",       rb_ca_bincmp_eps, 0);
 
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCABinCmp, "__reset_scratch_counter__",
                              rb_ca_bincmp_s_reset_scratch_counter, 0);
   rb_define_singleton_method(rb_cCABinCmp, "__scratch_count__",
@@ -867,4 +870,5 @@ Init_ca_obj_bincmp (void)
                              rb_ca_bincmp_s_reset_leaf_inplace_counter, 0);
   rb_define_singleton_method(rb_cCABinCmp, "__leaf_inplace_count__",
                              rb_ca_bincmp_s_leaf_inplace_count, 0);
+#endif
 }

data/ext/ca_obj_binop.c

@@ -177,6 +177,7 @@ ca_binop_setup (CABinOp *ca, CArray *left, CArray *right, uint16_t op_id)
 CABinOp *
 ca_binop_new (CArray *left, CArray *right, uint16_t op_id)
 {
+  /* check: the setup checks nothing */
   CABinOp *ca = (CABinOp *) ca_array_alloc(CA_OBJ_BINOP, left->ndim);
   ca_binop_setup(ca, left, right, op_id);
   return ca;
@@ -227,7 +228,7 @@ ca_binop_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
   ca_size_t s;
 
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinOp is read-only (xfer_index PUT)");
+    ca_refuse_read_only();
   }
 
   s = ca->bytes;
@@ -322,7 +323,7 @@ ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
     boolean8_t *slab_mask = NULL;
     void *mscratch = NULL;
 
-    if ( ca_binop_is_trapping(bo->op_id, bo->data_type) ) {
+    if ( ca_op_raises_on_cell(CA_OP_KIND_BINOP, bo->op_id, bo->data_type) ) {
       CArray *ops[2];
       ops[0] = bo->parent;
       ops[1] = bo->right;
@@ -356,7 +357,7 @@ ca_binop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinOp is read-only (xfer_stride PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_region(&req, ap, starts, counts, strides);
   ca_binop_eval((CABinOp *) ap, &req, data);
@@ -370,7 +371,7 @@ ca_binop_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 {
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinOp is read-only (xfer_addrs PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_addrs(&req, n, addrs);
   ca_binop_eval((CABinOp *) ap, &req, data);
@@ -393,15 +394,7 @@ static void
 ca_binop_func_allocate (void *ap)
 {
   CABinOp *ca = (CABinOp *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
-  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
-     soon as the view is, so it must not be handed to the GC as raw
-     xmalloc garbage. */
-  if ( ca->data_type == CA_OBJECT ) {
-    VALUE *p = (VALUE *) ca->ptr;
-    ca_size_t i;
-    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
-  }
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -418,19 +411,11 @@ ca_binop_func_attach (void *ap)
   int8_t    k;
   ca_size_t s;
 
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
   for ( k = 0; k < ca->ndim; k++ ) starts[k] = 0;
-  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
-     soon as the view is, so it must not be handed to the GC as raw
-     xmalloc garbage. */
-  if ( ca->data_type == CA_OBJECT ) {
-    VALUE *p = (VALUE *) ca->ptr;
-    ca_size_t i;
-    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
-  }
   ca_binop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 
@@ -452,7 +437,7 @@ NORETURN(static void ca_binop_func_fill_data (void *ap, void *ptr));
 static void
 ca_binop_func_fill_data (void *ap, void *ptr)
 {
-  rb_raise(rb_eRuntimeError, "CABinOp is read-only (fill_data)");
+  ca_refuse_read_only();
 }
 
 /* Build out.mask: the operands' masks ORed on each read (CAMaskOfOperands), so
@@ -584,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);
 
@@ -605,8 +591,7 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
   /* No kernel for that data_type (fixlen arithmetic, ...): raise as the
      eager binop does, before a view is built over it. */
   if ( ca_binop_kernel_lookup_vv(op_id, l_in_dt) == ca_binop_not_implement ) {
-    rb_raise(rb_eCADataTypeError,
-             "invalid data_type for binop (not implemented)");
+    ca_op_refuse_unimplemented(l_cary, l_in_dt, rb_eCADataTypeError);
   }
 
   if ( l_in_dt != l->data_type ) {
@@ -694,6 +679,7 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
 static VALUE
 rb_ca_binop_s_build (VALUE klass, VALUE l_cary, VALUE r_cary, VALUE op_id_val)
 {
+  /* fits: an operation number from the library's own table */
   uint16_t op_id = (uint16_t) NUM2UINT(op_id_val);
   (void) klass;
   return rb_ca_binop_build(l_cary, r_cary, op_id);
@@ -708,7 +694,7 @@ rb_ca_binop_trapping (VALUE self)
 {
   CABinOp *bo;
   TypedData_Get_Struct(self, CABinOp, &cabinop_data_type, bo);
-  return ca_binop_is_trapping(bo->op_id, bo->data_type) ? Qtrue : Qfalse;
+  return ca_op_raises_on_cell(CA_OP_KIND_BINOP, bo->op_id, bo->data_type) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -729,6 +715,7 @@ rb_ca_binop_right (VALUE self)
 }
 
 /* Test instrumentation (mirrors CAMonOp counters). */
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_binop_s_reset_scratch_counter (VALUE klass)
 {
@@ -754,6 +741,7 @@ rb_ca_binop_s_materialise_count (VALUE klass)
 {
   return SIZE2NUM(ca_binop_materialise_call_count);
 }
+#endif /* CARRAY_DEV_BUILD */
 
 static VALUE
 rb_ca_binop_s_allocate (VALUE klass)
@@ -834,6 +822,7 @@ Init_ca_obj_binop (void)
                                 rb_ca_binop_right, 0);
 
   /* Test instrumentation, not user-facing. */
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCABinOp, "__reset_scratch_counter__",
                              rb_ca_binop_s_reset_scratch_counter, 0);
   rb_define_singleton_method(rb_cCABinOp, "__scratch_count__",
@@ -842,4 +831,5 @@ Init_ca_obj_binop (void)
                              rb_ca_binop_s_reset_materialise_counter, 0);
   rb_define_singleton_method(rb_cCABinOp, "__materialise_count__",
                              rb_ca_binop_s_materialise_count, 0);
+#endif
 }

data/ext/ca_obj_bitarray.c

@@ -93,11 +93,13 @@ 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
      view takes no masked array and holds no mask of its own. */
+  /* mask: the constructor asks first, before it allocates (ca == NULL) */
   if ( ca_has_mask(parent) ) {
     rb_raise(rb_eArgError,
              "bitarray: the array has a mask, which a bit view can not "
@@ -105,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 ) {
@@ -395,7 +400,7 @@ ca_bitarray_func_allocate (void *ap)
 {
   CABitarray *ca = (CABitarray *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -403,7 +408,7 @@ ca_bitarray_func_attach (void *ap)
 {
   CABitarray *ca = (CABitarray *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_bitarray_attach(ca);
 }
 

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. */
@@ -205,7 +239,7 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
     data_type = CA_UINT64;
   }
 
-  CA_CHECK_BYTES(data_type, bytes);
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
 
   if ( bitlen > bytes * 8 ||
        ( ( data_type == CA_BOOLEAN ) && ( bitlen > 1 ) ) ) {
@@ -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
@@ -273,9 +286,6 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
 
   memcpy(ca->dim, parent->dim, ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
 
   return 0;
 }
@@ -288,6 +298,7 @@ ca_bitfield_new (CArray *parent, ca_size_t offset, ca_size_t bitlen,
   ca_bitfield_setup(NULL, parent, offset, bitlen, data_type);
   ca = (CABitfield *) ca_array_alloc(CA_OBJ_BITFIELD, parent->ndim);
   ca_bitfield_setup(ca, parent, offset, bitlen, data_type);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -452,7 +463,7 @@ ca_bitfield_func_allocate (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -460,7 +471,7 @@ ca_bitfield_func_attach (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_bitfield_attach(ca);
 }
 
@@ -668,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;
     }
@@ -708,6 +721,7 @@ rb_ca_bitfield_initialize_copy (VALUE self, VALUE other)
   }
   ca_bitfield_setup(ca, cs->parent, cs->bit_start, cs->bit_length,
                     cs->data_type);
+  ca_view_inherit_mask((VALUE) ca);
 
   return self;
 }

data/ext/ca_obj_block.c

@@ -124,6 +124,12 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
     }
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   /* strides[k] = step[k] * Pi_{j>k} size0[j] * parent->bytes */
   suffix = parent->bytes;
   for (i = ndim - 1; i >= 0; i--) {
@@ -141,10 +147,9 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
     }
   }
 
-  /* CAREFUL: the CABlock tail (offset / start / step / count / size0)
-     must be filled BEFORE ca_stride_setup.  ca_stride_setup may auto-
-     dispatch ca_create_mask when the parent has a mask, and
-     ca_block_func_create_mask reads those tail fields.
+  /* The CABlock tail (offset / start / step / count / size0) is filled
+     here; ca_block_func_create_mask reads it when the constructor takes
+     the parent's mask (ca_view_inherit_mask) after this setup.
 
      Pool path: start/step/count/size0 already point into _pool (wired
      by ca_block_pool_init); only memcpy the values.  Non-pool path:
@@ -161,10 +166,10 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
   memcpy(ca->count, count, ndim * sizeof(ca_size_t));
   memcpy(ca->size0, dim,   ndim * sizeof(ca_size_t));
 
-  ca_stride_setup((CAStride *) ca, CA_OBJ_BLOCK, parent,
-                  parent->data_type, parent->bytes,
-                  ndim, count, strides,
-                  base_offset_elements * parent->bytes);
+  ca_stride_setup_view((CAStride *) ca, CA_OBJ_BLOCK, parent,
+                       parent->data_type, parent->bytes,
+                       ndim, count, strides,
+                       base_offset_elements * parent->bytes);
 
   return 0;
 }
@@ -174,8 +179,11 @@ ca_block_new (CArray *parent, int8_t ndim, ca_size_t *dim,
               ca_size_t *start, ca_size_t *step, ca_size_t *count,
               ca_size_t offset)
 {
-  CABlock *ca = (CABlock *) ca_array_alloc(CA_OBJ_BLOCK, ndim);
+  CABlock *ca;
+  ca_block_setup(NULL, parent, ndim, dim, start, step, count, offset);
+  ca = (CABlock *) ca_array_alloc(CA_OBJ_BLOCK, ndim);
   ca_block_setup(ca, parent, ndim, dim, start, step, count, offset);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -265,6 +273,7 @@ rb_cb_initialize_copy (VALUE self, VALUE other)
   }
   ca_block_setup(ca, cs->parent, cs->ndim, cs->size0,
                  cs->start, cs->step, cs->count, cs->offset);
+  ca_view_inherit_mask((VALUE) ca);
   rb_ca_set_parent(self, rb_ca_parent(other));
   return self;
 }