carray 3.0.4 → 3.0.6

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

@@ -291,9 +291,11 @@ ca_bincmp_try_leaf_inplace (CArray *op, int8_t common_dt,
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
+ca_bincmp_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CABinCmp *bc = (CABinCmp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   int8_t    k;
   void     *left_scratch, *right_scratch;
   ca_size_t left_bytes, right_bytes;
@@ -437,6 +439,12 @@ ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
   if ( ! left_is_inplace  ) ca_lazy_arena_release(left_scratch);
 }
 
+static void
+ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(bc, 2, bc->operands, 0, NULL, ca_bincmp_eval_cells, req, data, CA_XFER_GET);
+}
+
 static void
 ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                             ca_size_t *strides, void *data, int dir)
@@ -647,6 +655,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

@@ -249,9 +249,11 @@ ca_size_t ca_binop_materialise_call_count = 0;
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
+ca_binop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CABinOp  *bo = (CABinOp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   int8_t    k;
   void     *scratch;
   volatile VALUE holder;
@@ -350,6 +352,13 @@ ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
   ca_lazy_arena_release(scratch);
 }
 
+static void
+ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(bo, 2, bo->operands, 0, NULL, ca_binop_eval_cells,
+                        req, data, CA_XFER_GET);
+}
+
 static void
 ca_binop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)
@@ -569,6 +578,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
@@ -467,7 +480,9 @@ ca_bitfield_func_sync (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_bitfield_sync(ca);
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void
@@ -666,8 +681,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
@@ -490,7 +491,9 @@ ca_byte_swap_func_sync (void *ap)
   ca_byte_swap_apply(ca, tmp);
   memcpy(ca->parent->ptr, tmp, ca_length(ca));
   ALLOCV_END(holder);
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void

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

@@ -49,7 +49,9 @@ ca_face_sync (void *ap)
 {
   CAView *cav = (CAView *) ap;
   /* alias means no copy-back is needed; parent sync propagates */
+  ca_view_pass_mask_to_parent(cav);
   ca_sync(cav->parent);
+  ca_view_sync_mask_after_parent(cav);
 }
 
 void
@@ -281,7 +283,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 +1236,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 +1284,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 +1313,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_fake.c

@@ -310,12 +310,14 @@ ca_fake_func_sync (void *ap)
   ca_update_mask(ca);
   if ( ca->mask ) {
     ca_cast_block_with_mask(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr, 
-                            (boolean8_t *)ca->parent->mask->ptr);
+                            (boolean8_t *)ca->mask->ptr);
   }
   else {
     ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);
   }
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void

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++) {