gisele-vm 0.6.0

data/lib/gisele/compiling/gts.rb

@@ -0,0 +1,74 @@
+module Gisele
+  module Compiling
+    class Gts < Stamina::Automaton
+
+      class Equivalence < Stamina::Automaton::Equivalence
+
+        def equivalent_states?(s, t)
+          super && (s.data == t.data)
+        end
+
+        def equivalent_edges?(e, f)
+          super && (e.data == f.data)
+        end
+      end
+
+      def to_dot
+        dotter = lambda{|elm,kind|
+          case kind
+            when :automaton
+              { :rankdir => "LR" }
+            when :state
+              { :label     => state_label(elm),
+                :shape     => state_shape(elm),
+                :fixedsize => "true",
+                :width     => "0.6",
+                :style     => "filled",
+                :fillcolor => state_color(elm) }
+            when :edge
+              { :label => edge_label(elm) }
+          end
+        }
+        super(false, &dotter)
+      end
+
+      def bytecode_equivalent!(other)
+        raise "Not DFA equivalent" unless Equivalence.new.call(self, other)
+        true
+      end
+
+    private
+
+      def state_label(state)
+        case state[:kind]
+        when :event  then "EVT"
+        when :launch then "LA"
+        else
+          state[:kind].to_s[0, 1].capitalize
+        end
+      end
+
+      def state_color(state)
+        case state[:kind]
+        when :end then "grey"
+        else
+          state.initial? ? "green" : "white"
+        end
+      end
+
+      def state_shape(state)
+        s = [:fork, :join].include?(state[:kind]) ? "octagon" : "circle"
+        state.accepting? ? "double#{s}" : s
+      end
+
+      def edge_label(edge)
+        if args=edge[:event_args]
+          "#{edge.symbol}(#{args.join ', '})"
+        else
+          edge.symbol || ""
+        end
+      end
+
+    end # class Gts
+  end # module Compiling
+end # module Gisele

data/lib/gisele/compiling/gts2bytecode.rb

@@ -0,0 +1,127 @@
+module Gisele
+  module Compiling
+    class Gts2Bytecode
+
+      attr_reader :builder
+
+      def initialize(builder = VM::Bytecode::Builder.new)
+        @builder = builder
+      end
+
+      def self.call(ts, namespace = nil)
+        builder = VM::Bytecode::Builder.new(namespace)
+        Gts2Bytecode.new(builder).call(ts)
+      end
+
+      def call(ts)
+        builder.at do |b|
+          b.then label(ts.initial_state)
+        end
+        ts.each_state do |s|
+          send :"on_#{s[:kind]}", s
+        end
+        VM::Bytecode.coerce(builder.to_a)
+      end
+
+      def on_nop(state)
+        unless state.out_edges.size == 1
+          raise ArgumentError, "Invalid :nop state"
+        end
+        edge = state.out_edges.first
+        at(state) do |b|
+          b.then label(edge.target)
+        end
+      end
+
+      def on_launch(state)
+        h = {}
+        state.out_edges.each do |edge|
+          h[edge.symbol] = label(edge.target)
+        end
+        at(state) do |b|
+          b.push h
+          b.flip
+          b.get
+          b.then
+        end
+      end
+
+      def on_event(state)
+        unless state.out_edges.size == 1
+          raise ArgumentError, "Invalid :event state #{state.inspect}"
+        end
+        edge = state.out_edges.first
+        at(state) do |b|
+          b.then label(edge.target)
+          b.then label(edge)
+        end
+        at(edge) do |b|
+          b.push  edge[:event_args] || []
+          b.event edge.symbol
+        end
+      end
+
+      def on_listen(state)
+        h = {}
+        state.out_edges.each do |edge|
+          h[edge.symbol] = label(edge.target)
+        end
+        at(state) do |b|
+          b.push h
+          b.then :listen
+        end
+      end
+
+      def on_fork(state)
+        join_edges = state.out_edges.select{|e| e.symbol == :"(wait)"}
+        unless join_edges.size == 1
+          raise ArgumentError, "Invalid :fork state"
+        end
+        join_state = join_edges.first.target
+        targets = state.out_adjacent_states - [ join_state ]
+        at(state) do |b|
+          b.push label(join_state)
+          b.push targets.map{|t| label(t)}
+          b.then :fork
+        end
+      end
+
+      def on_join(state)
+        unless state.out_edges.size == 1
+          raise ArgumentError, "Invalid :join state"
+        end
+        target = state.out_edges.first.target
+        at(state) do |b|
+          b.push :wake => label(target)
+          b.then :join
+        end
+      end
+
+      def on_end(state)
+        unless state.out_edges.size <= 1
+          raise ArgumentError, "Invalid :end state: #{state}"
+        end
+        at(state) do |b|
+          b.then :notify
+        end
+      end
+
+    private
+
+      def label(arg)
+        case arg
+        when Symbol                    then arg
+        when Stamina::Automaton::State then :"s#{arg.index}"
+        when Stamina::Automaton::Edge  then :"e#{arg.index}"
+        else
+          raise ArgumentError, "Unexpected argument: #{arg.inspect}"
+        end
+      end
+
+      def at(state, &bl)
+        builder.at(label(state), &bl)
+      end
+
+    end # class Gts2Bytecode
+  end # module Compiling
+end # module Gisele

data/lib/gisele/vm.rb

@@ -0,0 +1,87 @@
+require 'logger'
+require 'forwardable'
+require_relative 'vm/errors'
+require_relative 'vm/robustness'
+require_relative 'vm/null_object'
+require_relative 'vm/logging'
+require_relative 'vm/component'
+require_relative 'vm/prog'
+require_relative 'vm/prog_list'
+require_relative 'vm/event'
+require_relative 'vm/event_manager'
+require_relative 'vm/registry'
+require_relative 'vm/bytecode'
+require_relative 'vm/kernel'
+require_relative 'vm/lifecycle'
+require_relative 'vm/enacter'
+require_relative 'vm/console'
+require_relative 'vm/proxy'
+module Gisele
+  class VM
+    extend Forwardable
+
+    attr_reader   :bytecode
+    attr_reader   :registry
+    attr_reader   :kernel
+    attr_accessor :proglist
+    attr_accessor :event_manager
+
+    def initialize(bytecode = [:gvm])
+      @bytecode      = (Kernel.bytecode + Bytecode.coerce(bytecode)).verify!
+      @registry      = Registry.new(self)
+      @kernel        = Kernel.new
+      @proglist      = ProgList.memory
+      @event_manager = EventManager.new
+
+      init_lifecycle
+
+      # other registration
+      yield(self) if block_given?
+
+      # post installation of prior components
+      @registry.register @event_manager, true
+      @registry.register @proglist, true
+      @registry.register @kernel, true
+    end
+
+    def self.gts(gis)
+      Compiling::Gisele2Gts.compile(gis)
+    end
+
+    def self.compile(gis)
+      Compiling::Gts2Bytecode.call(gts(gis))
+    end
+
+    def vm
+      self
+    end
+
+    include Robustness
+    include Logging
+    include Lifecycle
+
+    def_delegators :registry,      :components,
+                                   :register,
+                                   :unregister,
+                                   :connect,
+                                   :disconnect,
+                                   :connected?
+
+    def_delegators :kernel,        :start,
+                                   :resume,
+                                   :progress
+
+    def_delegators :proglist,      :pick,
+                                   :fetch,
+                                   :save
+
+    def_delegators :event_manager, :event,
+                                   :subscribe,
+                                   :unsubscribe
+
+    def progs(restriction = nil)
+      proglist.to_relation(restriction)
+    end
+
+  end
+end

data/lib/gisele/vm/bytecode.rb

@@ -0,0 +1,84 @@
+require_relative 'bytecode/grammar'
+require_relative 'bytecode/builder'
+require_relative 'bytecode/printer'
+module Gisele
+  class VM
+    class Bytecode
+
+      def initialize(sexpr)
+        @sexpr = sexpr
+      end
+
+      def self.coerce(arg)
+        case arg
+        when Bytecode           then arg
+        when String, Path       then parse(arg)
+        when Grammar            then Bytecode.new(arg)
+        else
+          raise ArgumentError, "Invalid bytecode source: #{arg}"
+        end
+      end
+
+      def self.parse(source)
+        Bytecode.new(Grammar.sexpr(source))
+      end
+
+      def self.builder(namespace = nil)
+        Builder.new(namespace)
+      end
+
+      def self.build(namespace = nil)
+        builder = builder(namespace)
+        yield(builder)
+        Bytecode.new(builder.to_a)
+      end
+
+      def +(other)
+        other = Bytecode.coerce(other)
+        Bytecode.new [:gvm] + to_a[1..-1] + other.to_a[1..-1]
+      end
+
+      def [](label)
+        block = index[label]
+        block ? block[2..-1] : nil
+      end
+      alias :fetch :[]
+
+      def to_a
+        @sexpr
+      end
+
+      def to_s
+        Printer.call(to_a)
+      end
+
+      def verify!
+        unless (Bytecode::Grammar === @sexpr)
+          sexpr.sexpr_body.each do |block|
+            next if Bytecode::Grammar[:block] === block
+            invalid = block.sexpr_body[1..-1].find{|i|
+              !(Bytecode::Grammar[:instruction]===i)
+            }
+            raise InvalidBytecodeError, "Bad instruction: #{invalid}"
+          end
+        end
+        self
+      end
+
+    private
+
+      def index
+        @index ||= begin
+          index = Hash.new
+          to_a.each_with_index do |bl,i|
+            next if i==0
+            index[bl[1]] = bl
+          end
+          index
+        end
+      end
+
+    end # class Bytecode
+  end # class VM
+end # module Gisele
+

data/lib/gisele/vm/bytecode/builder.rb

@@ -0,0 +1,77 @@
+module Gisele
+  class VM
+    class Bytecode
+      class Builder
+
+        attr_reader :namespace
+
+        def initialize(namespace = nil)
+          @namespace     = namespace
+          @bytecode      = [:gvm]
+          @current_block = nil
+        end
+
+        def current_block
+          unless @current_block
+            raise BadUsageError, "Bytecode builder misused: no current block"
+          end
+          @current_block
+        end
+
+        def at(label = nil, auto=true)
+          raise BadUsageError, "Previous block not dumped." if @current_block
+          if label
+            label = label(label) if auto
+          else
+            label = (namespace || "main").to_s.to_sym
+          end
+          @current_block = [:block, label]
+          if block_given?
+            yield(self)
+            end_block
+          end
+        end
+
+        def end_block
+          bl, @current_block = @current_block, nil
+          @bytecode << bl
+          bl
+        end
+
+        def instruction(which, args)
+          instr = [which] + args
+          if Grammar[which] === instr
+            current_block << instr
+            instr
+          else
+            raise InvalidBytecodeError, "Invalid instruction: #{instr.inspect}"
+          end
+        end
+
+        def to_a
+          @bytecode
+        end
+
+        Grammar.instructions.each do |iname|
+          define_method(iname) do |*args|
+            instruction(iname, args)
+          end
+        end
+
+        [ :then, :fork ].each do |iname|
+          define_method(iname) do |label=nil, auto=true|
+            label = label(label) if label and auto
+            instruction(iname, label ? [ label ] : [ ])
+          end
+        end
+
+      private
+
+        def label(at)
+          (namespace ? "#{namespace}_#{at}" : "#{at}").to_sym
+        end
+
+      end # class Builder
+    end # class Bytecode
+  end # class VM
+end # module Gisele