carray 3.0.6 → 3.0.7

data/ext/ca_sweep_engine.c

@@ -36,6 +36,28 @@ ca_sweep_shape_str (CArray *ca)
   return s;
 }
 
+/* fsync is the kernel author's string: one '0' (input) or '1' (output) per
+ * operand.  Any other character would read as neither, and that operand
+ * would be neither written back nor given a mask. */
+static void
+ca_sweep_check_fsync (ca_sweep_state_t *st, const char *fallback_label)
+{
+  int k_op;
+  if ((int) strlen(st->fsync) != st->n_ops) {
+    rb_raise(rb_eRuntimeError,
+             "[BUG] invalid length of fsync arg in %s (expected %d)",
+             st->src_label ? st->src_label : fallback_label, st->n_ops);
+  }
+  for (k_op = 0; k_op < st->n_ops; k_op++) {
+    if (st->fsync[k_op] != '0' && st->fsync[k_op] != '1') {
+      rb_raise(rb_eRuntimeError,
+               "[BUG] invalid character '%c' in fsync arg \"%s\" in %s "
+               "(expected '0' or '1')", st->fsync[k_op], st->fsync,
+               st->src_label ? st->src_label : fallback_label);
+    }
+  }
+}
+
 void
 ca_sweep_refuse_shapes (CArray *a, CArray *b)
 {
@@ -60,8 +82,10 @@ ca_sweep_same_shape (CArray *a, CArray *b)
 
 /* Pair the operands: a scalar walks with stride 0, every other operand
  * must have the shape of the first non-scalar one, which is returned (NULL
- * when all operands are scalars).  Sets stride[] and n_kernel.  Allocates
- * nothing, so it runs before any operand is acquired. */
+ * when all operands are scalars).  A scalar OUTPUT would have every cell of
+ * the walk written over one cell, so it is refused beside an array.  Sets
+ * stride[] and n_kernel.  Allocates nothing, so it runs before any operand
+ * is acquired. */
 static CArray *
 ca_sweep_pair_operands (ca_sweep_state_t *st)
 {
@@ -82,6 +106,14 @@ ca_sweep_pair_operands (ca_sweep_state_t *st)
       ca_sweep_refuse_shapes(donor, ca);
     }
   }
+  for (k_op = 0; donor && k_op < st->n_ops; k_op++) {
+    if (st->fsync[k_op] == '1' && ca_is_scalar(st->cx[k_op])) {
+      rb_raise(rb_eArgError,
+               "%s: a scalar output has one cell, and an array of %lld cells "
+               "was given as an operand; a scalar output pairs only with "
+               "scalars", ca_calling_method_name(), (long long) st->n_kernel);
+    }
+  }
   return donor;
 }
 
@@ -117,6 +149,29 @@ ca_sweep_any_input_mask (ca_sweep_state_t *st)
   return 0;
 }
 
+/* The whole-buffer scratch for INPUT ca.  Object cells read from a lazy
+ * operand or a CAObject exist nowhere else until the kernel has used them,
+ * and the kernel may call Ruby, so the scratch is held for GC as long as it
+ * lives.  It is recorded in owned_buf before the hold, which can raise. */
+static char *
+ca_sweep_scratch_alloc (ca_sweep_state_t *st, int k_op)
+{
+  CArray *ca = st->cx[k_op];
+  st->owned_buf[k_op] = xmalloc(ca->elements * ca->bytes);
+  if (ca->data_type == CA_OBJECT) {
+    ca_object_cells_clear(st->owned_buf[k_op], ca->elements);
+    ca_gc_hold_buffer(st->owned_buf[k_op], ca->elements);
+  }
+  return st->owned_buf[k_op];
+}
+
+static void
+ca_sweep_scratch_free (void *buf)
+{
+  ca_gc_release_buffer(buf);
+  xfree(buf);
+}
+
 /* Give back everything acquire has taken so far, without syncing: detach
  * attached operands, free owned scratch (xmalloc on the whole-buffer path,
  * arena on the chunked one) and the mask buffers.  Called when a read
@@ -132,7 +187,7 @@ ca_sweep_abort (ca_sweep_state_t *st, int chunked)
       ca_detach(st->cx[k_op]);
     } else if (st->owned_buf[k_op]) {
       if (chunked) ca_lazy_arena_release(st->owned_buf[k_op]);
-      else         xfree(st->owned_buf[k_op]);
+      else         ca_sweep_scratch_free(st->owned_buf[k_op]);
     }
     st->owned_buf[k_op] = NULL;
   }
@@ -147,6 +202,21 @@ ca_sweep_abort (ca_sweep_state_t *st, int chunked)
   }
 }
 
+/* The outputs' masks are overwritten by the OR of the input masks.  When no
+ * input is masked that is all clear, and there is no m0 to carry it: clear
+ * them here, before an output is attached, so a view gathers the cleared
+ * mask.  An output without a mask does not get one. */
+static void
+ca_sweep_clear_output_masks (ca_sweep_state_t *st)
+{
+  int k_op;
+  for (k_op = 0; k_op < st->n_ops; k_op++) {
+    if (st->fsync[k_op] == '1' && ca_has_mask(st->cx[k_op])) {
+      ca_clear_mask(st->cx[k_op]);
+    }
+  }
+}
+
 typedef struct {
   ca_sweep_state_t *st;
   int               any_input_mask;
@@ -163,6 +233,8 @@ ca_sweep_acquire_body (VALUE arg)
   ca_sweep_state_t *st = ctx->st;
   int k_op;
 
+  if (!ctx->any_input_mask) ca_sweep_clear_output_masks(st);
+
   /* Per-operand acquire:
    *   OUTPUT (fsync == '1')       -> ca_attach + base = ca->ptr
    *   INPUT alias                 -> ca_attach + base = ca->ptr
@@ -178,9 +250,7 @@ ca_sweep_acquire_body (VALUE arg)
       st->attached[k_op] = 1;
       st->base[k_op]     = (char *) ca->ptr;
     } else {
-      ca_size_t bytes_total = ca->elements * ca->bytes;
-      st->owned_buf[k_op] = xmalloc(bytes_total);
-      st->base[k_op]      = st->owned_buf[k_op];
+      st->base[k_op] = ca_sweep_scratch_alloc(st, k_op);
       ca_xfer_all(ca, st->base[k_op], CA_XFER_GET);
     }
   }
@@ -209,7 +279,7 @@ ca_sweep_acquire_body (VALUE arg)
   }
 
   /* Overwrite each OUTPUT mask with the iter mask (creating the
-     OUTPUT mask if it did not exist).  No-op when m0 is NULL. */
+     OUTPUT mask if it did not exist). */
   if (st->m0) {
     for (k_op = 0; k_op < st->n_ops; k_op++) {
       CArray *ca = st->cx[k_op];
@@ -228,12 +298,7 @@ ca_sweep_acquire (ca_sweep_state_t *st)
   int k_op;
   int tag = 0;
 
-  if ((int) strlen(st->fsync) != st->n_ops) {
-    rb_raise(rb_eRuntimeError,
-             "[BUG] invalid length of fsync arg in %s (expected %d)",
-             st->src_label ? st->src_label : "ca_sweep_acquire",
-             st->n_ops);
-  }
+  ca_sweep_check_fsync(st, "ca_sweep_acquire");
 
   for (k_op = 0; k_op < st->n_ops; k_op++) {
     st->base[k_op]      = NULL;
@@ -343,7 +408,7 @@ ca_sweep_release (ca_sweep_state_t *st)
     if (st->attached[k_op]) {
       ca_detach(st->cx[k_op]);
     } else if (st->owned_buf[k_op]) {
-      xfree(st->owned_buf[k_op]);
+      ca_sweep_scratch_free(st->owned_buf[k_op]);
       st->owned_buf[k_op] = NULL;
     }
   }
@@ -363,6 +428,8 @@ ca_sweep_acquire_chunked_body (VALUE arg)
   ca_sweep_state_t *st = ctx->st;
   int k_op;
 
+  if (!ctx->any_input_mask) ca_sweep_clear_output_masks(st);
+
   /* per-operand acquire:
    *   OUTPUT (fsync == '1') : ca_attach + base_orig = ca->ptr (legitimate)
    *   INPUT  alias          : ca_attach + base_orig = ca->ptr (zero-copy)
@@ -378,9 +445,14 @@ ca_sweep_acquire_chunked_body (VALUE arg)
       st->attached[k_op]  = 1;
       st->base_orig[k_op] = (char *) ca->ptr;
     } else {
-      /* non-alias non-scalar INPUT: arena scratch sized for chunk_n_max */
-      ca_size_t scratch_bytes = st->chunk_n_max * ca->bytes;
-      st->owned_buf[k_op] = (char *) ca_lazy_arena_acquire(scratch_bytes);
+      /* non-alias non-scalar INPUT: arena scratch sized for chunk_n_max;
+       * the arena marks an object scratch while it is in use */
+      if (ca->data_type == CA_OBJECT) {
+        st->owned_buf[k_op] = (char *) ca_lazy_arena_acquire_object(st->chunk_n_max);
+      } else {
+        ca_size_t scratch_bytes = st->chunk_n_max * ca->bytes;
+        st->owned_buf[k_op] = (char *) ca_lazy_arena_acquire(scratch_bytes);
+      }
       /* base_orig stays NULL -- per-chunk gather lands the data in
        * owned_buf[k_op]; base[k_op] will be set to owned_buf[k_op] at
        * each chunk boundary. */
@@ -424,12 +496,7 @@ ca_sweep_acquire_chunked (ca_sweep_state_t *st)
   int tag = 0;
   CArray *shape_donor = NULL;
 
-  if ((int) strlen(st->fsync) != st->n_ops) {
-    rb_raise(rb_eRuntimeError,
-             "[BUG] invalid length of fsync arg in %s (expected %d)",
-             st->src_label ? st->src_label : "ca_sweep_acquire_chunked",
-             st->n_ops);
-  }
+  ca_sweep_check_fsync(st, "ca_sweep_acquire_chunked");
 
   for (k_op = 0; k_op < st->n_ops; k_op++) {
     st->base[k_op]      = NULL;

data/ext/ca_sweep_engine.h

@@ -2,10 +2,8 @@
  *
  *  ca_sweep_engine.h -- sweep (xfer_all) author surface engine, shared helper
  *
- *  Established in PROPOSAL_L0_AUTHOR_SURFACE L0.1 (2026-06-11).  Extracts
- *  the xfer_all-aware lifecycle template previously duplicated 7-times in
- *  ext/carray_call_cfunc.c (= one body per arity 1..7) into a single shared
- *  helper, also used by the chunked slab family (ca_call_cslab_*).
+ *  The xfer_all-aware lifecycle shared by ext/carray_call_cfunc.c (one body
+ *  per arity 1..7) and the chunked slab family (ca_call_cslab_*).
  *
  *  Lifecycle template:
  *    (1) per-operand acquire
@@ -14,7 +12,8 @@
  *          INPUT  (fsync=='0') non-alias  -> xmalloc + ca_xfer_all(GET)
  *    (2) operand pairing (scalar collapse; arrays must agree in shape)
  *    (3) mask OR across INPUT operands -> m0 (xmalloc, NULL if none)
- *    (4) mask propagate to OUTPUT operands (overwrite output->mask)
+ *    (4) mask propagate to OUTPUT operands (overwrite output->mask; cleared
+ *        when no INPUT is masked)
  *    (5) caller runs the per-cell loop using base[] + stride[]
  *    (6) per-operand release (reverse order):
  *          sync OUTPUTs, detach attached or xfree owned_buf, xfree m0
@@ -64,7 +63,7 @@ typedef struct ca_sweep_state {
   ca_size_t       n_kernel;
   const char     *src_label;
 
-  /* === chunked path fields (L0.1 chunk, PROPOSAL_L0_AUTHOR_SURFACE) === */
+  /* === chunked path fields === */
   /* Used by ca_sweep_acquire_chunked / ca_sweep_next_chunk / ca_sweep_release_chunked
    * (= the chunked slab family, ca_call_cslab_*).  Unused by the whole-materialise path
    * (ca_sweep_acquire / ca_sweep_release) — cfunc and other whole-buffer callers

data/ext/caframe_csv_reader.c

@@ -498,7 +498,7 @@ ca_csv_build_const_string_columns (VALUE text, ca_csv_walk_t *w)
     CArray *pe;
     int64_t *range;
     boolean8_t *m = NULL;
-    VALUE col = rb_carray_new(CA_FIXLEN, 1, dim, 2 * sizeof(int64_t), NULL);
+    volatile VALUE col = rb_carray_new(CA_FIXLEN, 1, dim, 2 * sizeof(int64_t), NULL);
     rb_ary_push(cols, col);
     TypedData_Get_Struct(col, CArray, &carray_data_type, pe);
     range = (int64_t *) pe->ptr;

data/ext/carray.h

@@ -1201,7 +1201,9 @@ double    OBJ2DBL (VALUE v);
 /* Mask-aware object->numeric parsers: return 1 with *out set on success, or
    0 (no value; caller masks the cell) on parse failure.  Used by the
    object->int/float cast loop so an unparseable cell becomes UNDEF instead
-   of a silent 0.0 (float) or a raise (int).  See ext/carray_cast.c. */
+   of a silent 0.0 (float) or a raise (int).  An Integer wider than the C
+   type gives its low bytes (two's complement), as a narrowing C cast does;
+   these parsers do not raise.  See ext/carray_cast.c. */
 int   ca_obj2dbl_ok   (VALUE v, double *out);
 int   ca_obj2cmplx_ok (VALUE v, double complex *out);
 int   rb_obj2long_ok  (VALUE v, long *out);

data/ext/carray_access.c

@@ -39,15 +39,9 @@ rb_ca_store_index (VALUE self, ca_size_t *idx, VALUE rval)
     ca_create_mask(ca);
     ca_store_index(ca->mask, idx, &one);
   }
-  else {                   /* unset mask and set value of the element at the index 'idx' */
+  else {                   /* set value of the element at the index 'idx' and unset its mask */
 
-    /* unset mask */
-    ca_update_mask(ca);
-    if ( ca->mask ) {
-      ca_store_index(ca->mask, idx, &zero);
-    }
-
-    /* store value */
+    /* A value that can not be stored leaves the cell masked. */
     {
       volatile VALUE holder;
       char *v = ALLOCV_N(char, holder, ca->bytes);
@@ -55,6 +49,11 @@ rb_ca_store_index (VALUE self, ca_size_t *idx, VALUE rval)
       ca_store_index(ca, idx, v);
       ALLOCV_END(holder);
     }
+
+    ca_update_mask(ca);
+    if ( ca->mask ) {
+      ca_store_index(ca->mask, idx, &zero);
+    }
   }
 
   return rval;
@@ -123,13 +122,9 @@ rb_ca_store_addr (VALUE self, ca_size_t addr, VALUE rval)
     ca_create_mask(ca);
     ca_store_addr(ca->mask, addr, &one);
   }
-  else {                   /* set value at the element */
-    ca_update_mask(ca);
-    if ( ca->mask ) {
-      ca_store_addr(ca->mask, addr, &zero); /* unset mask */
-    }
+  else {                   /* set value at the element and unset its mask */
 
-    /* store value */
+    /* A value that can not be stored leaves the cell masked. */
     {
       volatile VALUE holder;
       char *v = ALLOCV_N(char, holder, ca->bytes);
@@ -137,6 +132,11 @@ rb_ca_store_addr (VALUE self, ca_size_t addr, VALUE rval)
       ca_store_addr(ca, addr, v);
       ALLOCV_END(holder);
     }
+
+    ca_update_mask(ca);
+    if ( ca->mask ) {
+      ca_store_addr(ca->mask, addr, &zero);
+    }
   }
 
   return rval;
@@ -426,14 +426,38 @@ rb_ca_ref_address (VALUE self, CAIndexInfo *info)
   return rb_ca_fetch_addr(self, addr);
 }
 
+/* What a store to one cell takes from an array: its one cell.  A cell of an
+   object array holds any value, the array itself included, so only a
+   CScalar is opened there. */
+static VALUE
+ca_cell_of_store_value (VALUE self, VALUE rval)
+{
+  CArray *ca, *cv;
+  if ( rb_obj_is_cscalar(rval) ) {
+    return rb_ca_fetch_addr(rval, 0);
+  }
+  if ( ! rb_obj_is_carray(rval) ) {
+    return rval;
+  }
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ca->data_type == CA_OBJECT ) {
+    return rval;
+  }
+  TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
+  if ( cv->elements != 1 ) {
+    rb_raise(rb_eArgError,
+             "%s: shape mismatch writing to one cell (<- %" PRIi64 " cells)",
+             ca_calling_method_name(), (int64_t) cv->elements);
+  }
+  return rb_ca_fetch_addr(rval, 0);
+}
+
 static VALUE
 rb_ca_store_address (VALUE self, CAIndexInfo *info, volatile VALUE rval)
 {
   ca_size_t addr;
   addr = info->index[0].scalar;
-  if ( rb_obj_is_cscalar(rval) ) {
-    rval = rb_ca_fetch_addr(rval, 0);
-  }
+  rval = ca_cell_of_store_value(self, rval);
   rb_ca_store_addr(self, addr, rval);
   return rval;
 }
@@ -461,9 +485,7 @@ rb_ca_store_point (VALUE self, CAIndexInfo *info, volatile VALUE val)
   for (i=0; i<ca->ndim; i++) {
     idx[i] = info->index[i].scalar;
   }
-  if ( rb_obj_is_cscalar(val) ) {
-    val = rb_ca_fetch_addr(val, 0);
-  }
+  val = ca_cell_of_store_value(self, val);
   rb_ca_store_index(self, idx, val);
   return val;
 }
@@ -522,8 +544,8 @@ ca_store_all_cast_body (VALUE arg)
     memset(ca->mask->ptr, 0, ca->elements);
   }
   if ( ca->mask ) {
-    ca_cast_block_with_mask(ca->elements, c->cv, c->scratch, ca, ca->ptr,
-                            (boolean8_t*)ca->mask->ptr);
+    ca_cast_block_skip_masked(ca->elements, c->cv, c->scratch, ca, ca->ptr,
+                              (boolean8_t*)ca->mask->ptr);
   }
   else {
     ca_cast_block(ca->elements, c->cv, c->scratch, ca, ca->ptr);
@@ -567,9 +589,9 @@ ca_store_all_list_body (VALUE arg)
       }
       m++;
     }
-    ca_cast_block_with_mask(ca->elements, c->ico, (VALUE *)RARRAY_CONST_PTR(list),
-                            cast_target, ca->ptr,
-                            (boolean8_t*)ca->mask->ptr);
+    ca_cast_block_skip_masked(ca->elements, c->ico, (VALUE *)RARRAY_CONST_PTR(list),
+                              cast_target, ca->ptr,
+                              (boolean8_t*)ca->mask->ptr);
   }
   else {
     /* Every cell gets a value, so none stays masked. */
@@ -617,8 +639,8 @@ ca_face_source_for_store (VALUE self, CArray *ca, VALUE rval)
                rb_ca_data_class(rval), rb_ca_data_class(self));
     }
     rb_raise(rb_eTypeError,
-             "can not store a %s array into a record array of %"PRIsVALUE,
-             rb_obj_classname(rval), rb_ca_data_class(self));
+             "can not store a %"PRIsVALUE" array into a record array of %"PRIsVALUE,
+             rb_obj_class(rval), rb_ca_data_class(self));
   }
   if ( ca_is_face(ca) ) {
     if ( rb_obj_class(self) == rb_obj_class(rval)
@@ -637,9 +659,9 @@ ca_face_source_for_store (VALUE self, CArray *ca, VALUE rval)
       return rval;
     }
     rb_raise(rb_eTypeError,
-             "can not store a %s array into %s array "
+             "can not store a %"PRIsVALUE" array into %s array "
              "(to_type(:object) gives its values)",
-             rb_obj_classname(rval), ca_type_name[ca->data_type]);
+             rb_obj_class(rval), ca_type_name[ca->data_type]);
   }
   return rb_funcall(rval, rb_intern("to_type"), 1, INT2NUM(CA_OBJECT));
 }
@@ -647,6 +669,20 @@ ca_face_source_for_store (VALUE self, CArray *ca, VALUE rval)
 /* A store into no cells writes nothing, but the value is checked as it
    would be for any cells: the same statement does not raise or pass
    depending on how many cells the index picks. */
+/* Writing complex cells into real ones would drop the imaginary parts
+   without a word, where a Complex scalar is refused. */
+void
+ca_refuse_complex_into_real (CArray *ca, CArray *cv)
+{
+  if ( ca_is_complex_type(cv) && ! ca_is_complex_type(ca)
+       && ca->data_type != CA_OBJECT ) {
+    rb_raise(rb_eCADataTypeError,
+             "%s: cannot store %s cells in %s (#real and #to_type take the part wanted)",
+             ca_calling_method_name(), ca_type_name[cv->data_type],
+             ca_type_name[ca->data_type]);
+  }
+}
+
 static void
 ca_store_all_check_empty (VALUE self, VALUE rval)
 {
@@ -661,7 +697,10 @@ ca_store_all_check_empty (VALUE self, VALUE rval)
     rval = rb_funcall(rval, id_to_ca, 0);
   }
   if ( rb_obj_is_carray(rval) ) {
+    CArray *cv;
     ca_broadcast_to_destination(self, (volatile VALUE *) &rval);
+    TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
+    ca_refuse_complex_into_real(ca, cv);
   }
   else if ( TYPE(rval) == T_ARRAY ) {
     if ( NIL_P(rb_ary_flatten_for_elements(rval, ca->elements, ca)) ) {
@@ -733,6 +772,7 @@ rb_ca_store_all (VALUE self, VALUE rval)
     /* The destination owns the shape; see ca_broadcast_to_destination. */
     ca_broadcast_to_destination(self, &rval);
     TypedData_Get_Struct(rval, CArray, &carray_data_type, cv);
+    ca_refuse_complex_into_real(ca, cv);
 
     /* Fixlen cells of another width are fitted cell by cell, padded with
        NUL or cut to the destination's width, as a String or an Array of
@@ -1053,7 +1093,7 @@ extern VALUE rb_ca_remap_new (VALUE cary, VALUE rmapper);
    reads as masked (a CAGrid hole); the same-shape fast path is left to a
    mapper with no masked cell. */
 static VALUE
-rb_ca_fancy_index_chain (VALUE self, VALUE rmapper)
+rb_ca_fancy_index_chain (VALUE self, volatile VALUE rmapper)
 {
   CArray *ca, *cm;
   volatile VALUE flat_self, flat_mapper, gridded, result;
@@ -1144,7 +1184,7 @@ ca_argv_is_method_call (int argc, VALUE *argv)
 {
   const char *name;
   if ( argc < 1 || ! SYMBOL_P(argv[0]) ) return 0;
-  name = rb_id2name(SYM2ID(argv[0]));
+  name = rb_id2name(SYM2ID(argv[0]));   /* name: read at once by strlen */
   return ( name != NULL && strlen(name) > 1 );
 }
 
@@ -1660,14 +1700,14 @@ ca_face_convert_store_rval (VALUE self, CArray *ca, VALUE val)
         const char *method = ca_face_storage_method(self);
         if ( method ) {
           rb_raise(rb_eTypeError,
-                   "%s cannot store a bare %s array as raw storage "
+                   "%"PRIsVALUE" cannot store a bare %s array as raw storage "
                    "(write the %s storage, which #%s gives, directly)",
-                   rb_obj_classname(self), ca_type_name[cval->data_type],
+                   rb_obj_class(self), ca_type_name[cval->data_type],
                    ca_type_name[storage->data_type], method);
         }
         rb_raise(rb_eTypeError,
-                 "%s cannot store a bare %s array as raw storage",
-                 rb_obj_classname(self), ca_type_name[cval->data_type]);
+                 "%"PRIsVALUE" cannot store a bare %s array as raw storage",
+                 rb_obj_class(self), ca_type_name[cval->data_type]);
       }
     }
     return val;
@@ -1888,7 +1928,7 @@ rb_ca_store2 (VALUE self, int n, VALUE *rindex, VALUE rval)
 }
 
 static VALUE
-rb_ca_s_scan_index (VALUE self, VALUE rdim, VALUE ridx)
+rb_ca_s_scan_index (VALUE self, VALUE rdim, volatile VALUE ridx)
 {
   volatile VALUE rtype, rindex;
   CAIndexInfo info;
@@ -1899,11 +1939,13 @@ rb_ca_s_scan_index (VALUE self, VALUE rdim, VALUE ridx)
 
   Check_Type(rdim, T_ARRAY);
   Check_Type(ridx, T_ARRAY);
+  /* Converting an entry can run Ruby that changes the Array: read a copy. */
+  ridx = rb_ary_dup(ridx);
 
   ndim = (int) RARRAY_LEN(rdim);
   CA_CHECK_RANK_GIVEN(ndim);
   for (i=0; i<ndim; i++) {
-    dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
+    dim[i] = ca_integer_arg(rb_ary_entry(rdim, i), "a dimension", NULL);
   }
   CA_CHECK_DIM_GIVEN(ndim, dim);
   elements = ca_shape_elements(ndim, dim, 1);
@@ -1988,7 +2030,7 @@ rb_ca_s_scan_index (VALUE self, VALUE rdim, VALUE ridx)
 }
 
 static VALUE
-rb_ca_normalize_index (VALUE self, VALUE ridx)
+rb_ca_normalize_index (VALUE self, volatile VALUE ridx)
 {
   volatile VALUE rindex;
   CArray *ca;
@@ -1997,6 +2039,8 @@ rb_ca_normalize_index (VALUE self, VALUE ridx)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   Check_Type(ridx, T_ARRAY);
+  /* Converting an entry can run Ruby that changes the Array: read a copy. */
+  ridx = rb_ary_dup(ridx);
 
   info.range_check = 1;
   rb_ca_scan_index(ca->ndim, ca->dim, ca->elements,
@@ -2080,7 +2124,7 @@ parse_shape_kwarg (VALUE rshape, int *out_ndim, ca_size_t *dim,
   }
   ca_check_rank_fits(ndim, NULL);
   for (i = 0; i < ndim; i++) {
-    dim[i] = NUM2SIZE(rb_ary_entry(rshape, i));
+    dim[i] = ca_integer_arg(rb_ary_entry(rshape, i), "a dimension", NULL);
     if ( dim[i] < 0 ) {
       rb_raise(rb_eArgError, "negative dim %" PRId64 " at axis %d",
                (ca_size_t) dim[i], i);
@@ -2091,12 +2135,21 @@ parse_shape_kwarg (VALUE rshape, int *out_ndim, ca_size_t *dim,
   *out_elements = elements;
 }
 
+/* A scalar key of index2addr / addr2index, by the rule of `[]`: a Float that
+   is a whole number is that position, any other is no position at all. */
+static VALUE
+ca_scalar_position_key (VALUE v)
+{
+  return RB_FLOAT_TYPE_P(v) ? SIZE2NUM(ca_index_key_value(v)) : v;
+}
+
 static VALUE
 addr2index_do (int ndim, ca_size_t *dim, ca_size_t elements, VALUE raddr)
 {
   volatile VALUE out;
   int i;
 
+  raddr = ca_scalar_position_key(raddr);
   /* Scalar path (Integer input): returns Ruby Array of N Integers.
    * Preserves legacy shape for callers like `i, j = ca.addr2index(k)`. */
   if ( rb_obj_is_kind_of(raddr, rb_cInteger) ) {
@@ -2253,12 +2306,18 @@ index2addr_do (int ndim, ca_size_t *dim, int argc, VALUE *argv)
   ca_size_t out_dim[CA_RANK_MAX];
   ca_size_t out_elements = 1;
   int shape_from = -1;
+  VALUE keys[CA_RANK_MAX];
 
   if ( argc != ndim ) {
     rb_raise(rb_eArgError,
              "wrong number of indices (%d for %d)", argc, ndim);
   }
 
+  for (i = 0; i < ndim; i++) {
+    keys[i] = ca_scalar_position_key(argv[i]);
+  }
+  argv = keys;
+
   for (i = 0; i < ndim; i++) {
     if ( ! rb_obj_is_kind_of(argv[i], rb_cInteger) ) {
       all_number = 0;