dendroid 0.1.00 → 0.2.01

data/lib/dendroid/parsing/chart_walker.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require_relative 'walk_progress'
+
+module Dendroid
+  module Parsing
+    class ChartWalker
+      attr_reader :chart
+      attr_reader :last_item
+
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
+      def initialize(theChart)
+        @chart = theChart
+      end
+
+      def walk(start_item)
+        curr_rank = chart.size - 1
+
+        parents = []
+        progress = WalkProgress.new(curr_rank, start_item, parents)
+        paths = [progress]
+
+        if start_item.predecessors.size > 1
+          # Create n times start_item as predecessors, then for each path initialize to its unique own predecessor
+          forerunners = disambiguate(progress, start_item.predecessors)
+          if forerunners.size == 1
+            parents << ANDNode.new(start_item, curr_rank)
+          else
+            preds = sort_predecessors(forerunners)
+            if start_item.rule.rhs.size == 1
+              parents << ANDNode.new(start_item, curr_rank)
+              progress.push_or_node(start_item.origin, preds.size)
+            else
+              parents << OrNode.new(start_item.lhs, start_item.origin, curr_rank, preds.size)
+            end
+            progress.curr_item = start_item
+            fork(progress, paths, preds)
+          end
+        else
+          parents << ANDNode.new(start_item, curr_rank)
+        end
+        token2node = {}
+        entry2node = {}
+        sharing = {}
+        or_nodes_crossed = {}
+
+        loop do # Iterate over rank values
+          pass = :primary
+          loop do # Iterate over paths until all are ready for previous rank
+            paths.each do |prg|
+              next if prg.state == :Complete || prg.state == :Delegating
+              next if pass == :secondary && prg.state == :Waiting
+
+              step_back(prg, paths, token2node, entry2node, sharing, or_nodes_crossed)
+            end
+            # TODO: handle path removal
+            break if paths.none? { |pg| pg.state == :Running || pg.state == :Forking }
+
+            pass = :secondary
+          end
+          break if paths.all? { |prg| prg.state == :Complete }
+
+          entry2node.clear
+        end
+
+        parents[0]
+      end
+
+      def step_back(walk_progress, paths, token2node, entry2node, sharing, or_nodes_crossed)
+        loop do
+          case walk_progress.state
+          when :Waiting, :New
+            predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
+            last_parent = walk_progress.parents.last
+            if sharing.include? last_parent
+              delegating = sharing[last_parent]
+              unless delegating.include? walk_progress
+                delegating.each do |dlg|
+                  dlg.curr_rank = walk_progress.curr_rank
+                  dlg.curr_item = walk_progress.curr_item
+                  dlg.state = :Waiting
+                end
+                sharing.delete(last_parent)
+              end
+            end
+            walk_progress.state = :Running
+
+          when :Running
+            predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
+
+          when :Forking
+            # predecessors = [walk_progress.curr_item]
+            predecessors = [walk_progress.predecessor]
+            walk_progress.predecessor = nil
+            walk_progress.state = :Running
+          end
+
+          if predecessors.empty?
+            walk_progress.state = :Complete
+            break
+          end
+
+          case walk_progress.curr_item.algo
+          when :completer
+            completer_backwards(walk_progress, paths, entry2node, sharing, predecessors)
+            break if walk_progress.state == :Delegating
+
+          when :scanner
+            curr_token = chart.tokens[walk_progress.curr_rank - 1]
+            if token2node.include? curr_token
+              walk_progress.add_child_node(token2node[curr_token])
+              walk_progress.curr_rank -= 1
+            else
+              new_node = walk_progress.add_terminal_node(chart.tokens[walk_progress.curr_rank - 1])
+              token2node[curr_token] = new_node
+            end
+            if predecessors.size == 1
+              walk_progress.curr_item = predecessors[0]
+              walk_progress.state = :Waiting
+              break
+            else
+              # TODO: challenge assumption single predecessor
+              raise StandardError
+            end
+
+          when :predictor
+            unless walk_progress.parents.last.partial?
+              last_parent = walk_progress.parents.pop
+              if sharing.include? last_parent
+                delegating = sharing[last_parent]
+                unless delegating.include? walk_progress
+                  delegating.each do |dlg|
+                    dlg.curr_rank = walk_progress.curr_rank
+                    dlg.curr_item = walk_progress.curr_item
+                    dlg.state = :Running
+                  end
+                  sharing.delete(last_parent)
+                end
+              end
+              if last_parent.is_a?(OrNode)
+                if or_nodes_crossed.include?(last_parent)
+                  walk_progress.state = :Complete
+                  break
+                else
+                  or_nodes_crossed[last_parent] = true
+                end
+              end
+            end
+            index_empty = predecessors.find_index { |entry| entry.dotted_item.empty? }
+            if index_empty
+              entry_empty = predecessors.delete_at(index_empty)
+              walk_progress.add_node_empty(entry_empty)
+              raise StandardError unless predecessors.empty? # Uncovered case
+
+              walk_progress.curr_item = entry_empty
+              next
+            end
+            if predecessors.size == 1
+              walk_progress.curr_item = predecessors[0]
+            else
+              # curr_item has multiple predecessors from distinct rules
+              # look in lineage the latest entry that matches one of the ancestors AND
+              # has a free slot for the current symbol
+              matches = walk_progress.match_parent?(predecessors, true)
+              if matches.empty?
+                walk_progress.state = :Complete
+                break
+              end
+              (matching_pred, stack_offset) = matches.first
+              walk_progress.curr_item = matching_pred
+              unless stack_offset.zero?
+                removed = walk_progress.parents.pop(stack_offset)
+                if removed.is_a?(Array)
+                  or_nodes = removed.select { |entry| entry.is_a?(OrNode) }
+                  unless or_nodes.empty?
+                    or_nodes.reverse_each do |or_nd|
+                      if or_nodes_crossed.include?(or_nd)
+                        walk_progress.state = :Complete
+                        break
+                      else
+                        or_nodes_crossed[or_nd] = true
+                      end
+                    end
+                    break if walk_progress.state == :Complete
+
+                  end
+                elsif removed.is_a?(OrNode)
+                  if or_nodes_crossed.include?(removed)
+                    walk_progress.state = :Complete
+                    break
+                  else
+                    or_nodes_crossed[removed] = true
+                  end
+                end
+              end
+            end
+          else
+            raise StandardError
+          end
+        end
+
+        walk_progress
+      end
+
+      def disambiguate(_progress, predecessors)
+        predecessors
+      end
+
+      def sort_predecessors(predecessors)
+        predecessors
+      end
+
+      def predecessors_of(anEItem, parents)
+        # Rule: if anEItem has itself as predecessor AND parents contains
+        # only a start item, then remove anEItem from its own predecessor(s).
+        if (parents.size == 1) && anEItem.predecessors.include?(anEItem)
+          # raise StandardError unless parents[0].match(anEItem)
+          unless parents[0].match(anEItem)
+            raise StandardError
+
+          end
+          preds = anEItem.predecessors.dup
+          preds.delete(anEItem)
+          preds
+        else
+          anEItem.predecessors
+        end
+      end
+
+      def completer_backwards(walk_progress, paths, entry2node, sharing, predecessors)
+        # Trying to remove some predecessors with some disambiguation technique
+        forerunners = disambiguate(walk_progress, predecessors)
+
+        if forerunners.size == 1
+          pred = forerunners[0]
+          if entry2node.include? pred
+            shared_node = entry2node[pred]
+            if sharing.include? shared_node
+              sharing[shared_node] << walk_progress
+            else
+              sharing[shared_node] = [walk_progress]
+            end
+            walk_progress.add_child_node(shared_node)
+            walk_progress.parents.push(shared_node)
+            walk_progress.state = :Delegating
+
+          elsif pred.predecessors.size == 1
+            new_node = walk_progress.push_and_node(pred)
+            walk_progress.curr_item = pred
+            entry2node[pred] = new_node
+          else
+            pre_forerunners = disambiguate(walk_progress, pred.predecessors)
+            index_empty = pre_forerunners.find_index { |entry| entry.dotted_item.empty? }
+            if index_empty
+              entry_empty = pre_forerunners.delete_at(index_empty)
+              walk_progress.add_node_empty(entry_empty)
+              walk_progress.curr_item = entry_empty.predecessors[0] # Assuming only one predecessor
+            end
+            if pre_forerunners.size == 1
+              pred = forerunners[0]
+              new_node = walk_progress.push_and_node(pre_forerunners[0])
+              walk_progress.curr_item = pred
+              entry2node[pred] = new_node
+            else
+              prepreds = sort_predecessors(pre_forerunners)
+              new_node = walk_progress.push_or_node(pred.origin, prepreds.size)
+              walk_progress.curr_item = pred
+              entry2node[pred] = new_node
+              fork(walk_progress, paths, prepreds)
+            end
+          end
+        else
+          # AMBIGUITY: multiple valid predecessors
+          preds = sort_predecessors(forerunners)
+          walk_progress.push_or_node(preds)
+          fork(walk_progress, paths, preds)
+        end
+      end
+
+      def fork(walk_progress, paths, sorted_predecessors)
+        progs = [walk_progress]
+        walk_progress.fork(sorted_predecessors[0])
+        sorted_predecessors[1..].each do |prd|
+          alternate = walk_progress.dup
+          alternate.fork(prd)
+          paths << alternate
+          progs << alternate
+        end
+
+        progs.each { |pg| pg.push_and_node(pg.curr_item) }
+      end
+    end # class
+
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/PerceivedComplexity
+  end # module
+end # module

data/lib/dendroid/parsing/composite_parse_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'parse_node'
+
+module Dendroid
+  module Parsing
+    class CompositeParseNode < ParseNode
+      attr_reader :range
+      attr_reader :children
+
+      def initialize(lowerBound, upperBound, child_count)
+        super(lowerBound, upperBound)
+        @children = Array.new(child_count, nil)
+      end
+
+      def add_child(child_node, index)
+        children[index] = child_node
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/empty_rule_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'parse_node'
+
+module Dendroid
+  module Parsing
+    class EmptyRuleNode < ParseNode
+      attr_reader :rule
+      attr_reader :alt_index
+
+      def initialize(anEItem, rank)
+        super(rank, rank)
+        @rule = WeakRef.new(anEItem.dotted_item.rule)
+        @alt_index = anEItem.dotted_item.alt_index
+      end
+
+      def to_s
+        "_ #{super}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_empty_rule_node(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/or_node.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'composite_parse_node'
+
+module Dendroid
+  module Parsing
+    class OrNode < CompositeParseNode
+      attr_reader :symbol
+
+      def initialize(sym, lower, upper, arity)
+        @symbol = sym
+        super(lower, upper, arity)
+      end
+
+      def add_child(child_node, _index)
+        idx = children.find_index(&:nil?)
+        raise StandardError unless idx
+
+        # Use first found available slot...
+        super(child_node, idx)
+      end
+
+      def match(anEItem)
+        return false if range[0] != anEItem.origin
+
+        dotted = anEItem.dotted_item
+        (symbol == dotted.rule.lhs) && children.any? { |ch| ch.match(anEItem) }
+      end
+
+      def partial?
+        # children.any?(&:nil?)
+        false
+      end
+
+      def to_s
+        "OR: #{symbol.name} #{range}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_or_node(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/parse_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Dendroid
+  module Parsing
+    class ParseNode
+      # @return [Array<Integer>] The range of input tokens that match this node.
+      attr_reader :range
+
+      def initialize(lowerBound, upperBound)
+        @range = valid_range(lowerBound, upperBound)
+      end
+
+      def to_s
+        "[#{range[0]}, #{range[1]}]"
+      end
+
+      private
+
+      def valid_range(lowerBound, upperBound)
+        raise StandardError unless lowerBound.is_a?(Integer) && upperBound.is_a?(Integer)
+
+        [lowerBound, upperBound]
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/parse_tree_visitor.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+class ParseTreeVisitor
+  # Link to the result root node of the tree (forest)
+  attr_reader(:root)
+
+  # List of objects that subscribed to the visit event notification.
+  attr_reader(:subscribers)
+
+  # Indicates the kind of tree traversal to perform: :post_order, :pre-order
+  attr_reader(:traversal)
+
+  # Build a visitor for the given root.
+  # @param aParseTree [ParseTree] the parse tree to visit.
+  def initialize(aParseTree, aTraversalStrategy = :post_order)
+    raise StandardError if aParseTree.nil?
+
+    @root = aParseTree
+    @subscribers = []
+    @traversal = aTraversalStrategy
+  end
+
+  # 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 tree.
+  def start
+    root.accept(self)
+  end
+
+  # Visit event. The visitor is about to visit the root.
+  # @param aParseTree [ParseTree] the root to visit.
+  def start_visit_root(aParseTree)
+    broadcast(:before_root, aParseTree)
+  end
+
+  # Visit event. The visitor is about to visit the given non terminal node.
+  # @param aNonTerminalNode [ANDNode] the node to visit.
+  def visit_and_node(aNonTerminalNode)
+    if @traversal == :post_order
+      broadcast(:before_and_node, aNonTerminalNode)
+      traverse_subnodes(aNonTerminalNode)
+    else
+      traverse_subnodes(aNonTerminalNode)
+      broadcast(:before_and_node, aNonTerminalNode)
+    end
+    broadcast(:after_and_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor is about to visit the given non terminal node.
+  # @param aNonTerminalNode [OrNode] the node to visit.
+  def visit_or_node(aNonTerminalNode)
+    if @traversal == :post_order
+      broadcast(:before_or_node, aNonTerminalNode)
+      traverse_subnodes(aNonTerminalNode)
+    else
+      traverse_subnodes(aNonTerminalNode)
+      broadcast(:before_or_node, aNonTerminalNode)
+    end
+    broadcast(:after_or_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor is visiting the
+  # given terminal node.
+  # @param anEmptyRuleNode [EmptyRuleNode] the node to visit.
+  def visit_empty_rule_node(anEmptyRuleNode)
+    broadcast(:before_empty_rule_node, anEmptyRuleNode)
+    broadcast(:after_empty_rule_node, anEmptyRuleNode)
+  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_and_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor has completed the visit of the root.
+  # @param aParseTree [ParseTree] the root to visit.
+  def end_visit_root(aParseTree)
+    broadcast(:after_root, aParseTree)
+  end
+
+  private
+
+  # Visit event. The visitor is about to visit the subnodes of a non
+  # terminal node.
+  # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
+  def traverse_subnodes(aParentNode)
+    subnodes = aParentNode.children
+    broadcast(:before_subnodes, aParentNode, subnodes)
+
+    # Let's proceed with the visit of subnodes
+    subnodes.each { |a_node| a_node.accept(self) }
+
+    broadcast(:after_subnodes, aParentNode, subnodes)
+  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 |subscr|
+      next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+
+      subscr.send(msg, *args)
+    end
+  end
+end # class