redshift 1.3.15

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

@@ -0,0 +1,325 @@
+module RedShift
+  require "redshift/target/c/flow/delay"      if DelayFlow.needed
+  require "redshift/target/c/flow/derivative" if DerivativeFlow.needed
+  require "redshift/target/c/flow/euler"      if EulerDifferentialFlow.needed
+  require "redshift/target/c/flow/algebraic"  if AlgebraicFlow.needed
+  require "redshift/target/c/flow/rk4"        if RK4DifferentialFlow.needed
+  require "redshift/target/c/flow/expr"
+end
+
+module RedShift; class Flow
+  def translate flow_fn, result_var, rk_level, cl, orig_formula = nil
+    translation = {}
+    setup = []    ## should use accumulator
+    
+    orig_formula ||= @formula
+    c_formula = orig_formula.dup
+    strict = true
+    
+    re = /(?:([A-Za-z_]\w*)\.)?([A-Za-z_]\w*)(?!\w*\s*[(])/
+    
+    c_formula.gsub! re do |expr|
+
+      unless translation[expr]
+        link, var = $1, $2
+        if link
+          result =
+            translate_link(link, var, translation, flow_fn, cl, expr, rk_level)
+          strict &&= result # Don't combine with method call!!!
+                    
+        else # expr == 'var'
+          varsym = var.intern
+          
+          link_type, link_strictness = cl.link_variables[varsym]
+          
+          if link_type
+            # l ==> link_l
+            strict &&= (link_strictness == :strict)
+
+            link = var
+            link_cname = "link_#{link}"
+            unless translation[link]
+              translation[link] = "ct.#{link_cname}"
+
+              ct_struct = make_ct_struct(flow_fn, cl)
+
+              link_type_ssn = link_type.shadow_struct.name
+              ct_struct.declare link_cname => "#{link_type_ssn} *#{link_cname}"
+              flow_fn.setup  link_cname => "ct.#{link_cname} = shadow->#{link}"
+            end
+            
+          elsif (kind = cl.constant_variables[varsym])
+            strict &&= (kind == :strict)
+            translation[var] = "shadow->#{var}"
+          
+          elsif (kind = cl.continuous_variables[varsym])
+            # x ==> var_x
+            strict &&= (kind == :strict)
+
+            var_cname = "var_#{var}"
+            sh_cname = "shadow"
+            cs_cname = "cont_state"
+            cont_var = "#{cs_cname}->#{var}"
+            translation[var] = var_cname
+
+            flow_fn.declare var_cname => "double    #{var_cname}"
+            flow_fn.setup var_cname => %{
+              if (#{cont_var}.algebraic) {
+                if (#{cont_var}.rk_level < shadow->world->rk_level ||
+                   (shadow->world->rk_level == 0 &&
+                    (#{cont_var}.strict ? !#{cont_var}.d_tick :
+                     #{cont_var}.d_tick != shadow->world->d_tick)
+                    ))
+                  (*#{cont_var}.flow)((ComponentShadow *)#{sh_cname});
+              }
+              else {
+                #{cont_var}.d_tick = shadow->world->d_tick;
+              }
+            }
+            # The d_tick assignment is explained in component-gen.rb.
+            setup << "#{var_cname} = #{cont_var}.value_#{rk_level};"
+          
+          elsif (kind = cl.input_variables[varsym])
+            # x ==> var_x
+            strict &&= (kind == :strict)
+              # note that we check in Component#connect that the
+              # source var is strict
+
+            var_cname = "var_#{var}"
+            translation[var] = var_cname
+            src_comp    = cl.src_comp(varsym)
+
+            flow_fn.declare var_cname => "double    #{var_cname}"
+            flow_fn.setup var_cname => %{\
+              #{var_cname} = rs_eval_input_var(shadow, &shadow->#{src_comp});
+            }
+          
+          elsif (event_idx = cl.exported_events[varsym])
+            unless self.kind_of? ResetExpr
+              raise NoValueError,
+                "Event #{varsym.inspect} has no value in this context."
+            end
+            
+            strict = false # strict doesn't matter
+
+            var_cname = "event_#{var}"
+            translation[var] = var_cname
+            flow_fn.declare var_cname => "double    #{var_cname}"
+            flow_fn.setup var_cname => %{\
+              VALUE event_values, event_val;
+              event_values = shadow->event_values;
+              assert(event_values != Qnil);
+              event_val = RARRAY(event_values)->ptr[#{event_idx}];
+              #{var_cname} = NUM2DBL(event_val);
+            }
+          
+          elsif /\A[eE]\z/ =~ var
+            translation[expr] = expr # scientific notation
+          
+          elsif cl.const_defined?(var)
+            translation[expr] = cl.const_get(var)
+          
+          elsif external_constant?(var)
+            translation[expr] = expr
+            
+          else
+            raise NameError, "Unknown variable: #{var}"
+          end
+          
+        end
+      end
+      translation[expr]
+    end
+    
+    yield strict if block_given?  ## funky way to return another value
+    
+    setup << "#{result_var} = (#{c_formula})"
+    
+  rescue NameError, ArgumentError => ex
+    ex.message << "\nclass: #{cl.name}\nformula:\n#{orig_formula}\n\n"
+    raise ex
+  end
+  
+  def external_constant? var
+    RedShift.library.external_constant? var
+  end
+  
+  CT_STRUCT_NAME = "Context"
+
+  # Since MSVC doesn't support nested functions...
+  def make_ct_struct(flow_fn, cl)
+    sf = flow_fn.parent
+    ct_struct = sf.declare![CT_STRUCT_NAME]
+
+    if ct_struct
+      ct_struct = ct_struct[1] ## hacky
+
+    else
+      ct_struct = sf.declare_struct(CT_STRUCT_NAME)
+
+      ct_struct.declare :shadow => "#{cl.shadow_struct.name} *shadow"
+
+      flow_fn.declare :ct => "#{CT_STRUCT_NAME} ct"
+      flow_fn.setup   :ct_shadow => "ct.shadow = shadow"
+    end
+
+    ct_struct
+  end
+  
+  # l.x  ==>  get_l__x()->value_n
+  def translate_link(link, var, translation, flow_fn, cl, expr, rk_level)
+    link_type, link_strictness = cl.link_variables[link.intern]
+    raise(NameError, "No such link, #{link}") unless link_type
+    strict = (link_strictness == :strict)
+    
+    flow_fn.include link_type.shadow_library_include_file
+    
+    link_cname = "link_#{link}"
+    get_var_cname = "get_#{link}__#{var}"
+
+    ct_struct = make_ct_struct(flow_fn, cl)
+
+    varsym = var.intern
+    if (kind = link_type.constant_variables[varsym])
+      var_type = :constant
+    elsif (kind = link_type.continuous_variables[varsym])
+      var_type = :continuous
+    elsif (kind = link_type.input_variables[varsym])
+      var_type = :input
+    elsif (a = link_type.link_variables[varsym])
+      var_type = :link
+      link_link_type, kind = a
+    elsif (event_idx = link_type.exported_events[varsym])
+      unless self.kind_of? ResetExpr
+        raise NoValueError, "Event #{varsym.inspect} has no value in this context."
+      end
+      var_type = :event
+      kind = false # strict doesn't matter
+    else
+      raise NameError, "Unknown variable: #{var} in #{link_type}"
+    end
+
+    strict &&= (kind == :strict)
+    
+    if var_type == :continuous or var_type == :input
+      checked_var_cname = "checked_#{link}__#{var}" ## not quite unambig.
+      ct_struct.declare checked_var_cname => "int #{checked_var_cname}"
+      flow_fn.setup     checked_var_cname => "ct.#{checked_var_cname} = 0"
+    end
+
+    if var_type == :continuous
+      link_cs_ssn = link_type.cont_state_class.shadow_struct.name
+      link_cs_cname = "link_cs_#{link}"
+      ct_struct.declare link_cs_cname => "#{link_cs_ssn} *#{link_cs_cname}"
+    end
+
+    unless translation[link + "."]
+      translation[link + "."] = true # just so we know we've handled it
+
+      unless translation[link]
+        translation[link] = link_cname
+        link_type_ssn = link_type.shadow_struct.name
+        ct_struct.declare link_cname => "#{link_type_ssn} *#{link_cname}"
+        flow_fn.setup     link_cname => "ct.#{link_cname} = shadow->#{link}"
+      end ## same as below
+    end
+
+    sf = flow_fn.parent
+
+    exc_nil = flow_fn.declare_class(NilLinkError) ## class var
+    msg_nil = "Link #{link} is nil."
+
+    case var_type
+    when :continuous
+      cs_cname = "ct->#{link_cs_cname}"
+      cont_var = "#{cs_cname}->#{var}"
+      sf.declare get_var_cname => %{
+        inline static ContVar *#{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
+          if (!ct->#{checked_var_cname}) {
+            ct->#{checked_var_cname} = 1;
+            if (!ct->#{link_cname})
+              rs_raise(#{exc_nil}, ct->shadow->self, #{msg_nil.inspect});
+            #{cs_cname} = (#{link_cs_ssn} *)ct->#{link_cname}->cont_state;
+            if (#{cont_var}.algebraic) {
+              if (#{cont_var}.rk_level < ct->shadow->world->rk_level ||
+                 (ct->shadow->world->rk_level == 0 &&
+                  (#{cont_var}.strict ? !#{cont_var}.d_tick :
+                   #{cont_var}.d_tick != ct->shadow->world->d_tick)
+                 ))
+                (*#{cont_var}.flow)((ComponentShadow *)ct->#{link_cname});
+            }
+            else {
+              #{cont_var}.d_tick = ct->shadow->world->d_tick;
+            }
+          }
+          return &(#{cont_var});
+        }
+      } ## algebraic test is same as above
+
+      translation[expr] = "#{get_var_cname}(&ct)->value_#{rk_level}"
+    
+    when :constant
+      sf.declare get_var_cname => %{
+        inline static double #{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
+          if (!ct->#{link_cname})
+            rs_raise(#{exc_nil}, ct->shadow->self, #{msg_nil.inspect});
+          return ct->#{link_cname}->#{var};
+        }
+      }
+
+      translation[expr] = "#{get_var_cname}(&ct)"
+    
+    when :link
+      link_link_type_ssn = link_link_type.shadow_struct.name
+      sf.declare get_var_cname => %{
+        inline static #{link_link_type_ssn} *#{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
+          if (!ct->#{link_cname})
+            rs_raise(#{exc_nil}, ct->shadow->self, #{msg_nil.inspect});
+          return ct->#{link_cname}->#{var};
+        }
+      }
+
+      translation[expr] = "#{get_var_cname}(&ct)"
+
+    when :input
+      src_comp    = link_type.src_comp(var.intern)
+      result_name = "value_#{link}__#{var}"
+      ct_struct.declare result_name => "double #{result_name}"
+
+      sf.declare get_var_cname => %{
+        inline static double #{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
+          if (!ct->#{checked_var_cname}) {
+            ct->#{checked_var_cname} = 1;
+            if (!ct->#{link_cname})
+              rs_raise(#{exc_nil}, ct->shadow->self, #{msg_nil.inspect});
+            ct->#{result_name} = rs_eval_input_var(ct->#{link_cname},
+                &ct->#{link_cname}->#{src_comp});
+          }
+          return ct->#{result_name};
+        }
+      }
+      
+      translation[expr] = "#{get_var_cname}(&ct)"
+      
+    when :event
+      sf.declare get_var_cname => %{
+        inline static double #{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
+          VALUE event_values, event_val;
+          if (!ct->#{link_cname})
+            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}];
+          return NUM2DBL(event_val);
+        }
+      }
+
+      translation[expr] = "#{get_var_cname}(&ct)"
+    
+    else
+      raise ArgumentError, "Bad var_type: #{var_type.inspect}"
+    end
+
+    return strict
+  end    
+end; end

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

@@ -0,0 +1,85 @@
+module RedShift; class AlgebraicFlow
+  def flow_wrapper cl, state
+    var_name = @var
+    flow = self
+    flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
+    
+    Component::FlowWrapper.make_subclass flow_name do
+      @inspect_str = "#{cl.name}:#{state}: #{var_name} = #{flow.formula}"
+
+      ssn = cl.shadow_struct.name
+      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      
+      # We need the struct
+      shadow_library_source_file.include(cl.shadow_library_include_file)
+      
+      shadow_library_source_file.define(flow_name).instance_eval do
+        arguments "ComponentShadow *comp_shdw"
+        declare :shadow => %{
+          struct #{ssn} *shadow;
+          struct #{cont_state_ssn} *cont_state;
+          ContVar  *var;
+        }
+        exc = declare_class CircularDefinitionError
+        msg = "Circularity in algebraic formula for #{var_name} in state " +
+              "#{state} of class #{cl.name}."
+        setup :shadow => %{
+          shadow = (#{ssn} *)comp_shdw;
+          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          var = &cont_state->#{var_name};
+          assert(var->algebraic);
+          if (shadow->world->alg_nest > 100) {
+            shadow->world->alg_nest = 0;
+            rs_raise(#{exc}, shadow->self, #{msg.inspect});
+          }
+          shadow->world->alg_nest++;
+        }
+        ## 100 not always enough, so could increase limit exponentially,
+        ## and look in subsequent iterations for repeats of this [var, obj].
+        
+        ## optimization: it might be possible to translate once and
+        ## use gsub to make each of the four versions, or use a template.
+        body %{
+          switch (shadow->world->rk_level) {
+          case 0:
+            #{flow.translate(self, "var->value_0", 0, cl).join("
+            ")};
+            var->d_tick = shadow->world->d_tick;
+            break;
+            
+          case 1:
+            #{flow.translate(self, "var->value_1", 1, cl).join("
+            ")};
+            var->rk_level = shadow->world->rk_level;
+            break;
+            
+          case 2:
+            #{flow.translate(self, "var->value_2", 2, cl).join("
+            ")};
+            var->rk_level = shadow->world->rk_level;
+            break;
+            
+          case 3:
+            #{flow.translate(self, "var->value_3", 3, cl){|strict|
+              flow.instance_eval {@strict = strict}
+            }.join("
+            ")};
+            var->rk_level = shadow->world->rk_level;
+            break;
+            
+          default:
+            rb_raise(#{declare_class RuntimeError},
+              "Bad rk_level, %d!", shadow->world->rk_level);
+          }
+          
+          shadow->world->alg_nest--;
+        }
+      end # Case 0 applies during discrete update.
+          # alg flows are lazy
+
+      define_c_method :calc_function_pointer do
+        body "shadow->flow = &#{flow_name}", "shadow->algebraic = 1"
+      end
+    end
+  end
+end; end

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

@@ -0,0 +1,74 @@
+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;
+        double  *ptr;
+      } Buffer;
+    }.tabto(0)
+
+    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;
+
+        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",
+              :ary => "VALUE ary"
+      body %{
+        size = buf->len;
+        ary = rb_ary_new2(size);
+        RARRAY(ary)->len = size;
+        for (i = 0; i < size; i++) {
+          RARRAY(ary)->ptr[i] = rb_float_new(buf->ptr[i]);
+        }
+      }
+    }
+  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/
+    
+    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))"
+      @free = "free(shadow->#{@cvar}.ptr)"
+    end
+  end
+end