gisele-language 0.5.0

data/lib/gisele/language/grammar.citrus

@@ -0,0 +1,236 @@
+grammar Gisele::Language::Grammar
+
+  ### Units
+
+  rule unit_def
+    (spacing task_def (spaces task_def)* spacing)
+    <Gisele::Language::Syntax::UnitDef>
+  end
+
+  ### Task definitions
+
+  rule task_def
+    ('task' spaces task_name spaces 
+      (some_def spaces)*
+      (explicit_statement spaces)?
+    'end')
+    <Gisele::Language::Syntax::TaskDef>
+  end
+
+  rule some_def
+    fluent_def | trackvar_def | task_def
+  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
+    | case_st
+    | while_st
+    | seq_st
+    | par_st
+    | task_call_st
+  end
+
+  rule case_st
+    ('case' spaces (var_ref spaces)?
+      (when_clause spaces)+
+      (else_clause spaces)?
+    'end')
+    <Gisele::Language::Syntax::CaseSt>
+  end
+
+  rule when_clause
+    ('when' spaces bool_expr spaces process_statement)
+    <Gisele::Language::Syntax::WhenClause>
+  end
+
+  rule if_st
+    ('if' spaces bool_expr spaces 
+      process_statement spaces 
+      (elsif_clause spaces)* 
+      (else_clause spaces)? 
+    'end')
+    <Gisele::Language::Syntax::IfSt>
+  end
+
+  rule elsif_clause
+    ('elsif' spaces bool_expr spaces process_statement)
+    <Gisele::Language::Syntax::ElsifClause>
+  end
+
+  rule else_clause
+    ('else' spaces process_statement)
+    <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
+    (spacing theexpr:bool_or)
+    <Gisele::Language::Syntax::BoolExpr>
+  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 | bool_lit | var_ref
+  end
+
+  rule bool_paren
+    ('(' spacing expr:bool_or spacing ')')
+    <Gisele::Language::Syntax::BoolParen>
+  end
+
+  rule bool_lit
+    (boolean_literal)
+    <Gisele::Language::Syntax::BoolLit>
+  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
+
+  rule var_ref
+    (variable_name)
+    <Gisele::Language::Syntax::VarRef>
+  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
+    !(reserved_word spaces) [a-z] [A-Za-z0-9_]*
+  end
+
+  rule event_name
+    !(reserved_word spaces) [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
+
+  ### Reserved Words
+  rule reserved_word
+      "if"
+    | "else"
+    | "elsif"
+    | "when"
+    | "while"
+    | "seq"
+    | "par"
+    | "task"
+    | "refinement"
+    | "fluent"
+    | "trackvar"
+    | "initially"
+    | "end"
+    | "not"
+    | "or"
+    | "and"
+    | "true"
+    | "false"
+  end
+
+end

data/lib/gisele/language/grammar.sexp.yml

@@ -0,0 +1,83 @@
+parser:
+  grammar.citrus
+rules:
+  ### units and tasks
+  unit_def:
+    - [task_def+]
+  task_def:
+    - [task_name, some_def*, statement]
+  some_def:
+    - fluent_def
+    - trackvar_def
+    - task_def
+  ### variables
+  fluent_def:
+    - [var_name, event_set, event_set, initially]
+  trackvar_def:
+    - [var_name, event_set, event_set, initially]
+  event_set:
+    - [event*]
+  event:
+    - event_name
+    - task_event_name
+  var_ref:
+    - [var_name]
+  ### statements
+  statement:
+    - if_st
+    - case_st
+    - while_st
+    - seq_st
+    - par_st
+    - task_call_st
+    - nop_st
+  if_st:
+    - [bool_expr, statement, elsif_clause*, "else_clause?"]
+  case_st:
+    - [[var_ref, ~], when_clause+, "else_clause?"]
+  while_st:
+    - [bool_expr, statement]
+  seq_st:
+    - [statement+]
+  par_st:
+    - [statement+]
+  task_call_st:
+    - [task_name]
+  nop_st:
+    - []
+  ### clauses
+  elsif_clause:
+    - [bool_expr, statement]
+  else_clause:
+    - [statement]
+  when_clause:
+    - [bool_expr, statement]
+  ### boolean expressions
+  bool_expr:
+    - [bool_expression]
+  bool_expression:
+    - bool_or
+    - bool_and
+    - bool_not
+    - var_ref
+    - bool_lit
+  bool_or:
+    - [bool_expression, bool_expression]
+  bool_and:
+    - [bool_expression, bool_expression]
+  bool_not:
+    - [bool_expression]
+  bool_lit:
+    - [ boolean_literal  ]
+  boolean_literal:
+    - true
+    - false
+  ### terminals
+  task_name:       !ruby/regexp /^[A-Z][A-Za-z0-9_]*$/
+  var_name:        !ruby/regexp /^[a-z][A-Za-z0-9_]*$/
+  event_name:      !ruby/regexp /^[a-z][a-z0-9_]*$/
+  task_event_name: !ruby/regexp /^[A-Z][A-Za-z0-9_]*:(start|end)$/
+  initially:
+    - true
+    - false
+    - ~

data/lib/gisele/language/processors/elsif_flattener.rb

@@ -0,0 +1,36 @@
+module Gisele
+  module Language
+    class ElsifFlattener < Sexpr::Rewriter
+      grammar Language
+
+      def on_if_st(sexpr)
+        condition, dost, *clauses = sexpr.sexpr_body
+
+        base = [:if_st, condition, dost]
+        base = sexpr(base, sexpr.tracking_markers)
+
+        clauses.inject base do |cur_if, clause|
+          rw_clause = apply(clause)
+          cur_if << rw_clause
+          rw_clause.last
+        end
+
+        base
+      end
+
+      def on_elsif_clause(sexpr)
+        base = \
+          [:else_clause,
+           [:if_st, sexpr[1], apply(sexpr[2])] ]
+        base = sexpr(base, sexpr.tracking_markers)
+      end
+
+      def on_else_clause(sexpr)
+        [:else_clause, apply(sexpr.last)]
+      end
+
+      alias :on_missing :copy_and_apply
+
+    end # class ElsifFlattener
+  end # module Language
+end # module Gisele

data/lib/gisele/language/processors/if_to_case.rb

@@ -0,0 +1,65 @@
+module Gisele
+  module Language
+    class IfToCase < Sexpr::Rewriter
+      grammar Language
+
+      def on_if_st(sexpr)
+        condition, dost, *clauses = sexpr.sexpr_body
+
+        # create case_st with same markers as the if_st
+        when_clause = [:when_clause, condition, apply(dost)]
+        when_clause = sexpr(when_clause, sexpr.tracking_markers)
+        base        = [:case_st, nil, when_clause]
+        base        = sexpr(base, sexpr.tracking_markers)
+
+        # this is the condition for elsif clauses
+        @condition = negate(condition.last)
+
+        # make injection now
+        clauses.inject base do |memo,clause|
+          memo << apply(clause)
+        end
+      end
+
+      def on_elsif_clause(sexpr)
+        condition, dost, = sexpr.sexpr_body
+
+        # install new conditions for me and next elsif clauses
+        condition = condition.last
+        previous  = @condition
+        @condition = [:bool_and, negate(condition), @condition]
+
+        # convert elsif to when and keep the markers
+        base = \
+          [:when_clause,
+            [:bool_expr, [:bool_and, condition, previous]],
+            apply(dost) ]
+        sexpr(base, sexpr.tracking_markers)
+      end
+
+      def on_else_clause(sexpr)
+        dost, = sexpr.sexpr_body
+
+        # convert else to when and keep the markers
+        base = \
+          [:when_clause,
+            [:bool_expr, @condition],
+            apply(dost)]
+        sexpr(base, sexpr.tracking_markers)
+      end
+
+      alias :on_missing :copy_and_apply
+
+      private
+
+      def negate(cond)
+        if cond.first == :bool_not
+          cond.last
+        else
+          [:bool_not, cond]
+        end
+      end
+
+    end # class IfToCase
+  end # module Language
+end # module Gisele

data/lib/gisele/language/processors/scoping_helper.rb

@@ -0,0 +1,32 @@
+module Gisele
+  module Language
+    class ScopingHelper < Sexpr::Processor::Helper
+
+      module Methods
+
+        def scope_stack
+          @scope_stack ||= []
+        end
+
+        def with_scope(scope)
+          scope_stack.push(scope)
+          result = yield
+          scope_stack.pop
+          result
+        end
+
+      end # module Methods
+
+      def on_missing(rw, sexpr)
+        if sexpr.first.to_s =~ /_def/
+          rw.with_scope(sexpr) do
+            yield(rw, sexpr)
+          end
+        else
+          yield(rw, sexpr)
+        end
+      end
+
+    end # module ScopingHelper
+  end # module Language
+end # module Gisele

data/lib/gisele/language/processors/sugar_removal.rb

@@ -0,0 +1,17 @@
+module Gisele
+  module Language
+    class SugarRemoval < Sexpr::Rewriter
+      grammar Language
+
+      # (elsif ... -> else if ...)
+      use ElsifFlattener
+
+      def apply(sexpr)
+        # all is already done by preprocessors so that we can simply return
+        # the s-expression.
+        sexpr
+      end
+
+    end # class SugarRemoval
+  end # module Language
+end # module Gisele

data/lib/gisele/language/processors.rb

@@ -0,0 +1,4 @@
+require_relative 'processors/scoping_helper'
+require_relative 'processors/elsif_flattener'
+require_relative 'processors/if_to_case'
+require_relative 'processors/sugar_removal'

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_expr.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module BoolExpr
+        include Node
+
+        def _to_ast
+          [:bool_expr, captures[:theexpr].first.to_ast]
+        end
+
+      end # module BoolExpr
+    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
+          [:bool_lit, strip == "true"]
+        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/case_st.rb

@@ -0,0 +1,19 @@
+module Gisele
+  module Language
+    module Syntax
+      module CaseSt
+        include Node
+
+        def _to_ast
+          var     = captures[:var_ref].first
+          var     = var.to_ast if var
+          var     = nil if var && var.empty?
+          whens   = captures[:when_clause].map{|x| x.to_ast}
+          els     = captures[:else_clause].map{|x| x.to_ast}
+          [:case_st, var] + whens + els
+        end
+
+      end # module CaseSt
+    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_def, name, init, term, initval]
+        end
+
+      end # module FluentDef
+    end # module Syntax
+  end # module Language
+end # module Gisele

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