gisele-vm 0.6.0

data/lib/gisele/vm/bytecode/grammar.citrus

@@ -0,0 +1,116 @@
+grammar Gisele::VM::Bytecode::Grammar::Parser
+
+  rule file
+    ((trailing_space block)+ end_of_file?){
+      [:gvm] + self[:block].map{|x| x.value}
+    }
+  end
+
+  rule end_of_file
+    trailing_space ('__END__' .*)?
+  end
+
+  rule block
+    (label (spacing instruction)+){
+      [:block, self[:label].first.value] + self[:instruction].map{|x| x.value}
+    }
+  end
+
+  rule instruction
+    (opcode (spaces arglist)? spacing (eol_comment | eol)){
+      [self[:opcode].first.value] + Array(self[:arglist].map{|x| x.value}.first)
+    }
+  end
+
+  rule arglist
+    (arg (spacing ',' spacing arg)*){ self[:arg].map{|x| x.value} }
+  end
+
+  rule opcode
+    ([a-z]+){ strip.to_sym }
+  end
+
+  rule label
+      ([0-9]+ ':'){ strip[0...-1].to_i }
+    | ([a-zA-Z0-9_-]+ ":"){ strip[0...-1].to_sym }
+  end
+
+  rule arg
+    boolean | int | symbol | string | constant | array | hash
+  end
+
+  rule boolean
+    ('true' | 'false'){ strip == 'true' }
+  end
+
+  rule int
+   ( [\-]? '0' | [\-]? [1-9] [0-9]*){ strip.to_i }
+  end
+
+  rule symbol
+    (':' symbol_chars){ strip[1..-1].to_sym }
+  end
+
+  rule string
+      (['] (!['] .)* [']){ strip[1...-1] }
+    | (["] (!["] .)* ["]){ strip[1...-1] }
+  end
+
+  rule constant
+    ([A-Z][A-Za-z]* ('::' [A-Z][A-Za-z]*)*){
+      strip.split('::').inject(::Kernel){|cur,c| cur.const_get(c)}
+    }
+  end
+
+  rule array
+      ('[' spacing arglist spacing ']'){ self[:arglist].last.value }
+    | ('[' spacing ']'){ [] }
+  end
+
+  rule hash
+      ('{' spacing hash_entries spacing '}'){ Hash[self[:hash_entries].last.value] }
+    | ('{' spacing '}'){ Hash.new }
+  end
+
+  rule hash_entries
+    (hash_entry (spacing ',' spacing hash_entry)*){ self[:hash_entry].map{|x| x.value} }
+  end
+
+  rule hash_entry
+    (symbol_chars ':' spacing arg){
+      [ self[:symbol_chars].last.value, self[:arg].last.value ]
+    } |
+    (':' symbol_chars spacing '=>' spacing arg){
+      [ self[:symbol_chars].last.value, self[:arg].last.value ]
+    }
+  end
+
+  rule symbol_chars
+    ([a-zA-Z] [a-zA-Z0-9_]*){ strip.to_sym }
+  end
+
+  rule trailing_space
+    (eol_comment | spaces | [\n])*
+  end
+
+  rule eol_comment
+    "#" (![\n] .)* eol
+  end
+
+  rule spaces
+    space+
+  end
+
+  rule spacing
+    space*
+  end
+
+  rule space
+    [ \t]
+  end
+
+  rule eol
+    [\n] | !.
+  end
+
+end

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

@@ -0,0 +1,19 @@
+module Gisele
+  class VM
+    class Bytecode
+
+      # Load the Language through Sexpr
+      Grammar = Sexpr.load Path.dir/"grammar.sexp.yml"
+
+      # The Gisele bytecode language.
+      module Grammar
+
+        def instructions
+          grammar = YAML.load_file (Path.dir/"grammar.sexp.yml").to_s
+          grammar["rules"]["instruction"].map(&:to_sym)
+        end
+
+      end # module Grammar
+    end # class Bytecode
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/bytecode/grammar.sexp.yml

@@ -0,0 +1,113 @@
+parser:
+  grammar.citrus
+rules:
+  gvm:
+    - [ block* ]
+  block:
+    - [ label, instruction+ ]
+  label:
+    - '::Integer'
+    - '::Symbol'
+  instruction:
+    # generic
+    - send
+    - invoke
+    - get
+    - getr
+    - set
+    - del
+    # control
+    - nop
+    - then
+    - ifenil
+    - ifezero
+    # lifecycle
+    - puid
+    - self
+    - parent
+    - fetch
+    - fork
+    - forka
+    - save
+    - savea
+    # events
+    - event
+    # stack
+    - pop
+    - push
+    - flip
+    - fold
+    - unfold
+  # generic
+  send:
+    - [ 'symbol_arg?' ]
+  invoke:
+    - [ 'symbol_arg?' ]
+  get:
+    - [ 'symbol_arg?' ]
+  getr:
+    - [ 'symbol_arg?' ]
+  set:
+    - [ 'symbol_arg?' ]
+  del:
+    - [ 'symbol_arg?' ]
+  # control
+  nop:
+    - []
+  then:
+    - [ 'label_arg?' ]
+  ifenil:
+    - []
+  ifezero:
+    - []
+  # lifecycle
+  puid:
+    - []
+  self:
+    - []
+  parent:
+    - []
+  fetch:
+    - [ 'argument?' ]
+  fork:
+    - [ 'label_arg?' ]
+  forka:
+    - [ ]
+  save:
+    - [ 'integer_arg?' ]
+  savea:
+    - []
+  # stack
+  pop:
+    - [ 'integer_arg?' ]
+  push:
+    - [ argument ]
+  flip:
+    - []
+  fold:
+    - [ 'integer_arg?' ]
+  unfold:
+    - []
+  # events
+  event:
+    - [ 'symbol_arg?' ]
+  argument:
+    - boolean_arg
+    - symbol_arg
+    - integer_arg
+    - string_arg
+    - module_arg
+    - array_arg
+    - hash_arg
+  label_arg:
+    - symbol_arg
+    - integer_arg
+  boolean_arg:
+    - true
+    - false
+  symbol_arg:  '::Symbol'
+  integer_arg: '::Integer'
+  string_arg:  '::String'
+  module_arg:  '::Module'
+  array_arg:   '::Array'
+  hash_arg:    '::Hash'

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

@@ -0,0 +1,35 @@
+module Gisele
+  class VM
+    class Bytecode
+      class Printer < Sexpr::Rewriter
+
+        def on_gvm(sexpr)
+          z, *blocks = sexpr
+          max = blocks.inject(0){|m,bl|
+            length = bl[1].to_s.size
+            length > m ? length : m
+          }
+          @sep = "\n" + " "*(max + 2)
+          code = ""
+          code << blocks.map{|bl| apply(bl)}.join("\n")
+          code << "\n"
+        end
+
+        def on_block(sexpr)
+          z, label, *instr = sexpr
+          label = "#{label}: "
+          label << " "*(@sep.size - label.size - 1)
+          label << instr.map{|i| apply(i)}.join(@sep).strip
+        end
+
+        def on_missing(sexpr)
+          iname, *args = sexpr
+          label = "#{iname} "
+          label << args.map{|arg| arg.inspect}.join(', ')
+          label.strip
+        end
+
+      end # class Printer
+    end # class Bytecode
+  end # class VM
+end # class Gisele

data/lib/gisele/vm/command.rb

@@ -0,0 +1,140 @@
+module Gisele
+  class VM
+    #
+    # The Gisele Virtual Machine
+    #
+    # SYNOPSIS
+    #   gvm [--version] [--help]
+    #   gvm [--drb-server] [options] GIS_FILE
+    #   gvm --drb-client [options]
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class Command <  Quickl::Command(__FILE__, __LINE__)
+
+      # Install options
+      options do |opt|
+        opt.on('--help', "Show this help message") do
+          raise Quickl::Help
+        end
+        opt.on('--version', 'Show version and exit') do
+          raise Quickl::Exit, "gvm #{Gisele::VM::VERSION} (c) The University of Louvain"
+        end
+
+        @mode = :run
+        opt.on('-c', '--compile', 'Compile the input file and output the VM bytecode') do
+          @mode = :compile
+        end
+        opt.on('-g', '--gts', 'Outputs a gisele transition system') do
+          @mode = :gts
+        end
+
+        opt.separator("\nStorage")
+        @storage = "memory"
+        opt.on('--storage=URI',
+               "Use the specified storage (defaults to 'memory')") do |uri|
+          @storage = uri
+        end
+        @truncate = false
+        opt.on('-t', '--truncate', 'Truncate process instances first') do
+          @truncate = true
+        end
+
+        opt.separator("\nVM & Agents")
+        @interactive = false
+        opt.on('-i', '--interactive', 'Start a console in interactive VM mode') do
+          @interactive = true
+        end
+        @simulation = false
+        opt.on('-s', '--simulate', 'Use an agent simulating the environment') do
+          @simulation = true
+        end
+        @drb_server = false
+        opt.on('--drb-server', 'Register the VM as a DRb server') do
+          @drb_server = true
+        end
+        @drb_client = false
+        opt.on('--drb-client', 'Look for the virtual machine on DRb') do
+          @drb_client = true
+        end
+
+        opt.separator("\nLogging")
+        @verbose = Logger::INFO
+        opt.on('-v', '--verbose', 'Log in verbose mode') do
+          @verbose = Logger::DEBUG
+        end
+        opt.on('--silent', 'Only show warnings and errors') do
+          @verbose = Logger::WARN
+        end
+        @log_file = $stdout
+        opt.on('--log=FILE', 'Use a specific log file') do |file|
+          @log_file = file
+        end
+      end
+
+      def execute(args)
+        raise Quickl::Help if args.size > 1
+        @gis_file = Path(args.shift)
+        case @mode
+        when :run        then start_vm
+        when :compile    then puts VM.compile(@gis_file)
+        when :gts        then puts VM.gts(@gis_file).to_dot
+        end
+      end
+
+      def vm(gis_file = @gis_file)
+        @vm ||= @drb_client ? drb_vm : real_vm(gis_file)
+      end
+
+    private
+
+      def real_vm(gis_file = @gis_file)
+        bc = VM.compile(gis_file)
+        VM.new(bc) do |vm|
+          vm.proglist = VM::ProgList.new VM::ProgList.storage(@storage)
+          vm.register VM::Enacter.new
+          populate(vm)
+        end
+      end
+
+      def drb_vm
+        require_relative 'proxy'
+        Proxy::Client.new{|vm| populate(vm) }
+      end
+
+      def populate(vm)
+        # Install the logger
+        vm.logger       = Logger.new(@log_file)
+        vm.logger.level = @verbose
+
+        # Add the simulation if required
+        if @simulation
+          require_relative 'simulator/resumer'
+          vm.register Simulator::Resumer.new
+        end
+
+        # Add the DRb server if required
+        if @drb_server
+          require_relative 'proxy'
+          vm.register Proxy::Server.new
+        end
+
+        if @interactive
+          vm.register Console.new
+        end
+        vm
+      end
+
+      def start_vm
+        the_vm = vm
+        trap('INT'){
+          the_vm.info "Interrupt on user request (graceful shutdown)."
+          the_vm.stop
+        }
+        the_vm.run
+      end
+
+    end # class Command
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/component.rb

@@ -0,0 +1,91 @@
+module Gisele
+  class VM
+    class Component
+      extend Forwardable
+
+      def initialize
+        @vm        = nil
+        @connected = false
+      end
+
+      def vm
+        @vm || NullObject.new
+      end
+
+      def registered(vm)
+        @vm = vm
+      end
+
+      def unregistered
+        @vm = nil
+      end
+
+      def registered?
+        !@vm.nil?
+      end
+
+      def registered!
+        raise InvalidStateError, "Not registered" unless registered?
+      end
+
+      def connect
+        registered!
+        raise InvalidStateError, "Already connected" if connected?
+        @connected = true
+        info(welcome_message)
+        EM.next_tick do
+          info(heartbeat_in_message)
+          enter_heartbeat
+        end if respond_to?(:enter_heartbeat)
+      end
+
+      def disconnect
+        raise InvalidStateError, "Not connected" unless connected?
+        if respond_to?(:leave_heartbeat)
+          info(heartbeat_out_message)
+          leave_heartbeat
+        end
+        @connected = false
+        info(goodbye_message)
+      end
+
+      def connected?
+        @connected
+      end
+
+      def connected!
+        raise InvalidStateError, "Not connected" unless connected?
+      end
+
+      def_delegators :vm, :debug,  :info,  :warn,  :error,  :fatal
+      def_delegators :vm, :debug?, :info?, :warn?, :error?, :fatal?
+
+    private
+
+      def component_name
+        self.class.name.to_s.split('::').last
+      end
+
+      def welcome_message
+        "Component <#{component_name}> connecting."
+      end
+
+      def heartbeat_in_message
+        "Component <#{component_name}> entering heartbeat."
+      end
+
+      def heartbeat_out_message
+        "Component <#{component_name}> exiting heartbeat."
+      end
+
+      def goodbye_message
+        "Component <#{component_name}> disconnected."
+      end
+
+      def error_message(error, base = "An error occured:")
+        base.to_s << " " << error.message << "\n" << error.backtrace.join("\n")
+      end
+
+    end # class Component
+  end # class VM
+end # module Gisele