carray 1.1.4 → 1.1.5

data/carray_access.c

@@ -0,0 +1,1798 @@
+/* ---------------------------------------------------------------------------
+
+  carray_access.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+
+#if RUBY_VERSION_CODE >= 190
+#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
+#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
+#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
+#else
+static ID id_beg, id_end, id_excl;
+#define RANGE_BEG(r) (rb_ivar_get(r, id_beg))
+#define RANGE_END(r) (rb_ivar_get(r, id_end))
+#define RANGE_EXCL(r) (rb_ivar_get(r, id_excl))
+#endif
+
+static ID id_ca, id_to_ca;
+static VALUE sym_star, sym_perc;
+static VALUE S_CAInfo;
+
+VALUE
+rb_ca_store_index (VALUE self, int32_t *idx, VALUE rval)
+{
+  CArray *ca;
+  boolean8_t zero = 0, one = 1;
+
+  rb_ca_modify(self);
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( ca_is_empty(ca) ) {
+    return rval;
+  }
+
+  if ( rval == CA_UNDEF ) { /* set mask at the element */
+    ca_update_mask(ca);
+    if ( ! ca->mask ) {
+      ca_create_mask(ca);
+    }
+    ca_store_index(ca->mask, idx, &one);
+  }
+  else {                   /* unset mask and set value at the element */
+
+    /* unset mask */
+    ca_update_mask(ca);
+    if ( ca->mask ) {
+      ca_store_index(ca->mask, idx, &zero);
+    }
+
+    /* store value */
+    if ( ca->bytes <= 32) {
+      char v[32];
+      rb_ca_obj2ptr(self, rval, v);
+      ca_store_index(ca, idx, v);
+    }
+    else {
+      char *v = malloc_with_check(ca->bytes);
+      rb_ca_obj2ptr(self, rval, v);
+      ca_store_index(ca, idx, v);
+      free(v);
+    }
+  }
+
+  return rval;
+}
+
+VALUE
+rb_ca_fetch_index (VALUE self, int32_t *idx)
+{
+  volatile VALUE out;
+  CArray *ca;
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( ca_is_empty(ca) ) {
+    return Qnil;
+  }
+
+  /* fetch value from the element */
+  if ( ca->bytes <= 32) {
+    char v[32];
+    ca_fetch_index(ca, idx, v);
+    out = rb_ca_ptr2obj(self, v);
+  }
+  else {
+    char *v = malloc_with_check(ca->bytes);
+    ca_fetch_index(ca, idx, v);
+    out = rb_ca_ptr2obj(self, v);
+    free(v);
+  }
+
+  /* check if the element is masked */
+  ca_update_mask(ca);
+  if ( ca->mask ) {
+    boolean8_t mval;
+    ca_fetch_index(ca->mask, idx, &mval);
+    if ( mval ) {
+      return CA_UNDEF; /* the element is masked */
+    }
+  }
+
+  return out;
+}
+
+VALUE
+rb_ca_store_addr (VALUE self, int32_t addr, VALUE rval)
+{
+  CArray *ca;
+  boolean8_t zero = 0, one = 1;
+
+  rb_ca_modify(self);
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( ca_is_empty(ca) ) {
+    return rval;
+  }
+
+  if ( rval == CA_UNDEF ) { /* set mask at the element */
+    ca_update_mask(ca);
+    if ( ! ca->mask ) {
+      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 */
+    }
+
+    /* store value */
+    if ( ca->bytes <= 32) {
+      char v[32];
+      rb_ca_obj2ptr(self, rval, v);
+      ca_store_addr(ca, addr, v);
+    }
+    else {
+      char *v = malloc_with_check(ca->bytes);
+      rb_ca_obj2ptr(self, rval, v);
+      ca_store_addr(ca, addr, v);
+      free(v);
+    }
+  }
+
+  return rval;
+}
+
+VALUE
+rb_ca_fetch_addr (VALUE self, int32_t addr)
+{
+  volatile VALUE out;
+  CArray *ca;
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( ca_is_empty(ca) ) {
+    return Qnil;
+  }
+
+  /* fetch value from the element */
+  if ( ca->bytes <= 32) {
+    char v[32];
+    ca_fetch_addr(ca, addr, v);
+    out = rb_ca_ptr2obj(self, v);
+  }
+  else {
+    char *v = malloc_with_check(ca->bytes);
+    ca_fetch_addr(ca, addr, v);
+    out = rb_ca_ptr2obj(self, v);
+    free(v);
+  }
+
+  /* check if the element is masked */
+  ca_update_mask(ca);
+  if ( ca->mask ) {
+    boolean8_t mval;
+    ca_fetch_addr(ca->mask, addr, &mval);
+    if ( mval ) {
+      return CA_UNDEF; /* the element is masked */
+    }
+  }
+
+  return out;
+}
+
+/* rdoc:
+  class CArray
+    def fill
+    end
+    def fill_copy
+    end
+  end
+*/
+
+VALUE
+rb_ca_fill (VALUE self, VALUE rval)
+{
+  CArray *ca;
+
+  rb_ca_modify(self);
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( ca_is_empty(ca) ) {
+    return rval;
+  }
+
+  if ( rval == CA_UNDEF ) {
+    boolean8_t one = 1;
+    ca_update_mask(ca);
+    if ( ! ca->mask ) {
+      ca_create_mask(ca);
+    }
+    ca_fill(ca->mask, &one);
+  }
+  else {
+    char *fval = malloc_with_check(ca->bytes);
+    boolean8_t zero = 0;
+    rb_ca_obj2ptr(self, rval, fval);
+    if ( ca_has_mask(ca) ) {
+      ca_fill(ca->mask, &zero);
+    }
+    ca_fill(ca, fval);
+    free(fval);
+  }
+
+  return self;
+}
+
+VALUE
+rb_ca_fill_copy (VALUE self, VALUE rval)
+{
+  volatile VALUE out = rb_ca_template(self);
+  return rb_ca_fill(out, rval);
+}
+
+/* -------------------------------------------------------------------- */
+
+static void
+ary_guess_shape (VALUE ary, int level, int *max_level, int32_t *dim)
+{
+  volatile VALUE ary0;
+  if ( level > CA_RANK_MAX ) {
+    rb_raise(rb_eRuntimeError, "too deep level array for conversion to carray");
+  }
+
+  if ( TYPE(ary) == T_ARRAY ) {
+    if ( RARRAY_LEN(ary) == 0 && level == 0 ) {
+      *max_level = level;
+      dim[level] = 0;
+    }
+    else if ( RARRAY_LEN(ary) > 0 ) {
+      *max_level = level;
+      dim[level] = RARRAY_LEN(ary);
+      ary0 = rb_ary_entry(ary, 0);
+      if ( TYPE(ary0) == T_ARRAY ) {
+        int32_t dim0 = RARRAY_LEN(ary0);
+        int32_t i;
+        int flag = 0;
+        for (i=0; i<dim[level]; i++) {
+          VALUE x = rb_ary_entry(ary, i);
+          flag = flag || ( TYPE(x) != T_ARRAY ) || ( dim0 != RARRAY_LEN(x) );
+        }
+        if ( ! flag ) {
+          ary_guess_shape(ary0, level+1, max_level, dim);
+        }
+      }
+    }
+  }
+}
+
+/* rdoc:
+  def CArray.guess_array_shape (arg)
+  end
+*/  
+
+static VALUE
+rb_ca_s_guess_array_shape (VALUE self, VALUE ary)
+{
+  volatile VALUE out;
+  int32_t dim[CA_RANK_MAX];
+  int max_level = -1;
+  int i;
+  ary_guess_shape(ary, 0, &max_level, dim);
+  out = rb_ary_new2(max_level);
+  for (i=0; i<max_level+1; i++) {
+    rb_ary_store(out, i, INT2NUM(dim[i]));
+  }
+  return out;
+}
+
+static void
+ary_flatten_upto_level (VALUE ary, int max_level, int level,
+                        VALUE out, int *len)
+{
+  int32_t i;
+
+  if ( TYPE(ary) != T_ARRAY ) {
+    rb_raise(rb_eRuntimeError, "invalid shape array for conversion to carray");
+  }
+
+  if ( level == max_level ) {
+    *len += RARRAY_LEN(ary);
+    for (i=0; i<RARRAY_LEN(ary); i++) {
+      rb_ary_push(out, rb_ary_entry(ary, i));
+    }
+  }
+  else {
+    for (i=0; i<RARRAY_LEN(ary); i++) {
+      VALUE x = rb_ary_entry(ary, i);
+      ary_flatten_upto_level(x, max_level, level+1, out, len);
+    }
+  }
+}
+
+static VALUE
+rb_ary_flatten_for_elements (VALUE ary, int32_t elements, void *ap)
+{
+  CArray *ca = (CArray *) ap;
+  int32_t dim[CA_RANK_MAX];
+  int32_t total;
+  int max_level = -1, level = -1;
+  int same_shape, is_object = ( ca_is_object_type(ca) );
+  int i;
+
+  ary_guess_shape(ary, 0, &max_level, dim);
+
+  if ( max_level == -1 ) {
+    return Qnil;
+  }
+
+  if ( ! ca_is_object_type(ca) ) {
+    total = 1;
+    for (i=0; i<max_level+1; i++) {
+      total *= dim[i];
+      level = i;
+      if ( is_object && total == elements ) {
+        break;
+      }
+    }
+
+    if ( total != ca->elements ) {
+      rb_raise(rb_eRuntimeError, "invalid shape array for conversion to carray");
+    }
+    else {
+      VALUE out = rb_ary_new2(elements);
+      int len = 0;
+      ary_flatten_upto_level(ary, max_level, 0, out, &len);
+      if ( len != elements ) {
+        return Qnil;
+      }
+      else {
+        return out;
+      }
+    }
+  }
+  else {
+    same_shape = 1;
+    if ( max_level+1 < ca->rank ) {
+      same_shape = 0;
+    }
+    else {
+      for (i=0; i<ca->rank; i++) {
+        if ( ca->dim[i] != dim[i] ) {
+          same_shape = 0;
+          break;
+        }
+      }
+    }
+
+    if ( same_shape ) {
+      VALUE out = rb_ary_new2(elements);
+      int len = 0;
+      ary_flatten_upto_level(ary, ca->rank-1, 0, out, &len);
+
+      if ( len != elements ) {
+        return Qnil;
+      }
+      else {
+        return out;
+      }
+    }
+    else {
+      total = 1;
+      for (i=0; i<max_level+1; i++) {
+        total *= dim[i];
+        level = i;
+        if ( is_object && total == elements ) {
+          break;
+        }
+      }
+
+      if ( level >= 0 ) {
+        VALUE out = rb_ary_new2(elements);
+        int len = 0;
+        ary_flatten_upto_level(ary, level, 0, out, &len);
+        if ( len != elements ) {
+          return Qnil;
+        }
+        else {
+          return out;
+        }
+      }
+      else {
+        return Qnil;
+      }
+    }
+  }
+}
+
+#define CA_CHECK_INDEX_AT(index, dim, i)                                \
+  if ( index < 0 ) {                                                    \
+    index += (dim);                                                     \
+  }                                                                     \
+  if ( index < 0 || index >= (dim) ) {                                  \
+    rb_raise(rb_eIndexError,                                            \
+             "index out of range at %i-dim ( %i <=> 0..%i )",        \
+             i, index, dim-1);                                          \
+  }
+
+void
+rb_ca_scan_index (int ca_rank, int32_t *ca_dim, int32_t ca_elements,
+                  int argc, VALUE *argv, CAIndexInfo *info)
+{
+  int32_t i;
+
+  info->rank   = 0;
+  info->select = NULL;
+
+  if ( argc == 0 ) { /* ca[] -> CA_REG_ALL */
+    info->type = CA_REG_ALL;
+    return;
+  }
+
+  /* ca[:method, ...] -> CA_REG_METHOD_CALL
+     ca[:i, ...]      -> CA_REG_ITERATOR     */
+  if ( TYPE(argv[0]) == T_SYMBOL ) {
+    const char *symstr = rb_id2name(SYM2ID(argv[0]));
+    if ( strlen(symstr) > 1 ) { /* ca[:method, ...] -> CA_REG_METHOD_CALL */
+      info->type   = CA_REG_METHOD_CALL;
+      info->symbol = argv[0];
+      return;
+    }
+  }
+
+  if ( argc == 1 ) {
+
+    volatile VALUE arg = argv[0];
+
+    if ( arg == Qfalse ) { /* ca[false] -> CA_REG_ALL */
+      info->type = CA_REG_ALL;
+      return;
+    }
+
+    if ( rb_obj_is_carray(arg) ) {
+      CArray *cs;
+      Data_Get_Struct(arg, CArray, cs);
+      if ( ca_is_integer_type(cs) ) { 
+        #if 0
+        if ( ca_rank == 1 && cs->rank == 1 ) { /* ca[g] -> CA_REG_GRID (1d) */
+          info->type = CA_REG_GRID;
+        }
+        else {                             /* ca[m] -> CA_REG_MAPPER (2d...) */
+          info->type = CA_REG_MAPPING;
+        }
+        #endif
+        info->type = CA_REG_MAPPING;
+        return;
+      }
+      else if ( ca_is_boolean_type(cs) ) {
+                                         /* ca[selector] -> CA_REG_SELECT */
+        if ( ca_elements != cs->elements ) {
+          rb_raise(rb_eRuntimeError,
+           "mismatch of # of elements ( %i <=> %i ) in reference by selection",
+                   cs->elements, ca_elements);
+        }
+        info->type   = CA_REG_SELECT;
+        info->select = cs;
+        return;
+      }
+      else {
+        rb_raise(rb_eIndexError,
+                 "data_type %s is invalid for reference by selection/mapping"  \
+                 "(should be boolean or integer)",
+                 ca_type_name[cs->data_type]);
+      }
+    }
+
+    if ( TYPE(arg) == T_STRING ) {  /* ca["field"] -> CA_REG_MEMBER */
+      info->type   = CA_REG_MEMBER;
+      info->symbol = ID2SYM(rb_intern(StringValuePtr(arg)));
+      return;
+    }
+
+    if ( arg == sym_star ) {        /* ca[:*] -> CA_REG_UNBOUND_REPEAT */
+      info->type   = CA_REG_UNBOUND_REPEAT;
+      return;
+    }
+
+    if ( ca_rank > 1 ) { /* ca.rank > 1 */
+      if ( rb_obj_is_kind_of(arg, rb_cInteger) ) { /* ca[n] -> CA_REG_ADDRESS */
+        int32_t addr;
+        info->type = CA_REG_ADDRESS;
+        info->rank = 1;
+        addr = NUM2INT(arg);
+        CA_CHECK_INDEX(addr, ca_elements);
+        info->index[0].scalar = addr;
+        return;
+      }
+      else { /* ca[i..j] -> CA_REG_ADDRESS_COMPLEX */
+        info->type = CA_REG_ADDRESS_COMPLEX;
+        return;
+      }
+    }
+  }
+
+  /* continue to next section */
+
+  if ( argc >= 1 ) {
+    int32_t is_point = 0, is_all = 0, is_iterator = 0, is_repeat=0, is_grid=0;
+    int32_t has_rubber = 0;
+    int32_t *index_type = info->index_type;
+    CAIndex *index = info->index;
+
+    for (i=0; i<argc; i++) {
+      if ( argv[i] == sym_perc ) {
+        is_repeat = 1;
+        goto loop_exit; /* ca[--,:%,--] -> CA_REG_REPEAT */
+      }
+
+      if ( argv[i] == sym_star ) {
+        is_repeat = 2;
+        goto loop_exit; /* ca[--,:*,--] -> CA_REG_UNBOUND_REPEAT */
+      }
+
+      if ( argv[i] == Qfalse ) { /* ca[--,false,--] (rubber dimension) */
+        has_rubber = 1;
+        if ( argc > ca_rank + 1 ) {
+          rb_raise(rb_eIndexError,
+                   "index specification exceeds the rank of carray (%i)", 
+                   ca_rank);
+        }
+      }
+    }
+
+    if ( ! has_rubber && ca_rank != argc ) {
+      rb_raise(rb_eIndexError,
+               "number of indices exceeds the rank of carray (%i > %i)",
+               argc, ca_rank);
+    }
+
+    info->rank = argc;
+
+    for (i=0; i<argc; i++) {
+      volatile VALUE arg = argv[i];
+
+    retry:
+
+      if ( rb_obj_is_kind_of(arg, rb_cInteger) ) { /* ca[--,i,--] */
+        int32_t scalar;
+        index_type[i] = CA_IDX_SCALAR;
+        scalar = NUM2INT(arg);
+        CA_CHECK_INDEX_AT(scalar, ca_dim[i], i);
+        index[i].scalar = scalar;
+      }
+      else if ( NIL_P(arg) ) { /* ca[--,nil,--] */
+        index_type[i] = CA_IDX_ALL;
+      }
+      else if ( arg == Qfalse ) { /* ca[--,false,--] */
+        int32_t rrank = ca_rank - argc + 1;
+        int32_t j;
+        for (j=0; j<rrank; j++) {
+          index_type[i+j] = CA_IDX_ALL;
+        }
+        i += rrank-1;
+        argv -= rrank-1;
+        argc  = ca_rank;
+        info->rank = ca_rank;
+      }
+      else if ( rb_obj_is_kind_of(arg, rb_cRange) ) { /* ca[--,i..j,--] */
+        int32_t first, last, excl, count, step;
+        volatile VALUE iv_beg, iv_end, iv_excl;
+        iv_beg  = RANGE_BEG(arg);
+        iv_end  = RANGE_END(arg);
+        iv_excl = RANGE_EXCL(arg);
+        index_type[i] = CA_IDX_BLOCK; /* convert to block */
+        first = NUM2INT(iv_beg);
+        last  = NUM2INT(iv_end);
+        excl  = RTEST(iv_excl);
+        CA_CHECK_INDEX_AT(first, ca_dim[i], i);
+
+        if ( last < 0 ) { /* don't use CA_CHECK_INDEX for excl */
+          last += ca_dim[i];
+        }
+        if ( excl && ( first == last ) ) {
+          index[i].block.start = first;
+          index[i].block.count = 0;
+          index[i].block.step  = 1;
+        }
+        else {
+          if ( excl ) {
+            last += ( (last>=first) ? -1 : 1 );
+          }
+          if ( last < 0 || last >= ca_dim[i] ) {
+            rb_raise(rb_eIndexError,
+                     "index %i is out of range (0..%i) at %i-dim",
+                     last, ca_dim[i]-1, i);
+          }
+          index[i].block.start = first;
+          index[i].block.count = count = abs(last - first) + 1;
+          index[i].block.step  = step  = ( last >= first ) ? 1 : -1;
+        }
+      }
+      else if ( TYPE(arg) == T_ARRAY ) { /* ca[--,[array],--] */
+        if ( RARRAY_LEN(arg) == 1 ) {
+          VALUE arg0 = rb_ary_entry(arg, 0);
+          if ( NIL_P(arg0) ) {           /* ca[--,[nil],--]*/
+            index_type[i] = CA_IDX_ALL;
+          }
+          else if ( rb_obj_is_kind_of(arg0, rb_cRange) ) {
+                                         /* ca[--,[i..j],--] */
+            arg = arg0;
+            goto retry;
+          }
+          else {                         /* ca[--,[i],--]*/
+            int32_t start;
+            start = NUM2INT(arg0);
+            CA_CHECK_INDEX_AT(start, ca_dim[i], i);
+            index_type[i] = CA_IDX_BLOCK;
+            index[i].block.start = start;
+            index[i].block.count = 1;
+            index[i].block.step  = 1;
+          }
+        }
+        else if ( RARRAY_LEN(arg) == 2 ) {
+          VALUE arg0 = rb_ary_entry(arg, 0);
+          VALUE arg1 = rb_ary_entry(arg, 1);
+          if ( NIL_P(arg0) ) {              /* ca[--,[nil,k],--]*/
+            int32_t start, last, count, step, bound;
+            step  = NUM2INT(arg1);
+            if ( step == 0 ) {
+              rb_raise(rb_eRuntimeError, 
+                       "step in index equals to 0 in block reference");
+            }
+            start = 0;
+            last  = ca_dim[i]-1;
+            if ( step < 0 ) {
+              count = 1;
+            }
+            else {
+              count = last/step + 1;
+            }
+            bound = start + (count - 1)*step;
+            CA_CHECK_INDEX_AT(bound, ca_dim[i], i);
+            index_type[i] = CA_IDX_BLOCK;
+            index[i].block.start = start;
+            index[i].block.count = count;
+            index[i].block.step  = step;
+          }
+          else if ( rb_obj_is_kind_of(arg0, rb_cRange) ) { /* ca[--,[i..j,k],--]*/
+            int32_t start, last, excl, count, step, bound;
+            start = NUM2INT(RANGE_BEG(arg0));
+            last  = NUM2INT(RANGE_END(arg0));
+            excl  = RTEST(RANGE_EXCL(arg0));
+            step  = NUM2INT(arg1);
+            if ( step == 0 ) {
+              rb_raise(rb_eRuntimeError, 
+                       "step in index equals to 0 in block reference");
+            }
+            index_type[i] = CA_IDX_BLOCK;
+            CA_CHECK_INDEX_AT(start, ca_dim[i], i);
+            if ( last < 0 ) {
+              last += ca_dim[i];
+            }
+            if ( excl && ( start == last ) ) {
+              index[i].block.start = start;
+              index[i].block.count = 0;
+              index[i].block.step  = 1;
+            }
+            else {
+              if ( excl ) {
+                last += ( (last>=start) ? -1 : 1 );
+              }
+              if ( last < 0 || last >= ca_dim[i] ) {
+                rb_raise(rb_eIndexError,
+                         "index %i is out of range (0..%i) at %i-dim",
+                         last, ca_dim[i]-1, i);
+              }
+              if ( (last - start) * step < 0 ) {
+                count = 1;
+              }
+              else {
+                count = abs(last - start)/abs(step) + 1;
+              }
+              bound = start + (count - 1)*step;
+              CA_CHECK_INDEX_AT(bound, ca_dim[i], i);
+              index[i].block.start = start;
+              index[i].block.count = count;
+              index[i].block.step  = step;
+            }
+          }
+          else {                            /* ca[--,[i,j],--]*/
+            int32_t start, count, bound;
+            start = NUM2INT(arg0);
+            count = NUM2INT(arg1);
+            bound = start + (count - 1);
+            CA_CHECK_INDEX_AT(start, ca_dim[i], i);
+            CA_CHECK_INDEX_AT(bound, ca_dim[i], i);
+            index_type[i] = CA_IDX_BLOCK;
+            index[i].block.start = start;
+            index[i].block.count = count;
+            index[i].block.step  = 1;
+          }
+        }
+        else if ( RARRAY_LEN(arg) == 3 ) { /* ca[--,[i,j,k],--]*/
+          int32_t start, count, step, bound;
+          start = NUM2INT(rb_ary_entry(arg, 0));
+          count = NUM2INT(rb_ary_entry(arg, 1));
+          step  = NUM2INT(rb_ary_entry(arg, 2));
+          if ( step == 0 ) {
+            rb_raise(rb_eRuntimeError, 
+                     "step in index equals to 0 in block reference");
+          }
+          bound = start + (count - 1)*step;
+          CA_CHECK_INDEX_AT(start, ca_dim[i], i);
+          CA_CHECK_INDEX_AT(bound, ca_dim[i], i);
+          index_type[i] = CA_IDX_BLOCK;
+          index[i].block.start = start;
+          index[i].block.count = count;
+          index[i].block.step  = step;
+        }
+        else {
+          rb_raise(rb_eIndexError,
+                   "invalid form of index range at %i-dim "\
+                   "(should be [start[,count[,step]]], [range, step])",
+                   i);
+        }
+      }
+      else if ( rb_obj_is_kind_of(arg, rb_cSymbol) ) { /* ca[--,:i,--] */
+        if ( strlen(rb_id2name(SYM2ID(arg))) != 1 ) {
+          rb_raise(rb_eIndexError,
+                   "symbol :%s is invalid as the index for dimension iterator "\
+                   "(should be :a, :b, ... :z)",
+                   rb_id2name(SYM2ID(arg)));
+        }
+        index_type[i] = CA_IDX_SYMBOL;
+        index[i].symbol.id   = SYM2ID(arg);
+        index[i].symbol.spec = Qnil;
+      }
+      else if ( rb_obj_is_carray(arg) ) {              /* ca[--,ca,--] */
+        CArray *ci;
+        Data_Get_Struct(arg, CArray, ci);
+        if ( ca_is_boolean_type(ci) || ca_is_integer_type(ci) ) {
+          is_grid = 1;
+          goto loop_exit;
+        }
+        else {
+          rb_raise(rb_eIndexError,
+               "data_type %s is invalid for reference by gridding at %i-dim "\
+                   "(should be boolean or integer)",
+                   ca_type_name[ci->data_type], i);
+        }
+      }
+      else {
+        VALUE inspect = rb_inspect(arg);
+        rb_raise(rb_eIndexError,
+                 "object '%s' is invalid for the index for reference at %i-dim",
+                 StringValuePtr(inspect), i);
+      }
+    }
+
+    if ( ca_rank != info->rank ) {
+      rb_raise(rb_eIndexError,
+               "number of indices does not equal to the rank (%i != %i)",
+               info->rank, ca_rank);
+    }
+
+    is_point     = 1;
+    is_all       = 1;
+    is_iterator  = 0;
+    is_grid      = 0;
+
+    for (i=0; i<info->rank; i++) {
+      switch ( info->index_type[i] ) {
+      case CA_IDX_SCALAR:
+        is_all   = 0;
+        continue;
+      case CA_IDX_ALL:
+        is_point = 0;
+        continue;
+      case CA_IDX_SYMBOL:
+        is_iterator = 1;
+        goto loop_exit;
+      default:
+        is_point = 0;
+        is_all   = 0;
+      }
+    }
+
+   loop_exit:
+
+    if ( is_repeat == 1 ) {
+      info->type = CA_REG_REPEAT;
+    }
+    else if ( is_repeat == 2 ) {
+      info->type = CA_REG_UNBOUND_REPEAT;
+    }
+    else if ( is_grid ) {
+      info->type = CA_REG_GRID;
+    }
+    else if ( is_iterator ) {
+      info->type = CA_REG_ITERATOR;
+    }
+    else if ( is_point ) {
+      info->type = CA_REG_POINT;
+    }
+    else if ( is_all ) {
+      info->type = CA_REG_BLOCK;
+    }
+    else {
+      info->type = CA_REG_BLOCK;
+    }
+
+    if ( info->type == CA_REG_ITERATOR ) {
+      for (i=0; i<info->rank; i++) {
+        if ( info->index_type[i] == CA_IDX_SCALAR ) {
+          int32_t start = info->index[i].scalar;
+          info->index_type[i] = CA_IDX_BLOCK;
+          info->index[i].block.start = start;
+          info->index[i].block.step  = 1;
+          info->index[i].block.count = 1;
+        }
+      }
+    }
+
+    return;
+  }
+}
+
+/* ----------------------------------------------------------------------- */
+
+static VALUE
+rb_ca_ref_address (VALUE self, CAIndexInfo *info)
+{
+  CArray *ca;
+  int32_t addr;
+  Data_Get_Struct(self, CArray, ca);
+  addr = info->index[0].scalar;
+  return rb_ca_fetch_addr(self, addr);
+}
+
+static VALUE
+rb_ca_store_address (VALUE self, CAIndexInfo *info, volatile VALUE rval)
+{
+  CArray *ca;
+  int32_t addr;
+  Data_Get_Struct(self, CArray, ca);
+  addr = info->index[0].scalar;
+  if ( rb_obj_is_cscalar(rval) ) {
+    rval = rb_ca_fetch_addr(rval, 0);
+  }
+  rb_ca_store_addr(self, addr, rval);
+  return rval;
+}
+
+static VALUE
+rb_ca_ref_point (VALUE self, CAIndexInfo *info)
+{
+  CArray *ca;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  Data_Get_Struct(self, CArray, ca);
+  for (i=0; i<ca->rank; i++) {
+    idx[i] = info->index[i].scalar;
+  }
+  return rb_ca_fetch_index(self, idx);
+}
+
+static VALUE
+rb_ca_store_point (VALUE self, CAIndexInfo *info, volatile VALUE val)
+{
+  CArray *ca;
+  int32_t idx[CA_RANK_MAX];
+  int32_t i;
+  Data_Get_Struct(self, CArray, ca);
+  for (i=0; i<ca->rank; i++) {
+    idx[i] = info->index[i].scalar;
+  }
+  if ( rb_obj_is_cscalar(val) ) {
+    val = rb_ca_fetch_addr(val, 0);
+  }
+  rb_ca_store_index(self, idx, val);
+  return val;
+}
+
+static VALUE
+rb_ca_ref_all (VALUE self, CAIndexInfo *info)
+{
+  return rb_funcall(self, rb_intern("refer"), 0);
+}
+
+VALUE
+rb_ca_store_all (VALUE self, VALUE rval)
+{
+  CArray *ca;
+
+  rb_ca_modify(self);
+
+  if ( self == rval || rb_ca_is_empty(self) ) {
+    return rval;
+  }
+  
+  if ( rb_obj_is_cscalar(rval) ) {
+    rval = rb_ca_fetch_addr(rval, 0);
+  }
+
+  Data_Get_Struct(self, CArray, ca);
+
+ retry:
+
+  if ( rb_obj_is_carray(rval) ) {
+    CArray *cv;
+    Data_Get_Struct(rval, CArray, cv);
+
+    if ( cv->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
+      rval = ca_ubrep_bind_with(rval, self);
+      Data_Get_Struct(rval, CArray, cv);
+    }
+
+    if ( ca->elements != cv->elements ) {
+      rb_raise(rb_eRuntimeError,
+               "mismatch in data size (%i <-> %i) for storing to carray", 
+               ca->elements, cv->elements);
+    }
+
+    ca_attach(cv);
+    if ( ca->data_type != cv->data_type ) {
+      ca_allocate(ca);
+      ca_copy_mask_overwrite(ca, ca->elements, 1, cv);
+      if ( ca->mask ) {
+        ca_cast_block_with_mask(ca->elements, cv, cv->ptr, ca, ca->ptr, 
+                                (boolean8_t*)ca->mask->ptr);
+      }
+      else {
+        ca_cast_block(ca->elements, cv, cv->ptr, ca, ca->ptr);
+      }
+      ca_sync(ca);
+      ca_detach(ca);
+    }
+    else {
+      ca_copy_mask_overwrite(ca, ca->elements, 1, cv);
+      ca_sync_data(ca, cv->ptr);
+    }
+    ca_detach(cv);
+  }
+  else if ( TYPE(rval) == T_ARRAY ) {
+    volatile VALUE list =
+                 rb_ary_flatten_for_elements(rval, ca->elements, ca);
+    int32_t i;
+    if ( NIL_P(list) ) {
+      rb_raise(rb_eRuntimeError,
+               "failed to guess data size of given array");
+    }
+    else {
+      int has_mask = 0;
+      CArray ico;
+      ico.data_type = CA_OBJECT;
+      ico.bytes     = ca_sizeof[CA_OBJECT];
+      for (i=0; i<ca->elements; i++) {
+        if ( rb_ary_entry(list,i) == CA_UNDEF ) {
+          has_mask = 1;
+          ca_create_mask(ca);
+          break;
+        }
+      }
+      ca_allocate(ca);        
+      if ( has_mask ) {
+        boolean8_t *m;
+        m = (boolean8_t *)ca->mask->ptr;
+        for (i=0; i<ca->elements; i++) {
+          if ( rb_ary_entry(list,i) == CA_UNDEF ) {
+            *m = 1;
+          }
+          else {
+            *m = 0;
+          }
+          m++;
+        }
+        ca_cast_block_with_mask(ca->elements, &ico, RARRAY_PTR(list),
+                                ca, ca->ptr, 
+                                (boolean8_t*)ca->mask->ptr);
+      }
+      else {
+        ca_cast_block(ca->elements, &ico, RARRAY_PTR(list), ca, ca->ptr);
+      }
+      ca_sync(ca);
+      ca_detach(ca);
+    }
+  }
+  else if ( rb_respond_to(rval, id_ca) ) {
+    rval = rb_funcall(rval, id_ca, 0);
+    goto retry;
+  }
+  else if ( rb_respond_to(rval, id_to_ca) ) {
+    rval = rb_funcall(rval, id_to_ca, 0);
+    goto retry;
+  }
+  else {
+    rb_ca_fill(self, rval);
+  }
+
+  return rval;
+}
+
+static void
+rb_ca_index_restruct_block (int16_t *rankp, int32_t *shrink, int32_t *dim,
+                            int32_t *start, int32_t *step, int32_t *count,
+                            int32_t *offsetp)
+{
+  int32_t dim0[CA_RANK_MAX];
+  int32_t start0[CA_RANK_MAX];
+  int32_t step0[CA_RANK_MAX];
+  int32_t count0[CA_RANK_MAX];
+  int32_t idx[CA_RANK_MAX];
+  int16_t rank0, rank;
+  int32_t offset0, offset, length;
+  int32_t k, n;
+  int32_t i, j, m;
+
+  rank0   = *rankp;
+  offset0 = *offsetp;
+
+  /* store original start, step, count to start0, step0, count0 */
+  memcpy(dim0,   dim,   sizeof(int32_t) * rank0);
+  memcpy(start0, start, sizeof(int32_t) * rank0);
+  memcpy(step0,  step,  sizeof(int32_t) * rank0);
+  memcpy(count0, count, sizeof(int32_t) * rank0);
+
+  /* classify and calc rank */
+  n = -1;
+  for (i=0; i<rank0; i++) {
+    if ( ! shrink[i] ) {
+      n += 1;
+    }
+    idx[i] = n;
+  }
+  rank = n + 1;
+
+  *rankp = rank;
+
+  /* calc offset */
+
+  offset = 0;
+
+  if ( idx[0] == -1 ) {
+    j = 0;
+    while ( idx[++j] ) {
+      ;
+    }
+
+    offset = start0[0];
+    for (i=1; i<j; i++) {
+      offset = offset * dim0[i] + start0[i];
+    }
+
+    length = 1;
+    for (i=j; i<rank0; i++) {
+      length *= dim0[i];
+    }
+
+    offset *= length;
+  }
+
+  *offsetp = offset0 + offset;
+
+  /* calc dim, start, step, count */
+
+  for (i=0; i<rank0; i++) {
+    n = idx[i];
+    if ( n == -1) {
+      continue;
+    }
+
+    for (j=i+1, m=i; j<rank0 && (idx[j] == n); j++) {
+      ;
+    }
+
+    dim[n] = 1;
+    for (k=m; k<j; k++) {
+      dim[n] *= dim0[k];
+    }
+
+    start[n] = start0[m];
+    step[n]  = step0[m];
+    count[n] = count0[m];
+    for (k=m+1; k<j; k++) {
+      start[n] = start[n] * dim0[k] + start0[k];
+      step[n]  = step[n]  * dim0[k];
+      count[n] = count[n] * count0[k];
+    }
+
+    i = j - 1;
+  }
+
+}
+
+VALUE
+rb_ca_ref_block (VALUE self, CAIndexInfo *info)
+{
+  volatile VALUE refer;
+  CArray *ca;
+  int32_t dim[CA_RANK_MAX];
+  int32_t start[CA_RANK_MAX];
+  int32_t step[CA_RANK_MAX];
+  int32_t count[CA_RANK_MAX];
+  int32_t shrink[CA_RANK_MAX];
+  int16_t rank = 0;
+  int32_t offset = 0;
+  int32_t flag = 0;
+  int32_t elements;
+  int32_t i;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  rank = info->rank;
+
+  elements = 1;
+  for (i=0; i<info->rank; i++) {
+    dim[i] = ca->dim[i];
+    switch ( info->index_type[i] ) {
+    case CA_IDX_SCALAR:
+      elements *= 1;
+      break;
+    case CA_IDX_ALL:
+      elements *= ca->dim[i];
+      break;
+    case CA_IDX_BLOCK:
+      elements *= info->index[i].block.count;
+      break;
+    default:
+      rb_raise(rb_eIndexError, "invalid index for block reference");
+    }
+  }
+
+  for (i=0; i<info->rank; i++) {
+    switch ( info->index_type[i] ) {
+    case CA_IDX_SCALAR:
+      start[i]  = info->index[i].scalar;
+      step[i]   = 1;
+      count[i]  = 1;
+      shrink[i] = 1;
+      break;
+    case CA_IDX_ALL:
+      start[i]  = 0;
+      step[i]   = 1;
+      count[i]  = ca->dim[i];
+      shrink[i] = 0;
+      break;
+    case CA_IDX_BLOCK:
+      start[i]  = info->index[i].block.start;
+      step[i]   = info->index[i].block.step;
+      count[i]  = info->index[i].block.count;
+      shrink[i] = 0;
+      break;
+    }
+  }
+
+  for (i=0; i<rank; i++) {
+    if ( shrink[i] ) {
+      flag = 1;
+      break;
+    }
+  }
+
+  refer = self;
+  rank  = ca->rank;
+
+  offset = 0;
+
+  if ( flag ) {
+    rb_ca_index_restruct_block(&rank, shrink,
+                              dim, start, step, count, &offset);
+  }
+
+  return rb_ca_block_new(refer, rank, dim, start, step, count, offset);
+}
+
+static VALUE
+rb_ca_refer_new_flatten (VALUE self)
+{
+  CArray *ca;
+  int32_t dim0;
+
+  Data_Get_Struct(self, CArray, ca);
+  dim0 = ca->elements;
+  return rb_ca_refer_new(self, ca->data_type, 1, &dim0, ca->bytes, 0);
+}
+
+/* rdoc:
+  class CArray
+    def [] (*spec)
+    end
+  end
+*/
+
+static VALUE
+rb_ca_fetch_method (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE obj = Qnil;
+  CArray *ca;
+  CAIndexInfo info;
+
+ retry:
+
+  Data_Get_Struct(self, CArray, ca);
+  rb_ca_scan_index(ca->rank, ca->dim, ca->elements, argc, argv, &info);
+
+  switch ( info.type ) {
+  case CA_REG_ADDRESS_COMPLEX:
+    self = rb_ca_refer_new_flatten(self);
+    goto retry;
+  case CA_REG_ADDRESS:
+    obj = rb_ca_ref_address(self, &info);
+    break;
+  case CA_REG_POINT:
+    obj = rb_ca_ref_point(self, &info);
+    break;
+  case CA_REG_ALL:
+    obj = rb_ca_ref_all(self, &info);
+    break;
+  case CA_REG_BLOCK:
+    obj = rb_ca_ref_block(self, &info);
+    break;
+  case CA_REG_SELECT:
+    obj = rb_ca_select_new(self, argv[0]);
+    break;
+  case CA_REG_ITERATOR:
+    obj = rb_dim_iter_new(self, &info);
+    break;
+  case CA_REG_REPEAT:
+    obj = rb_ca_repeat(argc, argv, self);
+    break;
+  case CA_REG_UNBOUND_REPEAT:
+    obj = rb_funcall2(self, rb_intern("unbound_repeat"), argc, argv);
+    break;
+  case CA_REG_MAPPING:
+    obj = rb_ca_mapping(argc, argv, self);
+    break;
+  case CA_REG_GRID:
+    obj = rb_ca_grid(argc, argv, self);
+    break;
+  case CA_REG_METHOD_CALL: {
+    volatile VALUE idx;
+    idx = rb_funcall2(self, SYM2ID(info.symbol), argc-1, argv+1);
+    obj = rb_ca_fetch(self, idx);
+    break;
+  }
+  case CA_REG_MEMBER: {
+    volatile VALUE data_class = rb_ca_data_class(self);
+    if ( ! NIL_P(data_class) ) {
+      obj = rb_ca_field_as_member(self, info.symbol);
+      break;
+    }
+    else {
+      rb_raise(rb_eIndexError, 
+               "can't refer member of carray doesn't have data_class");
+    }
+    break;
+  }
+  default:
+    rb_raise(rb_eIndexError, "invalid index specified");
+  }
+
+  return obj;
+}
+
+/* rdoc:
+  class CArray
+    def []= (*spec)
+    end
+  end
+*/
+
+static VALUE
+rb_ca_store_method (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE obj = Qnil, rval;
+  CArray *ca;
+  CAIndexInfo info;
+
+  rb_ca_modify(self);
+
+  obj = rval = argv[argc-1];
+  argc -= 1;
+
+ retry:
+
+  Data_Get_Struct(self, CArray, ca);
+
+  rb_ca_scan_index(ca->rank, ca->dim, ca->elements, argc, argv, &info);
+
+  switch ( info.type ) {
+  case CA_REG_ADDRESS_COMPLEX:
+    self = rb_ca_refer_new_flatten(self);
+    goto retry;
+  case CA_REG_ADDRESS:
+    obj = rb_ca_store_address(self, &info, rval);
+    break;
+  case CA_REG_POINT:
+    obj = rb_ca_store_point(self, &info, rval);
+    break;
+  case CA_REG_ALL:
+    obj = rb_ca_store_all(self, rval);
+    break;
+  case CA_REG_BLOCK: {
+    volatile VALUE block;
+    block = rb_ca_ref_block(self, &info);
+    obj   = rb_ca_store_all(block, rval); 
+    break;
+  }
+  case CA_REG_SELECT: {
+    obj = rb_ca_select_new(self, argv[0]);
+    obj = rb_ca_store_all(obj, rval);
+    break;
+  }
+  case CA_REG_ITERATOR: {
+    obj = rb_dim_iter_new(self, &info);
+    obj = rb_funcall(obj, rb_intern("asign!"), 1, rval);
+    break;
+  }
+  case CA_REG_REPEAT: {
+    obj = rb_ca_repeat(argc, argv, self);
+    obj = rb_ca_store_all(obj, rval);
+    break;
+  }
+  case CA_REG_UNBOUND_REPEAT:
+    obj = rb_funcall2(self, rb_intern("unbound_repeat"), argc, argv);
+    obj = rb_ca_store_all(obj, rval);
+    break;
+  case CA_REG_MAPPING: {
+    obj = rb_ca_mapping(argc, argv, self);
+    obj = rb_ca_store_all(obj, rval);
+    break;
+  }
+  case CA_REG_GRID: {
+    obj = rb_ca_grid(argc, argv, self);
+    obj = rb_ca_store_all(obj, rval);
+    break;
+  }
+  case CA_REG_METHOD_CALL: {
+    volatile VALUE idx;
+    Data_Get_Struct(self, CArray, ca);
+    ca_attach(ca);
+    idx = rb_funcall2(self, SYM2ID(info.symbol), argc-1, argv+1);
+    obj = rb_ca_store(self, idx, rval);
+    ca_detach(ca);
+    break;
+  }
+  case CA_REG_MEMBER: {
+    volatile VALUE data_class = rb_ca_data_class(self);
+    if ( ! NIL_P(data_class) ) {
+      obj = rb_ca_field_as_member(self, info.symbol);
+      obj = rb_ca_store_all(obj, rval);
+    }
+    else {
+      rb_raise(rb_eIndexError, 
+               "can't store member of carray doesn't have data_class");
+    }
+    break;
+  }
+  }
+  return obj;
+}
+
+VALUE
+rb_ca_fetch (VALUE self, VALUE index)
+{
+  switch ( TYPE(index) ) {
+  case T_ARRAY:
+    return rb_ca_fetch_method(RARRAY_LEN(index), RARRAY_PTR(index), self);
+  default:
+    return rb_ca_fetch_method(1, &index, self);
+  }
+}
+
+VALUE
+rb_ca_fetch2 (VALUE self, int n, VALUE *rindex)
+{
+  return rb_ca_fetch_method(n, rindex, self);
+}
+
+VALUE
+rb_ca_store (VALUE self, VALUE index, VALUE rval)
+{
+  switch ( TYPE(index) ) {
+  case T_ARRAY:
+    index = rb_obj_clone(index);
+    rb_ary_push(index, rval);
+    return rb_ca_store_method(RARRAY_LEN(index), RARRAY_PTR(index), self);
+  default: {
+    VALUE rindex[2] = { index, rval };
+    return rb_ca_store_method(2, rindex, self);
+  }
+  }
+}
+
+VALUE
+rb_ca_store2 (VALUE self, int n, VALUE *rindex, VALUE rval)
+{
+  VALUE index = rb_ary_new4(n, rindex);
+  rb_ary_push(index, rval);
+  return rb_ca_store_method(RARRAY_LEN(index), RARRAY_PTR(index), self);
+}
+
+/* rdoc:
+  def CArray.scan_index(dim, idx)
+  end
+*/
+
+static VALUE
+rb_ca_s_scan_index (VALUE self, VALUE rdim, VALUE ridx)
+{
+  volatile VALUE rtype, rrank, rindex;
+  CAIndexInfo info;
+  int     rank;
+  int32_t dim[CA_RANK_MAX];
+  int32_t elements;
+  int i;
+
+  Check_Type(rdim, T_ARRAY);
+  Check_Type(ridx, T_ARRAY);
+
+  elements = 1;
+  rank = RARRAY_LEN(rdim);
+  for (i=0; i<rank; i++) {
+    dim[i] = NUM2LONG(rb_ary_entry(rdim, i));
+    elements *= dim[i];
+  }
+
+  CA_CHECK_RANK(rank);
+  CA_CHECK_DIM(rank, dim);
+
+  rb_ca_scan_index(rank, dim, elements,
+                   RARRAY_LEN(ridx), RARRAY_PTR(ridx), &info);
+
+  rtype  = INT2NUM(info.type);
+  rrank  = INT2NUM(info.rank);
+  rindex = rb_ary_new2(info.rank);
+
+  switch ( info.type ) {
+  case CA_REG_NONE:
+  case CA_REG_ALL:
+    break;
+  case CA_REG_ADDRESS:
+    rb_ary_store(rindex, 0, LONG2NUM(info.index[0].scalar));
+    break;
+  case CA_REG_ADDRESS_COMPLEX: {
+    volatile VALUE rinfo;
+    int32_t elements = 1;
+    for (i=0; i<rank; i++) {
+      elements *= dim[i];
+    }
+    rinfo = rb_ca_s_scan_index(self, rb_ary_new3(1, LONG2NUM(elements)), ridx);
+    rtype = LONG2NUM(CA_REG_ADDRESS_COMPLEX);
+    rindex = rb_struct_aref(rinfo, rb_str_new2("index"));
+    break;
+  }
+  case CA_REG_POINT:
+    for (i=0; i<rank; i++) {
+      rb_ary_store(rindex, i, LONG2NUM(info.index[i].scalar));
+    }
+    break;
+  case CA_REG_SELECT:
+    break;
+  case CA_REG_BLOCK:
+  case CA_REG_ITERATOR:
+    for (i=0; i<rank; i++) {
+      switch ( info.index_type[i] ) {
+      case CA_IDX_SCALAR:
+        rb_ary_store(rindex, i, LONG2NUM(info.index[i].scalar));
+        break;
+      case CA_IDX_ALL:
+        rb_ary_store(rindex, i,
+                     rb_ary_new3(3,
+                                 LONG2NUM(0),
+                                 rb_ary_entry(rdim, i),
+                                 LONG2NUM(1)));
+        break;
+      case CA_IDX_BLOCK:
+        rb_ary_store(rindex, i,
+                     rb_ary_new3(3,
+                                 LONG2NUM(info.index[i].block.start),
+                                 LONG2NUM(info.index[i].block.count),
+                                 LONG2NUM(info.index[i].block.step)));
+        break;
+      case CA_IDX_SYMBOL:
+        rb_ary_store(rindex, i,
+                     rb_ary_new3(2,
+                                 ID2SYM(info.index[i].symbol.id),
+                                 info.index[i].symbol.spec));
+        break;
+      default:
+        rb_raise(rb_eRuntimeError, "unknown index spec");
+      }
+    }
+    break;
+  case CA_REG_REPEAT:
+  case CA_REG_GRID:
+  case CA_REG_MAPPING:
+  case CA_REG_METHOD_CALL:
+  case CA_REG_UNBOUND_REPEAT:
+  case CA_REG_MEMBER:  
+    break;
+  default:
+    rb_raise(rb_eArgError, "unknown index specification");
+  }
+
+  return rb_struct_new(S_CAInfo, rtype, rindex);
+}
+
+/* rdoc:
+  class CArray
+    def normalize_index (idx)
+    end
+  end
+*/
+
+static VALUE
+rb_ca_normalize_index (VALUE self, VALUE ridx)
+{
+  volatile VALUE rindex;
+  CArray *ca;
+  CAIndexInfo info;
+  int i;
+
+  Data_Get_Struct(self, CArray, ca);
+  Check_Type(ridx, T_ARRAY);
+
+  rb_ca_scan_index(ca->rank, ca->dim, ca->elements,
+                   RARRAY_LEN(ridx), RARRAY_PTR(ridx), &info);
+
+  switch ( info.type ) {
+  case CA_REG_ALL:
+  case CA_REG_SELECT:
+  case CA_REG_ADDRESS:
+    rindex = rb_ary_new2(info.rank);
+    rb_ary_store(rindex, 0, LONG2NUM(info.index[0].scalar));
+    return rindex;
+  case CA_REG_POINT:
+    rindex = rb_ary_new2(info.rank);
+    for (i=0; i<ca->rank; i++) {
+      rb_ary_store(rindex, i, LONG2NUM(info.index[i].scalar));
+    }
+    return rindex;
+  case CA_REG_BLOCK:
+  case CA_REG_ITERATOR:
+    rindex = rb_ary_new2(info.rank);
+    for (i=0; i<ca->rank; i++) {
+      switch ( info.index_type[i] ) {
+      case CA_IDX_SCALAR:
+        rb_ary_store(rindex, i, LONG2NUM(info.index[i].scalar));
+        break;
+      case CA_IDX_ALL:
+        rb_ary_store(rindex, i, Qnil);
+        break;
+      case CA_IDX_BLOCK:
+        rb_ary_store(rindex, i,
+                     rb_ary_new3(3,
+                                 LONG2NUM(info.index[i].block.start),
+                                 LONG2NUM(info.index[i].block.count),
+                                 LONG2NUM(info.index[i].block.step)));
+        break;
+      case CA_IDX_SYMBOL:
+        rb_ary_store(rindex, i, ID2SYM(info.index[i].symbol.id));
+        break;
+      default:
+        rb_raise(rb_eRuntimeError, "unknown index spec");
+      }
+    }
+    return rindex;
+  case CA_REG_ADDRESS_COMPLEX:
+    self = rb_ca_refer_new_flatten(self);
+    return rb_ca_normalize_index(self, ridx);
+  default:
+    rb_raise(rb_eArgError, "unknown index specification");
+  }
+  rb_raise(rb_eArgError, "fail to normalize index");
+}
+
+/* ------------------------------------------------------------------- */
+
+/* rdoc:
+  class CArray
+    # converts addr to index
+    def addr2index (addr)
+    end
+  end
+*/
+
+VALUE
+rb_ca_addr2index (VALUE self, VALUE raddr)
+{
+  volatile VALUE out;
+  CArray *ca;
+  int32_t *dim;
+  int32_t addr;
+  int i;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  addr = NUM2INT(raddr);
+  if ( addr < 0 || addr >= ca->elements ) {
+    rb_raise(rb_eArgError,
+             "address %i is out of range (0..%i)",
+             addr, ca->elements-1);
+  }
+  dim = ca->dim;
+  out = rb_ary_new2(ca->rank);
+  for (i=ca->rank-1; i>=0; i--) { /* in descending order */
+    rb_ary_store(out, i, LONG2NUM(addr % dim[i]));
+    addr /= dim[i];
+  }
+
+  return out;
+}
+
+/* rdoc:
+  class CArray
+    def index2addr (*index)
+    end
+  end
+*/
+
+VALUE
+rb_ca_index2addr (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE obj;
+  CArray  *ca, *co, *cidx[CA_RANK_MAX];
+  int32_t *q, *p[CA_RANK_MAX], s[CA_RANK_MAX];
+  int32_t *dim;
+  int32_t addr, elements = 0;
+  int32_t i, k, n;
+  boolean8_t *m;
+  int     all_number = 1;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  if ( argc != ca->rank ) {
+    rb_raise(rb_eRuntimeError, "invalid rank of index");
+  }
+
+  for (i=0; i<ca->rank; i++) {
+    if ( ! rb_obj_is_kind_of(argv[i], rb_cInteger) ) {
+      all_number = 0;
+      break;
+    }
+  }
+
+  if ( all_number ) {
+    dim = ca->dim;
+    addr = 0;
+    for (i=0; i<ca->rank; i++) {
+      k = NUM2INT(argv[i]);
+      CA_CHECK_INDEX(k, dim[i]);
+      addr = dim[i] * addr + k;
+    }
+    return LONG2NUM(addr);
+  }
+
+  elements = 1;
+  for (i=0; i<ca->rank; i++) {
+    cidx[i] = ca_wrap_readonly(argv[i], CA_INT32);
+    if ( ! ca_is_scalar(cidx[i]) ) {
+      if ( elements == 1 ) {
+        elements = cidx[i]->elements;
+      }
+      else if ( elements != cidx[i]->elements ) {
+        rb_raise(rb_eRuntimeError, "mismatch in # of elements");
+      }
+    }
+  }
+
+  for (i=0; i<ca->rank; i++) {
+    ca_attach(cidx[i]);
+    ca_set_iterator(1, cidx[i], &p[i], &s[i]);
+  }
+
+  obj = rb_carray_new(CA_INT32, 1, &elements, 0, NULL);
+  Data_Get_Struct(obj, CArray, co);
+
+  q = (int32_t *) co->ptr;
+
+  ca_copy_mask_overwrite_n(co, elements, ca->rank, cidx);
+  m = ( co->mask ) ? (boolean8_t *) co->mask->ptr : NULL;
+
+  dim = ca->dim;
+
+  if ( m ) {
+    n = elements;  
+    while ( n-- ) {
+      if ( !*m ) {
+        addr = 0;
+        for (i=0; i<ca->rank; i++) {
+          k = *(p[i]);
+          p[i]+=s[i];
+          CA_CHECK_INDEX(k, dim[i]);
+          addr = dim[i] * addr + k;
+        }
+        *q = addr;
+      }
+      else {
+        for (i=0; i<ca->rank; i++) {
+          p[i]+=s[i];
+        }
+      }
+      m++; q++;
+    }
+  }
+  else {
+    n = elements;  
+    while ( n-- ) {
+      addr = 0;
+      for (i=0; i<ca->rank; i++) {
+        k = *(p[i]);
+        p[i]+=s[i];
+        CA_CHECK_INDEX(k, dim[i]);
+        addr = dim[i] * addr + k;
+      }
+      *q = addr;
+      q++;
+    }
+  }
+
+  for (i=0; i<ca->rank; i++) {
+    ca_detach(cidx[i]);
+  }
+
+  return obj;
+}
+
+
+void
+Init_carray_access ()
+{
+
+#if RUBY_VERSION_CODE >= 190
+#else
+  id_beg   = rb_intern("begin");
+  id_end   = rb_intern("end");
+  id_excl  = rb_intern("excl");
+#endif
+
+  id_ca    = rb_intern("ca");
+  id_to_ca = rb_intern("to_ca");
+  sym_star = ID2SYM(rb_intern("*"));
+  sym_perc = ID2SYM(rb_intern("%"));
+
+  rb_define_method(rb_cCArray, "[]", rb_ca_fetch_method, -1);
+  rb_define_method(rb_cCArray, "[]=", rb_ca_store_method, -1);
+
+  rb_define_method(rb_cCArray, "fill", rb_ca_fill, 1);
+  rb_define_method(rb_cCArray, "fill_copy", rb_ca_fill_copy, 1);
+
+  S_CAInfo = rb_struct_define("CAIndexInfo", "type", "index", NULL);
+
+  rb_define_singleton_method(rb_cCArray, "guess_array_shape",
+                                          rb_ca_s_guess_array_shape, 1);
+  rb_define_singleton_method(rb_cCArray, "scan_index", rb_ca_s_scan_index, 2);
+  rb_define_method(rb_cCArray, "normalize_index", rb_ca_normalize_index, 1);
+
+  rb_define_method(rb_cCArray, "index2addr", rb_ca_index2addr, -1);
+  rb_define_method(rb_cCArray, "addr2index", rb_ca_addr2index, 1);
+
+  rb_define_const(rb_cObject, "CA_REG_NONE",     INT2NUM(CA_REG_NONE));
+  rb_define_const(rb_cObject, "CA_REG_ALL",      INT2NUM(CA_REG_ALL));
+  rb_define_const(rb_cObject, "CA_REG_ADDRESS",  INT2NUM(CA_REG_ADDRESS));
+  rb_define_const(rb_cObject, "CA_REG_ADDRESS_COMPLEX",
+                                                 INT2NUM(CA_REG_ADDRESS_COMPLEX));
+  rb_define_const(rb_cObject, "CA_REG_POINT",    INT2NUM(CA_REG_POINT));
+  rb_define_const(rb_cObject, "CA_REG_BLOCK",    INT2NUM(CA_REG_BLOCK));
+  rb_define_const(rb_cObject, "CA_REG_SELECT",   INT2NUM(CA_REG_SELECT));
+  rb_define_const(rb_cObject, "CA_REG_ITERATOR", INT2NUM(CA_REG_ITERATOR));
+  rb_define_const(rb_cObject, "CA_REG_REPEAT",   INT2NUM(CA_REG_REPEAT));
+  rb_define_const(rb_cObject, "CA_REG_GRID",     INT2NUM(CA_REG_GRID));
+  rb_define_const(rb_cObject, "CA_REG_MAPPING",  INT2NUM(CA_REG_MAPPING));
+  rb_define_const(rb_cObject, "CA_REG_METHOD_CALL",
+                                                 INT2NUM(CA_REG_METHOD_CALL));
+  rb_define_const(rb_cObject, "CA_REG_UNBOUND_REPEAT",
+                                                 INT2NUM(CA_REG_UNBOUND_REPEAT));
+  rb_define_const(rb_cObject, "CA_REG_MEMBER",   INT2NUM(CA_REG_MEMBER));
+
+}
+