rley 0.2.15 → 0.3.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a8824f31c8801d99d12566267a5e8cd95bb26c1
-  data.tar.gz: d5a0887f857d5b0efe154f10a202932960bc2e9e
+  metadata.gz: 5b7bad0d01ea1fbe0656bf1765843288c1521b26
+  data.tar.gz: d7b96f2d154b172c0847b3a96eaf0b6422439db1
 SHA512:
-  metadata.gz: cbf13dc6ac58dced26074ed1b2f9a4aab99b2834ea720743621d0cec7f0e0b17b7dc89e19956765b4921f4e1f4601b1858da92bcf0260b86c41de5c1c040579d
-  data.tar.gz: fed291494d3178e6813f561ef301ac60fc88604c81c0f8b40ee8fa8639e20873cef29fc79d90b47993e228134b1dcf0a8502ad1c3336b7e91659cb3a0c006345
+  metadata.gz: 76fa3fcf95a3bb55ca2e13eb1b449032cb3030cf18c5ab114e2398aeec16401d8c2b738f9818831dd4360d143f24f1240ffd13b8f0c495dcb8f5c684675ec894
+  data.tar.gz: 52f7f640dfc96d9f78a9ee1a44da1fb81086d446b1196d9a422bb5f6e7312c0e6ea089ce595b78b3b4c1d51d4cf810b18cda26fefd2477f7b5190dc9dfb8bca3

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.3.00 / 2016-10-23
+* [CHANGE] Many new classes. The gem bundles a second parser that copes with ambiguous grammars. 
+
+
 ### 0.2.15 / 2016-02-14
 * [CHANGE] A lot of internal changes. This is the last version before a Grammar Flow Graph-based parsing implementation.
 

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.2.15'
+  Version = '0.3.00'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/gfg/call_edge.rb

@@ -0,0 +1,30 @@
+require_relative 'edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Specialization of an edge in a grammar flow graph
+    # that has a item vertex as its head (predecessor).    
+    # and a start vertex (.X) as its tail (successor).
+    # Responsibilities:
+    # - To know the successor vertex (tail)
+    class CallEdge < Edge
+      attr_reader(:key)
+    
+      # Pre-condition: thePredecessor is an ItemVertex
+      # Pre-condition: theSuccessor is an StartVertex
+      def initialize(thePredecessor, theSuccessor)
+        super(thePredecessor, theSuccessor)
+        do_set_key(thePredecessor, theSuccessor)
+      end
+      
+private
+      def do_set_key(thePredecessor, theSuccessor)
+        tail_d_item = thePredecessor.dotted_item
+        @key = "CALL_#{tail_d_item.production.object_id}_#{tail_d_item.position}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/edge.rb

@@ -11,6 +11,10 @@ module Rley # This module is used as a namespace
         @successor = theSuccessor
         thePredecessor.add_edge(self)
       end
+      
+      def to_s()
+        " --> #{successor.label}"
+      end      
 
     end # class
   end # module

data/lib/rley/gfg/end_vertex.rb

@@ -15,7 +15,7 @@ module Rley # This module is used as a namespace
       
       def label()
         return "#{non_terminal}."
-      end
+      end      
 
     end # class
   end # module

data/lib/rley/gfg/epsilon_edge.rb

@@ -13,10 +13,6 @@ module Rley # This module is used as a namespace
       def initialize(thePredecessor, theSuccessor)
         super(thePredecessor, theSuccessor)
       end
-      
-      def to_s()
-        " --> #{successor.label}"
-      end
 
     end # class
   end # module

data/lib/rley/gfg/grm_flow_graph.rb

@@ -2,7 +2,10 @@ require_relative 'start_vertex'
 require_relative 'end_vertex'
 require_relative 'item_vertex'
 require_relative 'epsilon_edge'
+require_relative 'call_edge'
+require_relative 'return_edge'
 require_relative 'scan_edge'
+require_relative 'shortcut_edge'
 
 module Rley # This module is used as a namespace
   module GFG # This module is used as a namespace
@@ -27,11 +30,18 @@ module Rley # This module is used as a namespace
 
         build_graph(theDottedItems)
       end
+      
+      # Return the vertex with given vertex label.
+      def find_vertex(aVertexLabel)
+        vertices.find { |a_vertex| a_vertex.label == aVertexLabel }
+      end
 
 private
       def add_vertex(aVertex)
+        fail StandardError, 'GFG vertex cannot be nil' if aVertex.nil?
+
         # TODO: make setting of start vertex more robust
-        start_vertex = aVertex if vertices.empty?
+        @start_vertex = aVertex if vertices.empty?
         vertices << aVertex
       end
 
@@ -54,7 +64,9 @@ private
           end
         end
       end
-      
+
+      # For each non-terminal from the grammar, say N
+      # Add the .N and N. vertices to the graph
       def build_all_starts_ends(theDottedItems)
         productions_raw = theDottedItems.map(&:production)
         productions = productions_raw.uniq
@@ -98,9 +110,12 @@ private
       #     Rule 5
       #     add a call edge: N => α[1] .A  α[n] -> .A
       #     add a return edge: A. -> N => α[1] A.  α[n]
+      #     add a shortcut edge: ( N => α[1] .A  α[n] ) -> ( N => α[1] A.  α[n] )
       def augment_graph(theDottedItems, firstItemPos)
         production = theDottedItems[firstItemPos].production
         max_index = production.rhs.size + 1
+        prev_vertex = nil
+        
         (0...max_index).each do |index|
           current_item = theDottedItems[firstItemPos+index]
           new_vertex = ItemVertex.new(current_item)
@@ -119,6 +134,12 @@ private
               build_call_return_edges(vertices[-2], new_vertex)
             end
           end
+          
+          prev_symbol = current_item.prev_symbol
+          if prev_symbol && prev_symbol.kind_of?(Syntax::NonTerminal)
+            build_shortcut_edge(prev_vertex, new_vertex)
+          end
+          prev_vertex = new_vertex
         end
       end
 
@@ -147,18 +168,22 @@ private
         ScanEdge.new(fromVertex, toVertex, fromVertex.dotted_item.next_symbol)
       end
 
-      def build_call_return_edges(call_vertex, return_vertex)
-        nt_symbol = call_vertex.dotted_item.next_symbol
+      def build_call_return_edges(calling_vertex, return_vertex)
+        nt_symbol = calling_vertex.dotted_item.next_symbol
 
         # Retrieve corresponding start vertex
         start_vertex = start_vertex_for[nt_symbol]
-        # Create an edge call vertex -> start vertex
-        EpsilonEdge.new(call_vertex, start_vertex)
+        # Create an edge 'calling' vertex -> start vertex
+        CallEdge.new(calling_vertex, start_vertex)
 
         # Retrieve corresponding end vertex
         end_vertex = end_vertex_for[nt_symbol]
         # Create an edge end vertex -> return vertex
-        EpsilonEdge.new(end_vertex, return_vertex)
+        ReturnEdge.new(end_vertex, return_vertex)
+      end
+      
+      def build_shortcut_edge(fromVertex, toVertex)
+        ShortcutEdge.new(fromVertex, toVertex)
       end
     end # class
   end # module

data/lib/rley/gfg/item_vertex.rb

@@ -1,26 +1,72 @@
-require_relative 'vertex'
-
-module Rley # This module is used as a namespace
-  module GFG # This module is used as a namespace
-    # TODO: modify definition
-    # Represents a specialized vertex in a grammar flow graph 
-    # that is associated to a given dotted item.
-    # Responsibilities (in addition to inherited ones):
-    # - Know its related non-terminal symbol
-    class ItemVertex < Vertex
-        attr_reader :dotted_item
-      
-      def initialize(aDottedItem)
-        super()
-        @dotted_item = aDottedItem
-      end
-      
-      def label()
-        return "#{dotted_item}"
-      end
-
-    end # class
-  end # module
-end # module
-
+require_relative '../syntax/non_terminal'
+require_relative 'vertex'
+
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # TODO: modify definition
+    # Represents a specialized vertex in a grammar flow graph
+    # that is associated to a given dotted item.
+    # Responsibilities (in addition to inherited ones):
+    # - Know its related non-terminal symbol
+    class ItemVertex < Vertex
+        # Link to the dotted item object
+        attr_reader :dotted_item
+
+        # Optional link to a "shortcut" edge.
+        # Applicable only if the dotted expects a non-terminal symbol.
+        attr_reader :shortcut
+
+      def initialize(aDottedItem)
+        super()
+        @dotted_item = aDottedItem
+      end
+      
+      # Set the "shortcut" edge.
+      def shortcut=(aShortcut)
+        unless aShortcut.kind_of?(ShortcutEdge)
+          fail StandardError, 'Invalid shortcut argument'
+        end
+=begin
+        unless next_symbol && next_symbol.kind_of?(Syntax::NonTerminal)
+          fail StandardError, 'Invalid shortcut usage'
+        end
+        
+        shortcut_d_item = aShortcut.successor.dotted_item
+        unless (dotted_item.production == shortcut_d_item.production) &&
+          (dotted_item.position == shortcut_d_item.prev_position)
+          fail StandardError, 'Shortcut refers to wrong vertex'
+        end
+=end        
+        @shortcut = aShortcut
+      end
+
+      def label()
+        return "#{dotted_item}"
+      end
+
+      # Returns true if the dotted item has a dot at the end of the production.
+      def complete?()
+        return dotted_item.reduce_item?
+      end
+
+      # Return the symbol before the dot else nil.
+      def prev_symbol()
+        return dotted_item.prev_symbol
+      end      
+      
+      # Return the symbol after the dot else nil.
+      def next_symbol()
+        return dotted_item.next_symbol
+      end
+      
+      # Return the non-terminal symbol at the left-hand side of the production
+      def lhs()
+        return dotted_item.lhs
+      end
+
+    end # class
+  end # module
+end # module
+
 # End of file

data/lib/rley/gfg/non_terminal_vertex.rb

@@ -3,7 +3,8 @@ require_relative 'vertex'
 module Rley # This module is used as a namespace
   module GFG # This module is used as a namespace
     # Represents a specialized vertex in a grammar flow graph 
-    # that is associated to a given non-terminal symbol.
+    # that is associated to a given non-terminal symbol and
+    # that may have in-degree or out-degree > 1
     # Responsibilities (in addition to inherited ones):
     # - Know its related non-terminal symbol
     class NonTerminalVertex < Vertex
@@ -13,6 +14,14 @@ module Rley # This module is used as a namespace
         super()
         @non_terminal = aNonTerminal
       end
+      
+protected
+
+      # Validation method for adding an outgoing edge to the vertex.
+      # A start vertex may accept an indegree and outdegree greater than one
+      def check_add_edge(anEdge)
+        return anEdge
+      end      
 
     end # class
   end # module

data/lib/rley/gfg/return_edge.rb

@@ -0,0 +1,31 @@
+require_relative 'edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Specialization of an edge in a grammar flow graph
+    # that has a end vertex (X.) as its head
+    # and an item vertex as its tail
+    
+    # Responsibilities:
+    # - To know the successor vertex (tail)
+    class ReturnEdge < Edge
+      attr_reader(:key)
+    
+      # Pre-condition: thePredecessor is an EndVertex
+      # Pre-condition: theSuccessor is an ItemVertex
+      def initialize(thePredecessor, theSuccessor)
+        super(thePredecessor, theSuccessor)
+        do_set_key(thePredecessor, theSuccessor)
+      end
+      
+private
+      def do_set_key(thePredecessor, theSuccessor)
+        tail_d_item = theSuccessor.dotted_item
+        @key = "RET_#{tail_d_item.production.object_id}_#{tail_d_item.prev_position}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/scan_edge.rb

@@ -2,7 +2,8 @@ require_relative 'edge'
 
 module Rley # This module is used as a namespace
   module GFG # This module is used as a namespace
-    # Abstract class. Represents an edge in a grammar flow graph
+    # Specialization of an edge in a grammar flow graph
+    # that is taken as a consequence of a scan rule.
     # Responsibilities:
     # - To know the successor vertex
     class ScanEdge < Edge

data/lib/rley/gfg/shortcut_edge.rb

@@ -0,0 +1,26 @@
+require_relative 'edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Abstract class. Represents an edge in a grammar flow graph
+    # Responsibilities:
+    # - To know the successor vertex
+    class ShortcutEdge < Edge
+      # The terminal symbol expected from the input stream
+      attr_reader :nonterminal
+      
+      def initialize(thePredecessor, theSuccessor)
+        @successor = theSuccessor
+        @nonterminal = thePredecessor.next_symbol
+        thePredecessor.shortcut = self
+      end
+      
+      def to_s()
+        " -#{nonterminal}-> #{successor.label}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/start_vertex.rb

@@ -12,10 +12,10 @@ module Rley # This module is used as a namespace
       def initialize(aNonTerminal)
         super(aNonTerminal)
       end
-      
+
       def label()
         return ".#{non_terminal}"
-      end
+      end       
 
     end # class
   end # module

data/lib/rley/gfg/vertex.rb

@@ -14,7 +14,33 @@ module Rley # This module is used as a namespace
       
       # Add an graph edge to this vertex
       def add_edge(anEdge)
-        edges << anEdge
+        arrow = check_add_edge(anEdge)
+        edges << arrow
+      end
+      
+      # Returns true iff the vertex corresponds to an dotted item that has its dot 
+      # at the end of a production (i.e. is a reduced item).
+      def complete?()
+        return false  # Default implementation
+      end
+      
+      # Return the symbol before the dot else nil.
+      def prev_symbol()
+        return nil  # Default implementation
+      end      
+      
+      # Return the symbol after the dot else nil.
+      def next_symbol()
+        return nil  # Default implementation
+      end
+      
+protected
+      # Validation method for adding an outgoing edge to the vertex.
+      # Vertices will accept an indegree and outdegree of at most one
+      # unless this method is overridden in subclasses
+      def check_add_edge(anEdge)
+        fail StandardError, 'At most one edge accepted' unless edges.empty?
+        return anEdge
       end
 
     end # class

data/lib/rley/parse_forest_visitor.rb

@@ -0,0 +1,115 @@
+module Rley # This module is used as a namespace
+  # A visitor class dedicated in the visit of a parse forest.
+  # It combines the Visitor and Observer patterns.
+  class ParseForestVisitor
+    # Link to the parse forest to visit
+    attr_reader(:pforest)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+    
+    # A Hash with pairs of the form: Node => node visit data
+    attr_reader(:agenda)
+    
+    # Indicates the kind of forest traversal to perform: :post_order, :pre-order
+    attr_reader(:traversal)
+
+    # Build a visitor for the given pforest.
+    # @param aParseForest [ParseForest] the parse tree to visit.
+    def initialize(aParseForest, aTraversalStrategy = :post_order)
+      @pforest = aParseForest
+      @subscribers = []
+      @traversal = aTraversalStrategy
+    end
+
+    public
+
+    # Add a subscriber for the visit event notifications.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to begin the visit of the parse forest.
+    def start()
+      pforest.accept(self)
+    end
+
+
+    # Visit event. The visitor is about to visit the pforest.
+    # @param aParseForest [ParseForest] the pforest to visit.
+    def start_visit_pforest(aParseForest)
+      broadcast(:before_pforest, aParseForest)
+    end
+
+
+    # Visit event. The visitor is about to visit the given non terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def visit_nonterminal(aNonTerminalNode)
+      if @traversal == :post_order
+        broadcast(:before_non_terminal, aNonTerminalNode)
+        traverse_children(aNonTerminalNode)
+      else
+        traverse_children(aNonTerminalNode)  
+        broadcast(:before_non_terminal, aNonTerminalNode)
+      end
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given terminal node.
+    # @param aTerminalNode [TerminalNode] the terminal to visit.
+    def visit_terminal(aTerminalNode)
+      broadcast(:before_terminal, aTerminalNode)
+      broadcast(:after_terminal, aTerminalNode)
+    end
+
+
+    # Visit event. The visitor has completed its visit of the given 
+    # non-terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def end_visit_nonterminal(aNonTerminalNode)
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor has completed the visit of the pforest.
+    # @param aParseForest [ParseForest] the pforest to visit.
+    def end_visit_pforest(aParseForest)
+      broadcast(:after_pforest, aParseForest)
+    end
+
+    private
+    
+    # Visit event. The visitor is about to visit the children of a non 
+    # terminal node.
+    # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
+    def traverse_children(aParentNode)
+      children = aParentNode.children
+      broadcast(:before_children, aParentNode, children)
+      
+      # Let's proceed with the visit of children
+      children.each { |a_node| a_node.accept(self) }
+      
+      broadcast(:after_children, aParentNode, children)
+    end
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |a_subscriber|
+        next unless a_subscriber.respond_to?(msg)
+        a_subscriber.send(msg, *args)
+      end
+    end
+  end # class
+end # module
+
+# End of file