redshift 1.3.15

data/lib/redshift/meta.rb

@@ -0,0 +1,183 @@
+module RedShift
+
+class Component
+  
+  class_superhash2 :flows
+  class_superhash :exported_events      # :event => index
+  class_superhash :states
+  class_superhash :continuous_variables, :constant_variables
+  class_superhash :link_variables       # :link_name => [type, strictness]
+  class_superhash :input_variables      # :var_name => :piecewise | :strict
+  class_superhash :queues
+    
+  @subclasses = []
+
+  class << self
+    # Component is abstract, and not included in subclasses. This returns nil
+    # when called on subs.
+    attr_reader :subclasses
+
+    def inherited(sub)
+      Component.subclasses << sub
+    end
+    
+    # Declare +events+ to be exported (optional). Returns array of corresponding
+    # event indexes which can be used in code generation.
+    def export(*events)
+      events.map do |event|
+        exported_events[event.to_sym] ||= exported_events.size
+      end
+    end
+
+    def queue(*var_names)
+      var_names.each do |var_name|
+        next if queues[var_name]
+        queues[var_name] = true
+        class_eval %{
+          def #{var_name}
+            @#{var_name} ||= Queue.new(self)
+          end
+        }
+      end
+    end
+    
+    def attach_link vars, strictness
+      unless not strictness or strictness == :strict
+        raise ArgumentError, "Strictness must be false or :strict"
+      end
+      unless vars.is_a? Hash
+        raise SyntaxError, "Arguments to link must be of form :var => class, " +
+          "where class can be either a Class or a string denoting class name"
+      end
+      vars.each do |var_name, var_type|
+        link_variables[var_name.to_sym] = [var_type, strictness]
+      end
+    end
+    
+    def attach_state name
+      state = State.new(name, self)
+      const_set(name, state)
+      states[name] = state
+    end
+
+    def attach states, features
+      if features.class != Array
+        features = [features]
+      end
+
+      case states
+        when Array;  attach_flows states, features
+        when Hash;   attach_transitions states, features
+        else         raise SyntaxError, "Bad state list: #{states.inspect}"
+      end
+    end
+    
+    def attach_flows states, new_flows
+      states.each do |state|
+        fl = flows(state)
+        for f in new_flows
+          fl[f.var] = f
+        end
+      end
+    end
+
+    def attach_transitions state_pairs, new_transitions
+      new_transitions.delete_if {|t| t.guard && t.guard.any?{|g| g==false}}
+      state_pairs.each do |src, dst|
+        a = own_transitions(src)
+        new_transitions.each do |t|
+          name = t.name
+          a.delete_if {|u,d| u.name == name}
+          a << [t, dst]
+        end
+      end
+    end
+    
+    # returns list of transitions from state s in evaluation order
+    # (just the ones defined in this class)
+    def own_transitions(s)
+      @own_transitions ||= {}
+      @own_transitions[s] ||= []
+    end
+    
+    def all_transitions(s)
+      if self < Component
+        own_transitions(s) + superclass.all_transitions(s)
+      else
+        own_transitions(s)
+      end
+    end
+
+    def outgoing_transition_data s
+      ary = []
+      all_strict = true
+      seen = {}
+      all_transitions(s).each do |t, d|
+        next if seen[t.name] # overridden in subclass
+        seen[t.name] = true
+
+        t_strict = !t.sync || t.sync.empty?
+        guard_list = t.guard
+        guard_list and guard_list.each do |g|
+          t_strict &&= g.respond_to?(:strict) && g.strict
+        end
+        all_strict &&= t_strict
+
+        ary << [t, d, t.guard, t_strict]
+      end
+
+      result = []
+      ary.reverse_each do |list| # since step_discrete reads them in reverse
+        result.concat list
+      end
+      result << (all_strict ? 1 : 0) # other bits are used elsewhere
+      result
+    end
+    
+    def attach_variables(dest, kind, var_names, var_type = nil)
+      if var_names.last.kind_of? Hash
+        h = var_names.pop
+        var_names.concat h.keys.sort_by {|n|n.to_s}
+        defaults h
+      end
+      var_names.each do |var_name|
+        dest[var_name.to_sym] = var_type ? [var_type, kind] : kind
+      end
+    end
+
+    # kind is :strict, :piecewise, or :permissive
+    def attach_continuous_variables(kind, var_names)
+      attach_variables(continuous_variables, kind, var_names)
+    end
+    
+    # kind is :strict, :piecewise, or :permissive
+    def attach_constant_variables(kind, var_names)
+      attach_variables(constant_variables, kind, var_names)
+    end
+    
+    def attach_input(kind, var_names)
+      var_names.each do |var_name|
+        input_variables[var_name.to_sym] = kind
+      end
+    end
+    
+    def find_var_superhash var_name
+      [continuous_variables, constant_variables,
+       link_variables, input_variables].find {|sh| sh[var_name]}
+    end
+  end
+
+  def states
+    self.class.states.values
+  end
+  
+  def flows s = state
+    self.class.flows s
+  end
+  
+  def transitions s = state
+    self.class.all_transitions s
+  end  
+end # class Component
+
+end # module RedShift

data/lib/redshift/mixins/zeno-debugger.rb

@@ -0,0 +1,69 @@
+class RedShift::World
+
+  # Include this module in a World class. See example in examples/zeno.rb. Has a
+  # very small performance cost, so don't use it in production runs. Note that,
+  # even without ZenoDebugger, RedShift will still detect zeno problems by
+  # raising a ZenoError when world.zeno_counter > world.zeno_limit, if
+  # zeno_limit >= 0.
+  #
+  # ZenoDebugger is compatible with other kinds of debuggers.
+
+  module ZenoDebugger
+
+    # Can be used to turn on and off this module, set to $REDSHIFT_DEBUG_ZENO by
+    # default.
+    attr_accessor :debug_zeno
+
+    # Zeno output goes to this object, $stderr by default, using #<<.
+    attr_accessor :zeno_output
+
+    # Can be used to see which components are causing trouble. Ny default,
+    # the output covers all compontents taking transitions. However, you
+    # can use this attr to focus more narrowly.
+    attr_accessor :zeno_watch_list
+    
+    # How many zeno steps before the debugger gives up. Set to ZENO_UNLIMITED to
+    # debug indefinitely, e.g., for interactive mode. By default, equal to 3
+    # times world.zeno_limit, so that batch runs will terminate.
+    attr_accessor :debug_zeno_limit
+    
+    def initialize
+      @debug_zeno       ||= $REDSHIFT_DEBUG_ZENO
+      @zeno_output      ||= $stderr
+      super
+    end
+
+    # This method is called for each discrete step after the zeno_limit has been
+    # exceeded. This implementation is just one possibility, useful for
+    # debugging. One other useful behavior might be to shuffle guards in the
+    # active components.
+    #
+    # In this implementation, when the zeno_counter exceeds zeno_limit, we start
+    # to add active objects to the zeno_watch_list. When the counter exceeds
+    # two times the zeno_limit, we call report_zeno. When the counter exceeds
+    # three times the zeno_limit, we fall back to the super definition of
+    # step_zeno, which is typically to raise a ZenoError.
+    
+    def step_zeno
+      self.debug_zeno_limit ||= zeno_limit*3
+      if debug_zeno and
+         (debug_zeno_limit == RedShift::ZENO_UNLIMITED or
+          zeno_counter < debug_zeno_limit)
+        report_zeno if zeno_counter >= 2*zeno_limit
+      else
+        super
+      end
+    end
+    
+    HEADER = '-'*10 + " Zeno step: %d; Components: %d; Active: %d " + '-'*10 + "\n"
+    
+    # Reports to zeno_output the list of active components.
+    def report_zeno
+      f = zeno_output
+      active = zeno_watch_list || curr_T
+
+      f << HEADER % [zeno_counter, components.size, curr_T.size]
+      f << '  ' + active.map{|c|c.inspect}.join("\n  ") + "\n"
+    end
+  end
+end

data/lib/redshift/port.rb

@@ -0,0 +1,57 @@
+module RedShift; class Component
+  class Port
+    attr_reader :component, :variable, :connectable
+    
+    def initialize component, variable, connectable
+      @component, @variable, @connectable = component, variable, connectable
+    end
+    
+    # Convenience method to get source port rather than component/var pair.
+    def source
+      source_component && source_component.port(source_variable)
+    end
+    
+    def check_connectable
+      unless connectable
+        raise TypeError, "Not an input: #{variable} in #{component.class}"
+      end
+    end
+    
+    def connect port
+      check_connectable
+      component.connect(variable, port && port.component, port && port.variable)
+    end
+    
+    def _connect port
+      component.connect(variable, port && port.component, port && port.variable, false)
+    end
+    
+    def <<(other)
+      connect(other)
+      return other
+    end
+    
+    def >>(other)
+      other.connect(self)
+      return other
+    end
+    
+    def disconnect
+      connect nil
+    end
+    
+    def source_component
+      check_connectable
+      component.source_component_for(variable)
+    end
+    
+    def source_variable
+      check_connectable
+      component.source_variable_for(variable)
+    end
+    
+    def value
+      component.send variable
+    end
+  end
+end; end

data/lib/redshift/queue.rb

@@ -0,0 +1,104 @@
+module RedShift
+  # a queue entry that contains multiple simultaneously enqueued objects
+  # (same in both continuous and discrete time)
+  class SimultaneousQueueEntries < Array; end
+
+  class Queue
+    # Owner of the queue.
+    attr_reader :component
+    
+    def initialize component
+      @q = []
+      @step_count = nil
+      @discrete_step = nil
+      @component = component
+    end
+    
+    def push obj
+      world = @component.world
+      step_count = world.step_count
+      discrete_step = world.discrete_step
+      
+      if step_count == @step_count and discrete_step == @discrete_step
+        last = @q[-1]
+        case last
+        when SimultaneousQueueEntries
+          last << obj
+        when nil; raise "Internal error: expected simultaneous queue entry."
+        else
+          @q[-1] = SimultaneousQueueEntries[last, obj]
+        end
+      
+      else
+        was_empty = @q.empty?
+        @step_count = step_count
+        @discrete_step = discrete_step
+        @q << obj
+        @component.inc_queue_ready_count if was_empty
+      end
+      
+      self
+    end
+  
+    alias << push
+    
+    class QueueEmptyError < StandardError; end
+    
+    # When popping from a queue, the result may be an instance
+    # of SimultaneousQueueEntries, which should probably be handled specially.
+    def pop
+      if @q.empty?
+        raise QueueEmptyError, "tried to pop empty queue in #{@component.inspect}"
+      end
+      obj = @q.shift
+      @component.dec_queue_ready_count if @q.empty?
+      obj
+    end
+    
+    # Correctly handles case when obj is SimultaneousQueueEntries.
+    def unpop obj
+      was_empty = @q.empty?
+      case obj
+      when SimultaneousQueueEntries
+        case obj.size
+        when 0
+          was_empty = false # just to prevent the inc
+        when 1
+          @q.unshift obj.first
+        else
+          @q.unshift obj
+        end
+      else
+        @q.unshift obj
+      end
+      @component.inc_queue_ready_count if was_empty
+    end
+    
+    # Called from guard evaluation in step_discrete. Returns true if at least
+    # one entry in the head of the queue matches _all_ of the conditions, which
+    # may be Procs (called to return boolean) or any objects with #===.
+    def head_matches(*conds)
+      return false if @q.empty?
+      head = @q[0]
+      case head
+      when SimultaneousQueueEntries
+        head.any? do |head_item|
+          item_matches conds, head_item
+        end
+      else
+        item_matches conds, head
+      end
+    end
+    
+    def item_matches conds, item
+      conds.all? do |cond|
+        case cond
+        when Proc
+          cond.call(item)
+        else
+          cond === item
+        end
+      end
+    end
+  end
+end

data/lib/redshift/redshift.rb

@@ -0,0 +1,111 @@
+# Copyright (C) 2001-2006, Joel VanderWerf
+# Distributed under the Ruby license. See www.ruby-lang.org.
+
+# Read all environment variables related to RedShift and store in globals
+## see importenv.rb for a way to keep these in sync
+ENV.keys.grep(/RedShift/i) do |key|
+  val = ENV[key] # make eval safe
+  eval "$#{key} = val unless defined? $#{key}"
+end
+
+if $REDSHIFT_DEBUG
+  f = $stderr
+  f.puts "  ----------------------------------------------------------------- "
+  f.puts " |RedShift debugging information enabled by env var REDSHIFT_DEBUG.|"
+  f.puts " |    Please ignore error messages that do not halt the progam.    |"
+  f.puts "  ----------------------------------------------------------------- "
+  f.puts "\n   debug level = #{$REDSHIFT_DEBUG}\n\n" if $REDSHIFT_DEBUG != true
+  
+  $REDSHIFT_DEBUG = ($REDSHIFT_DEBUG.to_i rescue 1)
+end
+
+class AssertionFailure < StandardError; end
+class Object ## get rid of this?
+  def assert(test, *msg)
+    raise AssertionFailure, *msg unless test
+  end
+end
+
+module Math
+  Infinity = 1.0/0.0 unless defined? Infinity
+end
+
+module RedShift
+  include Math
+  
+  VERSION = '1.3.15'
+
+  Infinity = Math::Infinity
+
+  def debug setting = true, &block
+    if block
+      begin
+        save_setting = $REDSHIFT_DEBUG
+        $REDSHIFT_DEBUG = setting
+        block.call
+      ensure
+        $REDSHIFT_DEBUG = save_setting
+      end
+    else
+      $REDSHIFT_DEBUG = setting
+    end
+  end
+  
+  # Returns a list of all worlds (instances of RedShift::World and subclasses),
+  # or just those descending from +world_class+.
+  # Not very efficient, since it uses <tt>ObjectSpace.each_object</tt>, but
+  # useful in irb.
+  def self.worlds(world_class = World)
+    worlds = []
+    ObjectSpace.each_object(world_class) {|w| worlds << w}
+    worlds
+  end
+
+#  class Warning < Exception; end
+#  
+#  # Warn with string str and skipping n stack frames.
+#  def warn str, n = 0
+#    warning = sprintf "\nWarning: #{str}\n\t#{caller(n).join("\n\t")}\n"
+#    #if $REDSHIFT_DEBUG -- in debug mode, exception is always printed ???
+#      raise Warning, warning
+#    #else
+#    #  $stderr.print warning
+#    #end
+#  end
+#  module_function :warn
+
+  @library_calls = []
+  
+  # Defer a block until just after the library ruby code is loaded, but before
+  # commit. Necessary for defining inline C functions or shadow_attrs. Note that
+  # a whole require statement could be placed inside the with_library block.
+  def RedShift.with_library(&block) # :yields: library
+    @library_calls << block
+  end
+
+  def RedShift.do_library_calls
+    @library_calls.each do |block|
+      block[library]
+    end
+  end
+
+  def RedShift.require_target
+    require $REDSHIFT_TARGET
+  end
+
+end # module RedShift
+
+case $REDSHIFT_TARGET
+when nil, /^c$/i
+  $REDSHIFT_TARGET = 'redshift/target/c'
+when /^spec$/i
+  $REDSHIFT_TARGET = 'redshift/target/spec'
+when /^dot$/i
+  $REDSHIFT_TARGET = 'redshift/target/dot'
+end
+
+# There could be other things here... Java, YAML, HSIF, Teja, pure ruby
+# reference impl. etc. (but procs are a problem for all but ruby)
+
+require 'redshift/syntax'
+