carray 3.0.6 → 3.0.7

data/ext/ca_obj_face.c

@@ -187,8 +187,22 @@ rb_ca_face_template (VALUE original_face, CArray *new_parent,
                                 dst);
 }
 
+/* A Face put on a fresh entity has nothing to be read-only for: the template
+   copied the flag of the Face it came from, which may be read-only only as
+   that view was.  A Face that cannot hold a new value keeps it. */
+static void
+ca_face_fresh_entity_is_writable (volatile VALUE lifted, VALUE face)
+{
+  CArray *lc;
+  TypedData_Get_Struct(lifted, CArray, &carray_data_type, lc);
+  if ( ca_test_flag(lc, CA_FLAG_READ_ONLY)
+       && RTEST(rb_funcall(face, rb_intern("holds_new_values?"), 0)) ) {
+    ca_unset_flag(lc, CA_FLAG_READ_ONLY);
+  }
+}
+
 VALUE
-ca_face_relift_entity (VALUE face, VALUE result)
+ca_face_relift_entity (VALUE face, volatile VALUE result)
 {
   static ID id_copy_state = 0;
   CArray *rc, *lc;
@@ -197,6 +211,7 @@ ca_face_relift_entity (VALUE face, VALUE result)
   TypedData_Get_Struct(result, CArray, &carray_data_type, rc);
   lifted = rb_ca_face_template(face, rc, rc->dim);
   rb_ca_set_parent(lifted, result);
+  ca_face_fresh_entity_is_writable(lifted, face);
   if ( ca_has_mask(rc) ) {
     /* The template starts without a mask. */
     TypedData_Get_Struct(lifted, CArray, &carray_data_type, lc);
@@ -304,6 +319,9 @@ ca_face_lift (VALUE view, VALUE face_parent)
   if ( ca_is_view(view_ca) ) {
     rb_ca_set_lifted_from(lifted, face_parent);
   }
+  else {
+    ca_face_fresh_entity_is_writable(lifted, face_parent);
+  }
 
   /* Optional Ruby callback for ivar / state carry.  Faces holding
      semantic state in the struct tail (CATime / CATimedelta
@@ -358,7 +376,7 @@ ca_face_lift (VALUE view, VALUE face_parent)
  * builder handed us a view whose parent is the marker, and leaving it
  * there would stack a redundant marker in the middle. */
 static VALUE
-ca_lazy_marker_lift (VALUE view, VALUE marker)
+ca_lazy_marker_lift (VALUE view, volatile VALUE marker)
 {
   CArray *view_ca, *mp;
   extern VALUE rb_ca_lazy_marker_new (VALUE cary);
@@ -741,16 +759,16 @@ ca_face_refuse_order (const char *name, VALUE face, const char *verb)
   const char *storage = ca_face_storage_method(face);
   if ( storage ) {
     rb_raise(rb_eArgError,
-             "%s: %s is not orderable by storage (a cell encodes the value "
+             "%s: %"PRIsVALUE" is not orderable by storage (a cell encodes the value "
              "rather than being it); %s its values instead -- %s -- or %s "
              "its storage, which #%s gives",
-             name, rb_obj_classname(face), verb,
+             name, rb_obj_class(face), verb,
              ca_face_conversion_hint(face), verb, storage);
   }
   rb_raise(rb_eArgError,
-           "%s: %s is not orderable by storage (a cell encodes the value "
+           "%s: %"PRIsVALUE" is not orderable by storage (a cell encodes the value "
            "rather than being it); %s its values instead -- %s",
-           name, rb_obj_classname(face), verb,
+           name, rb_obj_class(face), verb,
            ca_face_conversion_hint(face));
 }
 
@@ -808,17 +826,17 @@ ca_face_refuse_numeric (VALUE self, const char *name, VALUE eclass)
     const char *storage = ca_face_storage_method(self);
     if ( storage ) {
       rb_raise(eclass,
-               "%s: %s does not define it (a cell encodes the value rather "
+               "%s: %"PRIsVALUE" does not define it (a cell encodes the value rather "
                "than being a number); compute on its values instead -- %s -- "
                "or on its storage, which #%s gives",
-               name, rb_obj_classname(self), ca_face_conversion_hint(self),
+               name, rb_obj_class(self), ca_face_conversion_hint(self),
                storage);
     }
   }
   rb_raise(eclass,
-           "%s: %s does not define it (a cell encodes the value rather than "
+           "%s: %"PRIsVALUE" does not define it (a cell encodes the value rather than "
            "being a number); compute on its values instead -- %s",
-           name, rb_obj_classname(self), ca_face_conversion_hint(self));
+           name, rb_obj_class(self), ca_face_conversion_hint(self));
 }
 
 VALUE
@@ -839,21 +857,21 @@ ca_face_operand_descend (VALUE operand, const char *name)
     const char *storage = ca_face_storage_method(operand);
     if ( storage ) {
       rb_raise(rb_eArgError,
-               "%s: cannot take a %s operand: its storage is not its surface "
+               "%s: cannot take a %"PRIsVALUE" operand: its storage is not its surface "
                "(a cell encodes the value rather than being it), so comparing "
                "the storage would compare the encoding. Convert the operand "
                "to the receiver's space first -- %s -- or compare the storage "
                "of both sides, which #%s gives",
-               name, rb_obj_classname(operand),
+               name, rb_obj_class(operand),
                ca_face_conversion_hint(operand), storage);
     }
   }
   rb_raise(rb_eArgError,
-           "%s: cannot take a %s operand: its storage is not its surface "
+           "%s: cannot take a %"PRIsVALUE" operand: its storage is not its surface "
            "(a cell encodes the value rather than being it), so comparing "
            "the storage would compare the encoding. Convert the operand to "
            "the receiver's space first -- %s",
-           name, rb_obj_classname(operand), ca_face_conversion_hint(operand));
+           name, rb_obj_class(operand), ca_face_conversion_hint(operand));
   return Qnil;   /* not reached */
 }
 
@@ -862,11 +880,12 @@ ca_face_operand_descend (VALUE operand, const char *name)
 
    A Face equals only a Face of its own class.  When the two share their
    state (a time array's unit) and the storage holds the values in their
-   order, equal storage is equal values, so the storage is compared.
-   Otherwise `==` compares the values themselves (two time arrays of
-   different units, two const strings over different pools, two
-   categoricals with differently ordered labels), and `eql?`, which has to
-   agree with #hash, answers false. */
+   order, cell for cell at one width, equal storage is equal values, so the
+   storage is compared.  Otherwise `==` compares the values themselves (two
+   time arrays of different units, two const strings over different pools,
+   two categoricals with differently ordered labels, two fixed-length
+   strings of different widths), and `eql?`, which has to agree with #hash,
+   answers false. */
 int
 ca_face_equal (VALUE va, VALUE vb, int strict)
 {
@@ -889,7 +908,8 @@ ca_face_equal (VALUE va, VALUE vb, int strict)
     }
   }
   if ( ca_face_state_compatible(va, a, vb, b)
-       && ( strict || ca_test_flag(a, CA_FLAG_FACE_ORDERABLE_STORAGE) ) ) {
+       && ( strict || ( ca_test_flag(a, CA_FLAG_FACE_ORDERABLE_STORAGE)
+                        && a->bytes == b->bytes ) ) ) {
     return strict ? ca_eql_storage(ca_strip_face(a), ca_strip_face(b))
                   : ca_equal(ca_strip_face(a), ca_strip_face(b));
   }
@@ -959,8 +979,8 @@ ca_face_reconcile_operand (VALUE reference, VALUE operand, const char *name)
       if ( ca_is_face(op) ) {
         if ( op->obj_type != CA_OBJ_RECORD ) {
           rb_raise(rb_eTypeError,
-                   "%s: can not take a %s operand for a record array of "
-                   "%"PRIsVALUE, name, rb_obj_classname(operand),
+                   "%s: can not take a %"PRIsVALUE" operand for a record array of "
+                   "%"PRIsVALUE, name, rb_obj_class(operand),
                    rb_ca_data_class(reference));
         }
         if ( rb_ca_data_class(operand) != rb_ca_data_class(reference) ) {
@@ -987,16 +1007,16 @@ ca_face_reconcile_operand (VALUE reference, VALUE operand, const char *name)
     const char *storage = ca_face_storage_method(reference);
     if ( storage ) {
       rb_raise(rb_eArgError,
-               "%s: %s is not comparable by storage and has no to_comparable "
+               "%s: %"PRIsVALUE" is not comparable by storage and has no to_comparable "
                "to bring the operand into its space; compare the storage of "
                "both sides, which #%s gives",
-               name, rb_obj_classname(reference), storage);
+               name, rb_obj_class(reference), storage);
     }
   }
   rb_raise(rb_eArgError,
-           "%s: %s is not comparable by storage and has no to_comparable "
+           "%s: %"PRIsVALUE" is not comparable by storage and has no to_comparable "
            "to bring the operand into its space",
-           name, rb_obj_classname(reference));
+           name, rb_obj_class(reference));
   return Qnil;   /* not reached */
 }
 
@@ -1088,8 +1108,8 @@ ca_face_list_class (VALUE list, const char *who)
                "%s: cannot mix Face and non-Face arrays, or arrays of "
                "different Face classes; convert them first to one Face "
                "class or to no Face, or combine their storage (#%s gives "
-               "the storage of a %s)",
-               who, storage, rb_obj_classname(face));
+               "the storage of a %"PRIsVALUE")",
+               who, storage, rb_obj_class(face));
     }
     rb_raise(rb_eArgError,
              "%s: cannot mix Face and non-Face arrays, or arrays of "
@@ -1099,10 +1119,10 @@ ca_face_list_class (VALUE list, const char *who)
   }
   if ( n > 1 && ! ca_face_state_portable(ref->obj_type, face_class) ) {
     rb_raise(rb_eArgError,
-             "%s: %s state is not portable across several arrays (each "
+             "%s: %"PRIsVALUE" state is not portable across several arrays (each "
              "keeps its values in storage of its own); convert them first "
              "(%s)",
-             who, rb_class2name(face_class),
+             who, face_class,
              ca_face_conversion_hint(face));
   }
   for ( i = 1; i < n; i++ ) {
@@ -1111,8 +1131,8 @@ ca_face_list_class (VALUE list, const char *who)
     TypedData_Get_Struct(p, CArray, &carray_data_type, ca);
     if ( ! ca_face_state_compatible(rb_ary_entry(list, 0), ref, p, ca) ) {
       rb_raise(rb_eArgError,
-               "%s: Face state mismatch (the %s at index %ld differs from "
-               "index 0)", who, rb_class2name(face_class), i);
+               "%s: Face state mismatch (the %"PRIsVALUE" at index %ld differs from "
+               "index 0)", who, face_class, i);
     }
   }
   return face_class;
@@ -1195,7 +1215,7 @@ rb_ca_reconcile_operand (VALUE self, VALUE operand, VALUE rname)
 static VALUE
 rb_ca_face_lift_method (VALUE self, VALUE face_parent)
 {
-  CArray *fp;
+  CArray *fp, *vc, *storage;
   if ( ! rb_obj_is_kind_of(face_parent, rb_cCArray) ) {
     rb_raise(rb_eArgError, "face_lift: face_parent must be a CArray");
   }
@@ -1203,6 +1223,24 @@ rb_ca_face_lift_method (VALUE self, VALUE face_parent)
   if ( ! ca_is_face(fp) ) {
     rb_raise(rb_eArgError, "face_lift: face_parent must be a Face instance");
   }
+  rb_check_carray_object(self);
+  TypedData_Get_Struct(self, CArray, &carray_data_type, vc);
+  /* A Face of the same class is already lifted (see ca_face_lift). */
+  if ( ca_is_face(vc) && rb_obj_class(self) == rb_obj_class(face_parent) ) {
+    return self;
+  }
+  storage = ca_strip_face(fp);
+  /* A Face reads the cells under it as its own, so they must be held in
+     its surface type or its storage type.  A Face receiver is held in its
+     surface type, and is checked the same way. */
+  if ( ! ( vc->data_type == fp->data_type && vc->bytes == fp->bytes )
+       && ! ( vc->data_type == storage->data_type
+              && vc->bytes == storage->bytes ) ) {
+    rb_raise(rb_eArgError,
+             "face_lift: a %"PRIsVALUE" holds its cells as %s, not as %s",
+             rb_obj_class(face_parent), ca_type_name[storage->data_type],
+             ca_type_name[vc->data_type]);
+  }
   return ca_face_lift(self, face_parent);
 }
 

data/ext/ca_obj_fake.c

@@ -154,6 +154,71 @@ ca_fake_func_clone (void *ap)
   return ca_fake_new(ca->parent, ca->data_type, ca->bytes);
 }
 
+/* A read does not raise for a masked cell (ca_fake_cast_get), as attach
+   does not: the value under a mask is not defined, and converting it can
+   raise (NaN to an integer type).  The view's cells are its parent's at the same
+   addresses, so the parent's mask is read for the same cells.  The view's
+   own mask is not made here: once it exists, sync leaves masked cells
+   alone, and a read must not change what a later write does. */
+static CArray *
+ca_fake_read_mask (CAFake *ca)
+{
+  if ( ca->mask ) {
+    return ca->mask;
+  }
+  if ( ca_has_mask(ca->parent) ) {
+    return ca->parent->mask;
+  }
+  return NULL;
+}
+
+/* Convert n cells read from the parent.  A masked cell is converted as
+   well, so that the cell holds what the parent holds (a walk that sends
+   back only the cells a kernel changed compares against it), but a value
+   that cannot be converted (NaN to an integer) leaves zero bytes instead
+   of raising: the value under a mask is not defined. */
+typedef struct {
+  CArray *src_ca, *dst_ca;
+  char   *src, *dst;
+} ca_fake_cell_ctx_t;
+
+static VALUE
+ca_fake_cast_cell (VALUE arg)
+{
+  ca_fake_cell_ctx_t *c = (ca_fake_cell_ctx_t *) arg;
+  ca_ptr2ptr(c->src_ca, c->src, c->dst_ca, c->dst);
+  return Qnil;
+}
+
+static void
+ca_fake_cast_get (CAFake *ca, ca_size_t n, char *src, char *dst, boolean8_t *m)
+{
+  CArray *parent = ca->parent;
+  ca_size_t i;
+  if ( ! m ) {
+    ca_cast_block(n, parent, src, (CArray *) ca, dst);
+    return;
+  }
+  ca_cast_block_skip_masked(n, parent, src, (CArray *) ca, dst, m);
+  for ( i = 0; i < n; i++ ) {
+    if ( m[i] ) {
+      ca_fake_cell_ctx_t c;
+      int state = 0;
+      c.src_ca = parent;
+      c.dst_ca = (CArray *) ca;
+      c.src    = src + i * parent->bytes;
+      c.dst    = dst + i * ca->bytes;
+      /* A masked cell that cannot be converted reads as zero bytes. */
+      /* protect: converts a masked cell; nothing is held */
+      rb_protect(ca_fake_cast_cell, (VALUE) &c, &state);
+      if ( state ) {
+        rb_set_errinfo(Qnil);
+        memset(c.dst, 0, ca->bytes);
+      }
+    }
+  }
+}
+
 /* Per-cell GET/PUT via a parent-sized scratch cell — same code services
    both directions, casting through the parent data_type. */
 static void
@@ -161,10 +226,16 @@ ca_fake_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
   CAFake *ca = (CAFake *) ap;
   volatile VALUE holder;
-  char *v = ALLOCV_N(char, holder, ca->parent->bytes);
+  char *v;
+  v = ALLOCV_N(char, holder, ca->parent->bytes);
   if ( dir == CA_XFER_GET ) {
+    CArray *mask = ca_fake_read_mask(ca);
+    boolean8_t masked = 0;
+    if ( mask ) {
+      ca_fetch_index(mask, idx, &masked);
+    }
     ca_fetch_index(ca->parent, idx, v);
-    ca_ptr2ptr(ca->parent, v, ca, data);
+    ca_fake_cast_get(ca, 1, v, (char *) data, mask ? &masked : NULL);
   }
   else {
     ca_ptr2ptr(ca, data, ca->parent, v);
@@ -184,10 +255,22 @@ ca_fake_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
   CAFake *ca = (CAFake *) ap;
   CArray *parent = ca->parent;
   CArray *eff;
+  CArray *mask = ( dir == CA_XFER_GET ) ? ca_fake_read_mask(ca) : NULL;
   ca_size_t base;
   char   *v;
   volatile VALUE holder;
 
+  if ( mask ) {
+    volatile VALUE mholder;
+    boolean8_t *m = ALLOCV_N(boolean8_t, mholder, n + n * parent->bytes);
+    v = (char *) (m + n);
+    ca_xfer_addrs(mask, n, addrs, m, CA_XFER_GET);
+    ca_xfer_addrs(parent, n, addrs, v, CA_XFER_GET);
+    ca_fake_cast_get(ca, n, v, (char *) data, m);
+    ALLOCV_END(mholder);
+    return;
+  }
+
   /* Sequential-run + live-ptr fast path: cast directly from
      parent->ptr + base*pbytes to data, no intermediate scratch. */
   eff = ca_resolve_attached_root_via_identity(parent);
@@ -251,6 +334,24 @@ ca_fake_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t    k;
   char     *v;
   volatile VALUE holder;
+  CArray   *mask = ( dir == CA_XFER_GET ) ? ca_fake_read_mask(ca) : NULL;
+
+  if ( mask ) {
+    ca_size_t mstrides[CA_RANK_MAX];
+    boolean8_t *m;
+    for ( k = 0; k < ndim; k++ ) {
+      n *= counts[k];
+      pstrides[k] = strides[k] / ca->bytes * ca->parent->bytes;
+      mstrides[k] = strides[k] / ca->bytes;
+    }
+    m = ALLOCV_N(boolean8_t, holder, n + n * ca->parent->bytes);
+    v = (char *) (m + n);
+    ca_xfer_stride(mask, starts, counts, mstrides, m, CA_XFER_GET);
+    ca_xfer_stride(ca->parent, starts, counts, pstrides, v, CA_XFER_GET);
+    ca_fake_cast_get(ca, n, v, (char *) data, m);
+    ALLOCV_END(holder);
+    return;
+  }
 
   /* Fast path: fused walk + cast for GET/PUT */
   if ( ca_xfer_stride_transform_fused((CArray *)ca, ca->parent,
@@ -282,21 +383,19 @@ static void
 ca_fake_func_allocate (void *ap)
 {
   CAFake *ca = (CAFake *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_fake_func_attach (void *ap)
 {
   CAFake *ca = (CAFake *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 
   if ( ca->parent->mask ) {
-    ca_cast_block_with_mask(ca->elements, ca->parent, ca->parent->ptr, 
-                            ca, ca->ptr, 
-                            (boolean8_t*)ca->parent->mask->ptr);
+    ca_cast_block_skip_masked(ca->elements, ca->parent, ca->parent->ptr,
+                              ca, ca->ptr,
+                              (boolean8_t*)ca->parent->mask->ptr);
   }
   else {
     ca_cast_block(ca->elements, ca->parent, ca->parent->ptr, ca, ca->ptr);
@@ -309,8 +408,8 @@ ca_fake_func_sync (void *ap)
   CAFake *ca = (CAFake *) 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->mask->ptr);
+    ca_cast_block_skip_masked(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr,
+                              (boolean8_t *)ca->mask->ptr);
   }
   else {
     ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);
@@ -426,9 +525,9 @@ rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes)
        Both ways down stay open and say which one they are.  A Numeric Face
        is not one of these: its surface is its storage. */
     rb_raise(rb_eTypeError,
-             "%s has no view of its values in another data_type: "
+             "%"PRIsVALUE" has no view of its values in another data_type: "
              "#to_type gives the values, #parent.fake the raw storage",
-             rb_obj_classname(cary));
+             rb_obj_class(cary));
   }
   ca  = ca_fake_new(parent, data_type, bytes);
   obj = ca_wrap_struct(ca);

data/ext/ca_obj_farray.c

@@ -8,6 +8,7 @@
 
 #include "carray.h"
 #include "carray_internal.h"   /* ca_view_inherit_mask */
+#include "ca_obj_face.h"       /* CA_WRAPPER_LIFT */
 
 extern ca_operation_function_t ca_stride_func;
 
@@ -87,7 +88,12 @@ rb_ca_farray_new (VALUE cary)
 VALUE
 rb_ca_farray (VALUE self)
 {
-  return rb_ca_farray_new(self);
+  volatile VALUE obj = rb_ca_farray_new(self);
+  CArray *ca;
+
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
+  return obj;
 }
 
 static VALUE

data/ext/ca_obj_fixlen_string.c

@@ -10,8 +10,9 @@
   fixlen bytes as a struct via the data_class encode/decode hooks); here
   the bytes are the string, fetched and stored by the native fixlen path.
 
-  The Face's only job is to carry the CAFixlenString class across the view
-  chain and to organise the String method surface onto a dedicated class.
+  The Face carries the CAFixlenString class and the encoding of the text
+  across the view chain, and organises the String method surface onto a
+  dedicated class.
   Because the storage is CA_FIXLEN (portable), the Face wrap can be carried
   across multi-parent constructions (CAStack / Marshal / MemoryView).
 
@@ -23,6 +24,7 @@
 #include "carray.h"
 #include "ca_obj_face.h"
 #include "carray_internal.h"
+#include <ruby/encoding.h>
 
 typedef struct {
   /* === CAView prefix === */
@@ -39,7 +41,8 @@ typedef struct {
   CArray    *parent;
   uint32_t   attach;
   uint8_t    nosync;
-  /* === Face tail === (none: CAFixlenString carries no per-instance state) */
+  /* === Face tail === */
+  int        encoding_id;      /* rb_enc_to_index() value of the cells' text */
 } CAFixlenString;
 
 static size_t
@@ -83,7 +86,7 @@ static VALUE rb_cCAFixlenString;
 /* ------------------------------------------------------------------- */
 
 int
-ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent)
+ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent, int encoding_id)
 {
   if ( parent->data_type != CA_FIXLEN ) {
     rb_raise(rb_eTypeError,
@@ -136,6 +139,7 @@ ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent)
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->encoding_id = encoding_id;
 
 
   if ( ca_is_scalar(parent) ) {
@@ -150,12 +154,12 @@ ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent)
 }
 
 CAFixlenString *
-ca_fixlen_string_new (CArray *parent)
+ca_fixlen_string_new (CArray *parent, int encoding_id)
 {
   CAFixlenString *ca;
-  ca_fixlen_string_setup(NULL, parent);
+  ca_fixlen_string_setup(NULL, parent, encoding_id);
   ca = (CAFixlenString *) ca_array_alloc(CA_OBJ_FIXLEN_STRING, parent->ndim);
-  ca_fixlen_string_setup(ca, parent);
+  ca_fixlen_string_setup(ca, parent, encoding_id);
   ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
@@ -182,7 +186,7 @@ static void *
 ca_fixlen_string_func_clone (void *ap)
 {
   CAFixlenString *ca = (CAFixlenString *) ap;
-  return ca_fixlen_string_new(ca->parent);
+  return ca_fixlen_string_new(ca->parent, ca->encoding_id);
 }
 
 static void
@@ -216,9 +220,10 @@ ca_operation_function_t ca_fixlen_string_func = {
 
 /* ------------------------------------------------------------------- */
 
-/* CAFixlenString.wrap(fixlen_array) — zero-copy Face wrap */
+/* CAFixlenString.wrap(fixlen_array, encoding: nil) — zero-copy Face wrap.
+   Without an encoding the cells are bytes that claim no text encoding. */
 VALUE
-rb_ca_fixlen_string_wrap (VALUE parent_val)
+rb_ca_fixlen_string_wrap (VALUE parent_val, int encoding_id)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -227,17 +232,41 @@ rb_ca_fixlen_string_wrap (VALUE parent_val)
   rb_check_carray_object(parent_val);
   TypedData_Get_Struct(parent_val, CArray, &carray_data_type, parent);
 
-  ca  = ca_fixlen_string_new(parent);
+  ca  = ca_fixlen_string_new(parent, encoding_id);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, parent_val);
   return obj;
 }
 
 static VALUE
-rb_ca_fixlen_string_wrap_method (VALUE klass, VALUE raw)
+rb_ca_fixlen_string_wrap_method (int argc, VALUE *argv, VALUE klass)
 {
+  VALUE raw, ropt, renc = Qnil;
   (void) klass;
-  return rb_ca_fixlen_string_wrap(raw);
+  rb_scan_args(argc, argv, "1:", &raw, &ropt);
+  rb_scan_options(ropt, "encoding", &renc);
+  return rb_ca_fixlen_string_wrap(raw, NIL_P(renc) ? rb_ascii8bit_encindex()
+                                                   : rb_to_encoding_index(renc));
+}
+
+/* The encoding of the text in the cells; BINARY when the cells claim none. */
+static VALUE
+rb_ca_fixlen_string_encoding (VALUE self)
+{
+  CAFixlenString *ca;
+  TypedData_Get_Struct(self, CAFixlenString, &cafixlen_string_data_type, ca);
+  return rb_enc_from_encoding(rb_enc_from_index(ca->encoding_id));
+}
+
+/* Arrays of two text encodings cannot be read as one column; cells that
+   claim no encoding go with either. */
+static int
+ca_fixlen_string_state_compatible (CArray *a, CArray *b)
+{
+  int ea = ((CAFixlenString *) a)->encoding_id;
+  int eb = ((CAFixlenString *) b)->encoding_id;
+  int binary = rb_ascii8bit_encindex();
+  return ( ea == eb || ea == binary || eb == binary ) ? 1 : 0;
 }
 
 /* Per-cell scalar decode: strip trailing NUL padding from the raw K-byte
@@ -249,14 +278,15 @@ rb_ca_fixlen_string_wrap_method (VALUE klass, VALUE raw)
 static VALUE
 rb_ca_fixlen_string_storage_to_element (VALUE self, VALUE raw)
 {
-  (void) self;
   if ( TYPE(raw) == T_STRING ) {
+    CAFixlenString *ca;
     const char *p = RSTRING_PTR(raw);
     long n = RSTRING_LEN(raw);
     while ( n > 0 && p[n - 1] == '\0' ) {
       n--;
     }
-    return rb_str_new(p, n);
+    TypedData_Get_Struct(self, CAFixlenString, &cafixlen_string_data_type, ca);
+    return rb_enc_str_new(p, n, rb_enc_from_index(ca->encoding_id));
   }
   return raw;
 }
@@ -279,7 +309,7 @@ rb_ca_fixlen_string_initialize_copy (VALUE self, VALUE other)
   if ( ca_func[CA_OBJ_FIXLEN_STRING].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_FIXLEN_STRING, cs->parent->ndim);
   }
-  ca_fixlen_string_setup(ca, cs->parent);
+  ca_fixlen_string_setup(ca, cs->parent, cs->encoding_id);
   ca_view_inherit_mask((VALUE) ca);
   return self;
 }
@@ -304,7 +334,9 @@ Init_ca_obj_fixlen_string (void)
   rb_define_method(rb_cCAFixlenString, "initialize_copy",
                                        rb_ca_fixlen_string_initialize_copy, 1);
   rb_define_singleton_method(rb_cCAFixlenString, "wrap",
-                                       rb_ca_fixlen_string_wrap_method, 1);
+                                       rb_ca_fixlen_string_wrap_method, -1);
+  rb_define_method(rb_cCAFixlenString, "encoding",
+                                       rb_ca_fixlen_string_encoding, 0);
   rb_define_method(rb_cCAFixlenString, "storage_to_element",
                                        rb_ca_fixlen_string_storage_to_element, 1);
   ca_face_register_storage_to_element(CA_OBJ_FIXLEN_STRING,
@@ -314,6 +346,8 @@ Init_ca_obj_fixlen_string (void)
      or per-parent buffer), so the Face can be carried across multi-parent
      constructions like CAStack. */
   ca_face_register_state_portable(CA_OBJ_FIXLEN_STRING, 1);
+  ca_face_register_state_compatible(CA_OBJ_FIXLEN_STRING,
+                                    ca_fixlen_string_state_compatible);
 
   /* The bytes are the strings: a MemoryView consumer reads them as "Ns". */
   ca_face_register_memory_view(CA_OBJ_FIXLEN_STRING, 1);

data/ext/ca_obj_grid.c

@@ -15,6 +15,7 @@
 
 #include "carray.h"
 #include "carray_internal.h"   /* ca_attach_window */
+#include "ca_obj_face.h"       /* CA_WRAPPER_LIFT */
 
 /* Per-axis tagged kind.  Each axis is either STRIDE (start/step/count,
    no allocation) or INDEX (an owned ca_size_t index snapshot).  A Range
@@ -1087,9 +1088,11 @@ ca_grid_func_allocate (void *ap)
 {
   CAGrid *ca = (CAGrid *) ap;
   if ( ! cag_owns_buffer(ca) ) {
-    ca_attach(ca->parent);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
+  }
+  else {
+    ca->ptr = ca_alloc_cells((CArray *) ca);
   }
-  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -1104,10 +1107,10 @@ ca_grid_func_attach (void *ap)
     return;
   }
 
-  ca_attach(ca->parent);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_grid_describe_axes(ca, desc, pdims);
-  ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
-                                    ca->bytes, ca->elements, NULL);
+  ca_axis_dispatch_gather(ca->parent, pdims, desc, ca->ndim,
+                          ca->bytes, ca->elements, NULL, ca->ptr);
 }
 
 static void
@@ -1422,8 +1425,9 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
   extern int ca_csa_dispatch_bypass;
   if ( ! ca_csa_dispatch_bypass && argc > 0 && TYPE(argv[0]) == T_DATA ) {
     if ( rb_ca_select_axis_eligible_p(argc, argv, self) ) {
-      return ca_grid_drop_scalar_axes(rb_ca_select_axis(argc, argv, self),
-                                      argc, argv);
+      obj = rb_ca_select_axis(argc, argv, self);
+      CA_WRAPPER_LIFT(obj, self, ca);
+      return ca_grid_drop_scalar_axes(obj, argc, argv);
     }
   }
 
@@ -1492,6 +1496,7 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
                            (VALUE) &c);
   }
 
+  CA_WRAPPER_LIFT(obj, self, ca);
   return ca_grid_drop_scalar_axes(obj, argc, argv);
 }