carray 1.2.0 → 1.3.0

data/carray_cast_func.rb

@@ -169,7 +169,7 @@ puts %{
 #include "carray.h"
 
 static void
-ca_cast_not_implemented(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+ca_cast_not_implemented(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
 {
   rb_raise(rb_eCADataTypeError, 
            "can not cast data type from <%s> to <%s>",
@@ -187,12 +187,12 @@ FIXLEN.each do |type1|
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          char *p1 = ptr1;
-         int32_t bytes1;
+         ca_size_t bytes1;
          char *p2 = ptr2;
-         int32_t bytes2;
+         ca_size_t bytes2;
          if ( a1 == NULL || a2 == NULL ) {
            rb_raise(rb_eRuntimeError, "[BUG] failed to cast fixlen -> fixlen");
          }
@@ -240,10 +240,10 @@ FIXLEN.each do |type1|
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          char  *p1 = ptr1;
-         int32_t bytes;
+         ca_size_t bytes;
          VALUE *p2 = ptr2;
          if ( a1 == NULL ) {
            rb_raise(rb_eRuntimeError, "[BUG] failed to cast fixlen -> object");
@@ -278,7 +278,7 @@ puts
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          #{ctype1} *p1 = ptr1;
          #{ctype2} *p2 = ptr2;
@@ -325,13 +325,13 @@ puts
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          #{ctype1} *q1 = ptr1;
          #{ctype1} *p1 = q1;
          #{ctype2} *q2 = ptr2;
          #{ctype2} *p2 = q2;
-         int32_t k;
+         ca_size_t k;
          if ( m ) {
            boolean8_t *pm = m;
            #ifdef _OPENMP
@@ -375,18 +375,18 @@ puts
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          #{ctype1} *p1 = ptr1;
          VALUE *p2 = ptr2;
          if ( m ) {
            while ( n-- ) { 
-             if ( !*m ) { *p2 = #{conv}(*p1); } 
+             if ( !*m ) { *p2 = (VALUE) #{conv}(*p1); } 
              p1++; p2++; m++;
            }
          }
          else {
-           while ( n-- ) { *p2 = #{conv}(*p1); p1++; p2++; }
+           while ( n-- ) { *p2 = (VALUE) #{conv}(*p1); p1++; p2++; }
          }
          return;
       }
@@ -404,11 +404,11 @@ OBJECT.each do |type1|
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          VALUE *p1 = ptr1;
          char *p2 = ptr2;
-         int32_t bytes;
+         ca_size_t bytes;
          if ( a2 == NULL ) {
            rb_raise(rb_eRuntimeError, "[BUG] failed to cast object -> fixlen");
          }
@@ -463,18 +463,18 @@ OBJECT.each do |type1|
     CA_CAST_TABLE[type1][type2] = "ca_cast_#{ctype1}_#{ctype2}"
     puts <<-END_DEF  .gsub(/^ {6}/, '')
       static void
-      ca_cast_#{ctype1}_#{ctype2}(int32_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
+      ca_cast_#{ctype1}_#{ctype2}(ca_size_t n, CArray *a1, void *ptr1, CArray *a2, void *ptr2, boolean8_t *m)
       {
          VALUE *p1 = ptr1;
          #{ctype2} *p2 = ptr2;
          if ( m ) {
            while ( n-- ) { 
-             if ( !*m ) { *p2 = #{conv}(*p1); }
+             if ( !*m ) { *p2 = (#{ctype2}) #{conv}(*p1); }
              p1++; p2++; m++;
            }
          }
          else {
-           while ( n-- ) { *p2 = #{conv}(*p1); p1++; p2++; }
+           while ( n-- ) { *p2 = (#{ctype2}) #{conv}(*p1); p1++; p2++; }
          }
          return;
       }

data/carray_class.c

@@ -70,9 +70,9 @@ static VALUE
 rb_ca_s_sizeof (VALUE klass, VALUE rtype)
 {
   int8_t data_type;
-  int32_t bytes;
-  rb_ca_guess_type_and_bytes(rtype, INT2FIX(0), &data_type, &bytes);
-  return LONG2NUM(bytes);
+  ca_size_t bytes;
+  rb_ca_guess_type_and_bytes(rtype, INT2NUM(0), &data_type, &bytes);
+  return SIZE2NUM(bytes);
 }
 
 

data/carray_conversion.c

@@ -19,11 +19,11 @@
 #endif
 
 static void
-rb_ca_to_a_loop (VALUE self, int32_t level, int32_t *idx, VALUE ary)
+rb_ca_to_a_loop (VALUE self, int32_t level, ca_size_t *idx, VALUE ary)
 {
   volatile VALUE obj;
   CArray *ca;
-  int32_t i;
+  ca_size_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -57,7 +57,7 @@ rb_ca_to_a (VALUE self)
 {
   volatile VALUE ary;
   CArray *ca;
-  int32_t idx[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
   Data_Get_Struct(self, CArray, ca);
   ary = rb_ary_new2(ca->dim[0]);
   ca_attach(ca);
@@ -80,7 +80,7 @@ rb_ca_convert (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj;
   CArray *ca;
-  int32_t i;
+  ca_size_t i;
 
   obj = rb_apply(self, rb_intern("template"), rb_ary_new4(argc, argv));
 
@@ -235,15 +235,15 @@ rb_ca_load_binary (VALUE self, VALUE io)
   case T_STRING:
     if ( ca_length(ca) > RSTRING_LEN(io) ) {
       rb_raise(rb_eRuntimeError,
-               "data size mismatch (%li for %i)",
-               RSTRING_LEN(io), ca_length(ca));
+               "data size mismatch (%lld for %lld)",
+               (ca_size_t) RSTRING_LEN(io), (ca_size_t) ca_length(ca));
     }
     memcpy(ca->ptr, StringValuePtr(io), ca_length(ca));
     OBJ_INFECT(self, io);
     break;
   default:
     if ( rb_respond_to(io, rb_intern("read") ) ) {
-      VALUE buf = rb_funcall(io, rb_intern("read"), 1, INT2NUM(ca_length(ca)));
+      VALUE buf = rb_funcall(io, rb_intern("read"), 1, SIZE2NUM(ca_length(ca)));
       memcpy(ca->ptr, StringValuePtr(buf), ca_length(ca));
       OBJ_INFECT(self, io);
     }
@@ -271,10 +271,10 @@ ca_to_cptr (void *ap)
   CArray *ca = (CArray *) ap;
   void **ptr, **p, **r;
   char *q;
-  int offset[CA_RANK_MAX];
-  int count[CA_RANK_MAX];
-  int32_t ptr_num;
-  int32_t i, j;
+  ca_size_t offset[CA_RANK_MAX];
+  ca_size_t count[CA_RANK_MAX];
+  ca_size_t ptr_num;
+  ca_size_t i, j;
   
   if ( ! ca_is_attached(ca) ) {
     rb_raise(rb_eRuntimeError, "[BUG] ca_to_cptr called for detached array");
@@ -331,12 +331,12 @@ rb_ca_format (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj, elem, val;
   CArray *ca;
-  int32_t i, j;
+  ca_size_t i, j;
   ID id_format = rb_intern("format");
 
   Data_Get_Struct(self, CArray, ca);
 
-  obj = rb_ca_template_with_type(self, INT2FIX(CA_OBJECT), INT2FIX(0));
+  obj = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT), INT2NUM(0));
 
   ca_attach(ca);
   if ( ca_has_mask(ca) ) {
@@ -379,7 +379,7 @@ rb_ca_strptime (VALUE self, VALUE rfmt)
   CArray *ca;
   char *fmt;
   struct tm tmv;
-  int32_t i;
+  ca_size_t i;
   
   ca = ca_wrap_readonly(self, CA_OBJECT);
 
@@ -431,7 +431,7 @@ rb_ca_strftime (VALUE self, VALUE rfmt)
 {
   volatile VALUE obj, elem, val;
   CArray *ca;
-  int32_t i;
+  ca_size_t i;
   ID id_strftime = rb_intern("strftime");
   
   ca = ca_wrap_readonly(self, CA_OBJECT);

data/carray_copy.c

@@ -89,7 +89,7 @@ ca_template_safe (void *ap)
 }
 
 CArray *
-ca_template_safe2 (void *ap, int8_t data_type, int32_t bytes)
+ca_template_safe2 (void *ap, int8_t data_type, ca_size_t bytes)
 {
   CArray *ca = (CArray *) ap;
   CA_CHECK_DATA_TYPE(data_type);
@@ -119,9 +119,9 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
   volatile VALUE obj, rtype, rbytes = Qnil;
   CArray *ca, *co;
   int8_t data_type;
-  int32_t bytes;
+  ca_size_t bytes;
 
-  rb_scan_args(argc, argv, "01", &rtype);
+  rb_scan_args(argc, argv, "01", (VALUE *) &rtype);
   rb_scan_options(ropt, "bytes", &rbytes);
 
   Data_Get_Struct(self, CArray, ca);
@@ -168,7 +168,7 @@ rb_ca_template_n (int n, ...)
 {
   volatile VALUE varg, obj;
   CArray *ca;
-  int32_t elements = -1;
+  ca_size_t elements = -1;
   va_list vargs;
   int i;
 
@@ -204,11 +204,11 @@ rb_ca_template_n (int n, ...)
 /* ------------------------------------------------------------------- */
 
 static void
-ca_paste_loop (CArray *ca, int32_t *offset, int32_t *offset0,
-               int32_t *size, CArray *cs,
-               int32_t level, int32_t *idx, int32_t *idx0)
+ca_paste_loop (CArray *ca, ca_size_t *offset, ca_size_t *offset0,
+               ca_size_t *size, CArray *cs,
+               int32_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t i;
+  ca_size_t i;
   if ( level == ca->rank - 1 ) {
     idx[level] = offset[level];
     idx0[level] = offset0[level];
@@ -229,15 +229,15 @@ ca_paste_loop (CArray *ca, int32_t *offset, int32_t *offset0,
 /* ------------------------------------------------------------------- */
 
 void
-ca_paste (void *ap, int32_t *offset, void *sp)
+ca_paste (void *ap, ca_size_t *offset, void *sp)
 {
   CArray *ca = (CArray *) ap;
   CArray *cs = (CArray *) sp;
-  int32_t size[CA_RANK_MAX];
-  int32_t offset0[CA_RANK_MAX];
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t size[CA_RANK_MAX];
+  ca_size_t offset0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
 
   ca_check_same_data_type(ca, cs);
   ca_check_same_rank(ca, cs);
@@ -298,7 +298,7 @@ static VALUE
 rb_ca_paste (VALUE self, VALUE roffset, VALUE rsrc)
 {
   CArray *ca, *cs;
-  int32_t offset[CA_RANK_MAX];
+  ca_size_t offset[CA_RANK_MAX];
   int i;
 
   rb_ca_modify(self);
@@ -313,7 +313,7 @@ rb_ca_paste (VALUE self, VALUE roffset, VALUE rsrc)
   }
 
   for (i=0; i<ca->rank; i++) {
-    offset[i] = NUM2INT(rb_ary_entry(roffset,i));
+    offset[i] = NUM2SIZE(rb_ary_entry(roffset,i));
   }
 
   cs = ca_wrap_readonly(rsrc, ca->data_type);
@@ -325,11 +325,11 @@ rb_ca_paste (VALUE self, VALUE roffset, VALUE rsrc)
 
 
 static void
-ca_clip_loop (CArray *ca, int32_t *offset, int32_t *offset0,
-               int32_t *size, CArray *cs,
-               int32_t level, int32_t *idx, int32_t *idx0)
+ca_clip_loop (CArray *ca, ca_size_t *offset, ca_size_t *offset0,
+               ca_size_t *size, CArray *cs,
+               int32_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t i;
+  ca_size_t i;
   if ( level == ca->rank - 1 ) {
     idx[level] = offset[level];
     idx0[level] = offset0[level];
@@ -347,14 +347,14 @@ ca_clip_loop (CArray *ca, int32_t *offset, int32_t *offset0,
 /* ------------------------------------------------------------------- */
 
 void
-ca_clip (void *ap, int32_t *offset, void *sp)
+ca_clip (void *ap, ca_size_t *offset, void *sp)
 {
   CArray *ca = (CArray *) ap;
   CArray *cs = (CArray *) sp;
-  int32_t size[CA_RANK_MAX];
-  int32_t offset0[CA_RANK_MAX];
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t size[CA_RANK_MAX];
+  ca_size_t offset0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   int i;
 
   ca_check_same_data_type(ca, cs);
@@ -414,7 +414,7 @@ static VALUE
 rb_ca_clip (VALUE self, VALUE roffset, VALUE rsrc)
 {
   CArray *ca, *cs;
-  int32_t offset[CA_RANK_MAX];
+  ca_size_t offset[CA_RANK_MAX];
   int i;
 
   Data_Get_Struct(self, CArray, ca);
@@ -427,7 +427,7 @@ rb_ca_clip (VALUE self, VALUE roffset, VALUE rsrc)
   }
 
   for (i=0; i<ca->rank; i++) {
-    offset[i] = NUM2INT(rb_ary_entry(roffset, i));
+    offset[i] = NUM2SIZE(rb_ary_entry(roffset, i));
   }
 
   cs = ca_wrap_writable(rsrc, ca->data_type);

data/carray_core.c

@@ -329,7 +329,7 @@ ca_mark (void *ap)
   if ( ca_is_object_type(ca) ) {    /* object type array */
     if ( ca_is_attached(ca) ) { /* entity array */
       VALUE *p = (VALUE*) ca->ptr;
-      int32_t n = ca->elements;
+      ca_size_t n = ca->elements;
       while ( n-- ) {
         rb_gc_mark(*p++);
       }
@@ -377,11 +377,11 @@ ca_wrap_struct (void *ap)
 /* calculate index from address */
 
 void
-ca_addr2index (void *ap, int32_t addr, int32_t *idx)
+ca_addr2index (void *ap, ca_size_t addr, ca_size_t *idx)
 {
   CArray *ca = (CArray *) ap;
-  int32_t *dim = ca->dim;
-  int32_t i;
+  ca_size_t *dim = ca->dim;
+  int8_t i;
   for (i=ca->rank-1; i>=0; i--) {
     idx[i] = addr % dim[i];
     addr  /= dim[i];
@@ -390,12 +390,13 @@ ca_addr2index (void *ap, int32_t addr, int32_t *idx)
 
 /* calculate address from index */
 
-int32_t
-ca_index2addr (void *ap, int32_t *idx)
+ca_size_t
+ca_index2addr (void *ap, ca_size_t *idx)
 {
   CArray  *ca  = (CArray *) ap;
-  int32_t *dim = ca->dim;
-  int32_t  n, i;
+  ca_size_t *dim = ca->dim;
+  int8_t   i;
+  ca_size_t  n;
   n = idx[0];
   for (i=1; i<ca->rank; i++) {
     n = dim[i]*n+idx[i];
@@ -457,7 +458,7 @@ ca_test_cyclic_check(void *ap, void *ptr)
 /* return pointer of the element at given address */
 
 void *
-ca_ptr_at_addr (void *ap, int32_t addr)
+ca_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CArray *ca = (CArray *) ap;
 
@@ -478,7 +479,7 @@ ca_ptr_at_addr (void *ap, int32_t addr)
 /* return pointer of the element at given index */
 
 void *
-ca_ptr_at_index (void *ap, int32_t *idx)
+ca_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CArray *ca = (CArray *) ap;
   return ca_func[ca->obj_type].ptr_at_index(ca, idx);
@@ -487,7 +488,7 @@ ca_ptr_at_index (void *ap, int32_t *idx)
 /* fetch data of the element at given address to memory pointed by pval */
 
 void
-ca_fetch_addr (void *ap, int32_t addr, void *pval)
+ca_fetch_addr (void *ap, ca_size_t addr, void *pval)
 {
   CArray *ca = (CArray *) ap;
   char *ptr  = (char *)pval;
@@ -501,7 +502,7 @@ ca_fetch_addr (void *ap, int32_t addr, void *pval)
     ca_func[ca->obj_type].fetch_addr(ca, addr, ptr);
   }
   else if ( ca_func[ca->obj_type].fetch_index ) { /* delegate -> fetch_index */
-    int32_t idx[CA_RANK_MAX];
+    ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
     ca_func[ca->obj_type].fetch_index(ca, idx, ptr);
   }
@@ -520,7 +521,7 @@ ca_fetch_addr (void *ap, int32_t addr, void *pval)
 /* store value pointed by pval to the element at given address */
 
 void
-ca_store_addr (void *ap, int32_t addr, void *pval)
+ca_store_addr (void *ap, ca_size_t addr, void *pval)
 {
   CArray *ca = (CArray *) ap;
   char *ptr = (char *)pval;
@@ -539,7 +540,7 @@ ca_store_addr (void *ap, int32_t addr, void *pval)
     ca_func[ca->obj_type].store_addr(ca, addr, ptr);
   }
   else if ( ca_func[ca->obj_type].store_index ) { /* delegate -> store_index */
-    int32_t idx[CA_RANK_MAX];
+    ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
     ca_func[ca->obj_type].store_index(ca, idx, ptr);
   }
@@ -558,7 +559,7 @@ ca_store_addr (void *ap, int32_t addr, void *pval)
 /* fetch data of the element at given index to memory pointed by pval */
 
 void
-ca_fetch_index (void *ap, int32_t *idx, void *pval)
+ca_fetch_index (void *ap, ca_size_t *idx, void *pval)
 {
   CArray *ca = (CArray *) ap;
   char *ptr = (char *)pval;
@@ -569,7 +570,7 @@ ca_fetch_index (void *ap, int32_t *idx, void *pval)
     ca_func[ca->obj_type].fetch_index(ca, idx, ptr);
   }
   else if ( ca_func[ca->obj_type].fetch_addr ) { /* delegate -> fetch_addr */
-    int32_t addr = ca_index2addr(ca, idx);
+    ca_size_t addr = ca_index2addr(ca, idx);
     ca_func[ca->obj_type].fetch_addr(ca, addr, ptr);
   }
   else {
@@ -588,7 +589,7 @@ ca_fetch_index (void *ap, int32_t *idx, void *pval)
 /* store value pointed by pval to the element at given index */
 
 void
-ca_store_index (void *ap, int32_t *idx, void *pval)
+ca_store_index (void *ap, ca_size_t *idx, void *pval)
 {
   CArray *ca = (CArray *) ap;
   char *ptr = (char *) pval;
@@ -604,7 +605,7 @@ ca_store_index (void *ap, int32_t *idx, void *pval)
     ca_func[ca->obj_type].store_index(ca, idx, ptr);
   }
   else if ( ca_func[ca->obj_type].store_addr ) { /* delegate -> store_addr */
-    int32_t addr = ca_index2addr(ca, idx);
+    ca_size_t addr = ca_index2addr(ca, idx);
     ca_func[ca->obj_type].store_addr(ca, addr, ptr);
   }
   else {
@@ -648,9 +649,9 @@ ca_allocate (void *ap)
   }
 
   if ( ca->data_type == CA_OBJECT ) { /* protection against GC */
-    volatile VALUE rzero = INT2FIX(0);
+    volatile VALUE rzero = INT2NUM(0);
     VALUE *p = (VALUE*)ca->ptr;
-    int32_t i;
+    ca_size_t i;
     for (i=0; i<ca->elements; i++) {
       *p++ = rzero;
     }
@@ -1205,7 +1206,7 @@ rb_ca_field_as_member (VALUE self, VALUE sym)
   }
   else if ( rb_obj_is_kind_of(sym, rb_cInteger) ) {
     VALUE member_names = rb_const_get(data_class, rb_intern("MEMBERS"));
-    sym = rb_ary_entry(member_names, NUM2INT(sym));
+    sym = rb_ary_entry(member_names, NUM2SIZE(sym));
   }
 
   obj = rb_hash_aref(member, sym);