redshift 1.3.22 → 1.3.23

data/ext/redshift/dvector/dvector.h

@@ -0,0 +1,36 @@
+#ifndef dvector_h
+#define dvector_h
+
+#include <ruby.h>
+
+typedef struct {
+  long    len;
+  long    capa;
+  VALUE  *ptr;
+} RS_DVector;
+
+extern void rs_dv_grow(RS_DVector *dv);
+extern void rs_dv_shrink(RS_DVector *dv);
+
+inline static RS_DVector *rs_dv(VALUE obj)
+{
+    return (RS_DVector *)DATA_PTR(obj);
+}
+
+inline static void rs_dv_push(RS_DVector *dv, VALUE val)
+{
+    if (dv->len == dv->capa) {
+        rs_dv_grow(dv);
+    }
+    dv->ptr[dv->len++] = val;
+}
+
+inline static VALUE rs_dv_pop(RS_DVector *dv)
+{
+    if (dv->len == 0) {
+        return Qnil;
+    }
+    return dv->ptr[--dv->len];
+}
+
+#endif

data/ext/redshift/dvector/dvector.rb

@@ -0,0 +1,33 @@
+module RedShift; end
+
+# A linear collection of objects, like Array.
+#
+# Intended primarily for access from C code, using the inline
+# rs_dv_push() and rs_dv_pop() functions.
+#
+# Implements some of the same methods as Array, but not all.
+#
+# Like an Array, a DVector grows implicitly as elements are
+# pushed. But unlike an Array, a DVector shrinks only explicitly.
+# This is to minimize realloc() calls when a DVector rapidly
+# grows and shrinks.
+
+class RedShift::DVector
+  include Enumerable
+  require 'redshift/dvector/dvector.so'
+  
+  def self.[](*elts)
+    new elts
+  end
+  
+  def initialize(elts=nil)
+    push(*elts) if elts
+  end
+  
+  def inspect; to_a.inspect; end
+  def to_s; to_a.to_s; end
+  
+  def dup
+    self.class.new to_a
+  end
+end

data/ext/redshift/dvector/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'dvector'

data/lib/redshift/redshift.rb

@@ -70,7 +70,7 @@ end
 module RedShift
   include Math
   
-  VERSION = '1.3.22'
+  VERSION = '1.3.23'
 
   Infinity = Math::Infinity
 

data/lib/redshift/target/c/component-gen.rb

@@ -4,8 +4,6 @@ module RedShift
     # just so we can call shadow_struct_name on it
   end
 
-  HAVE_DEFINE_METHOD = Module.private_instance_methods.include?("define_method")
-  
   class Component
     include CShadow
     shadow_library RedShift.library
@@ -738,17 +736,13 @@ module RedShift
             g
           
           when Proc
-            if HAVE_DEFINE_METHOD
-              meth = Component.make_guard_method_name
-              class_eval do
-                define_method(meth, &g)
-              end
-              ## Currently, methods defined with define_method are a little
-              ## slower to invoke in ruby.
-              meth
-            else
-              g # a proc is slower than a method when called from step_discrete
+            meth = Component.make_guard_method_name
+            class_eval do
+              define_method(meth, &g)
             end
+            ## Currently, methods defined with define_method are a little
+            ## slower to invoke in ruby.
+            meth
           
           when String
             define_guard(g)
@@ -944,8 +938,8 @@ module RedShift
         idx_ary = rb_funcall(shadow->cont_state->self, #{svi}, 0);
         Check_Type(idx_ary, T_ARRAY); //## debug only
 
-        count = RARRAY(idx_ary)->len;
-        indexes = RARRAY(idx_ary)->ptr;
+        count = RARRAY_LEN(idx_ary);
+        indexes = RARRAY_PTR(idx_ary);
         
         for (i = 0; i < count; i++) {
           idx = NUM2INT(indexes[i]);
@@ -1084,7 +1078,7 @@ module RedShift
     }
 
     library.define(:s_init_flow).instance_eval do
-      arguments "void (*fn)()", "char *fname", "char *inspect_str", "int alg"
+      arguments "void (*fn)()", "const char *fname", "const char *inspect_str", "int alg"
 
       fw_ssn = Component::FlowWrapper.shadow_struct_name
       fw_cname = library.declare_class Component::FlowWrapper
@@ -1106,7 +1100,7 @@ module RedShift
     end
 
     library.define(:s_init_guard).instance_eval do
-      arguments "void (*fn)()", "char *fname", "char *inspect_str", "int strict"
+      arguments "int (*fn)()", "const char *fname", "const char *inspect_str", "int strict"
 
       gw_ssn = Component::GuardWrapper.shadow_struct_name
       gw_cname = library.declare_class Component::GuardWrapper
@@ -1128,7 +1122,7 @@ module RedShift
     end
 
     library.define(:s_init_expr).instance_eval do
-      arguments "void (*fn)()", "char *fname", "char *inspect_str"
+      arguments "double (*fn)()", "const char *fname", "const char *inspect_str"
 
       ew_ssn = Component::ExprWrapper.shadow_struct_name
       ew_cname = library.declare_class Component::ExprWrapper
@@ -1210,10 +1204,11 @@ module RedShift
         long        count;
         VALUE      *flows;
         int         has_diff;
-        struct RArray *ary;
         int         flags;
       }.tabto(0)
 
+      include("dvector/dvector.h")
+
       body %{
         var_count = shadow->var_count;
         vars = (ContVar *)&FIRST_CONT_VAR(shadow);
@@ -1222,8 +1217,7 @@ module RedShift
         shadow->outgoing = rb_funcall(shadow->self,
                            #{declare_symbol :outgoing_transition_data}, 0);
 
-        ary = RARRAY(shadow->outgoing);
-        flags = FIX2INT(ary->ptr[ary->len-1]);
+        flags = FIX2INT(RARRAY_PTR(shadow->outgoing)[RARRAY_LEN(shadow->outgoing)-1]);
         shadow->strict = flags & 0x01;
         shadow->sleepable = !!(flags & 0x02);
 
@@ -1236,8 +1230,8 @@ module RedShift
 
         if (flow_array != Qnil) {
           #{"Check_Type(flow_array, T_ARRAY);\n" if $REDSHIFT_DEBUG}
-          count = RARRAY(flow_array)->len;
-          flows = RARRAY(flow_array)->ptr;
+          count = RARRAY_LEN(flow_array);
+          flows = RARRAY_PTR(flow_array);
 
           if (count > var_count)
             rs_raise(#{declare_class IndexError}, shadow->self,
@@ -1287,7 +1281,7 @@ module RedShift
         if (has_diff && !shadow->has_diff) {
           if (!shadow->diff_list) {
             if (shadow->world->diff_list) { //# 0 if loading
-              rb_ary_push(shadow->world->diff_list, shadow->self);
+              rs_dv_push(rs_dv(shadow->world->diff_list), shadow->self);
             }
             shadow->diff_list = 1;
           }

data/lib/redshift/target/c/flow-gen.rb

@@ -110,7 +110,7 @@ module RedShift; class Flow
               VALUE event_values, event_val;
               event_values = shadow->event_values;
               assert(event_values != Qnil);
-              event_val = RARRAY(event_values)->ptr[#{event_idx}];
+              event_val = RARRAY_PTR(event_values)[#{event_idx}];
               #{var_cname} = NUM2DBL(event_val);
             }
           
@@ -311,7 +311,7 @@ module RedShift; class Flow
             rs_raise(#{exc_nil}, ct->shadow->self, #{msg_nil.inspect});
           event_values = ct->#{link_cname}->event_values;
           assert(event_values != Qnil);
-          event_val = RARRAY(event_values)->ptr[#{event_idx}];
+          event_val = RARRAY_PTR(event_values)[#{event_idx}];
           return NUM2DBL(event_val);
         }
       }

data/lib/redshift/target/c/flow/algebraic.rb

@@ -65,7 +65,7 @@ module RedShift; class AlgebraicFlow
             
           default:
             rb_raise(#{declare_class RuntimeError},
-              "Bad rk_level, %d!", shadow->world->rk_level);
+              "Bad rk_level, %ld!", shadow->world->rk_level);
           }
           
           shadow->world->alg_nest--;

data/lib/redshift/target/c/flow/delay.rb

@@ -153,7 +153,7 @@ module RedShift; class DelayFlow
             
           default:
             rb_raise(#{declare_class RuntimeError},
-              "Bad rk_level, %d!", shadow->world->rk_level);
+              "Bad rk_level, %ld!", shadow->world->rk_level);
           }
 
           shadow->world->rk_level++;

data/lib/redshift/target/c/flow/derivative.rb

@@ -84,7 +84,7 @@ module RedShift; class DerivativeFlow
 
             default:
               rb_raise(#{declare_class RuntimeError},
-                "Bad rk_level, %d!", shadow->world->rk_level);
+                "Bad rk_level, %ld!", shadow->world->rk_level);
             }
 
             shadow->world->rk_level++;

data/lib/redshift/target/c/flow/rk4.rb

@@ -64,7 +64,7 @@ module RedShift; class RK4DifferentialFlow
 
           default:
             rb_raise(#{declare_class RuntimeError},
-              "Bad rk_level, %d!", shadow->world->rk_level);
+              "Bad rk_level, %ld!", shadow->world->rk_level);
           }
           
           shadow->world->rk_level++;

data/lib/redshift/target/c/library.rb

@@ -22,9 +22,14 @@ module RedShift
       end
 
       include_file.include '<math.h>'
+      
+      base = File.expand_path("../../../..", __FILE__)
+      ext_rs = File.join(base, "ext/redshift")
+      include_dirs << ext_rs
     end
     
     # Call this to link with external libraries. See examples/external-lib.rb.
+    # Note also include_dirs array.
     def link_with *libs
       (@link_libs ||= []) << libs
     end

data/lib/redshift/target/c/world-gen.rb

@@ -5,14 +5,15 @@ class World
   shadow_library RedShift.library
   shadow_library_file "World"
   shadow_library_source_file.include(Component.shadow_library_include_file)
+  shadow_library_source_file.include("dvector/dvector.h")
 
   shadow_library_include_file.declare :step_discrete_macros => '
     #define INT2BOOL(i)  (i ? Qtrue : Qfalse)
 
     #define SWAP_VALUE(v, w) {VALUE ___tmp = v; v = w; w = ___tmp;}
 
-    #define EACH_COMP_DO(lc)                          \\
-    for (list = RARRAY(lc), list_i = list->len - 1;   \\
+    #define EACH_COMP_DO(lc)                           \\
+    for (list = rs_dv(lc), list_i = list->len - 1;     \\
           list_i >= 0 && (                             \\
             comp = list->ptr[list_i],                  \\
             comp_shdw = get_shadow(comp),              \\
@@ -23,7 +24,7 @@ class World
   '.tabto(0)
   # Note: EACH_COMP_DO(lc) block may use move_comp and remove_comp
   # but it should (re)move none or all. Must have declarations for comp
-  # comp_shdw, list, and list_i in scope.
+  # comp_shdw, list, and list_i in scope. lc must be a DVector.
 
   shadow_library_include_file.declare :cv_cache_entry => %{
     typedef struct {
@@ -60,19 +61,19 @@ class World
     sub.shadow_library_file file_name
   end
 
-  shadow_attr_accessor :curr_A => Array
-  shadow_attr_accessor :curr_P => Array
-  shadow_attr_accessor :curr_CR => Array
-  shadow_attr_accessor :curr_S => Array
-  shadow_attr_accessor :next_S => Array
-  shadow_attr_accessor :curr_T => Array
-  shadow_attr_accessor :active_E => Array
-  shadow_attr_accessor :prev_active_E => Array
-  shadow_attr_accessor :awake => Array
-  shadow_attr_accessor :prev_awake => Array
-  shadow_attr_accessor :strict_sleep => Array
-  shadow_attr_accessor :inert => Array
-  shadow_attr_accessor :diff_list => Array
+  shadow_attr_accessor :curr_A => DVector
+  shadow_attr_accessor :curr_P => DVector
+  shadow_attr_accessor :curr_CR => DVector
+  shadow_attr_accessor :curr_S => DVector
+  shadow_attr_accessor :next_S => DVector
+  shadow_attr_accessor :curr_T => DVector
+  shadow_attr_accessor :active_E => DVector
+  shadow_attr_accessor :prev_active_E => DVector
+  shadow_attr_accessor :awake => DVector
+  shadow_attr_accessor :prev_awake => DVector
+  shadow_attr_accessor :strict_sleep => DVector
+  shadow_attr_accessor :inert => DVector
+  shadow_attr_accessor :diff_list => DVector
   shadow_attr_accessor :queue_sleep => Hash
   protected \
     :curr_A, :curr_P, :curr_CR, :curr_T,
@@ -191,7 +192,7 @@ class World
 
   define_c_method :step_continuous do
     declare :locals => %{
-      VALUE             comp_rb_ary[2], *comp_ary;
+      VALUE             comp_dvector[2], *comp_ary;
       long              len;
       long              var_count;
       ContVar          *var, *end_var;
@@ -199,11 +200,11 @@ class World
       ComponentShadow  *comp_shdw;
     }.tabto(0)
     body %{
-      comp_rb_ary[0] = shadow->awake;
-      comp_rb_ary[1] = shadow->inert;
+      comp_dvector[0] = shadow->awake;
+      comp_dvector[1] = shadow->inert;
       for (li = 0; li < 2; li++) {
-        len = RARRAY(comp_rb_ary[li])->len;
-        comp_ary = RARRAY(comp_rb_ary[li])->ptr;
+        len = rs_dv(comp_dvector[li])->len;
+        comp_ary = rs_dv(comp_dvector[li])->ptr;
         for (ci = 0; ci < len; ci++) {
           Data_Get_Struct(comp_ary[ci], ComponentShadow, comp_shdw);
           var_count = comp_shdw->var_count;
@@ -221,8 +222,8 @@ class World
       }
       
       for (shadow->rk_level = 1; shadow->rk_level <= 3; shadow->rk_level++) {
-        len = RARRAY(shadow->diff_list)->len;
-        comp_ary = RARRAY(shadow->diff_list)->ptr;
+        len = rs_dv(shadow->diff_list)->len;
+        comp_ary = rs_dv(shadow->diff_list)->ptr;
         for (ci = 0; ci < len; ci++) {
           Data_Get_Struct(comp_ary[ci], ComponentShadow, comp_shdw);
           
@@ -231,7 +232,7 @@ class World
               comp_ary[ci] = comp_ary[len-1];
               ci--;
             }
-            len = RARRAY(shadow->diff_list)->len = len-1;
+            len = rs_dv(shadow->diff_list)->len = len-1;
             comp_shdw->diff_list = 0;
           }
           else {
@@ -252,8 +253,8 @@ class World
       
       shadow->rk_level = 4;
       for (li = 0; li < 2; li++) {
-        len = RARRAY(comp_rb_ary[li])->len;
-        comp_ary = RARRAY(comp_rb_ary[li])->ptr;
+        len = rs_dv(comp_dvector[li])->len;
+        comp_ary = rs_dv(comp_dvector[li])->ptr;
         for (ci = 0; ci < len; ci++) {
           Data_Get_Struct(comp_ary[ci], ComponentShadow, comp_shdw);
           var_count = comp_shdw->var_count;
@@ -310,84 +311,80 @@ class World
       VALUE            *ptr;
       long              len;
       long              i;
-      struct RArray    *list;
+      RS_DVector       *list;
       int               list_i;
       int               did_reset;
     }.tabto(0)
     
     insteval_proc = declare_symbol :insteval_proc
-    capa = RUBY_VERSION.to_f >= 1.7 ? "aux.capa" : "capa"
     epi = Component::EventPhaseItem
     spi = Component::SyncPhaseItem
     
     parent.declare :step_discrete_subs => %{
       inline static VALUE cur_syncs(ComponentShadow *comp_shdw)
       {
-        VALUE syncs = RARRAY(comp_shdw->trans)->ptr[#{Transition::S_IDX}];
+        VALUE syncs = RARRAY_PTR(comp_shdw->trans)[#{Transition::S_IDX}];
         assert(syncs == Qnil || RBASIC(syncs)->klass == SyncClass);
         return syncs;
       }
       inline static VALUE cur_actions(ComponentShadow *comp_shdw)
       {
-        VALUE actions = RARRAY(comp_shdw->trans)->ptr[#{Transition::A_IDX}];
+        VALUE actions = RARRAY_PTR(comp_shdw->trans)[#{Transition::A_IDX}];
         assert(actions == Qnil || RBASIC(actions)->klass == ActionClass);
         return actions;
       }
       inline static VALUE cur_posts(ComponentShadow *comp_shdw)
       {
-        VALUE posts = RARRAY(comp_shdw->trans)->ptr[#{Transition::P_IDX}];
+        VALUE posts = RARRAY_PTR(comp_shdw->trans)[#{Transition::P_IDX}];
         assert(posts == Qnil || RBASIC(posts)->klass == PostClass);
         return posts;
       }
       inline static VALUE cur_events(ComponentShadow *comp_shdw)
       {
-        VALUE events = RARRAY(comp_shdw->trans)->ptr[#{Transition::E_IDX}];
+        VALUE events = RARRAY_PTR(comp_shdw->trans)[#{Transition::E_IDX}];
         assert(events == Qnil || RBASIC(events)->klass == EventClass);
         return events;
       }
       inline static VALUE cur_resets(ComponentShadow *comp_shdw)
       {
-        VALUE resets = RARRAY(comp_shdw->trans)->ptr[#{Transition::R_IDX}];
+        VALUE resets = RARRAY_PTR(comp_shdw->trans)[#{Transition::R_IDX}];
         assert(resets == Qnil || RBASIC(resets)->klass == ResetClass);
         return resets;
       }
       inline static VALUE cur_connects(ComponentShadow *comp_shdw)
       {
-        VALUE connects = RARRAY(comp_shdw->trans)->ptr[#{Transition::C_IDX}];
+        VALUE connects = RARRAY_PTR(comp_shdw->trans)[#{Transition::C_IDX}];
         assert(connects == Qnil || RBASIC(connects)->klass == ConnectClass);
         return connects;
       }
       inline static void move_comp(VALUE comp, VALUE list, VALUE next_list)
       {
-        struct RArray *nl = RARRAY(next_list);
-        assert(RARRAY(list)->ptr[RARRAY(list)->len-1] == comp);
-        if (nl->len == nl->#{capa})
-          rb_ary_store(next_list, nl->len, comp);
-        else
-          nl->ptr[nl->len++] = comp;
-        --RARRAY(list)->len;
+        RS_DVector *dv = rs_dv(next_list);
+        assert(rs_dv(list)->ptr[rs_dv(list)->len-1] == comp);
+        rs_dv_push(dv, comp);
+        --rs_dv(list)->len;
       }
       inline static void move_comp_to_hash(VALUE comp, VALUE list, VALUE hash)
       {
-        struct RArray *l = RARRAY(list);
-        assert(l->ptr[l->len-1] == comp);
+        RS_DVector *dv = rs_dv(list);
+        assert(dv->ptr[dv->len-1] == comp);
         rb_hash_aset(hash, comp, Qtrue);
-        --l->len;
+        --dv->len;
       }
       inline static void move_all_comps(VALUE list, VALUE next_list)
       { //## this could be faster using memcpy
-        struct RArray *l = RARRAY(list);
-        while (l->len)
-          move_comp(l->ptr[l->len-1], list, next_list);
+        RS_DVector *dv = rs_dv(list);
+        while (dv->len)
+          move_comp(dv->ptr[dv->len-1], list, next_list);
       }
       inline static void remove_comp(VALUE comp, VALUE list,
                                    #{World.shadow_struct_name} *shadow)
       {
         ComponentShadow *comp_shdw = get_shadow(comp);
-        assert(RARRAY(list)->ptr[RARRAY(list)->len-1] == comp);
+        assert(rs_dv(list)->ptr[rs_dv(list)->len-1] == comp);
         assert(comp_shdw->world == shadow);
         comp_shdw->world = 0;
-        --RARRAY(list)->len;
+        --rs_dv(list)->len;
         //%% hook_remove_comp(comp_shdw->self);
       }
       inline static double eval_expr(VALUE comp, VALUE expr)
@@ -425,8 +422,8 @@ class World
         int i;
         VALUE kl;
         assert(BUILTIN_TYPE(guards) == T_ARRAY);
-        for (i = 0; i < RARRAY(guards)->len; i++) {
-          VALUE guard = RARRAY(guards)->ptr[i];
+        for (i = 0; i < RARRAY_LEN(guards); i++) {
+          VALUE guard = RARRAY_PTR(guards)[i];
 
           if (SYMBOL_P(guard)) {
             if (!RTEST(rb_funcall(comp, SYM2ID(guard), 0)))
@@ -449,8 +446,8 @@ class World
             case T_ARRAY:
               kl = RBASIC(guard)->klass;
               if (kl == QMatchClass) {
-                int len = RARRAY(guard)->len;
-                VALUE *ptr = RARRAY(guard)->ptr;
+                int len = RARRAY_LEN(guard);
+                VALUE *ptr = RARRAY_PTR(guard);
                 assert(len > 0);
                 VALUE queue_name = ptr[0];
                 VALUE queue = rb_funcall(comp, SYM2ID(queue_name), 0);
@@ -480,11 +477,11 @@ class World
         VALUE syncs = cur_syncs(comp_shdw);
         assert(RTEST(syncs));
         
-        for (i = RARRAY(syncs)->len - 1; i >= 0; i--) {
-          VALUE sync = RARRAY(syncs)->ptr[i];
-          assert(RARRAY(sync)->len == 3);
-          int link_offset = FIX2INT(RARRAY(sync)->ptr[#{spi::LINK_OFFSET_IDX}]);
-          VALUE event = RARRAY(sync)->ptr[#{spi::EVENT_IDX}];
+        for (i = RARRAY_LEN(syncs) - 1; i >= 0; i--) {
+          VALUE sync = RARRAY_PTR(syncs)[i];
+          assert(RARRAY_LEN(sync) == 3);
+          int link_offset = FIX2INT(RARRAY_PTR(sync)[#{spi::LINK_OFFSET_IDX}]);
+          VALUE event = RARRAY_PTR(sync)[#{spi::EVENT_IDX}];
           ComponentShadow *link_shdw =
             *(ComponentShadow **)(((char *)comp_shdw) + link_offset);
           
@@ -496,11 +493,11 @@ class World
           int found = 0;
           VALUE link_events = cur_events(link_shdw);
           if (RTEST(link_events)) {
-            VALUE  *ptr   = RARRAY(link_events)->ptr;
-            long    len   = RARRAY(link_events)->len;
+            VALUE  *ptr   = RARRAY_PTR(link_events);
+            long    len   = RARRAY_LEN(link_events);
       
             for (j = len; j > 0; j--, ptr++) {
-              VALUE link_event = RARRAY(*ptr)->ptr[#{epi::E_IDX}];
+              VALUE link_event = RARRAY_PTR(*ptr)[#{epi::E_IDX}];
               if (link_event == event) {
                 found = 1;
                 break;
@@ -525,14 +522,14 @@ class World
         int has_events = RTEST(events);
         
         if (has_events) {
-          VALUE  *ptr   = RARRAY(events)->ptr;
-          long    len   = RARRAY(events)->len;
+          VALUE  *ptr   = RARRAY_PTR(events);
+          long    len   = RARRAY_LEN(events);
           int     i;
           VALUE   comp  = comp_shdw->self;
 
           for (i = len; i > 0; i--, ptr++) {
-            int   event_idx = FIX2INT(RARRAY(*ptr)->ptr[#{epi::I_IDX}]);
-            VALUE event_val = RARRAY(*ptr)->ptr[#{epi::V_IDX}];
+            int   event_idx = FIX2INT(RARRAY_PTR(*ptr)[#{epi::I_IDX}]);
+            VALUE event_val = RARRAY_PTR(*ptr)[#{epi::V_IDX}];
 
             //## maybe this distinction should be made clear in the array
             //## itself, with a numeric switch, say.
@@ -542,9 +539,9 @@ class World
             else if (rb_obj_is_kind_of(event_val, ExprWrapperClass))
               event_val = rb_float_new(eval_expr(comp, event_val));
 
-            //%% hook_eval_event(comp, RARRAY(*ptr)->ptr[#{epi::E_IDX}],
+            //%% hook_eval_event(comp, RARRAY_PTR(*ptr)[#{epi::E_IDX}],
             //%%   event_val);
-            RARRAY(comp_shdw->next_event_values)->ptr[event_idx] = event_val;
+            RARRAY_PTR(comp_shdw->next_event_values)[event_idx] = event_val;
           }
         }
 
@@ -711,12 +708,12 @@ class World
         if (!RTEST(resets))
           return 0;
 
-        cont_resets     = RARRAY(resets)->ptr[0];
+        cont_resets     = RARRAY_PTR(resets)[0];
         has_cont_resets = RTEST(cont_resets);
 
         if (has_cont_resets) {
-          VALUE   *ptr = RARRAY(cont_resets)->ptr;
-          long    len  = RARRAY(cont_resets)->len;
+          VALUE   *ptr = RARRAY_PTR(cont_resets);
+          long    len  = RARRAY_LEN(cont_resets);
           int     i;
           VALUE   comp = comp_shdw->self;
           ContVar *var = (ContVar *)&FIRST_CONT_VAR(comp_shdw);
@@ -724,6 +721,7 @@ class World
 
           for (i = 0; i < len; i++, var++, ptr++) {
             VALUE reset = *ptr;
+            VALUE class_name;
             if (reset == Qnil) {
               var->reset = 0;
             }
@@ -736,25 +734,25 @@ class World
 
               switch(TYPE(reset)) {
                 case T_FLOAT:
-                  new_value = RFLOAT(reset)->value;
+                  new_value = RFLOAT_VALUE(reset);
                   break;
                 default:
                   if (RBASIC(reset)->klass == rb_cProc) {
                     VALUE val = rb_funcall(comp, #{insteval_proc}, 1, reset);
                     switch(TYPE(val)) {
                       case T_FLOAT:
-                        new_value = RFLOAT(val)->value;
+                        new_value = RFLOAT_VALUE(val);
                         break;
                       case T_FIXNUM:
                         new_value = FIX2INT(val);
                         break;
                       default:
+                        class_name = rb_funcall(
+                          rb_funcall(val, #{declare_symbol :class}, 0),
+                          #{declare_symbol :to_s}, 0);
                         rs_raise(#{declare_class VarTypeError}, comp,
                           "tried to reset cont var with %s.",
-                          STR2CSTR(rb_funcall(
-                            rb_funcall(val, #{declare_symbol :class}, 0),
-                            #{declare_symbol :to_s},
-                            0))
+                          StringValuePtr(class_name)
                         );
                     }
                   }
@@ -789,25 +787,25 @@ class World
         if (!RTEST(resets))
           return 0;
 
-        const_resets      = RARRAY(resets)->ptr[1];
-        link_resets       = RARRAY(resets)->ptr[2];
+        const_resets      = RARRAY_PTR(resets)[1];
+        link_resets       = RARRAY_PTR(resets)[2];
         has_const_resets  = RTEST(const_resets);
         has_link_resets   = RTEST(link_resets);
         comp              = comp_shdw->self;
 
         if (has_const_resets) {
-          VALUE   *ptr = RARRAY(const_resets)->ptr;
-          long    len  = RARRAY(const_resets)->len;
+          VALUE   *ptr = RARRAY_PTR(const_resets);
+          long    len  = RARRAY_LEN(const_resets);
 
           for (i = 0; i < len; i++) {
             VALUE   pair    = ptr[i];
-            int     offset  = NUM2INT(RARRAY(pair)->ptr[0]);
-            VALUE   reset   = RARRAY(pair)->ptr[1];
+            int     offset  = NUM2INT(RARRAY_PTR(pair)[0]);
+            VALUE   reset   = RARRAY_PTR(pair)[1];
             double new_value;
 
             switch(TYPE(reset)) {
               case T_FLOAT:
-                new_value = RFLOAT(reset)->value;
+                new_value = RFLOAT_VALUE(reset);
                 break;
               default:
                 if (RBASIC(reset)->klass == rb_cProc)
@@ -818,7 +816,7 @@ class World
             }
 
             //%% hook_eval_reset_constant(comp,
-            //%%     RARRAY(pair)->ptr[2], rb_float_new(new_value));
+            //%%     RARRAY_PTR(pair)[2], rb_float_new(new_value));
             cache_new_constant_value(
               (double *)((char *)comp_shdw + offset),
               new_value, shadow);
@@ -826,13 +824,13 @@ class World
         }
         
         if (has_link_resets) {
-          VALUE   *ptr = RARRAY(link_resets)->ptr;
-          long    len  = RARRAY(link_resets)->len;
+          VALUE   *ptr = RARRAY_PTR(link_resets);
+          long    len  = RARRAY_LEN(link_resets);
           
           for (i = 0; i < len; i++) {
             VALUE   pair    = ptr[i];
-            int     offset  = NUM2INT(RARRAY(pair)->ptr[0]);
-            VALUE   reset   = RARRAY(pair)->ptr[1];
+            int     offset  = NUM2INT(RARRAY_PTR(pair)[0]);
+            VALUE   reset   = RARRAY_PTR(pair)[1];
             VALUE   new_value;
 
             if (rb_obj_is_kind_of(reset, ExprWrapperClass)) {
@@ -852,19 +850,23 @@ class World
             }
 
             if (!NIL_P(new_value) &&
-                rb_obj_is_kind_of(new_value, RARRAY(pair)->ptr[3]) != Qtrue) {
+                rb_obj_is_kind_of(new_value, RARRAY_PTR(pair)[3]) != Qtrue) {
               VALUE to_s = #{declare_symbol :to_s};
+              VALUE s1 = rb_funcall(RARRAY_PTR(pair)[2], to_s, 0);
+              VALUE s2 = rb_funcall(RARRAY_PTR(pair)[3], to_s, 0);
+              VALUE s3 = rb_funcall(
+                  rb_funcall(new_value, #{declare_symbol :class}, 0), to_s, 0);
+
               rs_raise(#{declare_class LinkTypeError}, comp_shdw->self,
                 "tried to reset %s, which is declared %s, with %s.",
-                STR2CSTR(rb_funcall(RARRAY(pair)->ptr[2], to_s, 0)),
-                STR2CSTR(rb_funcall(RARRAY(pair)->ptr[3], to_s, 0)),
-                STR2CSTR(rb_funcall(
-                  rb_funcall(new_value, #{declare_symbol :class}, 0), to_s, 0))
+                StringValuePtr(s1),
+                StringValuePtr(s2),
+                StringValuePtr(s3)
                 );
             }
 
             //%% hook_eval_reset_link(comp,
-            //%%     RARRAY(pair)->ptr[2], (VALUE)new_value);
+            //%%     RARRAY_PTR(pair)[2], (VALUE)new_value);
             cache_new_link(
               (ComponentShadow **)((char *)comp_shdw + offset),
               new_value, shadow);
@@ -884,13 +886,13 @@ class World
         else {
           int     i;
           VALUE   comp = comp_shdw->self;
-          VALUE   *ptr = RARRAY(connects)->ptr;
-          long    len  = RARRAY(connects)->len;
+          VALUE   *ptr = RARRAY_PTR(connects);
+          long    len  = RARRAY_LEN(connects);
 
           for (i = 0; i < len; i++) {
             VALUE   pair      = ptr[i];
-            VALUE   input_var = RARRAY(pair)->ptr[0];
-            VALUE   connect_spec = RARRAY(pair)->ptr[1];
+            VALUE   input_var = RARRAY_PTR(pair)[0];
+            VALUE   connect_spec = RARRAY_PTR(pair)[1];
             VALUE   input_port;
             VALUE   other_port;
             
@@ -925,11 +927,11 @@ class World
         if (!RTEST(resets))
           return 0;
 
-        cont_resets   = RARRAY(resets)->ptr[0];
+        cont_resets   = RARRAY_PTR(resets)[0];
         var           = (ContVar *)&FIRST_CONT_VAR(comp_shdw);
         did_reset     = 0;
 
-        len = RARRAY(cont_resets)->len;
+        len = RARRAY_LEN(cont_resets);
         for (i = len; i > 0; i--, var++) {
           if (var->reset) {
             var->reset = 0;
@@ -948,8 +950,8 @@ class World
         
         assert(RTEST(actions));
 
-        for (i = 0; i < RARRAY(actions)->len; i++) {
-          VALUE val = RARRAY(actions)->ptr[i];
+        for (i = 0; i < RARRAY_LEN(actions); i++) {
+          VALUE val = RARRAY_PTR(actions)[i];
           //%% hook_call_action(comp, val);
 
           if (SYMBOL_P(val))
@@ -959,8 +961,8 @@ class World
           //## this tech. could be applied in EVENT and RESET.
           //## also, component-gen can make use of this optimization
           //## for procs, using code similar to that for guards.
-//#            rb_obj_instance_eval(1, &RARRAY(actions)->ptr[i], comp);
-//# rb_iterate(my_instance_eval, comp, call_block, RARRAY(actions)->ptr[i]);
+//#            rb_obj_instance_eval(1, &RARRAY_PTR(actions)[i], comp);
+//# rb_iterate(my_instance_eval, comp, call_block, RARRAY_PTR(actions)[i]);
         }
       }
 
@@ -1034,7 +1036,7 @@ class World
       {
         VALUE             comp;
         ComponentShadow  *comp_shdw;
-        struct RArray    *list;
+        RS_DVector       *list;
         int               list_i;
         VALUE            *ptr;
         long              len, cur;
@@ -1045,7 +1047,7 @@ class World
           if (shadow->discrete_step == 0)
             comp_shdw->checked = 0;
           
-          len = RARRAY(comp_shdw->outgoing)->len - 1; //# last is flags
+          len = RARRAY_LEN(comp_shdw->outgoing) - 1; //# last is flags
           cur = len;
 
           if (len == 0) {
@@ -1053,7 +1055,7 @@ class World
             continue;
           }
 
-          ptr = RARRAY(comp_shdw->outgoing)->ptr;
+          ptr = RARRAY_PTR(comp_shdw->outgoing);
           if (sync_retry)
             cur -= 4 * comp_shdw->tmp.trans.idx;
           else
@@ -1102,14 +1104,14 @@ class World
             comp_shdw->checked = 1;
           }
         }
-        assert(RARRAY(shadow->prev_awake)->len == 0);
+        assert(rs_dv(shadow->prev_awake)->len == 0);
       }
       
       inline static void do_sync_phase(#{World.shadow_struct_name} *shadow)
       {
         VALUE             comp;
         ComponentShadow  *comp_shdw;
-        struct RArray    *list;
+        RS_DVector       *list;
         int               list_i;
         int               changed;
         
@@ -1126,7 +1128,7 @@ class World
             }
           }
           
-          assert(RARRAY(shadow->curr_S)->len == 0);
+          assert(rs_dv(shadow->curr_S)->len == 0);
           SWAP_VALUE(shadow->curr_S, shadow->next_S);
           //%% hook_sync_step(shadow->curr_S, INT2BOOL(changed));
         } while (changed);
@@ -1163,7 +1165,7 @@ class World
         
         SWAP_VALUE(shadow->prev_awake, shadow->awake);
         
-        while (RARRAY(shadow->prev_awake)->len) {
+        while (rs_dv(shadow->prev_awake)->len) {
           //%% hook_enter_guard_phase();
           check_guards(shadow, sync_retry);
           //%% hook_leave_guard_phase();
@@ -1174,7 +1176,7 @@ class World
           sync_retry = 1;
         }
         
-        if (!RARRAY(shadow->curr_T)->len) {
+        if (!rs_dv(shadow->curr_T)->len) {
           //%% hook_end_step();
           break; //# out of main loop
         }
@@ -1182,7 +1184,7 @@ class World
         EACH_COMP_DO(shadow->curr_T) {
           //%% hook_begin_eval_events(comp);
           if (eval_events(comp_shdw, shadow))
-            rb_ary_push(shadow->active_E, comp);
+            rs_dv_push(rs_dv(shadow->active_E), comp);
           //%% hook_end_eval_events(comp);
         }
         
@@ -1192,22 +1194,22 @@ class World
           //%% hook_export_events(comp, comp_shdw->event_values);
         }
         SWAP_VALUE(shadow->active_E, shadow->prev_active_E);
-        assert(RARRAY(shadow->active_E)->len == 0);
+        assert(rs_dv(shadow->active_E)->len == 0);
         
         //%% hook_enter_eval_phase();
         EACH_COMP_DO(shadow->curr_T) {
           //%% hook_begin_eval_resets(comp);
           if (eval_continuous_resets(comp_shdw, shadow))
-            rb_ary_push(shadow->curr_CR, comp);
+            rs_dv_push(rs_dv(shadow->curr_CR), comp);
           eval_constant_resets(comp_shdw, shadow);
           eval_port_connects(comp_shdw, shadow);
           //%% hook_end_eval_resets(comp);
           
           if (RTEST(cur_actions(comp_shdw)))
-            rb_ary_push(shadow->curr_A, comp);
+            rs_dv_push(rs_dv(shadow->curr_A), comp);
           
           if (RTEST(cur_posts(comp_shdw)))
-            rb_ary_push(shadow->curr_P, comp);
+            rs_dv_push(rs_dv(shadow->curr_P), comp);
         }
         //%% hook_leave_eval_phase();
 
@@ -1215,7 +1217,7 @@ class World
         EACH_COMP_DO(shadow->curr_A) {
           do_actions(comp_shdw, cur_actions(comp_shdw), shadow);
         }
-        RARRAY(shadow->curr_A)->len = 0;
+        rs_dv(shadow->curr_A)->len = 0;
         //%% hook_leave_action_phase();
 
         //%% hook_begin_parallel_assign();
@@ -1223,7 +1225,7 @@ class World
         EACH_COMP_DO(shadow->curr_CR) {
           did_reset = assign_new_cont_values(comp_shdw) || did_reset;
         }
-        RARRAY(shadow->curr_CR)->len = 0;
+        rs_dv(shadow->curr_CR)->len = 0;
         did_reset = assign_new_constant_values(shadow) || did_reset;
         did_reset = assign_new_links(shadow) || did_reset;
         did_reset = assign_new_ports(shadow) || did_reset;
@@ -1233,7 +1235,7 @@ class World
         EACH_COMP_DO(shadow->curr_P) {
           do_actions(comp_shdw, cur_posts(comp_shdw), shadow);
         }
-        RARRAY(shadow->curr_P)->len = 0;
+        rs_dv(shadow->curr_P)->len = 0;
         //%% hook_leave_post_phase();
         
         EACH_COMP_DO(shadow->curr_T) {
@@ -1264,15 +1266,15 @@ class World
           else
             move_comp(comp, shadow->curr_T, shadow->awake);
         }
-        assert(RARRAY(shadow->curr_T)->len == 0);
-        assert(RARRAY(shadow->prev_awake)->len == 0);
+        assert(rs_dv(shadow->curr_T)->len == 0);
+        assert(rs_dv(shadow->prev_awake)->len == 0);
 
         //# Clear event values.
         EACH_COMP_DO(shadow->prev_active_E) {
-          rb_mem_clear(RARRAY(comp_shdw->event_values)->ptr,
-                       RARRAY(comp_shdw->event_values)->len);
+          rb_mem_clear(RARRAY_PTR(comp_shdw->event_values),
+                       RARRAY_LEN(comp_shdw->event_values));
         }
-        RARRAY(shadow->prev_active_E)->len = 0;
+        rs_dv(shadow->prev_active_E)->len = 0;
         
         //%% hook_end_step();
       }
@@ -1302,9 +1304,10 @@ class World
     
     cl.class_eval do
       shadow_library_source_file.include(Component.shadow_library_include_file)
+      shadow_library_source_file.include("dvector/dvector.h")
       
       if (instance_methods(false) + protected_instance_methods(false) +
-          private_instance_methods(false)).include?("step_discrete")
+          private_instance_methods(false)).grep(/^step_discrete$/).size > 0
         warn "Redefining step_discrete in #{self}"
       end
       
@@ -1315,7 +1318,7 @@ class World
         # at this point, we know the file is complete
         file_str = meth.parent.to_s
         
-        known_hooks ||= file_str.scan(hook)
+        known_hooks ||= file_str.scan(hook).map {|s|s.to_sym}
         unknown_hooks = cl_hooks - known_hooks
 
         unless unknown_hooks.empty?