carray 3.0.2 → 3.0.4

data/ext/carray_copy.c

@@ -36,6 +36,42 @@ ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg)
   }
 }
 
+void
+ca_fill_or_xfree (void *buf, VALUE (*fill)(VALUE), VALUE arg)
+{
+  int tag = 0;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    xfree(buf);
+    rb_jump_tag(tag);
+  }
+}
+
+void
+ca_fill_or_detach (int n, CArray **list, VALUE (*fill)(VALUE), VALUE arg)
+{
+  int tag = 0;
+  int k;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    for ( k = 0; k < n; k++ ) {
+      ca_detach(list[k]);
+    }
+    rb_jump_tag(tag);
+  }
+}
+
+VALUE
+ca_view_inherit_mask (VALUE view)
+{
+  CArray *ca     = (CArray *) view;
+  CArray *parent = ((CAView *) ca)->parent;
+  if ( parent && ca_has_mask(parent) ) {
+    ca_create_mask(ca);
+  }
+  return Qnil;
+}
+
 static VALUE
 ca_copy_fill (VALUE arg)
 {
@@ -72,14 +108,32 @@ ca_copy (void *ap)
 
   pair[0] = ca;
   pair[1] = co;
-  ca_fill_or_free(co, ca_copy_fill, (VALUE) pair);
+
+  /* Object cells read from a view that computes them exist only in
+     co->ptr, and copying the mask afterwards can build it -- a lazy
+     expression's mask is computed from its operands -- which allocates.
+     Hold them until the copy is complete.  carray_new has filled the
+     cells with valid VALUEs. */
+  if ( ca_is_object_type(co) ) {
+    int tag = 0;
+    int guard = ca_gc_hold_push(co->ptr, co->elements);
+    rb_protect(ca_copy_fill, (VALUE) pair, &tag);
+    ca_gc_hold_pop_to(guard);
+    if ( tag ) {
+      ca_free(co);
+      rb_jump_tag(tag);
+    }
+  }
+  else {
+    ca_fill_or_free(co, ca_copy_fill, (VALUE) pair);
+  }
 
   return co;
 }
 
 /* Ruby entry for `CArray#copy`.  Wraps `ca_copy` and, when `self` is a
  * Face (e.g. CARecord), lifts the wrapped result so the derived class
- * identity is preserved on the copy. */
+ * identity is preserved on the copy.  The copy keeps self's attributes. */
 VALUE
 rb_ca_copy (VALUE self)
 {
@@ -97,6 +151,7 @@ rb_ca_copy (VALUE self)
   obj = ca_wrap_struct(co);
   ca_gc_hold_pop_to(guard);
   CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  rb_ca_inherit_attr(obj, self);
   return obj;
 }
 
@@ -154,7 +209,7 @@ rb_ca_to_ca (int argc, VALUE *argv, VALUE self)
     CArray *ca;
     TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
     if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError, "can't modify read-only carray");
+      ca_refuse_read_only();
     }
   }
   return self;
@@ -201,7 +256,7 @@ CArray *
 ca_template_safe2 (void *ap, int8_t data_type, ca_size_t bytes)
 {
   CArray *ca = (CArray *) ap;
-  CA_CHECK_DATA_TYPE(data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
   if ( ca_is_scalar(ca) ) {
     return (CArray*) cscalar_new(data_type, bytes, NULL);
   }
@@ -220,9 +275,8 @@ ca_template_safe2 (void *ap, int8_t data_type, ca_size_t bytes)
  * The arity dispatch matches `CArray.new` (ca_obj_array.c) so the two
  * factories behave the same for block-driven initialisation. */
 static VALUE
-rb_ca_template_method (int argc, VALUE *argv, VALUE self)
+rb_ca_template_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
 {
-  volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE obj, rtype, rbytes = Qnil;
   CArray *ca, *co;
   int8_t data_type;
@@ -243,6 +297,19 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
     obj = ca_wrap_struct(co);
   }
 
+  /* Preserve the Face identity only for a same-type template (no explicit
+   * retype).  A retype (template(:boolean)) is a different-typed buffer and
+   * must not be re-wrapped as the Face.  A same-type template of a Face with
+   * a valid blank form (CARecord carries its data_class through the struct
+   * tail; identity Faces alias same-type storage) is lifted so the class is
+   * preserved.  A Face with no valid blank form (CAConstString's content-
+   * defined offset+buffer) overrides `template` in Ruby to return a plain
+   * array instead of a broken same-class shell.  The lift comes before the
+   * block initialiser so its values are stored through the Face. */
+  if ( NIL_P(rtype) ) {
+    CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  }
+
   if ( rb_block_given_p() ) {
     if ( rb_proc_arity(rb_block_proc()) == 0 ) {
       volatile VALUE rval = rb_yield_values2(0, NULL);
@@ -256,10 +323,7 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
       if ( co->ndim > 0 ) {
         ca_size_t idx[CA_RANK_MAX];
         volatile VALUE ridx = rb_ary_new2(co->ndim);
-        ca_attach(co);
         rb_ca_index_walk(obj, co, 0, idx, ridx, CA_LOOP_STORE);
-        ca_sync(co);
-        ca_detach(co);
       }
       else {
         volatile VALUE rval = rb_yield_values2(0, NULL);
@@ -268,21 +332,16 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
     }
   }
 
-  /* Preserve the Face identity only for a same-type template (no explicit
-   * retype).  A retype (template(:boolean)) is a different-typed buffer and
-   * must not be re-wrapped as the Face.  A same-type template of a Face with
-   * a valid blank form (CARecord carries its data_class through the struct
-   * tail; identity Faces alias same-type storage) is lifted so the class is
-   * preserved.  A Face with no valid blank form (CAConstString's content-
-   * defined offset+buffer) overrides `template` in Ruby to return a plain
-   * array instead of a broken same-class shell. */
-  if ( NIL_P(rtype) ) {
-    CA_FACE_LIFT_IF_FACE(obj, self, ca);
-  }
-
   return obj;
 }
 
+static VALUE
+rb_ca_template_method (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  return rb_ca_template_kw(argc, argv, ropt, self);
+}
+
 VALUE
 rb_ca_template (VALUE self)
 {
@@ -292,10 +351,9 @@ rb_ca_template (VALUE self)
 VALUE
 rb_ca_template_with_type (VALUE self, VALUE rtype, VALUE rbytes)
 {
-  VALUE ropt = rb_hash_new();
-  VALUE args[2] = { rtype, ropt };
+  volatile VALUE ropt = rb_hash_new();
   rb_set_options(ropt, "bytes", rbytes);
-  return rb_ca_template_method(2, args, self);
+  return rb_ca_template_kw(1, &rtype, ropt, self);
 }
 
 /* Returns `template` of the first non-scalar among `n` variadic CArray