rley 0.7.06 → 0.8.01

data/lib/rley/parse_rep/cst_builder.rb

@@ -16,13 +16,13 @@ module Rley # This module is used as a namespace
     # nodes) and using a step by step approach.
     class CSTBuilder < ParseTreeBuilder
       protected
-      
+
       # Method to override
       # Create a parse tree object with given
       # node as root node.
       def create_tree(aRootNode)
         return Rley::PTree::ParseTree.new(aRootNode)
-      end      
+      end
 
       # Method to override
       # Factory method for creating a node object for the given
@@ -42,10 +42,9 @@ module Rley # This module is used as a namespace
       # @param theChildren [Array] Children nodes (one per rhs symbol)
       def new_parent_node(aProduction, aRange, _tokens, theChildren)
         node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
-        if theChildren
-          theChildren.reverse_each { |child| node.add_subnode(child) }
-        end
-        return node
+        theChildren&.reverse_each { |child| node.add_subnode(child) }
+
+        node
       end
     end # class
   end # module

data/lib/rley/parse_rep/parse_forest_builder.rb

@@ -44,7 +44,7 @@ module Rley # This module is used as a namespace
       end
 
       # Notify the builder that the construction is over
-      def done!()
+      def done!
         result.done!
       end
 
@@ -64,7 +64,7 @@ module Rley # This module is used as a namespace
       end
 
       # Return the current_parent node
-      def curr_parent()
+      def curr_parent
         curr_path.last
       end
 
@@ -110,18 +110,18 @@ module Rley # This module is used as a namespace
       def process_item_entry(anEvent, anEntry, anIndex)
         case anEvent
           when :visit
-            if anEntry.exit_entry?
+            if anEntry.exit_entry? && last_visitee.end_entry? &&
+               last_visitee.antecedents.size > 1
               # Previous entry was an end entry (X. pattern)
               # Does the previous entry have multiple antecedent?
-              if last_visitee.end_entry? && last_visitee.antecedents.size > 1
-                # Store current path for later backtracking
-                # puts "Store backtrack context #{last_visitee}"
-                # puts "path [#{curr_path.map{|e|e.to_string(0)}.join(', ')}]"
-                entry2path_to_alt[last_visitee] = curr_path.dup
-                curr_parent.refinement = :or
-
-                create_alternative_node(anEntry)
-              end
+
+              # Store current path for later backtracking
+              # puts "Store backtrack context #{last_visitee}"
+              # puts "path [#{curr_path.map{|e|e.to_string(0)}.join(', ')}]"
+              entry2path_to_alt[last_visitee] = curr_path.dup
+              curr_parent.refinement = :or
+
+              create_alternative_node(anEntry)
             end
 
             # Does this entry have multiple antecedent?
@@ -155,6 +155,7 @@ module Rley # This module is used as a namespace
             # Restore path
             @curr_path = entry2path_to_alt[anEntry].dup
             raise StandardError, 'path is nil' if curr_path.nil?
+
             create_alternative_node(anEntry)
 
           when :revisit
@@ -178,7 +179,7 @@ module Rley # This module is used as a namespace
 
       # Create an empty parse forest
       def create_forest(aRootNode)
-        return Rley::SPPF::ParseForest.new(aRootNode)
+        Rley::SPPF::ParseForest.new(aRootNode)
       end
 
       # Factory method. Build and return an SPPF non-terminal node.
@@ -189,7 +190,7 @@ module Rley # This module is used as a namespace
         add_subnode(new_node)
         # puts "FOREST ADD #{curr_parent.key if curr_parent}/#{new_node.key}"
 
-        return new_node
+        new_node
       end
 
       # Add an alternative node to the forest
@@ -201,7 +202,7 @@ module Rley # This module is used as a namespace
         result.is_ambiguous = true
         # puts "FOREST ADD #{alternative.key}"
 
-        return alternative
+        alternative
       end
 
       # create a token node,
@@ -215,7 +216,7 @@ module Rley # This module is used as a namespace
         candidate = add_node_to_forest(new_node)
         entry2node[anEntry] = candidate
 
-        return candidate
+        candidate
       end
 
       def create_epsilon_node(anEntry, anIndex)
@@ -223,7 +224,7 @@ module Rley # This module is used as a namespace
         candidate = add_node_to_forest(new_node)
         entry2node[anEntry] = candidate
 
-        return candidate
+        candidate
       end
 
       # Add the given node if not yet present in parse forest
@@ -238,16 +239,19 @@ module Rley # This module is used as a namespace
         end
         add_subnode(new_node, false)
 
-        return new_node
+        new_node
       end
 
       # Add the given node as sub-node of current parent node
       # Optionally add the node to the current path
+      # rubocop: disable Style/OptionalBooleanParameter
       def add_subnode(aNode, addToPath = true)
         raise StandardError, 'node is nil' if aNode.nil?
+
         curr_parent.add_subnode(aNode) unless curr_path.empty?
         curr_path << aNode if addToPath
       end
+      # rubocop: enable Style/OptionalBooleanParameter
     end # class
   end # module
 end # module

data/lib/rley/parse_rep/parse_forest_factory.rb

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

data/lib/rley/parse_rep/parse_rep_creator.rb

@@ -7,18 +7,18 @@ module Rley # This module is used as a namespace
     # Utility class that helps to create a representation of a parse from
     # a given Parsing object.
     class ParseRepCreator
-      # @return [Rley::Parser::GFGParsing] 
+      # @return [Rley::Parser::GFGParsing]
       #  Link to Parsing object (= results of recognizer)
       attr_reader(:parsing)
-      
+
       # Constructor. Creates and initialize a ParseRepCreator instance.
       # @return [ParseRepCreator]
       def initialize(aParsingResult)
         @parsing = aParsingResult
-      end      
-      
+      end
+
       # Factory method that produces the representation of the parse.
-      # @return [Rley::PTree::ParseTree, Rley::SPPF::ParseForest] 
+      # @return [Rley::PTree::ParseTree, Rley::SPPF::ParseForest]
       #   The parse representation.
       def create(aBuilder = nil)
         a_walker = walker(parsing)
@@ -32,20 +32,20 @@ module Rley # This module is used as a namespace
           end
         rescue StopIteration
           # Do nothing: gobble the exception
-        rescue StandardError => exc
-          if exc.message =~ /^Ambiguous/
+        rescue StandardError => e
+          if e.message =~ /^Ambiguous/
             $stderr.puts parsing
           end
-          raise exc
+          raise e
         end
-        
+
         a_builder.done!
 
-        return a_builder.result
+        a_builder.result
       end
-      
+
       private
-      
+
       # Create a Parsing walker, that is, an object
       # that will iterate over the relevant nodes (= parsing entries)
       # of a GFGParsing
@@ -58,13 +58,11 @@ module Rley # This module is used as a namespace
 
       # By default, when a end vertex is re-visited don't jump
       # its corresponding start vertex.
-      def jump_to_start()
+      def jump_to_start
         false
       end
-      
     end # class
   end # module
 end # module
 
-# End of file 
-   
+# End of file

data/lib/rley/parse_rep/parse_tree_builder.rb

@@ -50,7 +50,7 @@ module Rley # This module is used as a namespace
       end
 
       # Notify the builder that the parse tree construction is complete.
-      def done!()
+      def done!
         result.done!
       end
 
@@ -92,7 +92,7 @@ module Rley # This module is used as a namespace
       private
 
       # Return the top of stack element.
-      def tos()
+      def tos
         @stack.last
       end
 
@@ -207,7 +207,7 @@ module Rley # This module is used as a namespace
       # @param anEntry [ParseEntry] The entry being visited
       def terminal_before_dot?(anEntry)
         prev_symbol = anEntry.prev_symbol
-        return prev_symbol && prev_symbol.terminal?
+        prev_symbol&.terminal?
       end
 
       # A terminal symbol was detected at left of dot.
@@ -260,7 +260,7 @@ module Rley # This module is used as a namespace
             non_terminal = anEntry.vertex.lhs
         end
 
-        return non_terminal
+        non_terminal
       end
     end # class
   end # module

data/lib/rley/parse_rep/parse_tree_factory.rb

@@ -1,27 +1,27 @@
-# frozen_string_literal: true
-
-require_relative 'parse_rep_creator'
-# require_relative 'parse_tree_builder' # TODO remove this line
-require_relative 'cst_builder'
-
-module Rley # This module is used as a namespace
-  module ParseRep # This module is used as a namespace
-    # Utility class that helps to create a ParseTree from
-    # a given Parsing object.
-    class ParseTreeFactory < ParseRepCreator
-      protected
-
-      # Create a Builder, that is, an object
-      # that will create piece by piece the forest
-      def builder(aParseResult, aBuilder = nil)
-        if aBuilder
-          aBuilder.new(aParseResult.tokens)
-        else
-          CSTBuilder.new(aParseResult.tokens)
-        end
-      end     
-    end # class
-  end # module
-end # module
-
-# End of file
+# frozen_string_literal: true
+
+require_relative 'parse_rep_creator'
+# require_relative 'parse_tree_builder' # TODO remove this line
+require_relative 'cst_builder'
+
+module Rley # This module is used as a namespace
+  module ParseRep # This module is used as a namespace
+    # Utility class that helps to create a ParseTree from
+    # a given Parsing object.
+    class ParseTreeFactory < ParseRepCreator
+      protected
+
+      # Create a Builder, that is, an object
+      # that will create piece by piece the forest
+      def builder(aParseResult, aBuilder = nil)
+        if aBuilder
+          aBuilder.new(aParseResult.tokens)
+        else
+          CSTBuilder.new(aParseResult.tokens)
+        end
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parse_tree_visitor.rb

@@ -37,7 +37,7 @@ module Rley # This module is used as a namespace
     end
 
     # The signal to begin the visit of the parse tree.
-    def start()
+    def start
       ptree.accept(self)
     end
 

data/lib/rley/parser/error_reason.rb

@@ -17,7 +17,7 @@ module Rley # Module used as a namespace
       end
 
       # @return [String] the result of invoking reason.to_s
-      def message()
+      def message
         return to_s
       end
 
@@ -27,11 +27,10 @@ module Rley # Module used as a namespace
       end
     end # class
 
-
     # This parse error occurs when no input for parsing was provided
     # while the grammar requires some non-empty input.
     class NoInput < ErrorReason
-      def initialize()
+      def initialize
         super(0)
       end
 
@@ -61,7 +60,7 @@ module Rley # Module used as a namespace
 
       protected
 
-      def position()
+      def position
         return last_token.position if last_token.respond_to?(:position)
 
         rank + 1
@@ -76,7 +75,7 @@ module Rley # Module used as a namespace
                    else
                      "'#{term_names[0]}'"
                    end
-        return explain
+        explain
       end
     end # class
 

data/lib/rley/parser/gfg_chart.rb

@@ -12,38 +12,52 @@ module Rley # This module is used as a namespace
     # the chart is an array with n + 1 entry sets.
     class GFGChart
       # @return [Array<ParseEntrySet>] entry sets (one per input token + 1)
-      attr_reader(:sets)
+      attr_reader :sets
+
+      # @return [Array<Array<Syntax::MatchClosest>>]
+      attr_reader :constraints
 
       # @param aGFGraph [GFG::GrmFlowGraph] The GFG for the grammar in use.
       def initialize(aGFGraph)
-        @sets = [ ParseEntrySet.new ]
+        @sets = [ParseEntrySet.new]
+        @constraints = [[]]        
         push_entry(aGFGraph.start_vertex, 0, 0, :start_rule)
       end
 
       # @return [Syntax::NonTerminal] the start symbol of the grammar.
-      def start_symbol()
-        return sets.first.entries[0].vertex.non_terminal
+      def start_symbol
+        sets.first.entries[0].vertex.non_terminal
       end
 
       # @param index [Integer]
       # @return [ParseEntrySet] Access the entry set at given position.
       def [](index)
-        return sets[index]
+        sets[index]
       end
 
       # Return the index value of the last non-empty entry set.
       # @return [Integer]
-      def last_index()
+      def last_index
         first_empty = sets.find_index(&:empty?)
-        index = if first_empty.nil?
-                  sets.size - 1
-                else
-                  first_empty.zero? ? 0 : first_empty - 1
-                end
-
-        return index
+        if first_empty.nil?
+          sets.size - 1
+        else
+          first_empty.zero? ? 0 : first_empty - 1
+        end
       end
 
+      # if an entry corresponds to dotted item with a constraint
+      # make this constraint active for this index
+      # :before 'IF'
+      # search backwards to find nearest 'IF' scan rule
+      # in n+1, retrieve all items with IF . pattern
+      # create a lambda
+      # for every subsequent push_entry with same index,
+      # the lambda checks the condition (i.e pattern: ELSE . )
+      # if the condition is false, then push new entry
+      # if the condition is true but the consequent is false, then discard push action
+      # consequent: candidate refers to same dotted_item and same origin, then condition is false
+
       # Push a parse entry for the chart entry with given index
       # @param anIndex [Integer] The rank of the token in the input stream.
       # @return [ParseEntry] the passed parse entry if it is pushed
@@ -53,27 +67,59 @@ module Rley # This module is used as a namespace
         # puts "  anOrigin: #{anOrigin}"
         # puts "  anIndex: #{anIndex}"
         # puts "  _reason: #{_reason}"
-        new_entry = ParseEntry.new(aVertex, anOrigin)
         if anIndex == sets.size
-          err_msg = "Internal error: unexpected push reason #{reason}"
-          raise StandardError, err_msg if reason != :scan_rule
+          if reason == :scan_rule
+            add_entry_set
+          else
+            err_msg = "Internal error: unexpected push reason #{reason}"
+            raise StandardError, err_msg
+          end
+        end
+
+        reject = false
+        unless constraints[anIndex].empty?
+          constraints[anIndex].each do |ct|
+            case ct
+              when Syntax::MatchClosest
+                not_found = sets[anIndex][0].prev_symbol != aVertex.prev_symbol
+                next if not_found
+
+                some_mismatch = ct.entries.find do |en|
+                  (en.vertex.dotted_item.production == aVertex.dotted_item.production) &&
+                    (en.origin != anOrigin)
+                end
+                reject = true if some_mismatch
+            end
+          end
+        end
+
+        return nil if reject
+
+        new_entry = ParseEntry.new(aVertex, anOrigin)
+        result = self[anIndex].push_entry(new_entry)
 
-          add_entry_set
+        if aVertex.kind_of?(GFG::ItemVertex) && aVertex.dotted_item.constraint
+          ct = aVertex.dotted_item.constraint
+
+          case ct
+            when Syntax::MatchClosest
+              update_match_closest(ct, anIndex)
+          end
+          constraints[anIndex] << ct
         end
-        pushed = self[anIndex].push_entry(new_entry)
 
-        return pushed
+        result
       end
 
       # Retrieve the first parse entry added to this chart
       # @return [ParseEntry]
-      def initial_entry()
-        return sets[0].first
+      def initial_entry
+        sets[0].first
       end
 
       # Retrieve the entry that corresponds to a complete and successful parse
       # @return [ParseEntry]
-      def accepting_entry()
+      def accepting_entry
         # Success can be detected as follows:
         # The last chart entry set has at least one complete parse entry
         # for the start symbol with an origin == 0
@@ -95,7 +141,7 @@ module Rley # This module is used as a namespace
 
         success_entries.first
       end
-      
+
       # @return [Integer] The number of states.
       def count_states
         sets.size
@@ -103,6 +149,7 @@ module Rley # This module is used as a namespace
 
       # @return [Integer] The total number of entries.
       def count_entries
+        # rubocop: disable Lint/UselessAssignment
         sets.reduce(0) do |sub_result, a_set|
           sub_result += a_set.size
         end
@@ -114,6 +161,26 @@ module Rley # This module is used as a namespace
           sub_result += a_set.count_edges
         end
       end
+      # rubocop: enable Lint/UselessAssignment
+
+      # Retrieve all entries that have a given terminal before the dot.
+      # @param criteria [Hash{Symbol => String}]
+      def search_entries(atIndex, criteria)
+        entries = sets[atIndex].entries
+        keyword = criteria.keys[0]
+        found = []
+        entries.each do |e|
+          case keyword
+            when :before # terminal before dot
+              term_name = criteria[keyword]
+              if e.dotted_entry? && e.vertex.dotted_item.position > -2
+                found << e if e.prev_symbol&.name == criteria[keyword]
+              end
+          end
+        end
+
+        found
+      end
 
       # @ return [String] A human-readable representation of the chart.
       def to_s
@@ -121,17 +188,42 @@ module Rley # This module is used as a namespace
         sets.each_with_index do |a_set, i|
           result << "State[#{i}]\n"
           a_set.entries.each do |item|
-            result << '  ' + item.to_s + "\n"
+            result << "  #{item}\n"
           end
         end
-        
+
         result
       end
 
       private
 
-      def add_entry_set()
+      def add_entry_set
          @sets << ParseEntrySet.new
+         @constraints << []
+      end
+
+      def update_match_closest(aConstraint, anIndex)
+        # Locate in the chart the closest matching terminal...
+        i = anIndex - 1
+        loop do
+          first_entry = sets[i][0]
+          prev_symbol = first_entry.prev_symbol
+          break if prev_symbol.name == aConstraint.closest_symb
+          i -= 1
+          break if i < 0
+        end
+
+        # Retrieve all entries of the kind: closest_symb .
+        if i > 0
+          entries = sets[i].entries.select do |en|
+            if en.prev_symbol
+              en.prev_symbol.name == aConstraint.closest_symb
+            else
+              false
+            end
+          end
+          aConstraint.entries = entries
+        end
       end
     end # class
   end # module