redshift 1.3.15

data/lib/redshift/target/spec.rb

@@ -0,0 +1,34 @@
+require 'pp'
+
+#
+# Note: This is not a complete program specification, since Procs and methods
+# cannot be dumped. It is useful for inspecting the vars, flows, and also
+# transitions, to the extent that these are defined without Procs.
+#
+
+class World
+  def World.new(*args)
+    exit ## could just call the code below and then exit...
+  end
+end
+
+END {
+  ## this duplicates some code from Library
+  cc = []
+  ObjectSpace.each_object(Class) do |cl|
+    cc << cl if cl < Component # Component is abstract
+  end
+  cc = cc.sort_by {|c| c.ancestors.reverse!.map!{|d|d.to_s}}
+
+  cc.each do |c|
+    puts "=" * 60
+    puts "=" * 20 + "class #{c.name}"
+    c.instance_eval do
+      instance_variables.each do |var|
+        val = eval(var)
+        puts "#{var}:"
+        pp val
+      end
+    end
+  end
+}

data/lib/redshift/world.rb

@@ -0,0 +1,300 @@
+require 'pstore'
+
+module RedShift
+
+class ZenoError < RuntimeError; end
+
+# Set zeno_level to this to turn off zeno checking.
+ZENO_UNLIMITED = -1
+
+class World
+  include Enumerable
+
+  {
+    :Debugger       => "debugger",
+    :ZenoDebugger   => "zeno-debugger"
+  }.each {|m,f| autoload(m, "redshift/mixins/#{f}")}
+
+  class ComponentList
+    include Enumerable
+
+    attr_reader :summands
+
+    def initialize(*summands)
+      @summands = summands
+    end
+
+    def each(&block)
+      summands.each { |enum| enum.each(&block) }
+      self
+    end
+    
+    def size
+      summands.inject(0) { |sum,enum| sum + enum.size }
+    end
+    
+    def inspect
+      to_a.inspect # looks better in irb, but slow
+    end
+    
+    def [](idx)
+      warn "World#[] is deprecated"
+      to_a[idx] ## very inefficient
+    end
+    
+    def clear
+      summands.each {|list| list.clear}
+    end
+  end
+
+  @subclasses = []
+
+  class << self
+    # World is not included in subclasses. This returns nil when called on subs.
+    attr_reader :subclasses
+
+    def inherited(sub)
+      World.subclasses << sub
+    end
+  end
+  
+  def self.new(*args, &block)
+    RedShift.require_target     # redefines World.new
+    new(*args, &block)          # which is what this line calls
+  end
+  
+  attr_reader :components
+  
+  def default_options
+    {
+      :name         =>  "#{self.class}_#{@@count}",
+      :time_unit    =>  "second",
+      :time_step    =>  0.1,
+      :zeno_limit   =>  100,
+      :clock_start  =>  0.0,
+      :clock_finish =>  Infinity,
+    }
+  end
+
+  @@count = 0
+
+  attr_accessor :name, :time_unit
+  
+  def started?; @started; end
+  def running?; @running; end
+
+  # Can override the options using assignments in the block.
+  # Note that clock_start should not be assigned after the block.
+  def initialize # :yields: world
+    self.curr_A = []; self.curr_P = []; self.curr_CR = []
+    self.curr_S = []; self.next_S = []; self.curr_T = []
+    self.active_E = []; self.prev_active_E = []
+    self.awake = []; self.prev_awake = []
+    self.strict_sleep = []; self.inert = []
+    self.diff_list = []; self.queue_sleep = {}
+    @components = ComponentList.new  \
+      awake, prev_awake, curr_T, strict_sleep, inert # _not_ diff_list
+
+    options = default_options
+
+    @name             = options[:name]
+    @time_unit        = options[:time_unit]
+    self.time_step    = options[:time_step]
+    self.zeno_limit   = options[:zeno_limit]
+    self.clock_start  = options[:clock_start]
+    self.clock_finish = options[:clock_finish]
+    
+    self.step_count = 0
+    
+    @@count += 1
+
+    do_defaults
+    yield self if block_given?
+    
+    self.base_step_count = 0
+    self.base_clock = clock_start
+  end
+  
+  def do_defaults
+    self.class.do_defaults self
+  end
+  private :do_defaults
+  
+  def self.do_defaults instance
+    superclass.do_defaults instance if superclass.respond_to? :do_defaults
+    if @defaults_procs
+      @defaults_procs.each do |pr|
+        instance.instance_eval(&pr)
+      end
+    end
+  end
+  
+  def do_setup
+    self.class.do_setup self
+    if @setup_procs
+      @setup_procs.each do |pr|
+        instance_eval(&pr)
+      end
+      @setup_procs = nil # so we can serialize
+    end
+  end
+  private :do_setup
+  
+  def self.do_setup instance
+    superclass.do_setup instance if superclass.respond_to? :do_setup
+    if @setup_procs
+      @setup_procs.each do |pr|
+        instance.instance_eval(&pr)
+      end
+    end
+  end
+
+  def create(component_class)
+    component = 
+      if block_given?
+        component_class.new(self) {|c| yield c}
+      else
+        component_class.new(self)
+      end
+    
+    unless component.is_a? Component # Component is abstract
+      raise TypeError, "#{component.class} is not a Component class"
+    end
+    
+    awake << component if component.world == self
+    component
+  end
+  
+  ## is this a good idea? tests? #add ?
+  def remove c
+    if components.summands.any? {|list| list.delete(c)}
+      raise unless c.world == self
+      c.__set__world(nil)
+    else
+      raise "Tried to remove #{c} from #{self}, but its world is #{c.world}."
+    end
+  end
+  
+  # All evolution methods untimately call step, which can be overridden.
+  # After each step, yields to block. It is the block's responsibility to
+  # step_discrete at this point after changing any vars.
+  def step(steps = 1)
+    @running = true
+    
+    unless @started
+      do_setup
+      @started = true
+    end
+    
+    step_discrete
+    steps.to_i.times do
+      break if clock > clock_finish
+      self.step_count += 1
+      step_continuous
+      step_discrete
+      @running = false
+      yield self if block_given?
+      @running = true
+    end
+    
+    self
+    
+  ensure
+    @running = false
+    ## how to continue stepping after an exception?
+  end
+  
+  def run(*args, &block)
+    ## warn "World#run is deprecated -- use #step or #evolve"
+    step(*args, &block)
+  end
+  
+  def evolve(time = 1.0, &block)
+    run((time.to_f/time_step).round, &block)
+  end
+
+  # Default implementation is to raise RedShift::ZenoError.
+  def step_zeno
+    raise RedShift::ZenoError, "Exceeded zeno limit of #{zeno_limit}."
+  end
+  
+  ## is this a good idea? tests?
+  def garbage_collect
+    self.components.clear
+    GC.start
+    ObjectSpace.each_object(Component) do |c|
+      components << c if c.world == self
+    end
+  end
+  
+  def each(&b)
+    @components.each(&b)
+  end
+  
+  def size
+    @components.size
+  end
+  
+  def include? component
+    component.world == self
+  end
+  alias member? include?
+  
+  def inspect
+    if @started
+      digits = -Math.log10(time_step).floor
+      digits = 0 if digits < 0
+
+      data = []
+      data << "%d step%s" % [step_count, ("s" if step_count != 1)]
+      data << "%.#{digits}f #{@time_unit}%s" % [clock, ("s" if clock != 1)]
+      data << "%d component%s" % [size, ("s" if size != 1)]
+      data << "discrete step = #{discrete_step}" ## only if in step_discrete?
+    else
+      data = ["not started. Do 'run 0' to setup, or 'run n' to run."]
+    end
+
+    str = [name, data.join("; ")].join(": ")
+    "<#{str}>"
+  end
+  
+  def save filename = @name
+    raise "Can't save world during its run method." if @running
+    File.delete(filename) rescue SystemCallError
+    store = PStore.new filename
+    store.transaction do
+      store['world'] = self
+      yield store if block_given?
+    end
+  end
+  
+  def World.open filename
+    RedShift.require_target
+    commit
+    
+    world = nil
+    store = PStore.new filename
+    store.transaction do
+      if store.root? 'world'
+        world = store['world']
+        yield store if block_given?
+      end
+    end
+    world
+  end
+
+# This is for when Component#world is nonpersistent  
+#  def __restore__world__refs
+#    ## need this list because @components is not restored yet
+#    [awake, prev_awake, curr_T, strict_sleep, inert].each do |list|
+#      list.each do |c|
+#          c.send :__set__world, self
+#      end
+#    end
+#    ## could be in C
+#  end
+#  private :__restore__world__refs
+  
+end # class World
+
+end # module RedShift

data/rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bones'
+rescue LoadError
+  abort '### please install the bones gem ###'
+end
+
+ensure_in_path 'lib'
+require 'redshift'
+
+Bones {
+  name            'redshift'
+  authors         'Joel VanderWerf'
+  email           'vjoel@users.sourceforge.net'
+  url             'http://rubyforge.org/projects/redshift'
+  rubyforge.name  'redshift'
+  version         RedShift::VERSION
+  readme_file     'README'
+  
+  summary         'Simulation of hybrid automata'
+  description <<END
+A framework for simulation of networks of hybrid automata, similar to SHIFT and Lambda-SHIFT. Includes ruby-based DSL for defining simulation components, and ruby/C code generation and runtime.
+END
+
+  depend_on       'cgen'
+
+  history_file    'RELEASE-NOTES'
+  changes         File.read(history_file)[/^\w.*?(?=^\w)/m]
+  (rdoc.dir       File.readlink(rdoc.dir)) rescue nil
+
+  spec.opts << '--color'
+  test.files = Dir["test/test-*.rb"]
+}
+
+task :release => ["rubyforge:release", "rubyforge:doc_release"]
+
+# EOF
+ 

data/test/test.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+if RUBY_VERSION == "1.6.6"
+  puts "DEBUG mode is turned off in Ruby 1.6.6 due to bug."
+  $DEBUG = false
+else
+  $DEBUG = true
+end
+
+if RUBY_VERSION == "1.8.0"
+  class Module
+    alias instance_methods_with_warning instance_methods
+    def instance_methods(include_super=true)
+      instance_methods_with_warning(include_super)
+    end
+  end
+end
+
+$REDSHIFT_DEBUG=3 ## what should this be?
+
+### have to fix the CLIB_NAME problem before can do this
+### require 'redshift' ## all the tests will need this anyway
+
+pat = ARGV.join("|")
+tests = Dir["test_*.rb"].grep(/#{pat}/)
+tests.sort!
+
+#trap("CLD") do
+#  # trapping "INT" doesn't work because child gets the signal
+#  exit!
+#end
+
+require 'rbconfig'
+ruby = Config::CONFIG["RUBY_INSTALL_NAME"]
+
+failed = tests.reject do |file|
+  puts "_"*50 + "\nStarting #{file}...\n"
+  system "#{ruby} #{file}"
+#  pid = fork { ## should use popen3 so we can weed out successful output
+#    $REDSHIFT_CLIB_NAME = file
+#    require 'redshift'
+#    load file
+#  }
+#  Process.waitpid(pid)
+end
+
+puts "_"*50
+if failed.empty?
+  puts "All tests passed."
+else
+  puts "Some tests failed:", failed
+end

data/test/test_buffer.rb

@@ -0,0 +1,58 @@
+require 'redshift'
+
+include RedShift
+
+RedShift.with_library do |library|
+  require "redshift/target/c/flow/buffer"
+  library.define_buffer
+end
+
+require 'test/unit'
+
+class TestBuffer < Test::Unit::TestCase
+
+  class T < Component
+    RedShift.with_library do
+      shadow_attr_accessor :b => "Buffer b"
+    end
+  end
+  
+  def setup
+    @world = World.new
+    @t = @world.create(T)
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_accessor
+    a = [1.0, 2.0, 3.0, 4.0]
+    @t.b = a
+    assert_equal(a, @t.b)
+  end
+  
+  def test_empty
+    assert_equal([], @t.b)
+  end
+  
+  def test_marshal
+    t2 = Marshal.load(Marshal.dump(@t))
+    assert_equal(@t.b, t2.b)
+  end
+  
+  def make_garbage
+    5.times do
+      @world = World.new
+      @world.create(T)
+    end
+  end
+    
+  def test_gc
+    make_garbage
+    n1 = ObjectSpace.each_object(T) {}
+    GC.start
+    n2 = ObjectSpace.each_object(T) {}
+    assert(n2 < n1)
+  end
+end