tla-parser-s 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a18b7ddd5c763aaf63218b27d64c38c71ccf5fb
-  data.tar.gz: 9f343d38938ddcf5cbdfd9abb2a7fcf624f30dee
+  metadata.gz: f9d948ffca5a15da6675b14f14e17e5181615d2b
+  data.tar.gz: cbbb074f624f0afbc29a579bb0fe7a4afa5d3c9d
 SHA512:
-  metadata.gz: 2fd17951f4589debafa7dc2bd69bdf9f02ea6d80e64c93d07d667df66340cb8d41b590ef78353c1509d1dd9db5355e81f6281022f231dd1cfba75fc3c549b3b5
-  data.tar.gz: 2a4f66ab14732a613469b71a576713db8e3a1df4fae94dc9528b69f830b637ed70f143349abe99ea0aa5ecc67b3d34b4239aca7e656d04a42b2d6973776114af
+  metadata.gz: 502e237ae5b32370fbfe1df73231fb90f56f7659a3af762442764d6f8e7de1ae6fa578a3872379f394ecdb549aaceb5f19f345a426b81b312f422bd763c766d6
+  data.tar.gz: f54fe71c01a2f878f322afe41c79ac1a621ecc92b599e8359c80032d48e5fadae43c1d89da9faa9bb8b10c794028669314a020487b4f8c58c971e883f7deedda

data/README.md

@@ -2,7 +2,7 @@
 [Up](../index.php) [Readme](README.html) [Releases](RELEASES.html) [Todo](TODO.html)
 
 
-# tla-parser-s - TLA+ language parser (for tla-sbuilder) - $Release:0.1.0$
+# tla-parser-s - TLA+ language parser (for tla-sbuilder) - $Release:0.1.2$
 
 A Ruby library for parsing
 [TLA+ language](http://research.microsoft.com/en-us/um/people/lamport/tla/book.html).

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/lib/parser/parser_nodes.rb

@@ -80,6 +80,13 @@ module Sexp
   class Parameters <IdentifierList
   end
 
+  class ProcVariables <IdentifierList
+    def identifier_nodes
+      recursive_select( Sexp::VariableDef).first.recursive_select( Sexp::Identifier )
+    end
+    
+  end
+
   
 
   class ExpressionList <Root
@@ -315,6 +322,37 @@ module Sexp
     end
 
   end
+  
+  class IfExpressionCondition < Root
+  end
+  class IfExpressionThen < Root
+  end
+  class IfExpressionElse < Root
+  end
+  class IfExpression < SimpleExpression
+    
+    # Node for condition
+    # @return [Expression] for IF condition
+    def condition_node
+      recursive_select( Sexp::IfExpressionCondition ).first.recursive_select(Sexp::Expression).first
+    end
+
+    # @return [Expression] for THEN expression
+    def then_expression_node
+      recursive_select( Sexp::IfExpressionThen ).first.recursive_select(Sexp::Expression).first       end
+
+    # @return [Expression] for ELSE expression    
+    def else_expression_node
+      tree_node = recursive_select( Sexp::IfExpressionElse ).first
+      return tree_node unless tree_node
+      tree_node.recursive_select(Sexp::Expression).first
+    end
+
+    def name
+      'IF'
+    end
+    
+  end
 
   class ChooseExpression < SimpleExpression
 
@@ -440,8 +478,8 @@ module Sexp
     def expression_val
       "exprsssion"
     end
-    def record_identifier
-      recursive_select( Sexp::RecordExceptIdentifier ).first.recursive_select( Sexp::Identifier ).first.expression_val
+    def record_base
+      recursive_select( Sexp::RecordExcepBase ).first.recursive_select( Sexp::Expression ).first
     end
     def record_field_definitions
       # rigth recursion results to empty RecordExceptField -node
@@ -459,7 +497,7 @@ module Sexp
     end
   end
   
-  class RecordExceptIdentifier < Root
+  class RecordExcepBase < Root
   end
   
 
@@ -532,6 +570,7 @@ module Sexp
     end
   end
 
+
   class AbstractSetExpression < AbstactExpression
     # AbstactExpression.traverse quit traversing the expression
     def lhs_node
@@ -564,6 +603,12 @@ module Sexp
       ret
     end
 
+    # Elements defined on constructore
+    def set_elements
+      elems = recursive_select( Sexp::Expression )
+      elems
+    end
+
     # For documentation purposes symbol table context needs a name
     # (For procedures, and macros name is ovbious. For a set
     # expression we define name set a string "Set+<generator set>"
@@ -576,7 +621,7 @@ module Sexp
     # variable defined in set constructor generate. Return name of
     # this variables.
     # 
-    # @return [Array] of one hash with ':node_type',':value' properties
+    # @return [Hash:Array] with :node_type,:value, :tree -properties
     def symbol_definitions
       return [] unless binds_node
       [ { :node_type => node_type, :value => binds_node.bind_var.expression_val, :tree=>binds_node } ]
@@ -590,6 +635,9 @@ module Sexp
   class SetExpression < AbstractSetExpression
   end
 
+  class SetConstructor < AbstractSetExpression
+  end
+
   class FieldBy < AbstactExpression
     # AbstractExpression.traverse - do not recurse will evaluate separetetely
     def lhs_node
@@ -602,6 +650,8 @@ module Sexp
     
   end
 
+  
+
   class FieldByName < FieldBy
     
     # @return [AbstactExpression] defining the name    
@@ -963,6 +1013,7 @@ module Sexp
       node = parameters_node
       return node.value if node
     end
+
     
     def body_node
       ret = recursive_select(Sexp::Statement).first
@@ -981,21 +1032,60 @@ module Sexp
       }
     end
 
-    # Symbols defined in this node
     #
-    # @return [Hash:Array] symbol hash with ':node_type', :value,
-    # :tree properties
-    def symbol_definitions
+    # @return [Hash:Array] symbol hash with ':node_type', :value,:tree properties
+    def parameter_definitions
       parameter_def = parameters
       return [] unless  parameter_def
       parameter_def[:value] 
     end
+
+    def declaration_definitions
+      []
+    end
+
+    # Symbols defined in this node. They include parameters
+    # and declarations (normally only in procedure)
+    def symbol_definitions
+      # unique b
+      return parameter_definitions + declaration_definitions
+    end
+    
   end
 
   class Macro < Callable
   end
 
   class Procedure < Callable
+
+    # @return [Nil|ProcVariables] of variable definition node for procedure
+    def procedure_variables_node
+      tree_nodes = recursive_select(Sexp::ProcVariables)
+      return tree_nodes.first if tree_nodes
+    end
+
+    # @return [VariableDef:Array] variable declarations
+    def variable_declarations
+      return [] unless procedure_variables_node
+      return procedure_variables_node.recursive_select(Sexp::VariableDef)
+    end
+
+    def procedure_variables
+      # node = procedure_variables_node
+      # return node.value if node
+      variable_declarations.map { |variable_declaration| variable_declaration.variable.value }
+    end
+    
+
+    # overrides method in parent to return decclartions in 
+    # @return [VariableDef:Array] of variable definition, empty array if no definition
+    def declaration_definitions
+      declaration_def = procedure_variables
+      return [] unless declaration_def.any?
+      declaration_def
+    end
+    
+    
   end
 
   class OperatorDef < Callable
@@ -1016,6 +1106,12 @@ module Sexp
     def name
       recursive_select(Sexp::Identifier).first.node_value
     end
+
+    # @return [Identifier] tree node for variable defined
+    def variable
+      tree_nodes = recursive_select(Sexp::Identifier).first      
+    end
+    
     
     # @return [Expression] tree node for init expression
     def init

data/lib/parser/parser_sexp.treetop

@@ -40,9 +40,16 @@ rule callable
 end
 
 rule procedure
+       'procedure' space? identifier ( '(' space? identifier_list? ')' <Parameters> ) space* procedure_variables? &'{' statement  space* ';'? <Procedure>
+end
+
 
-       'procedure' space? identifier ( '(' space? identifier_list? ')' <Parameters> ) space? &'{' statement  space* ';'? <Procedure>
+rule procedure_variables
+    ('variable' / 'variables') space* procedure_variable_decl  (procedure_variables_tail* <NonTerminal>) ';' space* <ProcVariables>
+end
 
+rule procedure_variables_tail
+    ',' space* procedure_variable_decl <NonTerminal>
 end
 
 rule macro
@@ -122,8 +129,9 @@ rule primary_expression
       unit_expression space* ( unit_expression_tail* <UnitExpression> ) <PrimaryExpression>
 end
 
+
 rule unit_expression
-   sequence_expression / set_expression / set_expression_map / record_expression / operator_expression / quantify_expression / choose_expression
+   sequence_expression / set_expression / set_expression_map / set_constructor / record_expression / operator_expression / quantify_expression / choose_expression / if_expression
      / identifier 
      / record_self
      / original_value
@@ -144,10 +152,11 @@ end
 
     
 rule record_expression
-    &( '[' space* identifier space* 'EXCEPT' ) '[' space* record_except ']' <RecordExcept> 
+    &( '[' space*  record_expression_base 'EXCEPT' ) '[' space* record_except ']' <RecordExcept> 
     / '['  space? record_expression_element?  ']'                           <RecordDefinition>
 end
 
+
 rule record_expression_element
 
      ( identifier space?  '|->' space? expression <RecordElement>)  space? record_expression_element_tail? <NonTerminal>
@@ -159,9 +168,14 @@ rule record_expression_element_tail
 end    
 
 rule record_except
-    ( identifier space*   'EXCEPT' <RecordExceptIdentifier>) space*  (lvalue space*  '='  space*  expression space* <RecordExceptField>) ( record_except_tail* <RecordExceptField>) <NonTerminal>
+    ( record_expression_base 'EXCEPT' <RecordExcepBase>) space*  (lvalue space*  '='  space*  expression space* <RecordExceptField>) ( record_except_tail* <RecordExceptField>) <NonTerminal>
+end
+
+rule record_expression_base
+     expression space* <NonTerminal>
 end
 
+
 rule record_except_tail
       ',' space*  lvalue space*  '=' space*  expression  <Root>
 end
@@ -171,7 +185,15 @@ rule choose_expression
      'CHOOSE' space* bound_expression space* ':' space* expression <ChooseExpression>
 
 end                                  
-                                   
+
+rule if_expression
+     'IF' (space* expression <IfExpressionCondition> ) space* 'THEN' (space* expression <IfExpressionThen>) if_expression_else?  <IfExpression>
+end
+
+rule if_expression_else
+ 'ELSE' space* expression <IfExpressionElse>
+end
+
 rule quantify_expression
      quantify_operator space?  ( quantify_expression_bound+  <BindsInExpression>) ':' space?  space? expression <QuantifyExpression>
 end
@@ -193,8 +215,13 @@ rule set_expression_map
 
 end
 
+
 rule set_expression
-    '{' space*  ( bound_expression ':' space*  <BoundInExpression> )?  (space* expression? <SetExpressionDef>)  '}' <SetExpression>
+    '{' space*  ( bound_expression ':' space*  <BoundInExpression> )  (space* expression? <SetExpressionDef>)  '}' <SetExpression>
+end
+
+rule set_constructor
+    '{' space* expression_list? space*  '}' space* <SetConstructor>
 end
 
 rule bound_expression
@@ -215,7 +242,7 @@ end
 # unlabeled statements
 
 rule unlabeled_statement 
-   goto / print / return_statement / skip / call / assignment_statement / compound_statement / assert /either / conditional / macro_call 
+   assignment_statement / compound_statement / either / conditional / macro_call / return_statement / skip / assert / goto / print / call 
 end
 
 rule conditional
@@ -281,16 +308,31 @@ rule call
 end
 
 rule skip
-    'skip'  <Skip>
+    'skip' <Skip>
 end
 
 # ------------------------------------------------------------------
 # variable
 
 rule variable
-     identifier space?  '=' space? expression space* ';'?  <VariableDef>
+     variable_decl_with_init ';'?  <VariableDef>     
 end
 
+rule procedure_variable_decl
+     variable_decl_with_init / variable_decl_without_init
+end
+
+
+rule variable_decl_with_init
+     identifier space* '=' space? expression space* <VariableDef>
+end
+
+rule variable_decl_without_init
+     identifier space* <VariableDef>
+end
+
+
+
 
 # ------------------------------------------------------------------
 # elementary

data/lib/semantics/context.rb

@@ -197,16 +197,33 @@ module TlaParserS
     # @return see 'resolveStatement'
     def resolveDefine( defineNode )
       # @logger.debug "resolveDefine starting callable=#{defineNode.inspect}"
-      
+
+      ret = nil
       pushContext( defineNode )
       # dumpContext
       if  defineNode.respond_to?( :body_node  ) then
+        # macro, procedure, operatordef
         @logger.info( "#{__method__} start with resolveStatement for #{defineNode.body_node}" )
         if defineNode.body_node.is_a?(Sexp::Expression)
+          # operator
           ret = resolveExpression( defineNode.body_node )
         else
+          # macro, procedure
           ret = resolveStatement( defineNode.body_node )
         end
+        # resolve expressions initializing variable declarations
+        if defineNode.respond_to?(:variable_declarations)
+          sret = []
+          defineNode.variable_declarations.each do |variable_declaration|
+            sret = sret.concat( resolveExpression( variable_declaration.init ))
+          end
+          # add resolved symbols from declaration init only if symbol
+          # not already resolved
+          sret.each do |s|
+            ret << s unless ret.map { |r| r[:symbol] }.include?( s[:symbol]) 
+          end
+        end
+        # puts "sret found=#{sret}, ret=#{ret}" if sret.any?
       elsif defineNode.respond_to?( :init  ) then
         @logger.info( "#{__method__} start with  resolveExpression #{defineNode.init}" )        
         ret = resolveExpression( defineNode.init )
@@ -255,6 +272,18 @@ module TlaParserS
             sret = sret.concat( resolveExpression( tuple_expr ))
           end
           ret = ret.concat( sret )
+        when "IfExpression"
+          @logger.debug( "#{__method__} IfExpression: enode=#{enode.inspect}" )
+          sret = resolveExpression( enode.condition_node )
+          ret.concat( sret )          
+          @logger.info( "#{__method__} IfExpression: condition-expr=#{sret}" )
+          sret = resolveExpression( enode.then_expression_node )
+          ret.concat( sret )
+          @logger.info( "#{__method__} IfExpression: then-expr=#{sret}" )          
+          sret = []
+          sret = resolveExpression( enode.else_expression_node ) if enode.else_expression_node 
+          ret.concat( sret )
+          @logger.info( "#{__method__} IfExpression: els-expr=#{sret}" )                    
         when "ChooseExpression"
           @logger.debug( "#{__method__} ChooseExpression: enode=#{enode.inspect}" )
           @logger.debug( "#{__method__} ChooseExpression: enode.binds_node=#{enode.binds_node}" )
@@ -275,16 +304,24 @@ module TlaParserS
           @logger.info( "#{__method__} RecordDefinition: resolved sret=#{sret.map {|e| { e[:symbol] => e[:resolved] ? e[:resolved][:symbol_type]+':'+e[:resolved][:context] : nil} }}" )                    
           ret = ret.concat( sret )
         when "RecordExcept"
-          # resolve where identier poinst
-          id = enode.record_identifier
-          ret << resolvedIdentifier( id, symbol_table.resolveContext( id ) )
-          @logger.debug( "#{__method__} RecordExcept: id=#{id}, ret=#{ret}" )
+          # resolve where base expression
+          # id = enode.record_identifier
+          # ret << resolvedIdentifier( id, symbol_table.resolveContext( id ) )
+          bret = resolveExpression( enode.record_base )
+          ret = ret.concat( bret )
+          @logger.debug( "#{__method__} RecordExcept: record_base -->=#{bret}" )
           sret = []
           # resolve EXCEPT constructor field rvalue expression
           enode.record_field_definitions && enode.record_field_definitions.each do |field_definition|
             sret = sret.concat( resolveExpression( field_definition.rvalue_expression ))
           end
           ret = ret.concat( sret )
+        when "SetConstructor"
+          sret = []
+          enode.set_elements && enode.set_elements.each do |set_element|
+            sret = sret.concat( resolveExpression( set_element ))
+          end
+          ret = ret.concat( sret )
         when "SetExpressionMap"
           @logger.debug( "#{__method__} SetExpressionMap: enode=#{enode.inspect}" )
           # resolve set mapped

data/lib/semantics/resolver.rb

@@ -207,10 +207,12 @@ module TlaParserS
         break if unResolved.empty?
         # next to resolve
         entryPoint = unResolved.to_a.shift
+        @logger.info( "#{__method__} next to resolve entryPoint #{entryPoint} " )              
+        next if resolved.include?( entryPoint )
 
         # array of hashes how entry point is resolved
         resolvedSymbols = resolveEntryPoint( entryPoint )
-        @logger.debug( "#{__method__} entryPoint #{entryPoint} ->resolvedSymbols=#{resolvedSymbols}" )      
+        @logger.info( "#{__method__} entryPoint #{entryPoint} ->resolvedSymbols=#{resolvedSymbols}" )      
 
         resolvedModules =                  # array of mod.names
           resolvedSymbols.                 # { :symbol=>, :resolved=> }

data/spec/fixtures/resolver1/op3.tla

@@ -0,0 +1 @@
+op3 == op2 \/ op1

data/spec/fixtures/resolver1/proc10.tla

@@ -0,0 +1,8 @@
+procedure proc10()
+    variable z=op3,a;
+    
+{
+   call proc1( z, a );
+   
+}
+

data/spec/fixtures/resolver1/proc8.tla

@@ -0,0 +1,6 @@
+procedure proc8()
+    variable z;
+{
+   call proc1( z );
+}
+

data/spec/fixtures/resolver1/proc9.tla

@@ -0,0 +1,6 @@
+procedure proc9()
+    variable z=op1;
+{
+   call proc1( z );
+}
+

data/spec/fixtures/resolver1/set_constrcutore.tla

@@ -0,0 +1 @@
+set_constrcutore = {  1, "Hello", var4 }

data/spec/fixtures/resolver1/var_if.tla

@@ -0,0 +1,3 @@
+var_if = IF op1 THEN var4 ELSE var5
+
+

data/spec/fixtures/resolver1/var_if_no_else.tla

@@ -0,0 +1,3 @@
+var_if_no_else = IF op1 THEN var4
+
+

data/spec/fixtures/resolver1/var_rec_except2.tla

@@ -0,0 +1,4 @@
+var_rec_except2 = [ op2(var5) EXCEPT ![id] = op1, ![uid] = @ ]
+
+
+

data/spec/parser/parser_spec.rb

@@ -125,7 +125,8 @@ describe  TlaParserS::Parser do
         rvalue_expression = field_node.rvalue_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
         elements << "#{lvalue_expression}=#{rvalue_expression}"
       end
-      ret = "[#{node.record_identifier} EXCEPT #{elements.join(',')}]"
+      record_base = node.record_base.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      ret = "[#{record_base} EXCEPT #{elements.join(',')}]"
       # puts "RecordExcept=>#{ret}"
       ret
     when "RecordDefinition"
@@ -149,7 +150,14 @@ describe  TlaParserS::Parser do
       # puts "SetExpression: bind_var=#{bind_var}"
       
       return "{#{set_expression}: #{bind_var} \\in #{bind_set}}"
-      
+
+    when "SetConstructor"
+      set_elements = []
+      node.set_elements && node.set_elements.each do |set_element|
+        set_elements << set_element.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      end
+      # puts "SetConstructor: set_elements=#{set_elements}"
+      "{#{ set_elements.join(',')}}"
     when "SetExpression"
       set_expression = nil
       bind_var = nil
@@ -191,6 +199,11 @@ describe  TlaParserS::Parser do
       
       "#{node_val}(#{arguments.join(',')})#{ record_field ? "." + record_field : ''}"
 
+    when "IfExpression"
+      condition_expression = node.condition_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      then_expression = node.then_expression_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      else_expression = node.else_expression_node && node.else_expression_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }            
+      "IF #{condition_expression} THEN #{then_expression}#{ else_expression ? ' ELSE ' + else_expression : ''}"
     when "ChooseExpression"
         bind_set = node.binds_node.bind_set.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
         bind_var = node.binds_node.bind_var.node_value
@@ -644,6 +657,7 @@ describe  TlaParserS::Parser do
         :expect => "macro1()", 
       },
       
+      
       {
         :str => "macro2(  1,A )",
         :desc => "macro call with actual parameters",
@@ -652,6 +666,69 @@ describe  TlaParserS::Parser do
         :exception => nil,
         :expect => "macro2(1,A)", 
       },
+
+      {
+        :str => 'return_error(1,A)',
+        :desc => "macro starting with reserved word 'return'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "return_error(1,A)", 
+      },
+      
+      {
+        :str => 'skip_error(1,A)',
+        :desc => "macro starting with reserved word 'skip'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "skip_error(1,A)", 
+      },
+      
+      {
+        :str => 'assert_error(1,A)',
+        :desc => "macro starting with reserved word 'assert'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "assert_error(1,A)", 
+      },
+      
+      {
+        :str => 'goto_error(1,A)',
+        :desc => "macro starting with reserved word 'goto'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "goto_error(1,A)", 
+      },
+      
+      {
+        :str => 'print_error(1,A)',
+        :desc => "macro starting with reserved word 'print'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "print_error(1,A)", 
+      },
+      
+      {
+        :str => 'call_error(1,A)',
+        :desc => "macro starting with reserved word 'call'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "call_error(1,A)", 
+      },
+      
+      {
+        :str => 'either_error(1,A)',
+        :desc => "macro starting with reserved word 'either'",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "either_error(1,A)", 
+      },
       
       {
         :str => "print   1",
@@ -1059,6 +1136,21 @@ describe  TlaParserS::Parser do
         :expect => '{1}',
       },
       
+      {
+        :str => '{ 1, 2 }',        
+        :desc => "Set two integer elements",
+        :start => :expression,
+        :debug => false,
+        :expect => '{1,2}',
+      },
+      
+      {
+        :str => '{ 1, "hello", A }',        
+        :desc => "Set constrcutor with integer, string, identifier",
+        :start => :expression,
+        :debug => false,
+        :expect => '{1,"hello",A}',
+      },
       
       {
         :str => '{ x  \in Set: TRUE }',        
@@ -1243,6 +1335,14 @@ describe  TlaParserS::Parser do
         :expect => '[v_ids EXCEPT ![id]=a]',
       },
 
+      {
+        :str => '[  op(TRUE) EXCEPT ![id] = a ] ',        
+        :desc => "Record except using operator",
+        :start => :expression,
+        :debug => false,
+        :expect => '[op(TRUE) EXCEPT ![id]=a]',
+      },
+
       {
         :str => '[  v_ids EXCEPT ![id] = a ] . fiildi [ aa ] ',        
         :desc => "Record except with record access)",
@@ -1293,6 +1393,22 @@ describe  TlaParserS::Parser do
         :expect => 'CHOOSE x \in t_Owner: 1+2',
       },
 
+      {
+        :str => 'IF 1=2 THEN   FALSE   ELSE   TRUE',        
+        :desc => "IF expression",
+        :start => :expression,
+        :debug => false,
+        :expect => 'IF 1=2 THEN FALSE ELSE TRUE',
+      },
+
+      {
+        :str => 'IF 1=2  THEN  (2=2)',        
+        :desc => "IF expression no elese",
+        :start => :expression,
+        :debug => false,
+        :expect => 'IF 1=2 THEN (2=2)',
+      },
+
       {
         :str => 'elementti \in Set',        
         :desc => "Expr in setup ",
@@ -1532,6 +1648,16 @@ describe  TlaParserS::Parser do
           :expect => "1",
         },
         
+        {
+          :str => "a = id",
+          :desc => "Init to identitifer",
+          :start => :variable,
+          :exception => nil,
+          :debug => false,
+          :expect => "id",
+        },
+
+        
       ].each_with_index do |testCase,i|
         
         it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
@@ -1541,6 +1667,7 @@ describe  TlaParserS::Parser do
             puts tree.inspect
           end
           expect( tree ).not_to eql( nil ) unless testCase[:exception]
+
           expect( tree.init.traverse { |memo, node_type, enode, node_val|
                   memo.concat( expression_value( node_type, enode, node_val  ))
                   } ).to eql( testCase[:expect] )
@@ -1570,6 +1697,22 @@ describe  TlaParserS::Parser do
           :debug => false,
           :expect => true,
         },
+        {
+          :str => "procedure proc(a) variable a=0; {}",
+          :desc => "Procedure with variable ",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+        {
+          :str => "procedure proc(a,b) variable v1=0,v2; {}",
+          :desc => "Procedure with two variables",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
         {
           :str => "procedure id(){}",
           :desc => "Procedure ",

data/spec/semantics/context_spec.rb

@@ -233,7 +233,72 @@ describe  TlaParserS::Context do
           :expect => [{"proc1" => "Procedure:Snippets" }, { "macro1" => "Macro:Snippets" } ],
         },
 
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          EOS
+          ],
+          :callable => "procedure procci() variable a=0; { call proc1( a ); macro1(); }",
+          :start => :procedure,
+          :desc => "Call proc, call macro, procedure variable decl with init",
+          :debug => false,
+          :expect_synopsis =>"Resolved in base context definitions ",
+          :expect => [{"proc1" => "Procedure:Snippets" }, {"a"=>"Identifier:procci"}, { "macro1" => "Macro:Snippets" } ],
+        },
+
+
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          EOS
+          ],
+          :callable => "procedure procci() variable a, b=0; { call proc1( a ); macro1(); }",
+          :start => :procedure,
+          :desc => "Call proc, call macro, procedure variable decl without init",
+          :debug => false,
+          :expect_synopsis =>"Resolved in base context definitions ",
+          :expect => [{"proc1" => "Procedure:Snippets" }, {"a"=>"Identifier:procci"}, { "macro1" => "Macro:Snippets" } ],
+        },
+
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          b=1;
+          EOS
+          ],
+          :callable => "procedure procci() variable a=b; { call proc1( a ); macro1(); }",
+          :start => :procedure,
+          :desc => "Call proc, call macro, procedure variable declaration with init",
+          :debug => false,
+          :expect_synopsis =>"Resolved in base context definitions ",
+          :expect => [{"proc1" => "Procedure:Snippets" }, {"a"=>"Identifier:procci"}, { "macro1" => "Macro:Snippets" }, { "b" => "VariableDef:Snippets" } ],
+        },
         
+        {
+          :initialContext => [
+            <<-EOS,
+          procedure proc1() {}
+          macro macro1() {}
+          op1 == TRUE
+          b=1;
+          EOS
+          ],
+          :callable => "procedure procci() variable a=b,c; { call proc1( a ); macro1(b); }",
+          :start => :procedure,
+          :desc => "Call proc, call macro, procedure variable declaration with init",
+          :debug => false,
+          :expect_synopsis =>"Resolved in base context definitions ",
+          :expect => [{"proc1" => "Procedure:Snippets" }, {"a"=>"Identifier:procci"}, { "macro1" => "Macro:Snippets" }, { "b" => "VariableDef:Snippets" } ],
+        },
         {
           :initialContext => [
             <<-EOS,

data/spec/semantics/resolver_spec.rb

@@ -91,13 +91,13 @@ describe  TlaParserS::Resolver do
           :entrypoints => ["proc3"],
           :expect => [ "proc3.tla", "macro1.tla", "variables.tla", "op1.tla", "directives.tla", "directives.cfg" ]
         },
-
+        
         {
           :desc => "Proc4 uses var4",
           :entrypoints => ["proc4"],
           :expect => [ "proc4.tla", "var4.tla", "directives.tla", "directives.cfg" ]
         },
-
+        
         {
           :desc => "Proc4_hide uses var4 -as formal parametr",
           :entrypoints => ["proc4_hide"],
@@ -116,6 +116,24 @@ describe  TlaParserS::Resolver do
           :expect => [ "proc7.tla", "proc6.tla", "directives.tla", "directives.cfg" ]
         },
         
+        {
+          :desc => "proc8 (with variable declaration)",
+          :entrypoints => ["proc8"],
+          :expect => [ "proc8.tla", "proc1.tla", "directives.tla", "macro1.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "proc9 (with variable declaration with init)",
+          :entrypoints => ["proc9"],
+          :expect => [ "proc9.tla", "proc1.tla", "op1.tla", "directives.tla", "macro1.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "proc10 (with two variable declaration with init)",
+          :entrypoints => ["proc10"],
+          :expect => [ "proc10.tla", "proc1.tla", "op3.tla", "directives.tla", "macro1.tla", "op2.tla", "op1.tla", "directives.cfg" ]
+        },
+
         {
           :desc => "Loop proc6->proc7",
           :entrypoints => ["proc6"],
@@ -158,12 +176,36 @@ describe  TlaParserS::Resolver do
           :expect => [ "var_rec_except.tla", "var5.tla", "op1.tla", "directives.tla", "directives.cfg" ]
         },
         
+        {
+          :desc => "Record except with base expression",
+          :entrypoints => ["var_rec_except2"],
+          :expect => [ "var_rec_except2.tla", "op2.tla", "var5.tla", "op1.tla", "directives.tla", "directives.cfg" ]
+        },
+        
         {
           :desc => "Choose x in Set:",
           :entrypoints => ["var_choose_except"],
           :expect => [ "var_choose_except.tla", "op1.tla", "var4.tla", "directives.tla", "directives.cfg" ]
         },
         
+        {
+          :desc => "var = IF THEN ELSE :",
+          :entrypoints => ["var_if"],
+          :expect => [ "var_if.tla", "op1.tla", "var4.tla", "var5.tla", "directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "var = IF THEN :",
+          :entrypoints => ["var_if_no_else"],
+          :expect => [ "var_if_no_else.tla", "op1.tla", "var4.tla","directives.tla", "directives.cfg" ]
+        },
+        
+        {
+          :desc => "Set constructore:",
+          :entrypoints => ["set_constrcutore"],
+          :expect => [ "set_constrcutore.tla", "var4.tla", "directives.tla", "directives.cfg" ]
+        },
+        
         {
           :desc => "Record exression",
           :entrypoints => ["var_rec_expr"],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tla-parser-s
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - jarjuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-03 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -92,7 +92,9 @@ files:
 - spec/fixtures/resolver1/macro2.tla
 - spec/fixtures/resolver1/op1.tla
 - spec/fixtures/resolver1/op2.tla
+- spec/fixtures/resolver1/op3.tla
 - spec/fixtures/resolver1/proc1.tla
+- spec/fixtures/resolver1/proc10.tla
 - spec/fixtures/resolver1/proc2.tla
 - spec/fixtures/resolver1/proc3.tla
 - spec/fixtures/resolver1/proc4.tla
@@ -100,6 +102,9 @@ files:
 - spec/fixtures/resolver1/proc5.tla
 - spec/fixtures/resolver1/proc6.tla
 - spec/fixtures/resolver1/proc7.tla
+- spec/fixtures/resolver1/proc8.tla
+- spec/fixtures/resolver1/proc9.tla
+- spec/fixtures/resolver1/set_constrcutore.tla
 - spec/fixtures/resolver1/stmt_assert.tla
 - spec/fixtures/resolver1/stmt_assign.tla
 - spec/fixtures/resolver1/stmt_assign2.tla
@@ -109,8 +114,11 @@ files:
 - spec/fixtures/resolver1/var4.tla
 - spec/fixtures/resolver1/var5.tla
 - spec/fixtures/resolver1/var_choose_except.tla
+- spec/fixtures/resolver1/var_if.tla
+- spec/fixtures/resolver1/var_if_no_else.tla
 - spec/fixtures/resolver1/var_quantify.tla
 - spec/fixtures/resolver1/var_rec_except.tla
+- spec/fixtures/resolver1/var_rec_except2.tla
 - spec/fixtures/resolver1/var_rec_expr.tla
 - spec/fixtures/resolver1/var_record.tla
 - spec/fixtures/resolver1/var_seq.tla