gisele 0.0.1 → 0.1.0

data/CHANGELOG.md

@@ -1,4 +1,42 @@
-# 0.0.1 / FIX ME
+# 0.1.0 / FIX ME
+
+## Enhancements
+
+* The main `gisele` command now accepts a --no-sugar option that removes syntactic
+  sugar. This option is limited to the rewriting of `if` statements as guarded `case`
+  commands for now. Additional rewriting could be added in the future.
+* All AST nodes (obtained via `Gisele.ast` or similar) now include the module 
+  `Gisele::Language::AST::Node` which contains a few utilities.
+
+## Breaking changes
+
+* The language package has been reorganized and is now considered as belonging to
+  the private API. Further changes there will therefore not b considered as Breaking
+  changes in the future (expect the structure of the AST, of course). 
+  The `Gisele.parse` and `Gisele.ast` methods belong to the public API and are therefore
+  the way to (parse / get an AST) from a process file / source.
+
+* The top AST element of a process file is always a :unit. The latter may contain 
+  one ore more task definitions. Import/include nodes will probably be added later
+  and authorized at the beginning of the file.
+
+* The following syntax nodes have been renamed:
+    :varref     -> :var_ref
+    :or         -> :bool_or
+    :and        -> :bool_and
+    :not        -> :bool_not
+    :if         -> :if_st
+    :else       -> :else_clause
+    :elsif      -> :elsif_clause
+    :while      -> :while_st
+    :seq        -> :seq_st
+    :par        -> :par_st
+    :task_call  -> :task_call_st
+    :task       -> :task_def
+    :signature  -> :task_signature
+    :refinement -> :task_refinement
+
+# 0.0.1 / 2012-02-16
 
 * Enhancements
 

data/gisele.noespec

@@ -12,7 +12,7 @@ variables:
   upper:
     Gisele
   version:
-    0.0.1
+    0.1.0
   summary: |-
     Gisele is a Process Analyzer Toolset
   description: |-

data/lib/gisele/command.rb

@@ -19,13 +19,21 @@ module Gisele
   #   debugging, that is with colors and extra information. Use --ast=ruby to get a ruby
   #   array for automatic processing.
   #
+  #   When --no-sugar is specified, syntactic sugar is first removed before making any other
+  #   transformation. For now, this rewrites all `if` statements as explicit `case` guarded
+  #   commands.
+  #
   class Gisele::Command <  Quickl::Command(__FILE__, __LINE__)
 
     # Install options
     options do |opt|
-      @ast = nil
+      @print_ast = nil
       opt.on('--ast=[MODE]', 'Prints the process abstract syntax tree (debug,ruby)') do |value|
-        @ast = (value || "debug").to_sym
+        @print_ast = (value || "debug").to_sym
+      end
+      @sugar = true
+      opt.on('--no-sugar', 'Apply syntactic sugar removal') do
+        @sugar = false
       end
       opt.on_tail('--help', "Show this help message") do
         raise Quickl::Help
@@ -42,8 +50,9 @@ module Gisele
         raise Quickl::IOAccessError, "File does not exists: #{file}"
       end
 
-      parsed = Gisele::Language::Parser.parse(file)
-      print_ast(parsed, @ast) if @ast
+      ast = Gisele.ast(file)
+      ast = Gisele::Language::SugarRemoval.new.call(ast) unless @sugar
+      print_ast(ast, @print_ast) if @print_ast
     end
 
     private

data/lib/gisele/errors.rb

@@ -0,0 +1,21 @@
+module Gisele
+
+  class Error < StandardError
+    attr_reader :cause
+    def initialize(msg, cause = $!)
+      super(msg)
+      @cause = cause
+    end
+  end
+
+  # Internal errors certainly denote bugs in the implementation.
+  # They are typically raised when a precondition is violated.
+  class InternalError < Error
+  end
+
+  # Raised when an unexpected node is encountered in an AST-driven
+  # transformation.
+  class UnexpectedNodeError < InternalError
+  end
+
+end # module Gisele

data/lib/gisele/language/ast/helpers.rb

@@ -0,0 +1,37 @@
+module Gisele
+  module Language
+    module AST
+      module Helpers
+
+        def ast(arg)
+          return node(arg) if looks_a_node?(arg)
+          Syntax.ast(arg)
+        end
+
+        def node(arg)
+          return arg if arg.is_a?(Node)
+          unless looks_a_node?(arg)
+            raise ArgumentError, "Array expected, #{arg.inspect} found."
+          end
+          extend_node(arg).tap do |node|
+            node.children.each{|c| node(c) if looks_a_node?(c)}
+          end
+        end
+
+        private
+
+        def looks_a_node?(arg)
+          arg.is_a?(Node) or (arg.is_a?(Array) and arg.first.is_a?(Symbol))
+        end
+
+        def extend_node(arg)
+          modname = Language.rule2mod(arg.first)
+          mod     = AST.const_get(modname) rescue Node
+          arg.extend(mod)
+        end
+
+        extend(self)
+      end # module Helpers
+    end # module AST
+  end # module Language
+end # module Gisele

data/lib/gisele/language/ast/node.rb

@@ -0,0 +1,54 @@
+module Gisele
+  module Language
+    module AST
+      module Node
+
+        # Returns the rule name, that is, the first Symbol element
+        # of the node array.
+        #
+        # Example:
+        #     file = ... path to a .gis file ...
+        #     Gisele.ast(file).rule_name
+        #     # => :unit
+        #
+        def rule_name
+          first
+        end
+
+        # Returns the children of this node.
+        #
+        # Children are defined as all but the rule name in the underlying
+        # array.
+        #
+        def children
+          self[1..-1]
+        end
+
+        # Applies copy-and-transform to this node.
+        #
+        # Example:
+        #   node = AST.node([:something, "world", [:subnode ...]])
+        #   node.copy do |base,child|
+        #     base << ... make something with child ...
+        #   end
+        #   # => [:something, ...]
+        #
+        def copy(&block)
+          base = AST.node([rule_name])
+          children.inject(base, &block)
+        end
+
+        # Duplicates this node.
+        #
+        # This method ensures that the node marking through modules
+        # will correctly be applied to the duplicated array.
+        #
+        def dup
+          AST.node(super)
+        end
+
+      end # module Node
+    end # module AST
+  end # module Language
+end # module Gisele
+require_relative 'unit'

data/lib/gisele/language/ast/unit.rb

@@ -0,0 +1,10 @@
+module Gisele
+  module Language
+    module AST
+      module Unit
+        include Node
+
+      end # module Node
+    end # module AST
+  end # module Language
+end # module Gisele

data/lib/gisele/language/ast.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module AST
+
+      def node(arg)
+        AST::Helpers.node(arg)
+      end
+      module_function :node
+
+    end # module AST
+  end # module Language
+end # module Gisele
+require_relative 'ast/helpers'
+require_relative 'ast/node'

data/lib/gisele/language/sugar_removal.rb

@@ -0,0 +1,53 @@
+module Gisele
+  module Language
+    class SugarRemoval < Transformer
+      alias :on_missing :copy_and_applyall
+
+      def on_if_st(node)
+        IfToGuardedCommands.new(self).call(node)
+      end
+
+      class IfToGuardedCommands < Transformer
+
+        def initialize(main)
+          @main = main
+        end
+
+        def on_if_st(node)
+          condition, dost, *clauses = node.children
+          base = [:case_st, [:when_clause, condition, @main.call(dost)] ]
+          @condition = negate(condition)
+          clauses.inject base do |memo,clause|
+            memo << call(clause)
+          end
+        end
+
+        def on_elsif_clause(node)
+          condition, dost, = node.children
+          prev, @condition = @condition, [:bool_and, negate(condition), @condition]
+          [:when_clause,
+            [:bool_and, condition, prev],
+            @main.call(dost)]
+        end
+
+        def on_else_clause(node)
+          dost, = node.children
+          [:when_clause,
+            @condition,
+            @main.call(dost)]
+        end
+
+        private
+
+        def negate(cond)
+          if cond.rule_name == :bool_not
+            cond.last
+          else
+            [:bool_not, cond]
+          end
+        end
+
+      end # class IfToGuardedCommands
+    end # class SugarRemoval
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/bool_and.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolAnd
+        include Node
+
+        def _to_ast
+          [:bool_and, left.to_ast, right.to_ast]
+        end
+
+      end # module BoolAnd
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/bool_lit.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolLit
+        include Node
+
+        def _to_ast
+          captures[:boolean_literal].first.value
+        end
+
+      end # module BoolLit
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/bool_not.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolNot
+        include Node
+
+        def _to_ast
+          [:bool_not, captures[:expr].first.to_ast]
+        end
+
+      end # module BoolParen
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/bool_or.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolOr
+        include Node
+
+        def _to_ast
+          [:bool_or, left.to_ast, right.to_ast]
+        end
+
+      end # module BoolOr
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/bool_paren.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolParen
+        include Node
+
+        def _to_ast
+          captures[:expr].first.to_ast
+        end
+
+      end # module BoolParen
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/else_clause.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module ElseClause
+        include Node
+
+        def _to_ast
+          [:else_clause, captures[:process_statement].first.to_ast]
+        end
+
+      end # module ElseClause
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/elsif_clause.rb

@@ -0,0 +1,16 @@
+module Gisele
+  module Language
+    module Syntax
+      module ElsifClause
+        include Node
+
+        def _to_ast
+          cond = captures[:bool_expr].first.to_ast
+          dost = captures[:process_statement].first.to_ast
+          [:elsif_clause, cond, dost]
+        end
+
+      end # module ElsifClause
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/event_set.rb

@@ -0,0 +1,15 @@
+module Gisele
+  module Language
+    module Syntax
+      module EventSet
+        include Node
+
+        def _to_ast
+          events = (captures[:event] || []).map{|e| e.value}
+          [:event_set] + events
+        end
+
+      end # module EventSet
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/fluent_def.rb

@@ -0,0 +1,18 @@
+module Gisele
+  module Language
+    module Syntax
+      module FluentDef
+        include Node
+
+        def _to_ast
+          name       = captures[:variable_name].first.strip
+          init, term = captures[:event_set].map{|x| x.to_ast}
+          initval    = captures[:initially_def].first
+          initval    = (initval && !initval.empty?) ? initval.value : nil
+          [:fluent, name, init, term, initval]
+        end
+
+      end # module FluentDef
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/grammar.citrus

@@ -0,0 +1,202 @@
+grammar Gisele::Language::Syntax::Grammar
+
+  ### Units
+
+  rule unit
+    ((spacing task_def)* spacing)
+    <Gisele::Language::Syntax::Unit>
+  end
+
+  ### Task definitions
+
+  rule task_def
+    ('task' spaces task_name spaces (task_signature spaces)? (task_refinement spaces)? 'end')
+    <Gisele::Language::Syntax::TaskDef>
+  end
+
+  rule task_signature
+    (task_signature_element (spaces task_signature_element)*)
+    <Gisele::Language::Syntax::TaskSignature>
+  end
+
+  rule task_signature_element
+    fluent_def | trackvar_def
+  end
+
+  rule task_refinement
+    ('refinement' spaces process_statement spaces 'end')
+    <Gisele::Language::Syntax::TaskRefinement>
+  end
+
+  ### Process statements
+
+  rule process_statement
+    implicit_seq_st | explicit_statement
+  end
+
+  rule implicit_seq_st
+    (explicit_statement spaces st_list)
+    <Gisele::Language::Syntax::ImplicitSeqSt>
+  end
+
+  rule st_list
+    (explicit_statement (spaces explicit_statement)*)
+    <Gisele::Language::Syntax::StList>
+  end
+
+  rule explicit_statement
+      if_st
+    | while_st
+    | seq_st
+    | par_st
+    | task_call_st
+  end
+
+  rule if_st
+    ('if' spaces bool_expr spaces process_statement spaces elsif_clause* else_clause? 'end')
+    <Gisele::Language::Syntax::IfSt>
+  end
+
+  rule elsif_clause
+    ('elsif' spaces bool_expr spaces process_statement spaces)
+    <Gisele::Language::Syntax::ElsifClause>
+  end
+
+  rule else_clause
+    ('else' spaces process_statement spaces)
+    <Gisele::Language::Syntax::ElseClause>
+  end
+
+  rule while_st
+    ('while' spaces bool_expr spaces process_statement spaces 'end')
+    <Gisele::Language::Syntax::WhileSt>
+  end
+
+  rule seq_st
+    ('seq' spaces st_list spaces 'end')
+    <Gisele::Language::Syntax::SeqSt>
+  end
+
+  rule par_st
+    ('par' spaces st_list spaces 'end')
+    <Gisele::Language::Syntax::ParSt>
+  end
+
+  rule task_call_st
+    (task_name)
+    <Gisele::Language::Syntax::TaskCallSt>
+  end
+
+  ### Boolean expressions
+
+  rule bool_expr
+    bool_or
+  end
+
+  rule bool_or
+      (left:bool_and spaces 'or' spaces right:bool_or)
+      <Gisele::Language::Syntax::BoolOr>
+    | bool_and
+  end
+
+  rule bool_and
+      (left:bool_not spaces 'and' spaces right:bool_and)
+      <Gisele::Language::Syntax::BoolAnd>
+    | bool_not
+  end
+
+  rule bool_not
+      ('not' &([ \t\n] | '(') spacing expr:bool_not)
+      <Gisele::Language::Syntax::BoolNot>
+    | bool_term
+  end
+
+  rule bool_term
+    bool_paren | boolean_literal | bool_varref
+  end
+
+  rule bool_paren
+    ('(' spacing expr:bool_expr spacing ')')
+    <Gisele::Language::Syntax::BoolParen>
+  end
+
+  rule bool_lit
+    (boolean_literal)
+    <Gisele::Language::Syntax::BoolLit>
+  end
+
+  rule bool_varref
+    (variable_name)
+    <Gisele::Language::Syntax::VarRef>
+  end
+
+  ### Variables
+
+  rule variable_def
+    trackvar_def | fluent_def
+  end
+
+  rule trackvar_def
+    ('trackvar' spaces variable_name spacing event_set (spacing ',' spacing event_set)? initially_def?)
+    <Gisele::Language::Syntax::TrackvarDef>
+  end
+
+  rule fluent_def
+    ('fluent' spaces variable_name spacing event_set spacing ',' spacing event_set initially_def?)
+    <Gisele::Language::Syntax::FluentDef>
+  end
+
+  rule initially_def
+    (spaces 'initially' spaces lit:boolean_literal){ lit.value }
+  end
+
+  ### Events
+
+  rule event_set
+    ('{' spacing (event (spacing ',' spacing event)*)? spacing '}')
+    <Gisele::Language::Syntax::EventSet>
+  end
+
+  rule event
+    task_start_or_end | event_name
+  end
+
+  rule task_start_or_end
+    task_name ':' ('start' | 'end')
+  end
+
+  ### Names
+  
+  rule task_name
+    [A-Z] [A-Za-z0-9_]*
+  end
+
+  rule variable_name
+    [a-z] [A-Za-z0-9_]*
+  end
+
+  rule event_name
+    [a-z] [a-z0-9_]*
+  end
+
+  ### Literals
+
+  rule boolean_literal
+    ('true' | 'false'){ strip == "true" }
+  end
+
+  ### Spacing
+
+  rule comment
+    "#" (![\n] .)*
+  end
+
+  rule spaces
+    (comment | [ \t\n])+
+  end
+
+  rule spacing
+    (comment | [ \t\n])*
+  end
+
+end

data/lib/gisele/language/syntax/if_st.rb

@@ -0,0 +1,18 @@
+module Gisele
+  module Language
+    module Syntax
+      module IfSt
+        include Node
+
+        def _to_ast
+          cond    = captures[:bool_expr].first.to_ast
+          dost    = captures[:process_statement].first.to_ast
+          elsifs  = captures[:elsif_clause].map{|x| x.to_ast}
+          els     = captures[:else_clause].map{|x| x.to_ast}
+          [:if_st, cond, dost] + elsifs + els
+        end
+
+      end # module IfSt
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/implicit_seq_st.rb

@@ -0,0 +1,16 @@
+module Gisele
+  module Language
+    module Syntax
+      module ImplicitSeqSt
+        include Node
+
+        def _to_ast
+          front = captures[:explicit_statement].first.to_ast
+          tail  = captures[:st_list].first.value
+          [:seq_st, front] + tail
+        end
+
+      end # module ImplicitSeqSt
+    end # module Syntax
+  end # module Language
+end # module Gisele