carray 3.0.3 → 3.0.4

data/ext/carray_struct.c

@@ -2,7 +2,7 @@
 
   C-native member access for CAStruct subclasses.  The hooked
   methods (`[]`, `[]=`, `initialize`) are installed on a subclass by
-  `CArray.__install_castruct_methods__(klass)` — called from the
+  `CArray.install_struct_methods(klass)` — called from the
   bottom of lib/carray/struct.rb once CAStruct is defined, so this
   ext can load before that file.
 
@@ -22,6 +22,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_obj2integer_fitting */
 #include <string.h>
 
 /* ---------------------------------------------------------------------
@@ -130,42 +131,42 @@ ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
     return;
   }
   case CA_INT8: {
-    int8_t v = (int8_t) NUM2INT(val);
+    int8_t v = (int8_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT8));
     memcpy(p, &v, 1);
     return;
   }
   case CA_UINT8: {
-    uint8_t v = (uint8_t) NUM2UINT(val);
+    uint8_t v = (uint8_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT8));
     memcpy(p, &v, 1);
     return;
   }
   case CA_INT16: {
-    int16_t v = (int16_t) NUM2INT(val);
+    int16_t v = (int16_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT16));
     memcpy(p, &v, 2);
     return;
   }
   case CA_UINT16: {
-    uint16_t v = (uint16_t) NUM2UINT(val);
+    uint16_t v = (uint16_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT16));
     memcpy(p, &v, 2);
     return;
   }
   case CA_INT32: {
-    int32_t v = (int32_t) NUM2LONG(val);
+    int32_t v = (int32_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT32));
     memcpy(p, &v, 4);
     return;
   }
   case CA_UINT32: {
-    uint32_t v = (uint32_t) NUM2ULONG(val);
+    uint32_t v = (uint32_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT32));
     memcpy(p, &v, 4);
     return;
   }
   case CA_INT64: {
-    int64_t v = (int64_t) NUM2LL(val);
+    int64_t v = (int64_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT64));
     memcpy(p, &v, 8);
     return;
   }
   case CA_UINT64: {
-    uint64_t v = (uint64_t) NUM2ULL(val);
+    uint64_t v = (uint64_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT64));
     memcpy(p, &v, 8);
     return;
   }
@@ -333,32 +334,32 @@ ca_struct_write_endian_swapped_fast (char *p, int type_code, VALUE val)
 {
   switch (type_code) {
   case CA_INT16: {
-    uint16_t v = (uint16_t) NUM2INT(val);
+    uint16_t v = (uint16_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT16));
     v = CA_BSWAP16(v); memcpy(p, &v, 2);
     return;
   }
   case CA_UINT16: {
-    uint16_t v = (uint16_t) NUM2UINT(val);
+    uint16_t v = (uint16_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT16));
     v = CA_BSWAP16(v); memcpy(p, &v, 2);
     return;
   }
   case CA_INT32: {
-    uint32_t v = (uint32_t) NUM2LONG(val);
+    uint32_t v = (uint32_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT32));
     v = CA_BSWAP32(v); memcpy(p, &v, 4);
     return;
   }
   case CA_UINT32: {
-    uint32_t v = (uint32_t) NUM2ULONG(val);
+    uint32_t v = (uint32_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT32));
     v = CA_BSWAP32(v); memcpy(p, &v, 4);
     return;
   }
   case CA_INT64: {
-    uint64_t v = (uint64_t) NUM2LL(val);
+    uint64_t v = (uint64_t) NUM2LL(ca_obj2integer_fitting(val, CA_INT64));
     v = CA_BSWAP64(v); memcpy(p, &v, 8);
     return;
   }
   case CA_UINT64: {
-    uint64_t v = NUM2ULL(val);
+    uint64_t v = (uint64_t) rb_num2ull(ca_obj2integer_fitting(val, CA_UINT64));
     v = CA_BSWAP64(v); memcpy(p, &v, 8);
     return;
   }
@@ -767,7 +768,7 @@ void
 Init_carray_struct (void)
 {
   /* Singleton on rb_cCArray so lib/carray/struct.rb can call it as
-     `CArray.__install_castruct_methods__(klass)`. */
-  rb_define_singleton_method(rb_cCArray, "__install_castruct_methods__",
-                             rb_carray_install_castruct_methods, 1);
+     `CArray.install_struct_methods(klass)`. */
+  rb_define_private_method(rb_singleton_class(rb_cCArray), "install_struct_methods",
+                           rb_carray_install_castruct_methods, 1);
 }

data/ext/carray_test.c

@@ -82,7 +82,8 @@ ca_check_same_data_type (void *ap1, void *ap2)
 {
   CArray *ca1 = (CArray *) ap1;
   CArray *ca2 = (CArray *) ap2;
-  if ( ca1->data_type != ca2->data_type ) {
+  if ( ca1->data_type != ca2->data_type ||
+       ( ca1->data_type == CA_FIXLEN && ca1->bytes != ca2->bytes ) ) {
     rb_raise(rb_eCADataTypeError, "data_type mismatch");
   }
 }
@@ -200,8 +201,9 @@ rb_ca_is_type (VALUE arg, int type)
    live in ca_obj_record.c; signatures stay in carray.h for cross-file
    extern use. */
 
-/* CArray#valid_index?(*idx) — 1 if the index tuple is in range, else 0.
- * The number of indices must equal ndim (raises otherwise). */
+/* CArray#valid_index?(*idx) -- whether self[*idx] names a cell: a negative
+ * index counts from the end of its axis, as it does at every door.  The
+ * number of indices must equal ndim (raises otherwise). */
 static VALUE
 rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
 {
@@ -217,6 +219,9 @@ rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
   }
   for (i=0; i<ca->ndim; i++) {
     idx = NUM2SIZE(argv[i]);
+    if ( idx < 0 ) {
+      idx += ca->dim[i];
+    }
     if ( idx < 0 || idx >= ca->dim[i] ) {
       return Qfalse;
     }
@@ -225,7 +230,8 @@ rb_ca_is_valid_index (int argc, VALUE *argv, VALUE self)
   return Qtrue;
 }
 
-/* CArray#valid_addr?(addr) — 1 if addr is in range 0...elements, else 0. */
+/* CArray#valid_addr?(addr) -- whether addr names a cell: a negative address
+ * counts from the end. */
 static VALUE
 rb_ca_is_valid_addr (VALUE self, VALUE raddr)
 {
@@ -234,6 +240,9 @@ rb_ca_is_valid_addr (VALUE self, VALUE raddr)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   addr = NUM2SIZE(raddr);
+  if ( addr < 0 ) {
+    addr += ca->elements;
+  }
   if ( addr < 0 || addr >= ca->elements ) {
     return Qfalse;
   }
@@ -249,6 +258,7 @@ rb_ca_has_same_shape (VALUE self, VALUE other)
 {
   CArray *ca, *cb;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  /* coerce: only the shape is compared */
   cb = ca_wrap_readonly(other, ca->data_type);
   return ca_has_same_shape(ca, cb) ? Qtrue : Qfalse;
 }
@@ -684,10 +694,21 @@ rb_ca_modify (VALUE self)
   rb_check_frozen(self);
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   if ( ca_is_readonly(ca) ) {
-    rb_raise(rb_eRuntimeError, "can not modify read-only array");
+    ca_refuse_read_only();
   }
 }
 
+/* The refusal of a write into a read-only array that is not frozen (a
+   frozen one is Ruby's FrozenError, from rb_check_frozen): every guard
+   raises it, the entry points through rb_ca_modify and the transfers and
+   fills below them, which are the last line when an entry is missed. */
+void
+ca_refuse_read_only (void)
+{
+  rb_raise(rb_eRuntimeError, "%s: can not modify read-only array",
+           ca_calling_method_name());
+}
+
 /* CArray#freeze — freeze self and set CA_FLAG_READ_ONLY so subsequent
  * mutations raise FrozenError. */
 VALUE

data/ext/carray_undef.c

@@ -18,6 +18,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "ruby.h"
+#include "ruby/ractor.h"
 
 static VALUE rb_cUNDEF;
 
@@ -63,6 +64,9 @@ Init_carray_undef (void)
      can be created.  The identity invariant relies on this. */
   CA_UNDEF = rb_funcall(rb_cUNDEF, rb_intern("new"), 0);
   rb_undef_method(CLASS_OF(rb_cUNDEF), "new");
+  /* Frozen and shareable: masked reads hand the same object to every
+     Ractor. */
+  rb_ractor_make_shareable(CA_UNDEF);
   rb_const_set(rb_cObject, rb_intern("UNDEF"), CA_UNDEF);
 
   /* CAREFUL: CA_UNDEF is dereferenced via raw pointer compare