dendroid 0.0.12 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56842965215f0cef73b768223b5acb907fc1642b57528a9e616852ae6adab2cc
-  data.tar.gz: d53478ebcb86c89a407d648c67bfd34dd1f3333f41f7b6e0eac1dcb3e2a25cb6
+  metadata.gz: bb2bba5cca25fb6a95bfa820891edb4882595062be6a3a439a0fee8c2515efb1
+  data.tar.gz: 52643afdeded2e2944e93124267c009d6c496ab6d645d4878087072f24685e67
 SHA512:
-  metadata.gz: 7ef9e4766ad0c786471d08ba6cffcdffaec2d9acf734e25dafa796e714e1103ee838421b3b817c0c732b91c1a238c5fd32c9c3a6f2954926880336b70caab8b9
-  data.tar.gz: 7e389e83762cedfbdbdf23acbcf821f478a237d8e2b6da6c4299db17d0ade7e760f77328e8f9f59cb10c251f6b1711257793c2b94c12e7ddd8bde2bcad5add66
+  metadata.gz: 47db9f266723dc8d292bdc8cbb7006bd8e9da8471bd89e933312231bf26ba90e5c40e7bf3e6eead665918a968f476705936507b66b753debde18391a4fa6936a
+  data.tar.gz: 2fdc6b316b2f250644818af70ea40bf68c263776fcbb751ac2b05e03555194a3d86344f28574d3d6efd1a303f0d89c619f7ac199d57468c5e8eddff9f397f123

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.2.00] - 2023-12-16
+Version bump: Very crude parser implementation (generate shared parse forests in case of ambiguity).
+
+## [0.1.00] - 2023-11-03
+Version bump: the Earley recognizer is functional.
+
 ## [0.0.12] - 2023-11-02
 Added more tests.
 

data/lib/dendroid/formatters/ascii_tree.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative 'base_formatter'
+
+# A formatter class that draws parse trees by using characters
+class Asciitree < BaseFormatter
+  # TODO
+  attr_reader(:curr_path)
+
+  # For each node in curr_path, there is a corresponding string value.
+  # Allowed string values are: 'first', 'last', 'first_and_last', 'other'
+  attr_reader(:ranks)
+
+  # @return [String] The character pattern used for rendering
+  # a parent - child nesting
+  attr_reader(:and_nesting_prefix)
+
+  # TODO: comment
+  attr_reader(:or_nesting_prefix)
+
+  # @return [String] The character pattern used for a blank indentation
+  attr_reader(:blank_indent)
+
+  # @return [String] The character pattern for indentation and nesting
+  # continuation.
+  attr_reader(:continuation_indent)
+
+  # Constructor.
+  # @param anIO [IO] The output stream to which the parse tree
+  # is written.
+  def initialize(anIO)
+    super(anIO)
+    @curr_path = []
+    @ranks = []
+
+    @and_nesting_prefix = '+-- '
+    @or_nesting_prefix = '/-- '
+    @blank_indent = '    '
+    @continuation_indent = '|   '
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # the children of a non-terminal node
+  # @param parent [NonTerminalNode]
+  # @param _children [Array<ParseTreeNode>] array of children nodes
+  def before_subnodes(parent, _children)
+    rank_of(parent)
+    curr_path << parent
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # a non-terminal node
+  # @param aNonTerm [NonTerminalNode]
+  def before_and_node(aNonTerm)
+    emit_and(aNonTerm)
+  end
+
+  def before_or_node(aNonTerm)
+    emit_or(aNonTerm)
+  end
+
+  def before_empty_rule_node(anEmptyRuleNode)
+    emit_and(anEmptyRuleNode, ': .')
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # a terminal node
+  # @param aTerm [TerminalNode]
+  def before_terminal(aTerm)
+    emit_terminal(aTerm, ": '#{aTerm.token.source}'")
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor completed the visit of
+  # the children of a non-terminal node.
+  # @param _parent [NonTerminalNode]
+  # @param _children [Array] array of children nodes
+  def after_subnodes(_parent, _children)
+    curr_path.pop
+    ranks.pop
+  end
+
+  private
+
+  # Parent node is last node in current path
+  # or current path is empty (then aChild is root node)
+  def rank_of(aChild)
+    if curr_path.empty?
+      rank = 'root'
+    elsif curr_path[-1].children.size == 1
+      rank = 'first_and_last'
+    else
+      parent = curr_path[-1]
+      siblings = parent.children
+      siblings_last_index = siblings.size - 1
+      rank = case siblings.find_index(aChild)
+             when 0 then 'first'
+             when siblings_last_index then 'last'
+             else
+               'other'
+             end
+    end
+    ranks << rank
+  end
+
+  # 'root', 'first', 'first_and_last', 'last', 'other'
+  def path_prefix(connector)
+    return '' if ranks.empty?
+
+    prefix = +''
+    @ranks.each_with_index do |rank, i|
+      next if i.zero?
+
+      case rank
+      when 'first', 'other'
+        prefix << continuation_indent
+
+      when 'last', 'first_and_last', 'root'
+        prefix << blank_indent
+      end
+    end
+
+    nesting = (connector == :and) ? and_nesting_prefix : or_nesting_prefix
+    prefix << nesting
+    prefix
+  end
+
+  def emit_and(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:and)}#{aNode.rule.lhs.name}#{aSuffix}")
+  end
+
+  def emit_or(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:or)}OR #{aNode.symbol.name}#{aSuffix}")
+  end
+
+  def emit_terminal(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:and)}#{aNode.symbol.name}#{aSuffix}")
+  end
+end # class

data/lib/dendroid/formatters/base_formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+
+# Superclass for parse tree formatters.
+class BaseFormatter
+  # The IO output stream in which the formatter's result will be sent.
+  # @return [IO] The output stream for the formatter.
+  attr_reader(:output)
+
+  # Constructor.
+  # @param anIO [IO] an output IO where the formatter's result will
+  # be placed.
+  def initialize(anIO)
+    @output = anIO
+  end
+
+  # Given a parse tree visitor, perform the visit
+  # and render the visit events in the output stream.
+  # @param aVisitor [ParseTreeVisitor]
+  def render(aVisitor)
+    aVisitor.subscribe(self)
+    aVisitor.start
+    aVisitor.unsubscribe(self)
+  end
+end # class

data/lib/dendroid/formatters/bracket_notation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'base_formatter'
+
+class BracketNotation < BaseFormatter
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # a non-terminal node
+  # @param and_node [ANDNode]
+  def before_and_node(and_node)
+    write("[#{and_node.rule.lhs.name} ")
+  end
+
+  def before_empty_rule_node(anEmptyRuleNode)
+    write("[#{anEmptyRuleNode.rule.lhs.name}]")
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # a terminal node
+  # @param aTerm [TerminalNode]
+  def before_terminal(aTerm)
+    write("[#{aTerm.symbol.name} ")
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor completed the visit of
+  # a terminal node.
+  # @param aTerm [TerminalNode]
+  def after_terminal(aTerm)
+    # Escape all opening and closing square brackets
+    escape_lbrackets = aTerm.token.source.gsub(/\[/, '\[')
+    escaped = escape_lbrackets.gsub(/\]/, '\]')
+    write("#{escaped}]")
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor completed the visit of
+  # a non-terminal node
+  # @param _nonterm [NonTerminalNode]
+  def after_and_node(_nonterm)
+    write(']')
+  end
+
+  private
+
+  def write(aText)
+    output.write(aText)
+  end
+end # class

data/lib/dendroid/grm_analysis/dotted_item.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
+require 'weakref'
+
 module Dendroid
-  # This module contains classes that from the analysis of grammar rules help to build objects
-  # needed by a recognizer or a parser for the language.
   module GrmAnalysis
     # For a given production rule, a dotted item represents a recognition state.
     # The dot partitions the rhs of the rule in two parts:
@@ -20,42 +20,40 @@ module Dendroid
     # An item with a dot in front of a terminal is called a shift item.
     # An item with the dot not at the beginning is sometimes referred to as a kernel item
     class DottedItem
-      # Reference to the production rule
+      # (Weak) reference to the production rule
       # @return [Dendroid::Syntax::Production]
       attr_reader :rule
 
       # @return [Integer] the dot position
       attr_reader :position
 
+      # @return [Integer] the alternative number
+      attr_reader :alt_index
+
       # Constructor.
-      # @param aRule [Dendroid::Syntax::Rule]
+      # @param aChoice [Dendroid::Syntax::Rule]
       # @param aPosition [Integer] Position of the dot in rhs of production.
-      def initialize(aRule, aPosition)
-        @rule = aRule
+      # @param index [Integer] the rank of the alternative at hand
+      def initialize(aChoice, aPosition, index)
+        @alt_index = index
+        @rule = WeakRef.new(aChoice)
         @position = valid_position(aPosition)
       end
 
-      # Return a String representation of the dotted item.
+      # Return a String representation of the alternative item.
       # @return [String]
       def to_s
-        rhs_names = rule.body.map(&:to_s)
+        rhs_names = rule.alternatives[alt_index].members.map(&:to_s)
         dotted_rhs = rhs_names.insert(position, '.')
         "#{rule.head} => #{dotted_rhs.join(' ')}"
       end
 
-      # Indicate whether the rhs of the rule is empty
+      alias inspect to_s
+
+      # Indicate whether the rhs of the alternative is empty
       # @return [Boolean]
       def empty?
-        rule.empty?
-      end
-
-      # Terminology inspired from Luger's book
-      # @return [Symbol] one of: :initial, :initial_and_completed, :partial, :completed
-      def state
-        return :initial_and_completed if empty?
-        return :initial if position.zero?
-
-        position == rule.body.size ? :completed : :partial
+        rule.alternatives[alt_index].empty?
       end
 
       # Indicate whether the dot is at the start of rhs
@@ -64,28 +62,46 @@ module Dendroid
         position.zero? || empty?
       end
 
-      # Indicate whether the dot is at the end of rhs
+      # Indicate the dot isn't at start nor at end position
+      # @return [Boolean]
+      def intermediate_pos?
+        return false if empty? || position.zero?
+
+        position < rule.alternatives[alt_index].size
+      end
+
+      # Indicate whether the dot is at the start of rhs
       # @return [Boolean]
       def final_pos?
-        empty? || position == rule.body.size
+        empty? || position == rule.alternatives[alt_index].size
       end
 
       alias completed? final_pos?
 
-      # Indicate the dot isn't at start nor at end position
-      # @return [Boolean]
-      def intermediate_pos?
-        return false if empty? || position.zero?
+      # Terminology inspired from Luger's book
+      # @return [Symbol] one of: :initial, :initial_and_completed, :partial, :completed
+      def state
+        return :initial_and_completed if empty?
+        return :initial if position.zero?
 
-        position < rule.body.size
+        position == rule.alternatives[alt_index].size ? :completed : :partial
       end
 
+
       # Return the symbol right after the dot (if any)
       # @return [Dendroid::Syntax::GrmSymbol, NilClass]
       def next_symbol
         return nil if empty? || completed?
 
-        rule.body[position]
+        rule.alternatives[alt_index].members[position]
+      end
+
+      # Return the symbol right before the dot (if any)
+      # @return [Dendroid::Syntax::GrmSymbol, NilClass]
+      def prev_symbol
+        return nil if empty? || position.zero?
+
+        rule.alternatives[alt_index].members[position - 1]
       end
 
       # Check whether the given symbol is the same as after the dot.
@@ -99,7 +115,7 @@ module Dendroid
       end
 
       # Check whether the dotted item is a shift item.
-      # In other words, it expects a terminal to be next symbol
+      # In other words, it expects a terminal to be the next symbol
       # @return [Boolean]
       def pre_scan?
         next_symbol&.terminal?
@@ -112,13 +128,13 @@ module Dendroid
       def ==(other)
         return true if eql?(other)
 
-        (position == other.position) && rule.eql?(other.rule)
+        (position == other.position) && rule.eql?(other.rule) && (alt_index == other.alt_index)
       end
 
       private
 
       def valid_position(aPosition)
-        raise StandardError if aPosition.negative? || aPosition > rule.body.size
+        raise StandardError if aPosition.negative? || aPosition > rule.alternatives[alt_index].size
 
         aPosition
       end

data/lib/dendroid/grm_analysis/grm_analyzer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../grm_analysis/production_items'
-require_relative '../grm_analysis/choice_items'
+require_relative '../grm_analysis/rule_items.rb'
 
 module Dendroid
   module GrmAnalysis
@@ -13,7 +12,6 @@ module Dendroid
       attr_reader :grammar
       attr_reader :items
       attr_reader :production2items
-      attr_reader :symbol2productions
 
       # @return [Dendroid::Syntax::Terminal] The pseudo-terminal `__epsilon` (for empty string)
       attr_reader :epsilon
@@ -37,7 +35,6 @@ module Dendroid
         @grammar = aGrammar
         @items = []
         @production2items = {}
-        @symbol2productions = {}
         @epsilon = Syntax::Terminal.new(:__epsilon)
         @endmarker = Syntax::Terminal.new(:"$$")
         @first_sets = {}
@@ -56,16 +53,15 @@ module Dendroid
         prod.next_item(aDottedItem)
       end
 
+      def symbol2production(sym)
+        grammar.nonterm2production[sym]
+      end
+
       private
 
       def build_dotted_items
         grammar.rules.each do |prod|
-          lhs = prod.head
-          symbol2productions[lhs] = [] unless symbol2productions.include? lhs
-          symbol2productions[lhs] << prod
-          # production2items[prod] = []
-          mixin = prod.choice? ? ChoiceItems : ProductionItems
-          prod.extend(mixin)
+          prod.extend(RuleItems)
           prod.build_items
           rule_items = prod.items.flatten
           items.concat(rule_items)
@@ -76,33 +72,31 @@ module Dendroid
       def build_first_sets
         initialize_first_sets
 
-        begin
+        loop do
           changed = false
           grammar.rules.each do |prod|
             head = prod.head
             first_head = first_sets[head]
             pre_first_size = first_head.size
-            if prod.choice?
-              prod.alternatives.each do |alt|
-                first_head.merge(sequence_first(alt.members))
-              end
-            else
-              first_head.merge(sequence_first(prod.body.members))
+            prod.rhs.each do |seq|
+              first_head.merge(sequence_first(seq.members))
             end
             changed = true if first_head.size > pre_first_size
           end
-        end until !changed
+          break unless changed
+        end
       end
 
       def initialize_first_sets
         grammar.symbols.each do |symb|
-          if symb.terminal?
-            first_sets[symb] = Set.new([symb])
-          elsif symb.nullable?
-            first_sets[symb] = Set.new([epsilon])
-          else
-            first_sets[symb] = Set.new
-          end
+          set_arg = if symb.terminal?
+                      [symb]
+                    elsif symb.nullable?
+                      [epsilon]
+                    else
+                      nil
+                    end
+          first_sets[symb] = Set.new(set_arg)
         end
       end
 
@@ -122,43 +116,11 @@ module Dendroid
       def build_follow_sets
         initialize_follow_sets
 
-        begin
+        loop do
           changed = false
           grammar.rules.each do |prod|
-            if prod.choice?
-              prod.alternatives.each do |alt|
-                body = alt.members
-                next if body.empty?
-
-                head = prod.head
-                head_follow = follow_sets[head]
-                # trailer = Set.new
-                last = true
-                last_index = body.size - 1
-                last_index.downto(0) do |i|
-                  symbol = body[i]
-                  next if symbol.terminal?
-
-                  follow_symbol = follow_sets[symbol]
-                  size_before = follow_symbol.size
-                  if last
-                    # Rule: if last non-terminal member (symbol) is nullable
-                    # then add FOLLOW(head) to FOLLOW(symbol)
-                    follow_sets[symbol].merge(head_follow) if symbol.nullable?
-                    last = false
-                  else
-                    symbol_seq = body.slice(i + 1, last_index - i)
-                    trailer_first = sequence_first(symbol_seq)
-                    contains_epsilon = trailer_first.include? epsilon
-                    trailer_first.delete(epsilon) if contains_epsilon
-                    follow_sets[symbol].merge(trailer_first)
-                    follow_sets[symbol].merge(head_follow) if contains_epsilon
-                  end
-                  changed = true if follow_sets[symbol].size > size_before
-                end
-              end
-            else
-              body = prod.body.members
+            prod.rhs.each do |alt|
+              body = alt.members
               next if body.empty?
 
               head = prod.head
@@ -189,7 +151,8 @@ module Dendroid
               end
             end
           end
-        end until !changed
+          break unless changed
+        end
       end
 
       def initialize_follow_sets

data/lib/dendroid/grm_analysis/{choice_items.rb → rule_items.rb}

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require_relative 'alternative_item'
+require_relative 'dotted_item.rb'
 
 module Dendroid
   module GrmAnalysis
     # Mix-in module for extending the Syntax::Choice class
     # with dotted items manipulation methods
-    module ChoiceItems
+    module RuleItems
       # Build the alternative items for this choice and assign them
       # to the `items` attributes
-      # @return [Array<Array<GrmAnalysis::AlternativeItem>>]
+      # @return [Array<Array<GrmAnalysis::Dottedtem>>]
       def build_items
         # AlternativeItem
         @items = Array.new(alternatives.size) { |_| [] }
         alternatives.each_with_index do |alt_seq, index|
           if alt_seq.empty?
-            @items[index] << AlternativeItem.new(self, 0, index)
+            @items[index] << DottedItem.new(self, 0, index)
           else
             (0..alt_seq.size).each do |pos|
-              @items[index] << AlternativeItem.new(self, pos, index)
+              @items[index] << DottedItem.new(self, pos, index)
             end
           end
         end
@@ -26,29 +26,29 @@ module Dendroid
 
       # Read accessor for the `items` attribute.
       # Return the dotted items for this production
-      # @return [Array<Array<GrmAnalysis::AlternativeItem>>]
+      # @return [Array<Array<GrmAnalysis::Dottedtem>>]
       def items
         @items
       end
 
       # Return the predicted items (i.e. the alternative items with the dot at start)
       # for this choice.
-      # @return [Array<GrmAnalysis::AlternativeItem>]
+      # @return [Array<GrmAnalysis::Dottedtem>]
       def predicted_items
         @items.map(&:first)
       end
 
       # Return the reduce items (i.e. the alternative items with the dot at end)
       # for this choice.
-      # @return [Array<GrmAnalysis::AlternativeItem>]
+      # @return [Array<GrmAnalysis::Dottedtem>]
       def reduce_items
         @items.map(&:last)
       end
 
       # Return the next item given the provided item.
       # In other words, advance the dot by one position.
-      # @param anItem [GrmAnalysis::AlternativeItem]
-      # @return [GrmAnalysis::AlternativeItem|NilClass]
+      # @param anItem [GrmAnalysis::Dottedtem]
+      # @return [GrmAnalysis::Dottedtem|NilClass]
       def next_item(anItem)
         items_arr = items[anItem.alt_index]
         return nil if anItem == items_arr.last

data/lib/dendroid/grm_dsl/base_grm_builder.rb

@@ -3,8 +3,7 @@
 require_relative '..\syntax\terminal'
 require_relative '..\syntax\non_terminal'
 require_relative '..\syntax\symbol_seq'
-require_relative '..\syntax\production'
-require_relative '..\syntax\choice'
+require_relative '..\syntax\rule'
 require_relative '..\syntax\grammar'
 
 module Dendroid
@@ -90,10 +89,10 @@ module Dendroid
         raw_rhs = productionRuleRepr.values.first
 
         if raw_rhs.is_a? String
-          new_prod = Dendroid::Syntax::Production.new(lhs, build_symbol_seq(raw_rhs))
+          new_prod = Dendroid::Syntax::Rule.new(lhs, [build_symbol_seq(raw_rhs)])
         else
           rhs = raw_rhs.map { |raw| build_symbol_seq(raw) }
-          new_prod = Dendroid::Syntax::Choice.new(lhs, rhs)
+          new_prod = Dendroid::Syntax::Rule.new(lhs, rhs)
         end
         rules << new_prod
         new_prod

data/lib/dendroid/parsing/and_node.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'composite_parse_node'
+
+module Dendroid
+  module Parsing
+    class ANDNode < CompositeParseNode
+      attr_reader :rule
+      attr_reader :alt_index
+
+      def initialize(anEItem, rank)
+        @rule = WeakRef.new(anEItem.dotted_item.rule)
+        @alt_index = anEItem.dotted_item.alt_index
+        upper_bound = rank
+        super(anEItem.origin, upper_bound, rule.rhs[alt_index].size)
+      end
+
+      def add_child(child_node, index)
+        if children[index].nil? # Is slot available?
+          super(child_node, index)
+        else
+          raise StandardError
+        end
+      end
+
+      def match(anEItem)
+        return false if range[0] != anEItem.origin
+
+        dotted = anEItem.dotted_item
+        same_rule = (rule.lhs == dotted.rule.lhs) && (alt_index == dotted.alt_index)
+        return false unless same_rule
+
+        dotted.initial_pos? ? true : partial?
+      end
+
+      def expecting?(symbol, position)
+        symb_seq = rule.rhs[alt_index]
+        symb_seq[position] == symbol
+      end
+
+      def partial?
+        children.any?(&:nil?)
+      end
+
+      def to_s
+        "#{rule.lhs} => #{rule.rhs[alt_index]} #{range}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_and_node(self)
+      end
+    end # class
+  end # module
+end # module