tla-parser-s 0.1.2 → 0.2.2

data/lib/semantics/resolver.rb

@@ -27,9 +27,12 @@ module TlaParserS
     # global context to use in resolving.
     #
     # constructor:
-    # #initContext: add initContext
-    # #initSnippets: parse TLA+ snippets to context
-    # #resolveModules: resolve modules
+    # Initialize & parse
+    #   #initContext: add initContext
+    #   #initSnippets: parse TLA+ snippets to context
+    # Services available after init & parse
+    #   #resolveModules: resolve modules
+    #   #sortModule: 
     #
     # ******************************************************************
     
@@ -37,15 +40,22 @@ module TlaParserS
     # ------------------------------------------------------------------
     # Logger
     
-    PROGNAME = "resolver"                  # progname for logger
+    PROGNAME = nil                         # progname default class-name
     include TlaParserS::Utils::MyLogger    # mix logger
 
     # ------------------------------------------------------------------
-    # constructore
+    
+    # @!group Construct && configure
+
+    # construct with 'options'
+    #
+    # @param options [Hash] to configure resolver
+    # @option options [String] :logfile name of file where to log to
+    #
     def initialize( options={} )
       
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.info( "#{__method__} initialized parser-resolver version #{TlaParserS::version}" )
 
       @report_unresolved = options[:report_unresolved]
 
@@ -60,37 +70,12 @@ module TlaParserS
       @directive_modules = []
     end
 
-    # Parse entry ie. file or possibly a string
-    #
-    # @param entry [File|String] to parse
-    # @param moduleName [String] identifying 'entry' for error messages
-    # @return [Snippets] parsed syntax tree node 
-    def parseSnippets( entry, moduleName )
-        begin
-          parser.parse( entry )
-        rescue ParseException => ee
-          msg = "Parsing '#{moduleName}' results to error \n\n#{ee.message}"
-          @logger.error( "#{__method__} #{msg}" )        
-          raise ParseException.new( ee ), msg, ee.backtrace
-        end
-          
-    end
+    # @!endgroup
 
-    # Add of definition names in 'snippets' to '@directives', and
-    # 'moduleName' to '@directive_modules' if any 'snippets' contained
-    # 'directive_definitions'
-    #
-    # @param moduleName [String] name of module where 'snippets' are parses
-    # @param snippets [Snippets] parsed snippts, respons to :directive_definitions
-    def addDirectives( snippets, moduleName )
-      new_directives = snippets.directive_definitions
-      
-      @logger.debug( "#{__method__} moduleName=#{moduleName} -> new_directives=#{new_directives}" )
-      @directives = directives + new_directives
-
-      @directive_modules << moduleName if new_directives && new_directives.any?
-    end
+    # ------------------------------------------------------------------
 
+    # @!group Initialize context & parse snippets
+    
     # Build initial context (TLA+ reserved words, etc)
     #
     # @param names [String:Array] to put context
@@ -107,46 +92,57 @@ module TlaParserS
           }
         end
       )
-
       
     end
 
-
-    # ------------------------------------------------------------------
     # Load TLA+ snippets from file (or strings in unit test), and
     # build global context to use in resolving.
     #
-    # @param entries [ File:Array | String:Array] containg TLA+ snippets
+    # @param  [File:Array|String:Array|File|String] entries containg TLA+ snippets
     #
     # @param blk [Block] yields entry 
     
     def initSnippets( entries, &blk )
 
+      # Make it to an array
+      entries = [ entries ] unless entries.is_a?( Array ) || entries.nil?
+
+      @logger.info "#{__method__} starts in #{Dir.pwd}"
+
       # create global context
       context.pushContext
 
+      # collect symbol definitions parsed
+      parsedSnippets = []
+
+
       # iterate
       entries && entries.each_with_index do |entry,i|
 
         # skip directories
         # next if entry.is_a?( File ) && File.directory?( entry )
-        next if File.directory?( entry )        
+        next if (entry.is_a?( String ) || entry.is_a?( File )) && File.directory?( entry )        
 
         # meaningfull modulename
-        moduleName = entry.is_a?( File ) ? entry.path : "entries[#{i}]"
+        moduleName = entry.is_a?( File ) ? entry.path : entry.respond_to?(:moduleName) ? entry.moduleName : "entries[#{i}]"
 
-        @logger.info( "#{__method__} entry=#{entry}" )
+        @logger.info( "#{__method__} entry=#{entry}, moduleName=#{moduleName}" )
         begin
 
           # String|File --> AST
           snippets = parseSnippets( entry, moduleName )
           yield( true, entry ) if blk
+          @logger.debug( "#{__method__} #{moduleName}: snippets=#{snippets.inspect}" )          if @logger.debug?
+
+          # collect an array of hashes with :node_type, :value, :true  -properties
+          parsedSnippets += snippets.symbol_definitions
 
-          # collect directive defitions
+          # collect '@directives' and, '@directive_modules' if
+          # snippets.directive_definitions because they should be 
+          # included to entry points
           addDirectives( snippets, moduleName )
 
-          # add to contex tree nodes, which respond to
-          # 'symbol_definitions'
+          # add to contex tree nodes, which respond to 'symbol_definitions'
           context.addContext( snippets, moduleName )
           
         rescue TlaParserS::ParseException => e
@@ -159,10 +155,18 @@ module TlaParserS
 
       end
 
+      @logger.info "#{__method__} finished"
       self
+      parsedSnippets
     end
 
+    
+    # @!endgroup
+
     # ------------------------------------------------------------------
+    # @!group Services to use after init & parse
+
+    
     # Find modules 1) containing TLA+ snippets reachable from
     # 'entryPoints', 2) modules reachabable for directive defintision,
     # and 3) modules containing directive definitions
@@ -173,9 +177,132 @@ module TlaParserS
       definitionModules = resolveModulesDo( entryPoints + directives, &blk )
       return definitionModules + directive_modules
     end
+
+    # ------------------------------------------------------------------
+    # Run topologica sort on module
+    require 'tsort'
+    # Define a class to do topological sort
+    class THash < Hash
+      include TSort
+      alias tsort_each_node each_key
+      def tsort_each_child(node, &block)
+        fetch(node).each(&block) 
+      end
+    end
+    # ------------------------------------------------------------------    
     
+    # Run topological sort on modules. 
+    #
+    # @param modules [String:Array] names of modules to sort
+    #
+    # @return [String:Array] of sorted modules
+    def sortModules( modules, &blk )
+      
+      @logger.info "#{__method__}: modulesstart=#{modules} - starts"
+      
+      sortteri =
+        modules.
+        #
+        # map { |m| puts "m0=#{m}"; m }.
+        #
+        # Find symbols in module :m to array :s
+        #
+        # [{ :m=<module-name>, :s=>[<symbol definitions in module>]}, ...]
+        #
+        map { |m| { :m => m, :s=> context.resolveModule(m) } }.
+        # map { |m| puts "m1[:s]=#{m[:s].map{ |s| s[:module] +':' + s[:symbol_name] } }"; m }.
+        #
+        # Resolver symbols in :s to array :r 
+        #
+        # At this point
+        # [{ :m=<module-name>, :s=>[<symbol definitions in module>], :r=>[{:symbol=>"", :resolved>={} }]}, .... ]
+        #
+        map { |m| m[:r] = m[:s].map{ |s| resolveEntryPoint( s[:symbol_name] ) }.flatten; m }.
+        # map { |m| puts "#{m[:m]}-> m2[:s]=#{m[:s].map{ |s| s[:module] +':' + s[:symbol_name] } }"; m }.        
+        # map { |m| puts "#{m[:m]}-> m2[:r]=#{m[:r].map { |r| r[:symbol] + '->' + r[:resolved][:symbol_name] + '@' + (r[:resolved][:module] ||'-' )}}"; m }.
+        #
+        # Drop unresolved symbols from :r
+        #
+        map { |m| m[:r] = m[:r].reject { |r| r[:resolved].nil? }; m}.
+        #
+        # Add m[:d] array of module names (drop resolves, which do not
+        # have module defined (correspoding to local references)
+        #
+        # [{ :m=<module-name>, :d=> [<resolved modules (filepaths?)>] :s=>[<symbol definitions in module>], :r=>[{:symbol=>"", :resolved>={} }]}, .... ]
+        # 
+        #
+        map { |m| m[:d] = m[:r].select { |r| r[:resolved][:module]}.map { |r| r[:resolved][:module]}.uniq; m}.
+        # map { |m| puts "m3=#{m[:m]}, :d=#{m[:d]}, [:s]=#{m[:s].map{ |s| s[:module] +':' + s[:symbol_name] } }"; m }.
+        #
+        # Reject modules, which do not define any snippets
+        # 
+        select { |m| m[:s].any? }.
+        # map { |m| puts "m4=#{m[:m]}, :d=#{m[:d]}, [:s]=#{m[:s].map{ |s| s[:module] +':' + s[:symbol_name] } }"; m }.
+        #
+        # clear prefix path from modulename in m[:d] elements
+        #
+        map { |m| m[:d] = m[:d].map{ |d| modules.select { |mo| d.end_with?(mo)}.first }.select {|d| d }; m }.                
+        # map { |m| puts "m5=#{m[:m]}, :d=#{m[:d]}"; m }.
+        #
+        #
+        # Finally create a tsort hash
+        #
+        inject( THash.new ){ |t, m| t[m[:m]] = m[:d]; t }.
+        #
+        # And sort it
+        #
+        tsort
+      
+      sortteri
+    end
+    
+    # @!endgroup
+    
+    # ------------------------------------------------------------------
+    # @!group Internal methods for parsing
+
+    
+    # Parse entry ie. file or possibly a string
+    #
+    # @param entry [File|String] to parse
+    #
+    # @param moduleName [String] identifying 'entry' for error messages
+    #
+    # @return [Snippets] parsed syntax tree node 
+    def parseSnippets( entry, moduleName )
+        begin
+          parser.parse( entry )
+        rescue ParseException => ee
+          msg = "Parsing '#{moduleName}' results to error \n\n#{ee.message}"
+          @logger.error( "#{__method__} #{msg}" )        
+          raise ParseException.new( ee ), msg, ee.backtrace
+        end
+          
+    end
+
+    # Add definition names in 'snippets' to '@directives', and
+    # 'moduleName' to '@directive_modules' if any of the 'snippets'
+    # contains 'directive_definitions'
+    #
+    # @param moduleName [String] name of module where 'snippets' are parses
+    # @param snippets [Snippets] parsed snippts, respons to :directive_definitions
+    def addDirectives( snippets, moduleName )
+      new_directives = snippets.directive_definitions
+      
+      @logger.debug( "#{__method__} moduleName=#{moduleName} -> new_directives=#{new_directives}" ) if @logger.debug?
+      @directives = directives + new_directives
+
+      @directive_modules << moduleName if new_directives && new_directives.any?
+    end
+
+    # @!endgroup    
+    
+
 
     # ------------------------------------------------------------------
+    
+    # @!group implement module resolve
+    
     # Find modules containing TLA+ snippets needed to implement code
     # for 'entryPoints'.  Notice: A module may include additional
     # entrypoint, which must also be satisfied.
@@ -189,7 +316,7 @@ module TlaParserS
     # @return [String:Arrays] of module names needed in implementation.
     def resolveModulesDo( entryPoints, &blk )
       
-      @logger.info( "#{__method__} resolveModules for entryPoint=#{entryPoints.join(',')}" )
+      @logger.info( "#{__method__} resolveModules for entryPoint=#{entryPoints.join(',')}, symbol-table depth=#{context.symbol_table.depth}" )
       yield( "start", entryPoints ) if blk
 
       # collected during processing
@@ -203,16 +330,17 @@ module TlaParserS
 
       while TRUE do
 
-        # done - if no mode 'unResolved'
+        # done - if no more in 'unResolved'
         break if unResolved.empty?
         # next to resolve
         entryPoint = unResolved.to_a.shift
-        @logger.info( "#{__method__} next to resolve entryPoint #{entryPoint} " )              
+        @logger.info( "#{__method__} next to resolve entryPoint #{entryPoint} " )
+        # already resolved
         next if resolved.include?( entryPoint )
 
         # array of hashes how entry point is resolved
         resolvedSymbols = resolveEntryPoint( entryPoint )
-        @logger.info( "#{__method__} entryPoint #{entryPoint} ->resolvedSymbols=#{resolvedSymbols}" )      
+        @logger.debug( "#{__method__} entryPoint #{entryPoint} ->resolvedSymbols=#{resolvedSymbols}" )       if @logger.debug?
 
         resolvedModules =                  # array of mod.names
           resolvedSymbols.                 # { :symbol=>, :resolved=> }
@@ -224,7 +352,7 @@ module TlaParserS
           map { |s| s[:module]  }          # extract moduleName
 
         
-        @logger.debug( "#{__method__} resolvedModules=#{resolvedModules}" )
+        @logger.debug( "#{__method__} resolvedModules=#{resolvedModules}" ) if @logger.debug?
         newModules = resolvedModules.select { |m| !moduleNames.include?( m ) }
 
         # collect unresolved
@@ -238,7 +366,7 @@ module TlaParserS
 
         # return list of definitions (ie. newEntryPoint) in 'modules'
         newEntryPoints = entryPointsForModules( newModules )
-        @logger.debug( "#{__method__} newEntryPoints=#{newEntryPoints}" )
+        @logger.debug( "#{__method__} newEntryPoints=#{newEntryPoints}" ) if @logger.debug?
         
         # one more resolved: move it to resolved
         unResolved = unResolved.delete( entryPoint )
@@ -246,7 +374,7 @@ module TlaParserS
 
         # still to resolve: unResolved + newEntryPoints - resolved
         unResolved = unResolved.union( newEntryPoints.to_set ).subtract( resolved )
-        @logger.debug( "#{__method__} unResolved=#{unResolved}" )
+        @logger.debug( "#{__method__} unResolved=#{unResolved}" ) if @logger.debug?
         
         # collect modules
         moduleNames = moduleNames.union( newModules.to_set )
@@ -286,12 +414,18 @@ module TlaParserS
     # @return [Hash:Array] identifier in entry points
     def resolveEntryPoint( entryPoint )
       symbolTableEntry = context.resolveSymbol( entryPoint )
-      @logger.debug( "#{__method__} symbolTableEntry #{entryPoint}-->#{symbolTableEntry}" )
+      @logger.debug( "#{__method__} symbolTableEntry #{entryPoint}-->#{symbolTableEntry}" ) if @logger.debug?
       if symbolTableEntry && symbolTableEntry[:resolved]
+        # return from cache
+        if symbolTableEntry[:cached]
+          return symbolTableEntry[:cached]
+        end
         tree = symbolTableEntry[:resolved][:tree]
-        @logger.debug( "#{__method__} tree-->#{tree.inspect}" )      
+        @logger.debug( "#{__method__} tree-->#{tree.inspect}" )       if @logger.debug?
         symbols = context.resolveDefine( tree )
-        @logger.debug( "#{__method__} resolveDefine-->#{symbols.join('\n')}" )
+        @logger.debug( "#{__method__} resolveDefine-->#{symbols.join('\n')}" ) if @logger.debug?
+        symbolTableEntry[:cached] = symbols
+        symbols
       else
         msg = <<-EOS  
         Unknown entrypoint '#{entryPoint}'
@@ -306,12 +440,24 @@ module TlaParserS
 
     end
 
+    # @!endgroup
+
+
+    # ------------------------------------------------------------------
+    # @!group private utilities
+    
+
     # return list of definitions in 'modules'
     #
-    # @param modules [String:Array] of module names to include
-    # @return [String:Array] of entry points in the module
+    # @param modules [String:Array|String] of module names to include
+    #
+    # @return [String:Array] of entry points in 'modules'
+    #
     def entryPointsForModules( modules )
 
+      # ensure that it is an array 
+      modules = modules.is_a?( Array ) ? modules : [modules]
+
       moduleSymbols = []
       modules.each do |moduleName|
         # resolve module entry poinsts
@@ -320,9 +466,11 @@ module TlaParserS
         moduleSymbols = moduleSymbols + moduleEntries
       end
       ret = moduleSymbols.map { |s| s[:symbol_name] }
-      @logger.debug( "#{__method__} modules=#{modules.join(',')}-->ret=#{ret.join(',')}" )
+      @logger.debug( "#{__method__} modules=#{modules.join(',')}-->ret=#{ret.join(',')}" ) if @logger.debug?
       return ret
     end
+
+    # @!endgroup    
     
   end
 

data/lib/semantics/symbol_table.rb

@@ -9,7 +9,7 @@ module TlaParserS
     # ------------------------------------------------------------------
     # Logger
     
-    PROGNAME = "symbols"                   # progname for logger
+    PROGNAME = nil                         # progname for logger default class name
     include TlaParserS::Utils::MyLogger    # mix logger
     
 
@@ -18,19 +18,29 @@ module TlaParserS
     def initialize( options={} )
 
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.info( "#{__method__} initialized symbol-table" )
       
       @stack = []
     end
 
+    def depth
+      @stack.length
+    end
+
     # Add a hash (with :symbol_type, :context_type, :context,
     # :symbol_name) to 'currentContext'
     #
     # @param entry [Hash] add hash to 'currentContext'
     def addEntry( entry )
       # get refeence to current contex
+      # do not ouput :tree property on info stack
+      @logger.info "#{__method__} @[#{@stack.length}] #{entry.inject({}){|e,(k,v)| e[k] = ( k == :tree ? true : v ); e } }"
+      @logger.debug "#{__method__} tree = #{entry[:tree].inspect}"  if @logger.debug?
+      # @logger.debug "#{__method__} @[#{@stack.length}] #{entry}"
+
       context = currentContext
-      context[entry[:symbol_name]] = entry      
+      context[entry[:symbol_name]] = entry
+      
     end
 
     # @param tree_node [SyntaxNode] node implementing
@@ -40,7 +50,7 @@ module TlaParserS
 
       if tree_node && tree_node.respond_to?(:symbol_definitions)
         tree_node.symbol_definitions.each do |symbol_definition|
-          @logger.debug( "#{__method__} symbol_definition=#{symbol_definition}" )
+          @logger.debug( "#{__method__} moduleName #{moduleName}, symbol_definition=#{symbol_definition}" ) if @logger.debug?
           entry = {
             :context_type => tree_node.node_type,            
             :context => tree_node.name,
@@ -50,7 +60,10 @@ module TlaParserS
           # optionally add moduleName
           entry[:module] = moduleName if moduleName
 
-          # syntax tree defined only on procedure & macros
+          # output before tree
+          @logger.debug( "#{__method__} @#{stack.length} entry=#{entry}, parse tree=#{symbol_definition[:tree] ? 'given' : 'not given' } " ) if @logger.debug?
+
+          # syntax tree defined only on procedure & macros (and variable defs)
           entry[:tree] = symbol_definition[:tree] if symbol_definition[:tree]
 
           addEntry( entry )
@@ -93,6 +106,18 @@ module TlaParserS
       entries
     end
 
+    # @return [Hash:Array] of symbol table entries
+    def symbols
+      entries = {}
+      stack.reverse_each do |context|
+        # add key to entries unless it is already there
+        context.keys().each { |k|  entries[k] = context[k] }
+      end
+      entries
+    end
+
+    
+
     def resolveContext( identifier )
       stack.reverse_each do |context|
         # @logger.debug "context=#{context}, identifier=#{identifier}"
@@ -101,7 +126,14 @@ module TlaParserS
       return nil
     end
 
+
+    # Return entries in a module.
+    #
+    # Implementation iterates, in reverse, order symbol table stack,
+    # and searches for entries with :module == 'moduleName'.
+    #
     # @param moduleName [String] name of module to resolve
+    #
     # @return [Hash:Array] of symbol definition
     #         {:context_type,:context,:symbol_type,:symbol_name} where
     #         {:module} == 'moduleName'
@@ -111,11 +143,12 @@ module TlaParserS
       entries = []
       stack.reverse_each do |context|
         context.each do |symbol,entry|
-          @logger.debug( "#{__method__} symbol=#{symbol}, entry=#{entry[:module]}" )      
-          entries << entry if entry[:module] == moduleName
+          @logger.debug( "#{__method__} symbol=#{symbol}, entry=#{entry[:module]}" )  if @logger.debug?
+          # entries << entry if entry[:module] == moduleName 
+          entries << entry if !entry[:module].nil? && entry[:module].end_with?( moduleName )
         end
       end
-      @logger.debug( "#{__method__} entries-->#{entries.join(',')}" )
+      @logger.debug( "#{__method__} entries-->#{entries.join(',')}" ) if @logger.debug?
       return entries
     end
 
@@ -123,10 +156,11 @@ module TlaParserS
       return stack.last
     end
 
-    def dumpContext
+    def dumpContext( &blk )
       stack.reverse_each.with_index do |context, i|
-        @logger.debug "Context #{i}"
-        @logger.debug context.to_yaml
+        yield i, context if blk
+        @logger.debug "Context #{i}" if @logger.debug?
+        @logger.debug context.to_yaml if @logger.debug?
       end
     end