tla-parser-s 0.1.0

data/lib/parser/parser_sexp.treetop

@@ -0,0 +1,442 @@
+# coding: utf-8
+grammar Sexp
+
+# ------------------------------------------------------------------
+# Default starting point we will parse TLA+ snippets
+
+rule snippets
+  ( space /  directive space?  <Snippet>/ callable space? <Snippet> / variable space?  <Snippet>)*  <Snippets>
+end
+
+# ------------------------------------------------------------------
+# directive
+
+rule directive
+     invariants / assumptions
+end
+
+rule assumptions
+    'ASSUME' space? identifier (assumption* <Assumption> ) <Assumption>
+end
+
+rule assumption
+    space? identifier <NonTerminal>
+end
+    
+rule invariants
+    'INVARIANT' space? identifier (invariant* <Invariant> ) <Invariant>
+end
+
+rule invariant
+    space? identifier <NonTerminal>
+end
+
+    
+# ------------------------------------------------------------------
+# callable
+
+rule callable
+     procedure / macro / operator
+end
+
+rule procedure
+
+       'procedure' space? identifier ( '(' space? identifier_list? ')' <Parameters> ) space? &'{' statement  space* ';'? <Procedure>
+
+end
+
+rule macro
+
+      'macro' space? identifier space?
+      ( '(' space?  identifier_list? space? ')' space? <Parameters> )
+      &'{' statement ';'? <Macro>
+
+end
+
+rule operator
+      identifier space?
+      ( '(' space?  identifier_list? ')' space?  <Parameters> )?
+      '==' space? expression <OperatorDef>
+end
+
+# ------------------------------------------------------------------
+# Formal parameters (for macro & procedure definitions)
+
+
+rule identifier_list
+    identifier space? identifier_list_tail? <IdentifierList>
+end
+
+# Right recursive rule
+rule identifier_list_tail
+    ',' space? identifier_list <NonTerminal>
+end
+
+# ------------------------------------------------------------------
+# actual parameters
+
+rule expression_list
+     expression expression_list_tail? <ExpressionList>
+end
+
+rule expression_list_tail
+      ',' space? expression_list <NonTerminal>
+end
+
+# ------------------------------------------------------------------
+# Expression
+
+rule expression
+
+    additive_expression space? <Expression>
+  
+end
+
+rule additive_expression
+
+   multitive_expression space?  additive_expression_tail? <AdditiveExpression>
+
+end
+
+rule additive_expression_tail
+   additive_operator space? additive_expression <AdditiveExpression>
+end
+
+rule multitive_expression
+
+   # primary_expression space? multitive_expression_tail? <MultitiveExpression>
+   unary_expression space? multitive_expression_tail? <MultitiveExpression>                           
+
+end
+
+rule multitive_expression_tail
+   multitive_operator space?  multitive_expression  <MultitiveExpression> 
+end
+
+rule unary_expression
+     unary_operator space? primary_expression <UnaryExpression>  /  primary_expression 
+end
+
+
+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
+     / identifier 
+     / record_self
+     / original_value
+     / string / integer / (  '(' space? expression space? ')' <ParenthesisExpression>)  <UnitExpression> 
+
+end
+
+rule unit_expression_tail                                   
+
+    '.' space* identifier space*  <FieldByName>  / '[' space* unit_expression space* ']' space* <FieldByValue> 
+
+end
+
+                                   
+rule operator_expression
+     identifier space? '(' space? expression_list?  space? ')'  <OperatorExpression>
+end
+
+    
+rule record_expression
+    &( '[' space* identifier space* '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>
+
+end
+
+rule record_expression_element_tail
+     ',' space? record_expression_element <NonTerminal>
+end    
+
+rule record_except
+    ( identifier space*   'EXCEPT' <RecordExceptIdentifier>) space*  (lvalue space*  '='  space*  expression space* <RecordExceptField>) ( record_except_tail* <RecordExceptField>) <NonTerminal>
+end
+
+rule record_except_tail
+      ',' space*  lvalue space*  '=' space*  expression  <Root>
+end
+
+rule choose_expression
+
+     'CHOOSE' space* bound_expression space* ':' space* expression <ChooseExpression>
+
+end                                  
+                                   
+rule quantify_expression
+     quantify_operator space?  ( quantify_expression_bound+  <BindsInExpression>) ':' space?  space? expression <QuantifyExpression>
+end
+
+rule quantify_expression_bound
+     bound_expression space?  quantify_expression_bound_tail?  <BindsInExpression>                                                                           
+end
+
+rule quantify_expression_bound_tail
+      ',' space? quantify_expression_bound <BindsInExpression>
+end
+
+rule sequence_expression
+    '<<' space* expression_list? space* '>>' <SequenceExpression>
+end
+
+rule set_expression_map
+    '{'  ( space*   expression space*  <SetExpressionDef>) ':'  ( space* bound_expression  <BoundInExpression> ) '}' <SetExpressionMap>
+
+end
+
+rule set_expression
+    '{' space*  ( bound_expression ':' space*  <BoundInExpression> )?  (space* expression? <SetExpressionDef>)  '}' <SetExpression>
+end
+
+rule bound_expression
+    identifier space* '\in' space+ 'DOMAIN'? space? expression  space* <BoundInExpression> 
+end
+
+
+
+# ------------------------------------------------------------------
+# statement
+
+rule statement
+    space* (identifier ':' space*  <Label>)? unlabeled_statement space*  <Statement>
+end
+
+
+# ------------------------------------------------------------------
+# unlabeled statements
+
+rule unlabeled_statement 
+   goto / print / return_statement / skip / call / assignment_statement / compound_statement / assert /either / conditional / macro_call 
+end
+
+rule conditional
+   'if' space* '(' space* expression space* ')' space* statement conditional_else?  <Conditional>
+end
+    
+rule conditional_else
+     'else' statement  <Statement>
+end
+
+rule assignment_statement
+
+  lvalue ':='  space* expression <Assignment>
+    
+end
+
+
+rule lvalue
+    primary_expression space* <LValue>                  
+end
+
+
+rule compound_statement
+    '{' space* ( compound_statement_list* <StatementList>) space* '}'    <CompoundStatement>
+end
+
+rule compound_statement_list
+     statement ';' <StatementList>
+end
+
+rule goto
+    'goto' space* identifier <Goto>
+end
+
+rule print
+    'print' space* expression <Print>
+end
+
+rule either
+    'either' space* statement space* (either_list+  <StatementList>)  <Either>
+end
+
+rule either_list
+     'or' space* statement <StatementList>
+end
+
+rule assert
+    'assert' space* expression <Assert>
+end
+
+rule return_statement
+    'return' <Return>
+end
+
+
+rule macro_call
+    identifier space? "(" space* expression_list? space* ")" <MacroCall>
+end
+
+
+rule call
+    'call' space? identifier space? "(" space? expression_list? space? ")" <Call>
+end
+
+rule skip
+    'skip'  <Skip>
+end
+
+# ------------------------------------------------------------------
+# variable
+
+rule variable
+     identifier space?  '=' space? expression space* ';'?  <VariableDef>
+end
+
+
+# ------------------------------------------------------------------
+# elementary
+
+rule identifier
+     !reserved_word name <Identifier>
+end
+
+rule record_self
+      '!' <Self>
+end                                                            
+    
+rule original_value
+      '@'     <OriginalValue>
+end
+                                
+
+rule name
+    [_A-Za-z] [_A-Za-z0-9]*
+end
+
+rule string
+     '"' [^"]* '"'  <StringValue>
+end
+
+rule integer
+    ('+'/'-')? [0-9]+  <IntegerValue>
+end
+
+# ------------------------------------------------------------------
+# atoms
+
+rule multitive_operator
+   '/\\' <Operator> /   '/' <Operator> /  '*' <Operator> / '\cap' <Operator> / '\intersect' <Operator> / '\in' <Operator>
+end
+
+rule additive_operator
+  "=>" <Operator>  /   '#'  <Operator> /
+   '<=>'  <Operator> / 
+   '>='  <Operator> /  '>'  <Operator> /  '='  <Operator> / 
+   '<='  <Operator> /  '<'  <Operator> /
+   '-'  <Operator> /  '+'  <Operator>
+  / '\/' <Operator>   /  '\cup'  <Operator>  /  '\union'  <Operator> 
+  /  '\\'  <Operator> 
+end
+
+rule unary_operator
+    '-'  <Operator> /  '+'  <Operator> / "\\lnot" <Operator> / "~" <Operator>
+end
+
+rule quantify_operator
+     '\\A' <Operator> / '\\E' <Operator>
+end
+
+rule reserved_word
+        "ASSUME"  <ReservedWord> /
+        "ELSE"  <ReservedWord> /
+        "LOCAL"  <ReservedWord> /
+        "UNION"  <ReservedWord> /
+        "ASSUMPTION"  <ReservedWord> /
+        "ENABLED"  <ReservedWord> /
+        "MODULE"  <ReservedWord> /
+        "AXIOM"  <ReservedWord> /
+        "EXCEPT"  <ReservedWord> /
+        "OTHER"  <ReservedWord> /
+        "VARIABLES"  <ReservedWord> /
+        "VARIABLE"  <ReservedWord> /
+        "CASE"  <ReservedWord> /
+        "EXTENDS"  <ReservedWord> /
+        "SF_"  <ReservedWord> /
+        "WF_"  <ReservedWord> /
+        "CHOOSE"  <ReservedWord> /
+        "IF"  <ReservedWord> /
+        "SUBSET"  <ReservedWord> /
+        "WITH"  <ReservedWord> /
+        "INSTANCE"  <ReservedWord> /
+        "IN"  <ReservedWord> /
+        "THEN"  <ReservedWord> /
+        "CONSTANTS"   <ReservedWord> /
+        "CONSTANT"  <ReservedWord> /
+        "THEOREM"  <ReservedWord> /
+        "COROLLARY"  <ReservedWord> /
+        "DOMAIN"  <ReservedWord> /
+        "LET"  <ReservedWord> /
+        "UNCHANGED"  <ReservedWord> /
+        "BY"  <ReservedWord> /
+        "HAVE"  <ReservedWord> /
+        "QED"  <ReservedWord> /
+        "TAKE"  <ReservedWord> /
+        "HIDE"  <ReservedWord> /
+        "RECURSIVE"  <ReservedWord> /
+        "USE"  <ReservedWord> /
+        "DEFINE"  <ReservedWord> /
+        "PROOF"  <ReservedWord> /
+        "WITNESS"  <ReservedWord> /
+        "PICK"  <ReservedWord> /
+        "DEFS"  <ReservedWord> /
+        "DEF"  <ReservedWord> /
+        "PROVE"  <ReservedWord> /
+        "SUFFICES"  <ReservedWord> /
+        "NEW"  <ReservedWord> /
+        "LAMBDA"  <ReservedWord> /
+        "STATE"  <ReservedWord> /
+        "ACTION"  <ReservedWord> /
+        "TEMPORAL"  <ReservedWord> /
+        "OBVIOUS"  <ReservedWord> /
+        "OMITTED"  <ReservedWord> /
+        "LEMMA"  <ReservedWord> /
+        "PROPOSITION"  <ReservedWord> /
+        "ONLY"   <ReservedWord>
+  
+end
+
+
+# ------------------------------------------------------------------
+# spaces && comments
+
+rule space
+   whitespace / newline / comment
+end
+
+rule whitespace
+    [\s]+
+end
+
+rule newline
+    [\n]+
+end
+
+rule comment
+   line_comment / block_comment
+end
+
+# New may be missing on last line on a file
+rule line_comment
+   '\\*' [^\n]* [\n]?
+end
+
+rule block_comment
+   '(*' 
+
+     (
+         !'*)'
+        (. / "\n")
+     )*
+   '*)' space?
+end
+
+end

data/lib/semantics/context.rb

@@ -0,0 +1,355 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module TlaParserS
+  
+  # ******************************************************************
+  # 
+  # Manage context to parse TLA+ snippets
+  #
+  #
+  # Builds context in three phases:
+  #
+  # 1) Initial context includes TLA+ standard definitions e.g. TRUE, FALSE
+  #    when context is created
+  # 2) Global context includes snippets defining macros, procedures,
+  #    operators, and variables. Using pushContext/addContext
+  # 3) During resolve phase push to context formal parameters, quantification
+  #    bind variables, variables in set constructor generator. Uses
+  #    pushContext/addContext methods internally from 'resolveDefine',
+  #
+  # 
+  # ******************************************************************
+
+  class Context
+    
+    extend Forwardable                      # for easy delegation
+
+    attr_accessor :symbol_table
+    
+    def_delegators :symbol_table, :currentContext, :dumpContext,
+    :popContext, :entries, :resolveModule
+
+    # ------------------------------------------------------------------
+    # Logger
+    
+    PROGNAME = "context"                   # progname for logger
+    include TlaParserS::Utils::MyLogger    # mix logger
+
+    # # TLA+ standar library symbols
+    
+    # GLOABLS = %w( TRUE FALSE )
+    
+
+    # ------------------------------------------------------------------
+    # constructore
+    def initialize( options={} )
+      
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+
+      initContext
+    end
+
+    # ------------------------------------------------------------------
+    # manage context
+
+    def initContext
+      @symbol_table = SymbolTable.new
+
+      # # create context for standar library && add entries
+      # @symbol_table.pushContext( nil )
+      # GLOABLS.each do |global|
+      #   entry = {
+      #     :context_type => "Init",
+      #     :context => "Global",
+      #     :symbol_type => "StandardLib",        
+      #     :symbol_name =>  global,
+      #   }
+
+      #   @symbol_table.addEntry( entry )
+      # end
+      return self      
+    end
+
+    # Create new context in symbol table && add etnries
+    def initEntries( entries )
+      
+      return unless entries && entries.any?
+
+      # create new context
+      pushContext
+
+      # add entries
+      entries.each do |entry|
+        @symbol_table.addEntry( entry )        
+      end
+      
+    end
+    
+
+    # Add more symbols to current context levell
+    #
+    def addContext( snippets, moduleName=nil )
+      symbol_table.addContext( snippets, moduleName )
+      return self
+    end
+    
+
+    # Add one level to context & and add snipets there
+    #
+    # @param snippets [SyntaxNode] implementing 'symbol_definitions` method
+    # 
+    def pushContext( snippets=nil, moduleName=nil )
+      warn "Method symbol_definitions not implemented on #{snippets}"  if  snippets && !snippets.respond_to?(:symbol_definitions)
+      symbol_table.pushContext( snippets, moduleName )
+      return self
+    end
+
+
+    # @param symbol [String] to resolve
+    # @return [Hash] with :symbol, :resolved properties
+    def resolveSymbol( symbol )
+      resolved = symbol_table.resolveContext( symbol )
+      return     {
+        :symbol => symbol,
+        :resolved => resolved,
+      }
+    end
+
+    # ------------------------------------------------------------------
+    # Resolver
+
+    # @param stmt [Statement] parse tree node for statement  to resolve
+    # @return see 'resolveExpression'
+    private def resolveStatement( stmt, ret=[] )
+
+      stmt.traverse(ret) do |ret,node_type, node|
+        @logger.debug( "#{__method__}: enter node_type=#{node_type}, #{node.text_value}ret=#{ret}." )
+        case node_type
+        when "Statement"
+        when "Skip"
+        when "Return"          
+        when "Goto"
+        when "Identifier"
+          @logger.debug( "#{__method__}: Identifier node=#{node.inspect}" )          
+          ret.concat( resolveExpression( node ))
+        when "Conditional"
+          ret.concat( resolveExpression( node.condition ))
+          @logger.debug( "#{__method__}: Conditional if_true=#{node.if_true.inspect}" )                    
+          ret.concat( resolveStatement( node.if_true, ret ))
+          ret.concat( resolveStatement( node.if_not_true, ret )) if node.if_not_true
+        when "Either"
+          ret = node.choices.each { |s| resolveStatement( s, ret ) }
+        when "Assert"
+          ret.concat( resolveExpression( node.assertion ))          
+        when "Assignment"
+          lvalue = node.lvalue
+          @logger.debug( "#{__method__}: Assignment lvalue=#{lvalue.inspect}" )                              
+          ret.concat( resolveExpression( node.lvalue.expression ) )
+          ret.concat( resolveExpression( node.rvalue ))
+          # lvalue = node.lvalue.node_value
+          # @logger.debug( "#{__method__}: Assign lvalue=#{lvalue}" )
+          # # take just first variable
+          # lvalue = lvalue.split( /[.\[]/ ).first
+          # ret <<  resolvedIdentifier( lvalue, symbol_table.resolveContext( lvalue ))
+          # # resovel expression
+          # ret.concat( resolveExpression( node.rvalue ))
+        when "Print"
+          @logger.debug( "#{__method__}: Print node=#{node.inspect}" )
+          sret = resolveExpression( node.print_expression )
+          @logger.debug( "#{__method__}: Print sret=#{sret}" )          
+          ret = ret.concat( sret )
+        when "CompoundStatement"
+          ret = node.statements.each { |s| resolveStatement( s, ret ) }
+          # sret = []
+          # node.statements.each { |s| sret = resolveStatement( s, sret ) }
+          # ret.concat( sret )
+        when "MacroCall"
+          # resolve macro definition
+          ret << resolvedIdentifier( node.called, symbol_table.resolveContext( node.called ) )
+          # resolve actual parameters
+          node.actual_parameters.each do |expr_node|
+            eret = resolveExpression(expr_node )
+            @logger.debug "actual param eret=#{eret}"
+            ret.concat( eret )
+          end # actual paramtere
+        when "Call"
+          # resolve procedure definition
+          ret << resolvedIdentifier( node.called, symbol_table.resolveContext( node.called ) )
+          # resolve actual parameters
+          ret = node.actual_parameters.each do |expr_node|
+            ret.concat( resolveExpression( expr_node ))
+          end # actual paramtere
+        else
+          msg = "#{__method__}: Unknwon statement node type #{node_type} for node #{node.inspect}" 
+          @logger.warn( msg )
+          warn msg
+        end
+        @logger.debug( "#{__method__}: leave node_type=#{node_type} ret=#{ret}." )      
+        ret
+      end
+      ret
+    end #  def resolveStatement( stmt )
+
+
+    # @return see 'resolveStatement'
+    def resolveDefine( defineNode )
+      # @logger.debug "resolveDefine starting callable=#{defineNode.inspect}"
+      
+      pushContext( defineNode )
+      # dumpContext
+      if  defineNode.respond_to?( :body_node  ) then
+        @logger.info( "#{__method__} start with resolveStatement for #{defineNode.body_node}" )
+        if defineNode.body_node.is_a?(Sexp::Expression)
+          ret = resolveExpression( defineNode.body_node )
+        else
+          ret = resolveStatement( defineNode.body_node )
+        end
+      elsif defineNode.respond_to?( :init  ) then
+        @logger.info( "#{__method__} start with  resolveExpression #{defineNode.init}" )        
+        ret = resolveExpression( defineNode.init )
+        @logger.debug( "#{__method__} resolveExpression-->#{ret}" )        
+      else
+        msg = <<-EOS
+        Unknown tree node object #{defineNode}.
+
+        Should be 'Callabe' or 'VariableDef'
+        EOS
+        @logger.error( "#{__method__} #{msg}" )        
+        raise ContextException.new msg
+        
+      end
+        
+      popContext()
+      ret
+    end
+    
+
+    # @param expression [Expression] parse tree node for exprresion to resolve
+    # @return [Hash:Array] {:symbol,:resolved} hashes, where :resolved is the result
+    # of symbol table lookup
+    def resolveExpression( expr )
+
+      ret = []
+      expr && expr.traverse do |m, node_type, enode, node_val  |
+        @logger.debug( "#{__method__} node_type=#{node_type}, node_val=#{node_val}" )          
+        case node_type
+        when "Identifier"
+          ret << resolvedIdentifier( node_val, symbol_table.resolveContext( node_val ) )
+        when "AdditiveExpression", "MultitiveExpression", "UnaryExpression", "ParenthesisExpression"
+        when "PrimaryExpression"
+          sret = []
+          enode.attribute_accessors && enode.attribute_accessors.each do |identifier|
+            sret = sret.concat( resolveExpression( identifier ))
+          end
+          ret = ret.concat( sret )
+        when "FieldByValue"
+          ret << resolvedIdentifier( node_val, symbol_table.resolveContext( node_val ) )          
+        when "FieldByName"
+        when "SequenceExpression"
+          @logger.debug( "#{__method__} SequenceExpression: enode=#{enode.inspect}" )
+          sret = []
+          enode.tuples && enode.tuples.each do |tuple_expr|
+            sret = sret.concat( resolveExpression( tuple_expr ))
+          end
+          ret = ret.concat( sret )
+        when "ChooseExpression"
+          @logger.debug( "#{__method__} ChooseExpression: enode=#{enode.inspect}" )
+          @logger.debug( "#{__method__} ChooseExpression: enode.binds_node=#{enode.binds_node}" )
+          # bind node defines symbol table
+          pushContext( enode )
+          choose_expression=enode.choose_expression
+          @logger.debug( "#{__method__} ChooseExpression: choose_expression=#{choose_expression.inspect}" )                    
+          sret = resolveExpression( choose_expression )
+          @logger.info( "#{__method__} ChooseExpression: resolved sret=#{sret.map {|e| { e[:symbol] => e[:resolved] ? e[:resolved][:symbol_type]+':'+e[:resolved][:context] : nil} }}" )          
+          ret = ret.concat( sret )
+          popContext()
+        when "RecordDefinition"
+          @logger.debug( "#{__method__} RecordDefinition: enode=#{enode.inspect}" )
+          sret = []
+          enode.record_fields.each do |record_field|
+            sret = sret.concat( resolveExpression( record_field.element_expression ))
+          end
+          @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}" )
+          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 "SetExpressionMap"
+          @logger.debug( "#{__method__} SetExpressionMap: enode=#{enode.inspect}" )
+          # resolve set mapped
+          sret = resolveExpression( enode.binds_node.bind_set )
+          ret = ret.concat( sret )
+          
+          # resolve expression  in set map
+          pushContext( enode )
+          sret = resolveExpression( enode.set_expression )
+          @logger.debug( "#{__method__} SetExpressionMap: resolved sret=#{sret}" )          
+          ret = ret.concat( sret )
+        when "SetExpression"
+          @logger.debug( "#{__method__} SetExpression: enode=#{enode.inspect}" )
+          pushContext( enode )
+          sret = resolveExpression( enode.set_expression )
+          @logger.debug( "#{__method__} SetExpression: resolved sret=#{sret}" )          
+          ret = ret.concat( sret )
+          popContext( )          
+        when "OperatorExpression"
+          @logger.debug( "#{__method__} OperatorExpression: enode=#{enode.inspect}" )
+          operator_name = enode.operator_name
+          ret << resolvedIdentifier( operator_name, symbol_table.resolveContext( operator_name ) )
+          sret = []
+          enode.arguments && enode.arguments.each do |argument_node|
+            sret = sret.concat( resolveExpression( argument_node ))
+          end
+          @logger.info( "#{__method__} OperatorExpression: resolved sret=#{sret.map {|e| { e[:symbol] => e[:resolved] ? e[:resolved][:symbol_type]+':'+e[:resolved][:context] : nil} }}" )          
+          ret = ret.concat( sret )
+          
+        when "QuantifyExpression"
+          
+          @logger.debug( "#{__method__} SetExpression: node.symbol_definitions=#{enode.symbol_definitions}" )
+          pushContext( enode )
+          sret = resolveExpression( enode.binds_nodes.first.bind_set )
+          ret = ret.concat( sret )          
+          @logger.debug( "#{__method__} resolved sret=#{sret}" )                    
+          @logger.debug( "#{__method__} SetExpression: #{enode.quantified_expression.inspect}" )
+          qret = resolveExpression( enode.quantified_expression )
+          @logger.debug( "#{__method__} resolved qret=#{qret}" )          
+          ret = ret.concat( qret )
+          @logger.debug( "#{__method__} resolved ret=#{ret}" )                    
+          popContext( )          
+        when "IntegerValue", "StringValue", "OriginalValue"
+        else
+          
+          msg = "Unknwon expression node type #{node_type} with value #{node_val}"
+          @logger.error( "#{__method__} #{msg}" )        
+          raise ContextException.new msg
+          
+        end
+      end
+      ret 
+    end #  def resolveExpression( expr )
+
+    private
+    # @return {Hash} with {:sybol,:resolved} -properties
+    def resolvedIdentifier( identifier, resolved )
+      { :symbol => identifier, :resolved => resolved }
+    end
+                            
+    
+    
+    
+  end # class
+
+  
+
+end