rley 0.2.15 → 0.3.00

data/lib/rley/parser/parse_entry.rb

@@ -0,0 +1,148 @@
+require_relative '../gfg/start_vertex'
+require_relative '../gfg/end_vertex'
+require_relative '../gfg/item_vertex'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+
+    # Responsibilities:
+    # - To know whether the vertex is a start, end or item vertex
+    # - To know the next symbol to expect
+    class ParseEntry
+      # Link to a vertex of the GFG
+      attr_reader(:vertex)
+
+      # Links to preceding parse entries
+      attr_reader(:antecedents)
+
+      # the position in the input that matches the beginning of the rhs
+      # of the production.
+      attr_reader(:origin)
+
+      def initialize(aVertex, theOrigin)
+        @vertex = valid_vertex(aVertex)
+        @origin = theOrigin
+        @antecedents = []
+      end
+
+      # Add a link to an antecedent parse entry
+      def add_antecedent(anAntecedent)
+        antecedents << anAntecedent
+      end
+
+      # Equality comparison. A parse entry behaves as a value object.
+      def ==(other)
+        return true if object_id == other.object_id
+
+        if (vertex == other.vertex) && (origin == other.origin)
+          result = true
+        else
+          result = false
+        end
+
+        return result
+      end
+
+      # Returns true iff the vertex is a start vertex (i.e. of the form: .X)
+      def start_entry?()
+        return vertex.kind_of?(GFG::StartVertex)
+      end
+
+      # Returns true iff the vertex is at the start of rhs
+      # (i.e. of the form: X => .Y
+      def entry_entry?()
+        return false unless vertex.kind_of?(GFG::ItemVertex)
+
+        return vertex.dotted_item.at_start?
+      end
+
+      # Returns true iff the vertex corresponds to a dotted item
+      # X => Y
+      def dotted_entry?
+        return vertex.kind_of?(GFG::ItemVertex)
+      end
+
+      # Returns true iff the vertex is at end of rhs (i.e. of the form: X => Y.)
+      def exit_entry?()
+        return vertex.complete?
+      end
+
+      # Returns true iff the vertex is an end vertex (i.e. of the form: X.)
+      def end_entry?()
+        return vertex.kind_of?(GFG::EndVertex)
+      end
+
+
+      # Return the symbol before the dot (if any)
+      def prev_symbol()
+        return vertex.prev_symbol
+      end
+
+      # Return the symbol after the dot (if any)
+      def next_symbol()
+        return vertex.next_symbol
+      end
+      
+      # Return true if the entry has no antecedent entry
+      def orphan?()
+        return antecedents.empty?
+      end
+
+=begin
+      # Returns true if the dot is at the end of the rhs of the production.
+      # In other words, the complete rhs matches the input.
+      def complete?()
+        return vertex.reduce_item?
+      end
+
+      # Returns true if the dot is at the start of the rhs of the production.
+      def predicted?()
+        return vertex.predicted_item?
+      end
+
+      # Next expected symbol in the production
+      def next_symbol()
+        return vertex.next_symbol
+      end
+
+      # Does this parse state have the 'other' as successor?
+      def precedes?(other)
+        return false if self == other
+
+        return false unless origin == other.origin
+        other_production = other.dotted_rule.production
+        return false unless dotted_rule.production == other_production
+
+        prev_position = other.dotted_rule.prev_position
+        if prev_position.nil?
+          result = false
+        else
+          result = dotted_rule.position == prev_position
+        end
+
+        return result
+      end
+=end
+
+      # Give a String representation of itself.
+      # The format of the text representation is
+      # "format of dotted rule" + " | " + origin
+      # @return [String]
+      def to_s()
+        return vertex.label + " | #{origin}"
+      end
+
+
+      private
+
+      # Return the validated GFG vertex
+      def valid_vertex(aVertex)
+        fail StandardError, 'GFG vertex cannot be nil' if aVertex.nil?
+
+        return aVertex
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/parse_entry_set.rb

@@ -0,0 +1,104 @@
+require 'forwardable' # Delegation
+
+require_relative '../syntax/terminal'
+require_relative '../syntax/non_terminal'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Responsibilities:
+    # - To know all the parse entries in the set
+    class ParseEntrySet
+      extend Forwardable
+      def_delegators :entries, :empty?, :size, :first, :last, :pop, :each   
+
+      # The set of parse entries
+      attr_reader :entries
+
+      # A Hash with pairs of the form:
+      #   terminal symbol => [ parse entry expecting the terminal ]
+      #attr_reader :entries4term
+
+      # A Hash with pairs of the form:
+      #   non terminal symbol => [ parse entry expecting the non-terminal ]
+      # attr_reader :entries4n_term
+
+      def initialize()
+        @entries = []
+        @entries4term = Hash.new { |hash, key| hash[key] = [] } 
+        @entries4n_term = Hash.new { |hash, key| hash[key] = [] }
+      end
+      
+      # Access the entry at given position
+      def [](index)
+        return entries[index]
+      end  
+
+      def entries4term(aTerminal)
+        return @entries4term.fetch(aTerminal, [])
+      end
+      
+      def entries4n_term(aNonTerminal)
+        return @entries4n_term.fetch(aNonTerminal, [])
+      end
+      
+      # Append the given entry (if it isn't yet in the set)
+      # to the list of parse entries
+      # @param aState [ParseEntry] the parse entry to push.
+      # @return [ParseEntry] the passed parse entry it doesn't   added
+      def push_entry(anEntry)
+        match = entries.find { |entry| entry == anEntry }
+        if match
+          result = match
+        #if entries.include?(anEntry)  # TODO: check performance
+        #  result = false
+        else
+          @entries << anEntry
+          expecting = anEntry.next_symbol
+          add_lookup4symbol(anEntry) if expecting
+          result = anEntry
+        end
+        
+        return result      
+      end
+
+      
+      # Return an Array of Arrays of ambiguous parse entries.
+      def ambiguities()
+        complete_entries = entries.select { |entry| entry.exit_entry? }
+        return [] if complete_entries.size <= 1
+        
+        # Group parse entries by lhs symbol and origin
+        groupings = complete_entries.group_by do |entry|
+          "#{entry.vertex.dotted_rule.lhs.object_id}"
+        end
+        
+        # Retain the groups having more than one element.
+        ambiguous_groups = []
+        groupings.each_value do |a_group|
+          ambiguous_groups << a_group if a_group.size > 1
+        end
+        
+        return ambiguous_groups
+      end
+
+      # The list of distinct expected terminal symbols. An expected symbol
+      # is on the left of a dot in a parse state of the parse set.
+      def expected_terminals()
+        return @entries4term.keys
+      end      
+      
+private
+      def add_lookup4symbol(anEntry)
+        symb = anEntry.next_symbol
+        case symb
+        when Syntax::Terminal
+          @entries4term[symb] << anEntry  
+          
+        when Syntax::NonTerminal
+          @entries4n_term[symb] << anEntry
+        end
+      end
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/parser/parse_entry_tracker.rb

@@ -0,0 +1,56 @@
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Helper class that keeps track of the parse entries used
+    # while a Parsing instance is constructing a parse forest.
+    class ParseEntryTracker
+      # The index of the current entry set
+      attr_reader(:entry_set_index)
+      
+      # The current parse entry
+      attr_reader(:parse_entry)
+      
+      # The already processed entries from current entry set
+      attr_reader(:processed_entries)      
+      
+      # Constructor.
+      def initialize(aEntrySetIndex)
+        self.entry_set_index = aEntrySetIndex
+      end
+      
+      # Write accessor. Sets the value of the entry set index
+      def entry_set_index=(anIndex)
+        @entry_set_index = anIndex
+        @processed_entries = {}
+      end
+
+      # Write accessor. Set the given parse entry as the current one.
+      def parse_entry=(aParseEntry)
+        fail StandardError, 'Nil parse entry' if aParseEntry.nil?
+        @parse_entry = aParseEntry
+        processed_entries[parse_entry] = true
+      end
+      
+      # Take the first provided entry that wasn't processed yet.
+      def select_entry(theEntrys)
+        a_entry = theEntrys.find { |st| !processed_entries.include?(st) }
+        self.parse_entry = a_entry
+      end
+      
+      # The dotted item for the current parse entry.
+      def curr_dotted_item()
+        parse_entry.dotted_rule
+      end
+      
+      def symbol_on_left()
+        return curr_dotted_item.prev_symbol
+      end
+      
+      # Notification that one begins with the previous entry set
+      def to_prev_entry_set()      
+        self.entry_set_index = entry_set_index - 1
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/parse_forest_builder.rb

@@ -0,0 +1,229 @@
+require_relative '../sppf/epsilon_node'
+require_relative '../sppf/non_terminal_node'
+require_relative '../sppf/alternative_node'
+require_relative '../sppf/parse_forest'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Builder GoF pattern. Builder pattern builds a complex object
+    # (say, a parse forest) from simpler objects (terminal and non-terminal
+    # nodes) and using a step by step approach.
+    class ParseForestBuilder
+      # Link to parse result
+      attr_reader(:parsing)
+
+      # Link to forest object
+      attr_reader(:forest)
+
+      # Link to current path
+      attr_reader(:curr_path)
+
+      # A hash with pairs of the form: visited parse entry => forest node
+      attr_reader(:entry2node)
+
+      # A hash with pairs of the form: parent end entry => path to alternative node
+      # This is needed for synchronizing backtracking
+      attr_reader(:entry2path_to_alt)
+
+      def initialize(aParsingResult)
+        @parsing = aParsingResult
+        @curr_path = []
+        @entry2node = {}
+        @entry2path_to_alt = {}
+      end
+
+      def receive_event(anEvent, anEntry, anIndex)
+        # puts "Event: #{anEvent} #{anEntry} #{anIndex}"
+        case anEntry.vertex
+          when GFG::StartVertex
+            process_start_entry(anEvent, anEntry, anIndex)
+
+          when GFG::ItemVertex
+            process_item_entry(anEvent, anEntry, anIndex)
+
+          when GFG::EndVertex
+            process_end_entry(anEvent, anEntry, anIndex)
+          else
+            fail NotImplementedError
+        end
+      end
+
+      # Return the current_parent node
+      def curr_parent()
+        return self.curr_path.last
+      end
+
+private
+
+      def process_start_entry(anEvent, anEntry, anIndex)
+        self.curr_path.pop while curr_parent.kind_of?(SPPF::AlternativeNode)
+        self.curr_path.pop
+      end
+
+      def process_end_entry(anEvent, anEntry, anIndex)
+        case anEvent
+        when :visit
+          if curr_path.empty?
+            # Build parse forest with root node derived from the
+            # accepting parse entry.
+            @forest = create_forest(anEntry)
+          else
+            # if current_parent node matches the lhs non-terminal of anEntry
+            # set its origin to the origin of its first child (if not yet assigned)
+            curr_parent.range.assign(low: anEntry.origin)
+            @entry2node[anEntry] = self.curr_parent
+            if anEntry.antecedents.size > 1
+              # Store current path for later backtracking
+              # puts "Store backtrack context #{anEntry}"
+              # puts "path [#{curr_path.join(', ')}]"
+              self.entry2path_to_alt[anEntry] = curr_path.dup
+              curr_parent.refinement = :or
+
+              create_alternative_node(anEntry.antecedents.first)
+            end
+          end
+
+        when :backtrack
+          # Restore path
+          @curr_path = self.entry2path_to_alt[anEntry].dup
+          # puts "Restore path #{curr_path.join(', ')}]"
+          antecedent_index = curr_parent.subnodes.size
+          # puts "Current parent #{curr_parent.to_string(0)}"
+          # puts "Antecedent index #{antecedent_index}"
+          create_alternative_node(anEntry.antecedents[antecedent_index])
+
+        when :revisit
+          # Remove most recent entry in path
+          @curr_path.pop
+
+          # Remove also its reference in parent
+          curr_parent.subnodes.pop
+
+          # Retrieve the already existing node corresponding to re-visited entry
+          popular = @entry2node[anEntry]
+
+          # Share with parent
+          curr_parent.add_subnode(popular)
+
+        else
+          fail NotImplementedError
+        end
+      end
+
+=begin
+  if it is a dotted item entry (pattern is: X => α . β):
+    if there is at least one symbol before the dot
+      if that symbol is a non-terminal:
+
+      if that symbol is a terminal # else
+        create a token node,
+          with same origin as token,
+          with same right extent = origin + 1
+        add the new node as first child of current_parent
+        set curr_entry_set_index to curr_entry_set_index - 1
+    if it is a dotted item entry with a beginning dot: # else
+      if current_parent node matches the lhs non-terminal of anEntry
+        set its origin to the origin of its first child (if not yet assigned)
+      remove this node from the path
+=end
+      def process_item_entry(anEvent, anEntry, anIndex)
+        # Retrieve the grammar symbol before the dot (if any)
+        prev_symbol = anEntry.prev_symbol
+        case prev_symbol
+          when Syntax::Terminal
+            # create a token node,
+            #   with same origin as token,
+            #   with same right extent = origin + 1
+            # add the new node as first child of current_parent
+            create_token_node(anEntry, anIndex)
+
+
+          when Syntax::NonTerminal
+            # create a node with the non-terminal before the dot,
+            #   with same right extent as curr_entry_set_index
+            # add the new node as first child of current_parent
+            # append the new node to the curr_path
+            range = { high: anIndex }
+            create_non_terminal_node(anEntry, range, prev_symbol)
+
+          when NilClass # Dot at the beginning of production
+            if anEntry.vertex.dotted_item.production.empty?
+              # Empty rhs => create an epsilon node
+              create_epsilon_node(anEntry, anIndex)
+            end
+        end
+      end
+      
+      # Create an empty parse forest
+      def create_forest(anEntry)
+        full_range = { low: 0, high: parsing.chart.last_index }
+        root_node = create_non_terminal_node(anEntry, full_range)
+        return Rley::SPPF::ParseForest.new(root_node)      
+      end
+
+
+      # Factory method. Build and return an SPPF non-terminal node.
+      def create_non_terminal_node(anEntry, aRange, nonTSymb = nil)
+        non_terminal = nonTSymb.nil? ? anEntry.vertex.non_terminal : nonTSymb
+        new_node = Rley::SPPF::NonTerminalNode.new(non_terminal, aRange)
+        entry2node[anEntry] = new_node
+        add_subnode(new_node)
+
+        return new_node
+      end
+
+
+      # Add an alternative node to the forest
+      def create_alternative_node(anEntry)
+        alternative = Rley::SPPF::AlternativeNode.new(anEntry.vertex, curr_parent.range)
+        add_subnode(alternative)
+
+        return alternative
+      end
+
+      def create_token_node(anEntry, anIndex)
+        token_position = anIndex - 1
+        curr_token = parsing.tokens[token_position]
+        new_node = SPPF::TokenNode.new(curr_token, token_position)
+        candidate = add_node_to_forest(new_node)
+        entry2node[anEntry] = candidate        
+
+        return candidate        
+      end
+
+
+      def create_epsilon_node(anEntry, anIndex)
+        new_node = SPPF::EpsilonNode.new(anIndex)
+        candidate = add_node_to_forest(new_node)
+        entry2node[anEntry] = candidate        
+
+        return candidate
+      end
+      
+      # Add the given node if not yet present in parse forest
+      def add_node_to_forest(aNode)
+        key_node = aNode.key
+        if forest.include?(key_node)
+          new_node = forest.key2node[key_node]
+        else
+          new_node = aNode
+          forest.key2node[key_node] = new_node
+          # puts "FOREST ADD #{key_node}"
+        end
+        add_subnode(new_node, false)  
+
+        return new_node
+      end
+
+
+      # Add the given node as sub-node of current parent node
+      # Optionally add the node to the current path
+      def add_subnode(aNode, addToPath = true)
+        curr_parent.add_subnode(aNode) unless curr_path.empty?
+        self.curr_path << aNode if addToPath
+      end
+    end # class
+  end # module
+end # module
+
+# End of file