tla-parser-s 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a18b7ddd5c763aaf63218b27d64c38c71ccf5fb
+  data.tar.gz: 9f343d38938ddcf5cbdfd9abb2a7fcf624f30dee
+SHA512:
+  metadata.gz: 2fd17951f4589debafa7dc2bd69bdf9f02ea6d80e64c93d07d667df66340cb8d41b590ef78353c1509d1dd9db5355e81f6281022f231dd1cfba75fc3c549b3b5
+  data.tar.gz: 2a4f66ab14732a613469b71a576713db8e3a1df4fae94dc9528b69f830b637ed70f143349abe99ea0aa5ecc67b3d34b4239aca7e656d04a42b2d6973776114af

data/README.md

@@ -0,0 +1,75 @@
+<link href="../site.css" rel="stylesheet"></link>
+[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$
+
+A Ruby library for parsing
+[TLA+ language](http://research.microsoft.com/en-us/um/people/lamport/tla/book.html).
+
+## <a id="USAGE">Usage</a>
+
+### Command line interface
+
+Run 
+
+	bin/tla-resolver.rb resolve v_pets --dir-globs demo/*
+
+to parse files in `demo/*`, and to output
+
+	demo/state_pet.tla
+	
+because `v_pets` in defined in module `state_pet.tla`
+
+Run
+
+	bin/tla-resolver.rb resolve enter_pet --dir-globs demo/*
+
+
+to parse files in `demo/*`, and to output
+
+
+	demo/transaction_enter_pet.tla
+	demo/state_pet.tla
+
+because `enter_pet` macro defined in `demo/transaction_enter_pet.tla`
+uses also variable definition `v_pets` defined in `demo/state_pet.tla`.
+
+
+### Api usage
+
+
+
+	require 'tla-parser-s'       # TLA+ parser && resolver
+
+	# create new context resolver
+	resolver =  TlaParserS::Resolver.new( options )
+
+    # Add Globals some constant symbols to resolver (to avoid unresolve warnings)
+    GLOBALS = %w( TRUE FALSE Cardinality)
+    resolver.initContext( GLOBALS )
+
+    # parse snippets in dir '"demo/**./*"'
+    snippet_files = Dir.glob( "demo/**./*" ) 
+    resolver.initSnippets( snippet_files ) do |status, entry|
+        if ! status
+          	warn "Error parsing #{entry} - continue"
+		end
+		# continue
+        true
+	end
+
+    # resolve depencies
+    depencies = resolver.resolveModules( getEntryPoints ) do |type,arr|
+        case type
+		when "start"
+		when "resolved"
+		when "unresolved"
+		else
+			raise "Unkown type #{type}"
+		end
+	end
+
+	# dendencies of 'getEntryPoints' array
+	depencies
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/tla-resolver.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/cli/cli.rb"
+
+TlaParserS::Cli.start
+
+

data/lib/cli/cli.rb

@@ -0,0 +1,90 @@
+require 'thor'
+
+require_relative '../tla-parser-s.rb'
+
+module TlaParserS
+
+  class Cli < Thor
+
+    include TlaParserS::Utils::MyLogger    # mix logger
+    PROGNAME = "main"                      # logger progname
+
+    VERSION_BANNER =  <<-EOS
+    #{File.basename $0} - #{TlaParserS::version}   
+    EOS
+
+    # ------------------------------------------------------------------
+    # make two thor tasks share options?
+    # http://stackoverflow.com/questions/14346285/how-to-make-two-thor-tasks-share-options
+
+    class << self
+      def add_shared_option(name, options = {})
+        @shared_options = {} if @shared_options.nil?
+        @shared_options[name] =  options
+      end
+
+      def shared_options(*option_names)
+        option_names.each do |option_name|
+          opt =  @shared_options[option_name]
+          raise "Tried to access shared option '#{option_name}' but it was not previously defined" if opt.nil?
+          yield option_name, opt if block_given?
+          option option_name, opt
+        end
+      end
+    end
+
+    # ------------------------------------------------------------------
+    # constructore
+
+    def initialize(*args)
+      super
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    # ------------------------------------------------------------------
+    # class options
+
+    class_option :log, :aliases => "-l", :type =>:string, :default => nil, 
+                 :enum => [ "DEBUG", "INFO", "WARN", "ERROR" ],
+                 :desc => "Set log level "
+
+    class_option :log_file, :type =>:string, :default => TlaParserS::Utils::MyLogger::LOGFILE,
+                 :desc => "Set file for log output"
+
+    # ------------------------------------------------------------------
+    # make default task to be version
+    default_task :version
+
+    desc :version, "Output version"
+    def version()
+      puts VERSION_BANNER
+    end
+
+    # ------------------------------------------------------------------
+    # resolver
+
+    desc "resolve ENTRYPOINTS", "Load modules in 'dir-globs' and resolve modules for [ENTRYPOINTS]"
+
+    option :dir_globs, :aliases => '-g', :type =>:array, :default => [],
+           :desc => "Array of directory globs to load TLA+ modules"
+    
+    option :report_unresolved, :aliases => '-u', :type =>:boolean, :default => true,
+           :desc => "Output unresolved symbols to stderr"
+    
+    def resolve( *entrypoints )
+      entries = []
+      # iterate globs and choose dirtory entries
+      options[:dir_globs].each { |glob|  entries += Dir.glob( glob ).select { |path| File.file?(path ) }  }
+      @logger.info( "#{__method__} entries=#{entries}" )
+      result = TlaParserS::Resolver.new( options ).
+        initSnippets( entries.map { |fileName| File.new(fileName )}  ).
+        resolveModules( entrypoints )
+      @logger.info( "#{__method__} result=#{result}" )      
+      puts result
+    end
+    
+    
+  end
+end
+

data/lib/parser/exception.rb

@@ -0,0 +1,6 @@
+module TlaParserS
+
+  class ParseException < Exception
+  end
+
+end

data/lib/parser/lvalue.rb

@@ -0,0 +1,63 @@
+module TlaParserS
+
+  
+  module LValue
+
+    # default implmentation for 'recurse_lvalue' when no block: create expression
+    #
+    def default_lvalue( memo, node )
+      case node.node_type
+      when  "LValue"
+      # when 'Identifier', "LValue"        
+      memo = node.lvalue
+      # when 'RecordField'
+      #   memo = memo ? "#{memo}.#{node.lvalue}" : node.lvalue
+      # when 'RecordFieldName'
+      #   memo = memo ? "#{memo}[#{node.lvalue}]" : node.lvalue
+      when 'UnitExpression'
+      # no output - just recurs
+      when 'FieldByName'
+        memo = "#{memo}.#{node.lvalue}"
+      when 'FieldByValue'
+        memo = "#{memo}[#{node.lvalue}]"        
+      else
+        raise "Lvalue recursion, parser error unkown node_type #{node_type} #{node.inspect}" 
+      end
+      memo
+    end # recurs
+
+    # @return [String] lvalue
+    def lvalue
+      # n = recursive_select( Sexp::Root ).first
+      # return nil unless n
+      recursive_select( Sexp::Identifier ).first.node_value
+    end
+    
+
+    # Recurse down 'RecordField' structure and create string for
+    # lvalue or yield block with 'ret' and 'node'.
+    # 
+    # @param ret [Object|String] to create in recursion
+    # @return [String] like A, A.b, A[c], A[d].e
+    def recurse_lvalue( ret=nil, &blk )
+      if ( blk )
+        ret = yield( ret, self )
+      else
+        ret = default_lvalue( ret, self )
+      end
+      ret = lvalue_down.recurse_lvalue( ret, &blk ) if lvalue_down
+      ret
+      
+    end
+
+    # Eac lvalue should implement something like this:
+    # # @return [nil|RecordField] down next level in hierarchy
+    # def lvalue_down
+    #   down = recursive_select( Sexp::RecordField ).first
+    #   return nil unless down
+    #   down.recursive_select( Sexp::RecordField ).first
+    # end
+    
+    
+  end
+end

data/lib/parser/parser.rb

@@ -0,0 +1,129 @@
+# coding: utf-8
+require 'treetop'
+
+# see http://thingsaaronmade.com/blog/a-quick-intro-to-writing-a-parser-using-treetop.html
+
+module TlaParserS
+
+  require_relative "parser_nodes"
+
+  class Parser
+
+    
+    # ------------------------------------------------------------------
+    # attributes
+
+    # Load the Treetop grammar from the 'sexp_parser' file, and 
+    # create a new instance of that parser as a class variable 
+    # so we don't have to re-create it every time we need to 
+    # parse a string
+    @@parser = nil
+    
+
+    # ------------------------------------------------------------------
+    # Logger
+    
+    PROGNAME = "parser"                  # progname for logger
+    include TlaParserS::Utils::MyLogger    # mix logger
+
+    # ------------------------------------------------------------------
+    # version
+
+    # @return version [String] string from file 'VERSION'
+    def self.version
+      TlaParserS::version
+    end
+
+    
+
+    # ------------------------------------------------------------------
+    # constructore
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      
+      self.loadParsers
+    end
+    
+    # @return [SexpParser] cached parser from 'parser_sexp.treetop'
+    def loadParsers
+      # cached
+      return @@parser  unless @@parser.nil?
+      base_path   = File.expand_path(File.dirname(__FILE__))
+      parser_path = File.join( base_path, 'parser_sexp.treetop')
+      @logger.info( "#{__method__} loading parser from parser path #{parser_path}" )
+      Treetop.load( parser_path)
+      @@parser = SexpParser.new
+      @@parser 
+    end
+
+    
+
+    # ------------------------------------------------------------------
+    # parse
+
+
+    # @param start [symbol] treep grammar non-terminal to start iwth
+    def parse( data, start = nil )
+      return nil if data.nil?
+
+      
+      # to pass a file
+      if data.respond_to? :read
+        data = data.read
+      # elsif ! data.respond_to? :lines
+      #   data.lines = data.to_a
+      end
+
+      
+      # Pass the data over to the parser instance
+      parser = getTheParser
+      tree = parser.parse(data, :root=>start )
+      
+      # If the AST is nil then there was an error during parsing
+      # we need to report a simple error message to help the user
+      if(tree.nil?)
+        # adopted from http://whitequark.org/blog/2011/09/08/treetop-typical-errors/
+        parser.failure_reason =~ /(Expected .*) after/m
+        expected = $1.nil? ? parser.failure_reason : $1
+        msg= <<-EOS
+        Parse error:
+        Line     : #{parser.failure_line}, offset   : #{parser.index}
+        #{expected.gsub( "\n", '$NEWLINE')}
+        #{data.lines.to_a[ parser.failure_line()-1 ]}
+        #{'~' * (parser.failure_column-1)}^
+        EOS
+        # puts msg
+        @logger.error( "#{__method__} #{msg}, for data #{data}" )
+        raise ParseException.new msg
+      end
+
+      self.class.clean_tree( tree )
+      return tree
+    end # parse
+
+    # @return [SexpParser] static parser to use
+    def getTheParser
+      @@parser
+    end
+    
+    # ------------------------------------------------------------------
+    # priv
+
+    private
+
+    # we have created a tree from our input, but it has a lot of
+    # extraneous nodes that we don’t need or care about. Let’s put in
+    # a system for cleaning up the tree:
+    def self.clean_tree(root_node)
+      return if(root_node.elements.nil?)
+      # comment the following line if parse loosees nodes
+      root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+      root_node.elements.each {|node| self.clean_tree(node) }
+    end    
+
+    
+
+    
+  end # class
+end # module

data/lib/parser/parser_nodes.rb

@@ -0,0 +1,1063 @@
+require_relative 'lvalue'
+
+module Sexp
+
+  # ------------------------------------------------------------------
+  # Abstract
+  
+  class Root <Treetop::Runtime::SyntaxNode
+  end
+
+  class NonTerminal <Root
+  end
+  
+  
+  class RootContainer < Root
+
+    # @return [String] of from sub-elements
+    def value
+      self.elements.map {|x| x.value }
+    end
+    
+  end
+
+  class Snippet < RootContainer
+  end
+
+  class Snippets < RootContainer
+
+    def name
+      node_type
+    end
+
+    # @return [Directive:array] of parses' tree nodes
+    def directives
+      recursive_select( Sexp::Directive )
+    end
+    
+    def directive_definitions
+      directives.map { |d| d.directives }.flatten
+    end
+    
+    # @return [Callable:array] of 'Callable' tree nodes
+    def callables
+      recursive_select( Sexp::Callable )
+    end
+    
+    # @return [array] of 'Define' tree nodes
+    def defines
+      recursive_select( Sexp::Define )
+    end
+
+    # Snippets is main level parse target, and it adds to symbol table
+    # base context entries for 'Define' nodes
+    # 
+    # @return [Array] of hash with ':node_type', :value properties
+    # 
+    def symbol_definitions
+      defines.map { |c| { :node_type => c.node_type, :value => c.name, :tree => c } }
+    end
+    
+  end
+  
+  # ------------------------------------------------------------------
+  # Node lists
+
+  class IdentifierList <Root
+
+    def identifier_nodes
+      recursive_select( Sexp::Identifier)
+    end
+    def identifiers
+      identifier_nodes.map{ |r| r.value }
+    end
+    def node_value
+      identifiers
+    end
+    
+  end
+
+  class Parameters <IdentifierList
+  end
+
+  
+
+  class ExpressionList <Root
+  end
+  
+  # ------------------------------------------------------------------
+  # expression
+
+  # Expression as a binary tree
+  class AbstactExpression < Root
+
+    # @return [String|Integer|etc] from sub-classes with applicable value
+    def node_value
+      expression_val
+    end
+
+    # @return [AbstractExpression] sub expressions in a binary tree
+    def expressions
+      # expressions = recursive_select( Sexp::AbstactExpression )
+      expressions = elements && elements.select { |e| e.is_a?( Sexp::AbstactExpression ) }
+      # raise "Parser error - compound expression should build binary tree" if expressions && expressios.length >2
+            
+    end
+
+    def has_rhs
+      expressions && expressions.length > 1
+    end
+
+    def lhs_node
+      expressions && expressions[0]
+    end
+    
+    def rhs_node
+      expressions[1]
+    end
+
+    # override in sub classes to make `traverse` method to yield
+    # `node_value` to block. Block may use `node_value`, or use
+    # `node_type` to determine, how to access AST properties on `node`
+    #
+    # @return [String] non nil value to yield in pre-order
+    def expression_prefix
+      nil
+    end
+    
+    # @return [String] non nil value to yield in in-order    
+    def expression_val
+      nil
+    end
+
+    # @return [String] non nil value to yield in post-order        
+    def expression_postfix
+      nil
+    end
+
+    # walk down binary tree for the expresssion, and yield
+    # 'expression_prefix', 'expxression_val', and 'expression_postfix'
+    #
+    # @param [String] variable contructed in `blk` during `traversal` 
+    # @returns [String] memo constructured during the traversal
+    def traverse( memo="",  &blk )
+
+      memo = yield memo, node_type, self, expression_prefix   if blk && expression_prefix
+      memo = lhs_node.traverse( memo, &blk ) if lhs_node
+      memo = yield memo, node_type, self, expression_val  if blk && expression_val
+      memo = rhs_node.traverse( memo,  &blk ) if has_rhs
+      memo = yield memo, node_type, self, expression_postfix   if blk && expression_postfix
+      memo
+      
+    end
+    
+  end
+  
+  class InfixExpression < AbstactExpression
+
+    # during traverse show operator in between 'lhs' and 'rhs'
+    def expression_val
+      operator
+    end
+    
+    # 
+    # @return [String] operator to use (nil if no rhs, else rhs.operator)
+    def operator 
+      return nil if !has_rhs
+      rhs_operators = expressions[1].recursive_select( Sexp::Operator )
+      return rhs_operators && rhs_operators.any? && rhs_operators.first.node_value
+    end
+
+  end
+
+  class PrimaryExpression < InfixExpression
+
+    # AbstractExpression.traverse: postfix expression does not recurse
+    # to UnitExpressions, instead yield block iterates using 'attribute_accessors'
+    
+    def expressions
+      # expressions = recursive_select( Sexp::AbstactExpression )
+      super.select { |e| !e.is_a?(Sexp::UnitExpression) }
+    end
+
+    # AbstactExpression.travers yield if non-nil
+    def expression_postfix
+      return "has-attribute-accessors" if has_attribute_accessors
+    end
+    
+    # Access record by field name  or by value
+    # @return [AbstactExpression:Array] to acccess record fields
+    def attribute_accessors
+      deffi = elements.select{ |e| e.is_a?( Sexp::UnitExpression )}.first
+      return unless deffi && !deffi.text_value.empty?
+      deffi = deffi.recursive_select( Sexp::AbstactExpression )
+      return deffi
+    end
+
+
+    # @return [boolean] true if expression defines record accessor
+    def has_attribute_accessors
+      attribute_accessors && attribute_accessors.any?
+    end
+
+  end
+  
+  
+  class MultitiveExpression < InfixExpression
+  end
+
+  class LValue < Root
+
+    # AbstractExpression.travers: no automatic traversal
+    def expressions
+      nil
+    end
+
+    # @return [AbstactExpression] for the LValue
+    def expression
+      recursive_select( Sexp::AbstactExpression).first
+    end
+
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # Implement traverse down for 'recurse_lvalue'. In my case recurse
+    # 'Sexp::UnitExpression', which define record access by value or by name
+    #
+    # @return [nil|RecordField] down next level in hierarchy
+    def lvalue_down
+      down = recursive_select( Sexp::UnitExpression ).first
+      # down = recursive_select( Sexp::RecordField ).first
+      # return nil unless down
+      # down.recursive_select( Sexp::RecordField ).first
+    end
+    
+  end
+  
+  
+  class UnitExpression < AbstactExpression
+    
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # Implement traversal for 'recurse_lvalue'
+    # @return [nil|AbstractExpression] down next level in hierarchy
+    
+    def lvalue_down
+      down = recursive_select( Sexp::AbstactExpression ).first
+    end
+    
+    
+  end
+
+  class OperatorExpression < AbstactExpression
+
+    # @return [String] operator name as expression value -->
+    # `AbstactExpression` traverse yields in-order
+    def expression_val
+      operator_name
+    end
+
+    def operator_name
+      recursive_select( Sexp::Identifier ).first.node_value      
+    end
+    # @return [Expression:Array] list or arguments
+    def arguments
+      recursive_select( Sexp::Expression )
+    end
+
+    def record_field_node
+      recursive_select( Sexp::RecordField ).first
+    end
+    def record_field
+      node = record_field_node
+      return nil unless node
+      node.node_value
+    end
+    
+    
+    # @return [Array] empty array to quit recursion in 'AbstactExpression'
+    def expressions
+      []
+    end
+  end
+  
+  class PrefixExpression < AbstactExpression
+    
+    # during traverse: show operator before 'expression_val'
+    def expression_prefix
+      operator
+    end
+
+    def operator_node
+      recursive_select( Sexp::Operator ).first
+    end
+    def operator
+      operator_node.text_value
+    end
+    
+  end
+
+  
+  class SimpleExpression < AbstactExpression
+
+    # do not automatically recurse during 'traverse'
+    def lhs_node
+      nil
+    end
+
+    
+    # def expression_value
+    #   text_value
+    # end
+    def expression_val
+      text_value
+    end
+
+  end
+
+  class ChooseExpression < SimpleExpression
+
+    # @return [BoundInExpression] root node for x \in S
+    def binds_node
+      recursive_select( Sexp::BoundInExpression ).first
+    end
+
+    # Choose defines 'choose_expression' in left hand size
+    # in binary tree  modeling expression.
+    #
+    # @return [AbstractExpression] synxtax tree node for the quentified expression
+    def choose_expression
+      expressions.first
+    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>"
+    #
+    # @return [String] name identifying context in symbol table
+    def name
+      "Choose-in-#{binds_node.bind_set.text_value}"
+    end
+    
+    # @return [Hash:Array] see 'symbol_definition'
+    def symbol_definitions
+      [symbol_definition]
+    end
+
+    # @return [Hash] of symbol_definition {:node_type,:value,:tree}
+    # for the bind variabe in choose
+    def symbol_definition
+      { :node_type => node_type, :value => binds_node.bind_var.expression_val, :tree=>binds_node }
+    end
+    
+    
+  end
+  
+  
+  # Parse goal 
+  class Expression < AbstactExpression
+  end
+
+  class QuantifyExpression < PrefixExpression
+
+    # do not automatically recurse during 'traverse'
+    def lhs_node
+      nil
+    end
+
+    def binds_nodes
+      recursive_select( Sexp::BindsInExpression ).first.recursive_select( Sexp::BoundInExpression )
+    end
+
+    # Quantification defines 'quantified_expression' in left hand size
+    # in binary tree  modeling expression.
+    #
+    # @return [AbstractExpression] synxtax tree node for the quentified expression
+    def quantified_expression
+      expressions.first
+    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>"
+    #
+    # @return [String] name identifying context in symbol table
+    def name
+      "Quantification-??"
+    end
+    
+    # Some variables in 'constructor_expression' (most likely) refer
+    # to variable defined in set constructor generate. Return name of
+    # this variables.
+    # 
+    # @return [Array] of one hash with ':node_type',':value' properties
+    def symbol_definitions
+      binds_nodes.map do |binds_node|
+        { :node_type => node_type, :value => binds_node.bind_var.expression_val, :tree=>binds_node }
+      end
+    end
+    
+  end
+
+  class BoundInExpression < Root
+    def bind_var
+      elements.select{ |e| e.is_a?( Sexp::Identifier ) }.first
+    end
+    def bind_set
+      elements.select{ |e| e.is_a?( Sexp::Expression ) }.first
+    end
+
+  end
+
+  class BindsInExpression < Root
+  end
+
+  class SetExpressionDef < Root
+  end
+  
+
+  class ParenthesisExpression < AbstactExpression
+    def expression_prefix
+      "("
+    end
+    def expression_postfix
+      ")"
+    end
+  end
+
+  class RecordExcept < AbstactExpression
+    def expressions
+      nil
+    end
+    def lhs_node
+      nil
+    end
+    def rhs_node
+      nil
+    end
+    def expression_val
+      "exprsssion"
+    end
+    def record_identifier
+      recursive_select( Sexp::RecordExceptIdentifier ).first.recursive_select( Sexp::Identifier ).first.expression_val
+    end
+    def record_field_definitions
+      # rigth recursion results to empty RecordExceptField -node
+      recursive_select( Sexp::RecordExceptField ).select{ |f| f.elements && f.elements.any? }
+    end
+  end
+  
+  class RecordExceptField < Root
+    def lvalue_expression
+      recursive_select( Sexp::LValue ).first
+    end
+    def rvalue_expression
+      # first is expression for lvalue
+      recursive_select( Sexp::Expression ).last
+    end
+  end
+  
+  class RecordExceptIdentifier < Root
+  end
+  
+
+  class RecordDefinition < AbstactExpression
+    # output during 'AbstactExpression.traverse'
+    def expression_val
+      "[]"
+    end
+
+    # @return [RecordElement:Array] of record field definitions 
+    def record_fields
+      ret = recursive_select( Sexp::RecordElement )
+      ret
+    end
+
+
+  end
+
+  class RecordField < AbstactExpression
+
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # Implement traversal for 'recurse_lvalue'
+    # @return [nil|RecordField] down next level in hierarchy
+    def lvalue_down
+      down = recursive_select( Sexp::RecordField ).first
+      return nil unless down
+      down.recursive_select( Sexp::RecordField ).first
+    end
+
+
+    # # @return [String] identifier name for lvalue
+    # def lvalue
+    #   # default recursion creates string for expression lvalue
+    #   recurse_lvalue
+    # end
+
+    # AbstactExpression.traverse calls once: collect rec.id.field,
+    # expression value is the lvalue 
+    def expression_val
+      # return A, A.b, A.b[c]
+      recurse_lvalue
+    end
+
+
+  end
+  class RecordFieldName < RecordField
+
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # # @return [String] for record value return '[record_field]'
+    # def record_field_value
+    #   "[#{record_name}]"
+    # end
+    
+    
+  end
+
+  class SequenceExpression < AbstactExpression
+    # AbstactExpression.travers 
+    def expression_val
+      "<<>>"
+    end
+
+    # @return [Expression:Array] of sequence expressions
+    def tuples
+      recursive_select( Sexp::Expression )
+    end
+  end
+
+  class AbstractSetExpression < AbstactExpression
+    # AbstactExpression.traverse quit traversing the expression
+    def lhs_node
+      nil
+    end
+    
+    # AbstactExpression.traverse calls in yield
+    def expression_val
+      true
+    end
+
+    # Return set generator ( x \in Set ) for set constructor
+    #
+    # @return [BoundInExpression|nil] syntax tree node defining
+    # generator variable and set
+    def binds_node
+      ret = recursive_select( Sexp::BoundInExpression ).first
+      return nil unless ret
+      ret = ret.recursive_select( Sexp::BoundInExpression ).first
+      # puts ret
+      ret
+    end
+    
+    def set_expression 
+      deffi = recursive_select( Sexp::SetExpressionDef )
+      return nil unless deffi && deffi.any?
+      ret = deffi.first.elements[0]
+      # # ret = deffi.first.recursive_select( Sexp::SetExpression ).first
+      # puts "set_expression=#{ret.inspect}"
+      ret
+    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>"
+    #
+    # @return [String] name identifying context in symbol table
+    def name
+      "Set-#{binds_node.bind_set.text_value}"
+    end
+    # Some variables in 'set_expression' (most likely) refer to
+    # variable defined in set constructor generate. Return name of
+    # this variables.
+    # 
+    # @return [Array] of one hash with ':node_type',':value' properties
+    def symbol_definitions
+      return [] unless binds_node
+      [ { :node_type => node_type, :value => binds_node.bind_var.expression_val, :tree=>binds_node } ]
+    end
+    
+  end
+
+  class SetExpressionMap < AbstractSetExpression
+  end
+
+  class SetExpression < AbstractSetExpression
+  end
+
+  class FieldBy < AbstactExpression
+    # AbstractExpression.traverse - do not recurse will evaluate separetetely
+    def lhs_node
+      nil
+    end
+    def rhs_node
+      nil
+    end
+
+    
+  end
+
+  class FieldByName < FieldBy
+    
+    # @return [AbstactExpression] defining the name    
+    def field_name_expression
+      recursive_select( Sexp::AbstactExpression ).first
+    end
+    
+    def expression_val
+      field_name_expression && field_name_expression.expression_val
+    end
+
+    # implements lvalue
+    include TlaParserS::LValue
+    def lvalue_down
+      down = recursive_select( Sexp::UnitExpression ).first
+      # down = recursive_select( Sexp::RecordField ).first
+      # return nil unless down
+      # down.recursive_select( Sexp::RecordField ).first
+    end
+    
+    
+  end
+
+  class FieldByValue < FieldBy
+    
+    def expression_val
+      field_value_expression && field_value_expression.expression_val
+    end
+
+    def field_value_expression
+      recursive_select( Sexp::AbstactExpression ).first
+    end
+    
+
+    # # @return [AbstactExpression] defining the value
+    # def val_expression
+    #   recursive_select( Sexp::AbstactExpression ).first
+    # end
+
+    # implements lvalue
+    include TlaParserS::LValue
+    def lvalue_down
+      down = recursive_select( Sexp::UnitExpression ).first
+      # down = recursive_select( Sexp::RecordField ).first
+      # return nil unless down
+      # down.recursive_select( Sexp::RecordField ).first
+    end
+    
+  end
+  
+  
+  
+  class UnaryExpression < PrefixExpression
+
+  end
+  
+  class AdditiveExpression < InfixExpression
+  end
+  
+  class Identifier < SimpleExpression
+
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # No need to recurse down from identifier
+    def lvalue_down
+      nil
+    end
+
+    # @return [String] identifier name for lvalue
+    def lvalue
+      node_value
+    end
+    
+  end
+
+  class Self < Identifier
+  end
+  
+  class OriginalValue < SimpleExpression
+
+    # implements lvalue
+    include TlaParserS::LValue
+
+    # No need to recurse down from identifier
+    def lvalue_down
+      nil
+    end
+
+
+    # @return [String] identifier name for lvalue
+    def lvalue
+      node_value
+    end
+    
+  end
+  
+  
+
+  class StringValue < SimpleExpression
+  end
+  
+  class IntegerValue < SimpleExpression
+    def expression_val
+      retun 0 if text_value.nil?
+      text_value.to_i
+    end
+  end
+
+  # ------------------------------------------------------------------
+  # statements
+
+  # Tree node with 'Label' and Unlabeled statement
+  class Statement <Root
+
+
+    # ------------------------------------------------------------------
+    # Parsed node structure: Label && Unlabeled statement
+    
+    # Locate 'Label' as direct child. Compound statements may contain
+    # statement, which are also labeled, and we cannot just do
+    # 'recursive_select'
+    def find_labelnode
+      
+      # return labelnode = recursive_select( Sexp::Label ).first
+      if !elements.nil? then
+        elements.each do |e|
+          return e if e.is_a?( Sexp::Label ) 
+        end
+      end
+      # Label node not found
+      nil
+    end
+
+    # @return [Label:SyntaxTree] label assigned to the statement (nil if no label)
+    def statement_label
+      labelnode = find_labelnode
+      return labelnode.label if labelnode
+      return nil
+    end
+    
+    # @return [UnlabeledStatement:TreeNode] TLA -language statement
+    def get_statement
+      ret = recursive_select( Sexp::UnlabeledStatement ).first
+      ret
+    end
+
+    # tree structure (for compund statments)
+    def statements
+      nil
+    end
+    
+
+    # ------------------------------------------------------------------
+    # traverse
+    
+    # @return [string] the value for traserval
+    def statement_val
+      nil
+    end
+
+    def traverse( memo="", &blk )
+      # visit label as 'Statement' node
+      memo = yield( memo, node_type, self ) if statement_label
+      
+      # visit the real thing 'as object sekf'
+      uls = get_statement
+      # raise "No unlabeled_statement statement found #{self} from \n '#{inspect}'  " unless uls
+
+      memo = yield( memo, uls.node_type, uls )  if uls
+
+      statements.each{ |s| memo = s.traverse( memo, &blk ) } if statements
+
+      memo
+    end
+
+    def node_value
+      statement_val
+    end
+    
+  end
+
+  
+  class UnlabeledStatement < Statement
+    def statement_label
+      labelnode = parent.statement_label  if parent && parent.respond_to?(:statement_label)
+    end
+    
+  end
+
+  class CompoundStatement < UnlabeledStatement
+
+    def statements
+      stmts=recursive_select(Sexp::StatementList).first.recursive_select(Sexp::Statement)
+      stmts
+
+    end
+    
+  end
+
+  class StatementList < Root
+  end
+  
+  class Goto < UnlabeledStatement
+    
+    def goto_label
+      recursive_select( Sexp::Identifier).map{ |r| r.node_value }.first      
+    end
+    
+  end
+
+  class Print < UnlabeledStatement
+
+    # @return [Expression] to print
+    def print_expression
+      recursive_select( Sexp::Expression).first
+    end
+    
+  end
+
+  class Assignment < UnlabeledStatement
+
+    # @return [LValue] where to assign to
+    def lvalue
+      recursive_select( Sexp::LValue).first      
+    end
+
+    # @return [Expression] expression to assign
+    def rvalue
+      recursive_select( Sexp::Expression).first            
+    end
+    
+  end
+  
+
+  class Return < UnlabeledStatement
+  end
+
+  class Conditional < UnlabeledStatement
+
+    def condition
+      recursive_select( Sexp::Expression).first
+    end
+
+    def true_or_else
+      recursive_select( Sexp::Statement)
+    end
+
+    def if_true
+      true_or_else.first
+    end
+
+    def if_not_true
+      return true_or_else[1] if true_or_else.length == 2
+    end
+    
+  end
+  
+
+  class Either < UnlabeledStatement
+
+    # Return array of choices
+    def choices
+      recursive_select( Sexp::Statement)
+    end
+    
+  end
+  
+  
+  class Assert < UnlabeledStatement
+    
+    def assertion
+      recursive_select( Sexp::Expression).first
+    end
+    
+  end
+
+  class Called  < UnlabeledStatement
+
+    def called
+      recursive_select( Sexp::Identifier).map{ |r| r.node_value }.first      
+    end
+
+    def statement_val
+      "call #{called}"
+    end
+
+    # @return [Array] actual parameters parsed as 'Expression' nodes
+    def actual_parameters
+      recursive_select( Sexp::Expression)
+    end
+
+    
+  end
+
+  class Call  < Called
+  end
+
+  class MacroCall  < Called
+  end
+  
+
+  class Skip < UnlabeledStatement
+    def statement_val
+      text_value
+    end
+  end
+
+  # ---------------------------------
+  # optional statement label 
+
+  class Label < Root
+
+    def label
+      recursive_select(Sexp::Identifier).first.node_value
+    end
+    
+    def node_value
+      label if respond_to?( :label )
+    end
+
+  end
+
+  # ------------------------------------------------------------------
+  # directives  (assumption, invariants)
+  class Directive < Root
+
+    # @return [String:Array] of directive names
+    def directives
+      recursive_select( Sexp::Identifier ).map { |i| i.node_value }
+    end
+
+    
+  end
+  
+  class Invariant < Directive
+  end
+
+  class Assumption < Directive
+  end
+
+  # ------------------------------------------------------------------
+  # callable (procedures, macros, processes?)
+
+  class Define < Root
+    def name
+      recursive_select(Sexp::Identifier).first.node_value
+    end
+    
+  end
+  
+  class Callable < Define
+    
+    def parameters_node
+      tree_nodes = recursive_select(Sexp::Parameters)
+      return tree_nodes.first if tree_nodes
+    end
+    def parameters
+      node = parameters_node
+      return node.value if node
+    end
+    
+    def body_node
+      ret = recursive_select(Sexp::Statement).first
+      ret
+    end
+    def body
+      node = body_node
+      node.value  if node
+    end
+    
+    def node_value
+      {
+        :name => "name",
+        :parameters => parameters,
+        :body => body,
+      }
+    end
+
+    # Symbols defined in this node
+    #
+    # @return [Hash:Array] symbol hash with ':node_type', :value,
+    # :tree properties
+    def symbol_definitions
+      parameter_def = parameters
+      return [] unless  parameter_def
+      parameter_def[:value] 
+    end
+  end
+
+  class Macro < Callable
+  end
+
+  class Procedure < Callable
+  end
+
+  class OperatorDef < Callable
+    
+    # For operator no body:
+    def body_node
+      tree_nodes = recursive_select(Sexp::Expression)
+      return tree_nodes.first if tree_nodes
+    end
+  end
+
+  # ------------------------------------------------------------------
+  # Variable
+
+  class VariableDef < Define
+
+    #
+    def name
+      recursive_select(Sexp::Identifier).first.node_value
+    end
+    
+    # @return [Expression] tree node for init expression
+    def init
+      tree_nodes = recursive_select(Sexp::Expression).first      
+    end
+
+    # Return entries for symbol table. In this case, add just variable
+    # definition.
+    # @return [Array] of 1 hash with :node_type, :value -properties
+    def symbol_definitions
+      [ { :node_type => node_type, :value => name } ]
+    end
+    
+  end
+
+  class RecordElement < Root
+    def element_name
+      recursive_select( Sexp::Identifier ).first
+    end
+    def element_expression
+      recursive_select( Sexp::Expression ).first
+    end
+  end
+  
+
+  # ------------------------------------------------------------------
+  # simple
+  
+  class ReservedWord < Root
+  end
+  
+  class Operator < Root
+  end
+
+  
+
+  # class Body < RootContainer
+  # end
+  
+  class VariableDeclaration < RootContainer
+  end
+
+
+  
+end