redshift 1.3.17 → 1.3.18

data/ext/redshift/util/isaac/rand.c

@@ -0,0 +1,140 @@
+/*
+------------------------------------------------------------------------------
+rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain.
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: added main (ifdef'ed out), also rearranged randinit()
+  010626: Note that this is public domain
+  
+ADAPTED Aug2004 for use in Ruby by Joel VanderWerf
+ADAPTED Jan2010 for 64 bit systems (same algorithm and results as 32 bit)
+ADAPTED Jun2010 for use within the redshift project
+------------------------------------------------------------------------------
+*/
+#ifndef RAND
+#include "rand.h"
+#endif
+
+
+#define ind(mm,x)  ((mm)[(x>>2)&(RANDSIZ-1)])
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+  x = *m;  \
+  a = ((a^(mix)) + *(m2++)); \
+  *(m++) = y = (ind(mm,x) + a + b); \
+  *(r++) = b = (ind(mm,y>>RANDSIZL) + x); \
+}
+
+void rs_isaac_rand(ctx)
+randctx *ctx;
+{
+   register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   mm=ctx->randmem; r=ctx->randrsl;
+   a = ctx->randa; b = (ctx->randb + (++ctx->randc));
+   for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   for (m2 = mm; m2<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   ctx->randb = b; ctx->randa = a;
+}
+
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+   a^=b<<11; d+=a; b+=c; \
+   b^=c>>2;  e+=b; c+=d; \
+   c^=d<<8;  f+=c; d+=e; \
+   d^=e>>16; g+=d; e+=f; \
+   e^=f<<10; h+=e; f+=g; \
+   f^=g>>4;  a+=f; g+=h; \
+   g^=h<<8;  b+=g; h+=a; \
+   h^=a>>9;  c+=h; a+=b; \
+}
+
+/* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
+void rs_isaac_init(ctx, flag)
+randctx *ctx;
+int     flag;
+{
+   int i;
+   ub4 a,b,c,d,e,f,g,h;
+   ub4 *m,*r;
+   ctx->randa = ctx->randb = ctx->randc = 0;
+   m=ctx->randmem;
+   r=ctx->randrsl;
+   a=b=c=d=e=f=g=h=0x9e3779b9;  /* the golden ratio */
+
+   for (i=0; i<4; ++i)          /* scramble it */
+   {
+     mix(a,b,c,d,e,f,g,h);
+   }
+
+   if (flag) 
+   {
+     /* initialize using the contents of r[] as the seed */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+     /* do a second pass to make all of the seed affect all of m */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+   else
+   {
+     /* fill in mm[] with messy stuff */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+
+   rs_isaac_rand(ctx);            /* fill in the first set of results */
+   ctx->randcnt=RANDSIZ;  /* prepare to use the first set of results */
+}
+
+
+#ifdef NEVER
+#include <stdio.h>
+
+int main()
+{
+  ub4 i,j;
+  randctx ctx;
+  ctx.randa=ctx.randb=ctx.randc=(ub4)0;
+  for (i=0; i<RANDSIZ; ++i) ctx.randrsl[i]=(ub4)0;
+  rs_isaac_init(&ctx, 1);
+  for (i=0; i<2; ++i)
+  {
+    rs_isaac_rand(&ctx);
+    for (j=0; j<RANDSIZ; ++j)
+    {
+      printf("%.8lx",(long unsigned int)ctx.randrsl[j]);
+      if ((j&7)==7) printf("\n");
+    }
+  }
+}
+#endif

data/ext/redshift/util/isaac/rand.h

@@ -0,0 +1,61 @@
+/*
+------------------------------------------------------------------------------
+rand.h: definitions for a random number generator
+By Bob Jenkins, 1996, Public Domain
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: renamed seed to flag
+  980605: recommend RANDSIZL=4 for noncryptography.
+  010626: note this is public domain
+
+ADAPTED Aug2004 for use in Ruby by Joel VanderWerf
+ADAPTED Jan2010 for 64 bit systems (same algorithm and results as 32 bit)
+ADAPTED Jun2010 for use within the redshift project
+------------------------------------------------------------------------------
+*/
+
+#include <stdint.h>
+
+typedef uint32_t ub4;
+
+#ifndef RAND
+#define RAND
+#define RANDSIZL   (8)  /* I recommend 8 for crypto, 4 for simulations */
+#define RANDSIZ    (1<<RANDSIZL)
+
+/* context of random number generator */
+struct randctx
+{
+  ub4 randcnt;
+  ub4 randrsl[RANDSIZ];
+  ub4 randmem[RANDSIZ];
+  ub4 randa;
+  ub4 randb;
+  ub4 randc;
+};
+typedef  struct randctx  randctx;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed.
+------------------------------------------------------------------------------
+*/
+void rs_isaac_init(randctx *r, int flag);
+
+void rs_isaac_rand(randctx *r);
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand(/o_ randctx *r _o/) to retrieve a single 32-bit random value
+------------------------------------------------------------------------------
+*/
+#define rand(r) \
+   (!(r)->randcnt-- ? \
+     (rs_isaac_rand(r), (r)->randcnt=RANDSIZ-1, (r)->randrsl[(r)->randcnt]) : \
+     (r)->randrsl[(r)->randcnt])
+
+#endif  /* RAND */
+
+

data/lib/redshift/mixins/shell.rb

@@ -0,0 +1,72 @@
+require 'redshift/util/irb-shell'
+
+class Object
+  include IRB::ExtendCommandBundle
+  # so that Marshal.dump still works, even when doing ">> irb obj"
+end
+
+def IRB.parse_opts
+  # Don't touch ARGV, which belongs to the app which called this module.
+end
+
+# extend a World instance with this (or include in a World subclass)
+module RedShift::Shell
+  def shell
+    @shell ||= IRBShell.new(binding, self)
+  end
+  
+  def run(*)
+    shell.install_interrupt_handler
+    super
+  end
+
+  def step(*)
+    super do
+      yield self if block_given?
+      if shell.handle_interrupt {before_shell}
+        after_shell
+        return
+      end
+    end
+  end
+  
+  # Override to complete some action before dropping into shell.
+  def before_shell
+  end
+  
+  # Override to complete some action after leaving shell.
+  def after_shell
+  end
+  
+  # Typically, call this in a rescue clause, if you to let the user
+  # examine state and possibly continue:
+  #
+  #   rescue ... => e
+  #     require 'redshift/mixins/irb-shell'
+  #     world.extend RedShift::IRBShell
+  #     world.recoverable_error e, "Assertion failure", e.backtrace
+  #
+  def recoverable_error e, msg = "Error", bt = []
+    puts "#{msg} at time #{clock}"
+    puts "From " + bt[0..2].join("\n     ") unless bt.empty
+    puts "     ..." if bt.length > 3
+    shell.run
+  end
+
+private
+  def q
+    exit
+  end
+
+  ## commands:
+  ##  step [n] {block}
+  ##  step_until/while
+  ##  continue -- safer than ^D, does step_discrete in case of changes
+  ##  step_continuous
+  ##  step_discrete [n]
+  ##  break [class/component/transition/comp.event/condition]
+  ##    until step_until, stops inside step_discrete
+  ##  clear
+  ##
+  ## customize prompt
+end

data/lib/redshift/redshift.rb

@@ -33,7 +33,7 @@ end
 module RedShift
   include Math
   
-  VERSION = '1.3.17'
+  VERSION = '1.3.18'
 
   Infinity = Math::Infinity
 

data/lib/redshift/syntax.rb

@@ -476,6 +476,7 @@ end
 #
 def Component.flow(*states, &block)
   raise "no flows specified. Put { on same line!" unless block  
+  states = states.map {|s| must_be_state(s)}
   states = [Enter] if states == []
   
   attach states, FlowSyntax.parse(block)
@@ -507,18 +508,18 @@ def Component.transition(edges = {}, &block)
   end
   
   edges.each do |s, d|
-    must_be_state(d)
+    d = must_be_state(d)
 
     case s
     when Array
       s.each do |t|
-        must_be_state(t)
+        t = must_be_state(t)
         warn << t if e[t]
         e[t] = d
       end
 
     else
-      must_be_state(s)
+      s = must_be_state(s)
       warn << s if e[s]
       e[s] = d
     end
@@ -554,9 +555,15 @@ def Component.transition(edges = {}, &block)
 end
 
 def Component.must_be_state s
-  unless s.kind_of? State
-    raise TypeError, "Not a state: #{s}"
+  return s if s.kind_of?(State)
+  state = const_get(s.to_s)
+rescue NameError
+  raise TypeError, "Not a state: #{s.inspect}"
+else
+  unless state.kind_of?(State)
+    raise TypeError, "Not a state: #{s.inspect}"
   end
+  state
 end
 
 end

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

@@ -594,19 +594,18 @@ module RedShift
       
       def add_var_to_offset_table var_name
         ssn = shadow_struct.name
+        lit = shadow_library.literal_symbol(var_name,
+          shadow_library_source_file)
         offset_table_method.body %{\
-          rb_hash_aset(table, #{shadow_library.literal_symbol(var_name)},
+          rb_hash_aset(table, #{lit},
             INT2FIX((char *)&(((struct #{ssn} *)0)->#{var_name}) - (char *)0));
         } ## can we just use offsetof() ?
       end
 
       def define_links
-        own_links = link_variables.own
-        return if own_links.empty?
-        
         ssn = shadow_struct.name
         
-        own_links.keys.sort_by{|k|k.to_s}.each do |var_name|
+        link_variables.own.keys.sort_by{|k|k.to_s}.each do |var_name|
           var_type, strictness = link_variables[var_name]
 
           unless var_type.is_a? Class
@@ -632,12 +631,16 @@ module RedShift
                 rs_raise(#{exc}, shadow->self, #{msg.inspect});
             }
           end
-
-          shadow_library_include_file.include(
-            var_type.shadow_library_include_file)
           
           add_var_to_offset_table(var_name)
         end
+        
+        link_variables.keys.sort_by{|k|k.to_s}.each do |var_name|
+          var_type, strictness = link_variables[var_name]
+        
+          shadow_library_source_file.include(
+            var_type.shadow_library_include_file)
+        end
       end
       
       def check_variables

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

@@ -1,140 +1,31 @@
+require 'redshift/buffer/buffer.so'
+require 'redshift/buffer/dir'
+
 class RedShift::Library
   def define_buffer
-    return if @define_buffer
-    @define_buffer = true
-    
-    include_file, source_file = add_file "buffer"
-
-    include_file.declare :Buffer => %{
-      typedef struct {
-        long    len;
-        long    offset;
-        double  *ptr;
-      } Buffer;
-    }.tabto(0)
-
-    source_file.define_c_function(:buffer_init).instance_eval {
-      arguments "Buffer *buf", "long len", "double fill"
-      scope :extern
-      body %{
-        int i;
-        buf->ptr = ALLOC_N(double, len);
-        buf->len = len;
-        buf->offset = 0;
-        for (i=0; i<len; i++) {
-          buf->ptr[i] = fill;
-        }
-      }
-    }
-    
-    source_file.define_c_function(:buffer_resize).instance_eval {
-      arguments "Buffer *buf", "long len"
-      scope :extern
-      body %{
-        long    i;
-        long    old_len = buf->len;
-        long    offset  = buf->offset;
-        double *ptr     = buf->ptr;
-        double *dst, *src;
-        double  fill;
-
-        if (len < old_len) {
-          if (offset < len) {
-            dst = ptr + offset;
-            src = ptr + offset + old_len - len;
-            memmove(dst, src, (len - offset) * sizeof(double));
-          }
-          else {
-            dst = ptr;
-            src = ptr + offset - len;
-            offset = 0;
-            memmove(dst, src, len * sizeof(double));
-          }
-          REALLOC_N(ptr, double, len);
-          // ## maybe better: don't release space, just use less of it
-        }
-        else if (len > old_len) {
-          REALLOC_N(ptr, double, len);
-
-          fill = ptr[offset];
-          dst = ptr + offset + len - old_len;
-          src = ptr + offset;
-          memmove(dst, src, (old_len - offset) * sizeof(double));
-
-          for (i = 0; i < len - old_len; i++) {
-            ptr[offset + i] = fill;
-          }
-        }
-        else
-          return;
-
-        buf->len = len;
-        buf->offset = offset;
-        buf->ptr = ptr;
-      }
-    }
-    
-    source_file.define_c_function(:buffer_inhale_array).instance_eval {
-      arguments "Buffer *buf", "VALUE ary"
-      scope :extern
-      body %{
-        int  size, i;
-
-        Check_Type(ary, T_ARRAY);
-
-        size = RARRAY(ary)->len;
-        if (buf->ptr) {
-          REALLOC_N(buf->ptr, double, size);
-        }
-        else {
-          buf->ptr = ALLOC_N(double, size);
-        }
-        buf->len = size;
-        buf->offset = 0;
-
-        for (i = 0; i < size; i++) {
-          buf->ptr[i] = NUM2DBL(RARRAY(ary)->ptr[i]);
-        }
-      }
-    }
-
-    source_file.define_c_function(:buffer_exhale_array).instance_eval {
-      arguments "Buffer *buf"
-      return_type "VALUE"
-      returns "ary"
-      scope :extern
-      declare :size => "int size",
-              :i => "int i",
-              :j => "int j",
-              :ary => "VALUE ary"
-      body %{
-        size = buf->len;
-        ary = rb_ary_new2(size);
-        RARRAY(ary)->len = size;
-        for (i = buf->offset, j=0; i < size; i++, j++) {
-          RARRAY(ary)->ptr[j] = rb_float_new(buf->ptr[i]);
-        }
-        for (i = 0; i < buf->offset; i++, j++) {
-          RARRAY(ary)->ptr[j] = rb_float_new(buf->ptr[i]);
-        }
-      }
-    }
+    unless @buffer_defined
+      @buffer_defined = true
+      text = File.read(File.join(REDSHIFT_BUFFER_DIR, "buffer.h"))
+      buffer_h = CGenerator::CFile.new("buffer.h", self, nil, true)
+      buffer_h.declare :buffer_header_text => text
+      add [buffer_h]
+    end
   end
-
+  
   # An embedded struct that holds a pointer +ptr+ to an externally stored
   # array of doubles of length +len+.
   class BufferAttribute < CShadow::CNativeAttribute
-    @pattern = /\A(Buffer)\s+(\w+)\z/
+    @pattern = /\A(RSBuffer)\s+(\w+)\z/
     
     def initialize(*args)
       super
-      lib = owner_class.shadow_library
       owner_class.shadow_library_include_file.include "buffer.h"
       
-      @reader = "result = buffer_exhale_array(&shadow->#{@cvar})"
-      @writer = "buffer_inhale_array(&shadow->#{@cvar}, arg)"
-      @dump = "rb_ary_push(result, buffer_exhale_array(&shadow->#{@cvar}))"
-      @load = "buffer_inhale_array(&shadow->#{@cvar}, rb_ary_shift(from_array))"
+      @reader = "result = rs_buffer_exhale_array(&shadow->#{@cvar})"
+      @writer = "rs_buffer_inhale_array(&shadow->#{@cvar}, arg)"
+      @dump = "rb_ary_push(result, rs_buffer_exhale_array(&shadow->#{@cvar}))"
+      @load =
+        "rs_buffer_inhale_array(&shadow->#{@cvar}, rb_ary_shift(from_array))"
       @free = "free(shadow->#{@cvar}.ptr)"
     end
   end