rley 0.5.04 → 0.5.05

data/lib/rley/parser/parse_forest_factory.rb

@@ -13,6 +13,13 @@ module Rley # This module is used as a namespace
       def builder(aParseResult, _builder = nil)
         ParseForestBuilder.new(aParseResult.tokens)
       end
+      
+      # When a end vertex is re-visited then jump
+      # its corresponding start vertex. This behaviour
+      # makes sense for sharing nodes.
+      def jump_to_start()
+        true
+      end       
     end # class
   end # module
 end # module

data/lib/rley/parser/parse_rep_creator.rb

@@ -42,8 +42,14 @@ module Rley # This module is used as a namespace
         walker_factory = ParseWalkerFactory.new
         accept_entry = aParseResult.accepting_entry
         accept_index = aParseResult.chart.last_index
-        walker_factory.build_walker(accept_entry, accept_index)
-      end      
+        walker_factory.build_walker(accept_entry, accept_index, jump_to_start)
+      end
+
+      # By default, when a end vertex is re-visited don't jump
+      # its corresponding start vertex.
+      def jump_to_start()
+        false
+      end
       
     end # class
   end # module

data/lib/rley/parser/parse_tree_builder.rb

@@ -84,13 +84,15 @@ module Rley # This module is used as a namespace
       # @param anIndex [anIndex] The token index at end of anEntry
       def process_end_entry(anEvent, anEntry, anIndex)
         case anEvent
-          when :visit
+          when :visit, :revisit
             range = { low: anEntry.origin, high: anIndex }
             non_terminal = entry2nonterm(anEntry)
             # Create raw node and push onto stack
             push_raw_node(range, non_terminal)
+          #when :revisit
+          #  # TODO: design specification
           else
-            raise NotImplementedError
+            raise NotImplementedError, "Cannot handle event #{anEvent}"
         end
       end
 
@@ -143,7 +145,7 @@ module Rley # This module is used as a namespace
       end
 
       # @param anEntry [ParseEntry] Entry matching (pattern: N => . alpha)
-      # @param anIndex [_index] The token index at end of anEntry
+      # @param _index [Integer] The token index at end of anEntry
       def process_entry_entry(anEntry, _index)
         dotted_item = anEntry.vertex.dotted_item
         rule = dotted_item.production

data/lib/rley/parser/parse_tree_factory.rb

@@ -17,7 +17,7 @@ module Rley # This module is used as a namespace
         else
           CSTBuilder.new(aParseResult.tokens)
         end
-      end
+      end     
     end # class
   end # module
 end # module

data/lib/rley/parser/parse_walker_factory.rb

@@ -18,7 +18,8 @@ module Rley # This module is used as a namespace
       :nterm2start, # Nested hashes. Pairs of first level are of the form:
       # non-terminal symbol => { index(=origin) => start entry }
       :return_stack, # @return [Array<ParseEntry>] A stack of parse entries
-      :backtrack_points
+      :backtrack_points,
+      :lazy_walk # If true and revisit end vertex then jump to start vertex      
     )
 
 
@@ -26,7 +27,7 @@ module Rley # This module is used as a namespace
       :entry_set_index, # Sigma set index of current parse entry
       :return_stack, # A stack of parse entries
       :visitee, # The parse entry being visited
-      :antecedent_index
+      :antecedent_index,
     )
 
     # A factory that creates an Enumerator object
@@ -47,11 +48,12 @@ module Rley # This module is used as a namespace
       # @param acceptingEntry [ParseEntry] the final ParseEntry of a 
       #    successful parse.
       # @param maxIndex [Integer] the index of the last input token.
+      # @param lazyWalk [Boolean] if true then take some shortcut in re-visits.
       # @return [Enumerator] yields visit events when walking over the 
       #   parse result
-      def build_walker(acceptingEntry, maxIndex)
+      def build_walker(acceptingEntry, maxIndex, lazyWalk = false)
         # Local context for the enumerator
-        ctx = init_context(acceptingEntry, maxIndex)
+        ctx = init_context(acceptingEntry, maxIndex, lazyWalk)
 
         walker = Enumerator.new do |receiver| # 'receiver' is a Yielder
           # At this point: current entry == accepting entry
@@ -79,7 +81,7 @@ module Rley # This module is used as a namespace
       private
 
       # Context factory method
-      def init_context(acceptingEntry, maxIndex)
+      def init_context(acceptingEntry, maxIndex, lazyWalk)
         context = ParseWalkerContext.new
         context.entry_set_index = maxIndex
         context.curr_entry = acceptingEntry
@@ -87,6 +89,7 @@ module Rley # This module is used as a namespace
         context.nterm2start = init_nterm2start
         context.return_stack = []
         context.backtrack_points = []
+        context.lazy_walk = lazyWalk
 
         return context
       end
@@ -116,11 +119,13 @@ module Rley # This module is used as a namespace
         if aContext.visitees.include?(anEntry) # Already visited?...
           case anEntry.vertex
             when GFG::EndVertex
-              # Jump to related start entry...
-              pairs = aContext.nterm2start[anEntry.vertex.non_terminal]
-              new_entry = pairs[anEntry.origin]
-              aContext.curr_entry = new_entry
-              aContext.entry_set_index = new_entry.origin
+              if aContext.lazy_walk
+                # Jump to related start entry...
+                pairs = aContext.nterm2start[anEntry.vertex.non_terminal]
+                new_entry = pairs[anEntry.origin]
+                aContext.curr_entry = new_entry
+                aContext.entry_set_index = new_entry.origin
+              end
               event = [:revisit, anEntry, index]
 
             when GFG::StartVertex

data/spec/rley/parser/ambiguous_parse_spec.rb

@@ -48,7 +48,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         factory = ParseWalkerFactory.new
         accept_entry = sentence_result.accepting_entry
         accept_index = sentence_result.chart.last_index
-        @walker = factory.build_walker(accept_entry, accept_index)
+        @walker = factory.build_walker(accept_entry, accept_index, true)
       end
 
       context 'Ambiguous expression' do

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -299,8 +299,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = [
             '.Ss | 0',              # Initialization
             "Ss => . A A 'x' | 0",  # start rule
-            '.A | 0',               # call rule
-            'A => . | 0',           # start rule
+            '.A | 0',               # call rule         
+            'A => . | 0',           # start rule             
             'A. | 0',               # exit rule
             "Ss => A . A 'x' | 0",  # end rule
             "Ss => A A . 'x' | 0"   # end rule

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -60,7 +60,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       context 'Initialization:' do
-        it 'should be created with a GFG, tokens, trace' do
+        it 'should be created with a GFG, tokens' do
           expect { GFGParsing.new(sample_gfg, grm1_tokens) }
             .not_to raise_error
         end

data/spec/rley/parser/groucho_spec.rb

@@ -107,7 +107,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         factory = ParseWalkerFactory.new
         accept_entry = sentence_result.accepting_entry
         accept_index = sentence_result.chart.last_index
-        @walker = factory.build_walker(accept_entry, accept_index)
+        @walker = factory.build_walker(accept_entry, accept_index, true)
       end
 
       context 'Parse ambiguous sentence' do

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -92,7 +92,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           factory = ParseWalkerFactory.new
           accept_entry = sample_result.accepting_entry
           accept_index = sample_result.chart.last_index
-          @walker = factory.build_walker(accept_entry, accept_index)
+          @walker = factory.build_walker(accept_entry, accept_index, true)
         end
 
         it 'should initialize the root node' do

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -84,14 +84,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should return the accepting parse entry in the first place' do
-          walker = subject.build_walker(accept_entry, accept_index)
+          walker = subject.build_walker(accept_entry, accept_index, false)
           first_event = walker.next
           expectations = [:visit, sample_result.accepting_entry, 4]
           event_expectations(first_event, expectations)
         end
 
-        it 'should traverse the parse graph backwards' do
-          walker = subject.build_walker(accept_entry, accept_index)
+        it 'could traverse the parse graph backwards' do
+          walker = subject.build_walker(accept_entry, accept_index, false)
           event1 = walker.next
           expectations = [:visit, 'Phi. | 0', 4]
           event_expectations(event1, expectations)
@@ -163,9 +163,146 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event_expectations(event17, expectations)
 
           event18 = walker.next
-          expectations = [:revisit, 'T. | 1', 4]
+          expectations = [:revisit, 'T. | 1', 4]  # Re-visiting end vertex
           event_expectations(event18, expectations)
 
+          # No lazy walk: don't jump directly after corresponding start vertex
+          event19 = walker.next
+          expectations = [:revisit, 'T => b b b . | 1', 4]
+          event_expectations(event19, expectations)
+
+          event20 = walker.next
+          expectations = [:revisit, 'T => b b . b | 1', 3]
+          event_expectations(event20, expectations)
+
+          event21 = walker.next
+          expectations = [:revisit, 'T => b . b b | 1', 2]
+          event_expectations(event21, expectations)
+
+          event22 = walker.next
+          expectations = [:revisit, 'T => . b b b | 1', 1]
+          event_expectations(event22, expectations)
+
+          event23 = walker.next
+          expectations = [:revisit, '.T | 1', 1]
+          event_expectations(event23, expectations)
+
+          # Multiple visit occurred: jump to antecedent of start entry
+          event24 = walker.next
+          expectations = [:visit, 'S => A . T | 0', 1]
+          event_expectations(event24, expectations)
+
+          event25 = walker.next
+          expectations = [:visit, 'A. | 0', 1]
+          event_expectations(event25, expectations)
+
+          # Backtrack created: first alternative selected
+          event26 = walker.next
+          expectations = [:visit, 'A => a . | 0', 1]
+          event_expectations(event26, expectations)
+
+          event27 = walker.next
+          expectations = [:visit, 'A => . a | 0', 0]
+          event_expectations(event27, expectations)
+
+          event28 = walker.next
+          expectations = [:visit, '.A | 0', 0]
+          event_expectations(event28, expectations)
+
+          event29 = walker.next
+          expectations = [:visit, 'S => . A T | 0', 0]
+          event_expectations(event29, expectations)
+
+          event30 = walker.next
+          expectations = [:revisit, '.S | 0', 0]
+          event_expectations(event30, expectations)
+
+          event31 = walker.next
+          expectations = [:revisit, 'Phi => . S | 0', 0]
+          event_expectations(event31, expectations)
+
+          event32 = walker.next
+          expectations = [:revisit, '.Phi | 0', 0]
+          event_expectations(event32, expectations)
+
+          # Backtracking is occurring
+          event33 = walker.next
+          expectations = [:backtrack, 'A. | 0', 1]
+          event_expectations(event33, expectations)
+
+          event34 = walker.next
+          expectations = [:visit, 'A => B A . | 0', 1]
+          event_expectations(event34, expectations)
+
+          event35 = walker.next
+          expectations = [:revisit, 'A. | 0', 1] # Revisiting end vertex
+          event_expectations(event35, expectations)
+
+          # No lazy walk: don't jump directly after corresponding start vertex
+          event36 = walker.next
+          expectations = [:revisit, 'A => a . | 0', 1]
+          event_expectations(event36, expectations)
+
+          event37 = walker.next
+          expectations = [:revisit, 'A => . a | 0', 0]
+          event_expectations(event37, expectations)
+
+          event38 = walker.next
+          expectations = [:revisit, '.A | 0', 0]
+          event_expectations(event38, expectations)
+
+          event39 = walker.next
+          expectations = [:visit, 'A => B . A | 0', 0]
+          event_expectations(event39, expectations)
+
+          event40 = walker.next
+          expectations = [:visit, 'B. | 0', 0]
+          event_expectations(event40, expectations)
+
+          event41 = walker.next
+          expectations = [:visit, 'B => . | 0', 0]
+          event_expectations(event41, expectations)
+
+          event42 = walker.next
+          expectations = [:visit, '.B | 0', 0]
+          event_expectations(event42, expectations)
+
+          event43 = walker.next
+          expectations = [:visit, 'A => . B A | 0', 0]
+          event_expectations(event43, expectations)
+
+          event44 = walker.next
+          expectations = [:revisit, '.A | 0', 0]
+          event_expectations(event44, expectations)
+
+          event45 = walker.next
+          expectations = [:revisit, 'S => . A T | 0', 0]
+          event_expectations(event45, expectations)
+
+          event46 = walker.next
+          expectations = [:revisit, '.S | 0', 0]
+          event_expectations(event46, expectations)
+
+          event47 = walker.next
+          expectations = [:revisit, 'Phi => . S | 0', 0]
+          event_expectations(event47, expectations)
+
+          event48 = walker.next
+          expectations = [:revisit, '.Phi | 0', 0]
+          event_expectations(event48, expectations)
+        end
+
+
+        it 'could traverse lazily the parse graph backwards' do
+          walker = subject.build_walker(accept_entry, accept_index, true)
+
+          17.times { walker.next }
+
+          event18 = walker.next
+          expectations = [:revisit, 'T. | 1', 4]
+          event_expectations(event18, expectations)
+          
+          # Lazy walk: make start entry .T the current one
           # Multiple visit occurred: jump to antecedent of start entry
           event19 = walker.next
           expectations = [:visit, 'S => A . T | 0', 1]
@@ -195,7 +332,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event25 = walker.next
           expectations = [:revisit, '.S | 0', 0]
           event_expectations(event25, expectations)
-          
+
           event26 = walker.next
           expectations = [:revisit, 'Phi => . S | 0', 0]
           event_expectations(event26, expectations)
@@ -236,30 +373,30 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event35 = walker.next
           expectations = [:visit, 'A => . B A | 0', 0]
           event_expectations(event35, expectations)
-          
+
           event36 = walker.next
           expectations = [:revisit, '.A | 0', 0]
           event_expectations(event36, expectations)
 
           event37 = walker.next
           expectations = [:revisit, 'S => . A T | 0', 0]
-          event_expectations(event37, expectations)          
-          
+          event_expectations(event37, expectations)
+
           event38 = walker.next
           expectations = [:revisit, '.S | 0', 0]
           event_expectations(event38, expectations)
-          
+
           event39 = walker.next
           expectations = [:revisit, 'Phi => . S | 0', 0]
           event_expectations(event39, expectations)
 
           event40 = walker.next
           expectations = [:revisit, '.Phi | 0', 0]
-          event_expectations(event40, expectations)                   
+          event_expectations(event40, expectations)
         end
 
         it 'should raise an exception at end of visit' do
-          walker = subject.build_walker(accept_entry, accept_index)
+          walker = subject.build_walker(accept_entry, accept_index, true)
           40.times { walker.next }
 
           expect { walker.next }.to raise_error(StopIteration)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.5.04
+  version: 0.5.05
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-26 00:00:00.000000000 Z
+date: 2017-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -146,6 +146,13 @@ files:
 - examples/general/calc_iter1/calc_lexer.rb
 - examples/general/calc_iter1/calc_parser.rb
 - examples/general/calc_iter1/spec/calculator_spec.rb
+- examples/general/calc_iter2/calc_ast_builder.rb
+- examples/general/calc_iter2/calc_ast_nodes.rb
+- examples/general/calc_iter2/calc_demo.rb
+- examples/general/calc_iter2/calc_grammar.rb
+- examples/general/calc_iter2/calc_lexer.rb
+- examples/general/calc_iter2/calc_parser.rb
+- examples/general/calc_iter2/spec/calculator_spec.rb
 - lib/rley.rb
 - lib/rley/constants.rb
 - lib/rley/formatter/asciitree.rb