rley 0.7.08 → 0.8.03

data/examples/general/left.rb

@@ -11,7 +11,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
 
   # Grammar with left recursive rule.
   rule 'l_dots' => []
-  rule 'l_dots' => %w[l_dots DOT]
+  rule 'l_dots' => 'l_dots DOT'
 end
 
 # And now, let's build the grammar...

data/examples/general/right.rb

@@ -11,7 +11,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
 
   # Grammar with right recursive rule.
   rule 'r_dots' => []
-  rule 'r_dots' => %w[DOT r_dots]
+  rule 'r_dots' => 'DOT r_dots'
 end
 
 # And now, let's build the grammar...

data/lib/rley/base/dotted_item.rb

@@ -28,6 +28,11 @@ module Rley # This module is used as a namespace
       # @return [Integer]
       attr_reader :position
 
+      # A possible constraint between symbol on left of dot and
+      # the closest preceding given terminal
+      # @return [NilClass, Syntax::MatchClosest]
+      attr_accessor :constraint
+
       # @param aProduction [Syntax::Production]
       # @param aPosition [Integer] Position of the dot in rhs of production.
       def initialize(aProduction, aPosition)

data/lib/rley/base/grm_items_builder.rb

@@ -12,12 +12,18 @@ module Rley # This module is used as a namespace
       def build_dotted_items(aGrammar)
         items = []
         aGrammar.rules.each do |prod|
+          index_prev = items.size
           rhs_size = prod.rhs.size
           if rhs_size.zero?
             items << DottedItem.new(prod, 0)
           else
             items += (0..rhs_size).map { |i| DottedItem.new(prod, i) }
           end
+
+          prod.constraints.each do |cs|
+            # Attach constraint to dotted item n + 1
+            items[index_prev + cs.idx_symbol + 1].constraint = cs
+          end
         end
 
         return items

data/lib/rley/constants.rb

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

data/lib/rley/engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './syntax/grammar_builder'
+require_relative './notation/grammar_builder'
 require_relative './parser/gfg_earley_parser'
 require_relative './parse_tree_visitor'
 require_relative './parse_forest_visitor'
@@ -61,7 +61,7 @@ module Rley # This module is used as a namespace
     #     add_production('elements' => 'INTEGER')
     #   end
     def build_grammar(&aBlock)
-      builder = Rley::Syntax::GrammarBuilder.new(&aBlock)
+      builder = Rley::Notation::GrammarBuilder.new(&aBlock)
       @grammar = builder.grammar
     end
 

data/lib/rley/interface.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative './notation/grammar_builder'
+
+module Rley # Module used as a namespace
+  # Factory method.
+  # A grammar builder constructs a Rley grammar piece by piece
+  # from DSL instructions in a provided code block.
+  # @param aBlock [Proc] a code block
+  # @return [Rley::Notation::GrammarBuilder] An object that builds a grammar.
+  def self.grammar_builder(&aBlock)
+    Rley::Notation::GrammarBuilder.new(&aBlock)
+  end
+end # module
+
+# End of file

data/lib/rley/notation/all_notation_nodes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'grouping_node'
+require_relative 'symbol_node'

data/lib/rley/notation/ast_builder.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative '../parse_rep/ast_base_builder'
+require_relative '../engine'
+require_relative 'all_notation_nodes'
+
+module Rley
+  module Notation
+    # The purpose of ASTBuilder is to build piece by piece an AST
+    # (Abstract Syntax Tree) from a sequence of input tokens and
+    # visit events produced by walking over a GFGParsing object.
+    class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
+      unless defined?(Name2special)
+        # Mapping Token name => operator | separator | delimiter characters
+        # @return [Hash{String => String}]
+        Name2special = {
+          'COMMA' =>  ',',
+          'ELLIPSIS' => '..',
+          'LEFT_BRACE' =>  '{',
+          'LEFT_PAREN' => '(',
+          'PLUS' => '+',
+          'QUESTION_MARK' => '?',
+          'RIGHT_BRACE' => '}',
+          'RIGHT_PAREN' => ')',
+          'STAR' => '*'
+        }.freeze
+      end
+
+      protected
+
+      def terminal2node
+        Terminal2NodeClass
+      end
+
+      # Method override
+      def new_leaf_node(_production, _terminal, aTokenPosition, aToken)
+        Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
+      end
+
+      # Factory method for creating a parent node object.
+      # @param aProduction [Production] Production rule
+      # @param aRange [Range] Range of tokens matched by the rule
+      # @param theTokens [Array] The input tokens
+      # @param theChildren [Array] Children nodes (one per rhs symbol)
+      def new_parent_node(aProduction, aRange, theTokens, theChildren)
+        mth_name = method_name(aProduction.name)
+        if respond_to?(mth_name, true)
+          node = send(mth_name, aProduction, aRange, theTokens, theChildren)
+        else
+          # Default action...
+          node = case aProduction.rhs.size
+                 when 0
+                   return_epsilon(aRange, theTokens, theChildren)
+                 when 1
+                   return_first_child(aRange, theTokens, theChildren)
+                 else
+                   node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
+                   theChildren&.reverse_each do |child|
+                     node.add_subnode(child) if child
+                   end
+
+                   node
+                 end
+        end
+
+        node
+      end
+
+      # Return the AST node corresponding to the second symbol in the rhs
+      def reduce_to_2nd_symbol(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
+      #####################################
+      #  SEMANTIC ACTIONS
+      #####################################
+
+      # rule('rhs' => 'member_seq').tag 'sequence'
+      def reduce_sequence(_production, _range, _tokens, theChildren)
+        if theChildren[0].size == 1
+          theChildren[0].first
+        else
+          SequenceNode.new(theChildren[0].first.position, theChildren[0], nil)
+        end
+      end
+
+      # rule('member_seq' => 'member_seq member').tag 'more_members'
+      def reduce_more_members(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[1]
+      end
+
+      # rule('member_seq' => 'member')
+      def reduce_one_member(_production, _range, _tokens, theChildren)
+        [theChildren[0]]
+      end
+
+      # rule('strait_member' => 'base_member annotation')
+      def reduce_annotated_member(_production, _range, _tokens, theChildren)
+        theChildren[0].annotation = theChildren[1]
+
+        theChildren[0]
+      end
+
+      # rule('base_member' => 'SYMBOL')
+      def reduce_symbol(_production, _range, _tokens, theChildren)
+        SymbolNode.new(theChildren[0].token.position, theChildren[0].token.lexeme)
+      end
+
+      # rule('base_member' => 'LEFT_PAREN member_seq RIGHT_PAREN')
+      def reduce_grouping(_production, _range, tokens, theChildren)
+        if theChildren[1].size == 1
+          theChildren[1].first
+        else
+          rank = theChildren[0].range.high
+          pos = tokens[rank].position
+          GroupingNode.new(pos, theChildren[1], nil)
+        end
+      end
+
+      # rule('quantified_member' => 'base_member quantifier')
+      def reduce_quantified_member(_production, _range, _tokens, theChildren)
+        theChildren[0].repetition = theChildren[1]
+        theChildren[0]
+      end
+
+      # rule('quantifier' => 'QUESTION_MARK')
+      def reduce_question_mark(_production, _range, _tokens, _theChildren)
+        :zero_or_one
+      end
+
+      # rule('quantifier' => 'STAR')
+      def reduce_star(_production, _range, _tokens, _theChildren)
+        :zero_or_more
+      end
+
+      # rule('quantifier' => 'PLUS')
+      def reduce_plus(_production, _range, _tokens, _theChildren)
+        :one_or_more
+      end
+
+      # rule('annotation' => 'LEFT_BRACE mapping RIGHT_BRACE').tag ''
+      def reduce_annotation(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
+      # rule('mapping' => 'mapping COMMA key_value')
+      def reduce_more_pairs(_production, _range, _tokens, theChildren)
+        hsh = theChildren[0]
+        hsh[theChildren[2].first] = theChildren[2].last
+
+        hsh
+      end
+
+      # rule('mapping' => 'key_value').tag 'one_pair'
+      def reduce_one_pair(_production, _range, _tokens, theChildren)
+        { theChildren[0].first => theChildren[0].last }
+      end
+
+      # rule('key_value' => 'KEY value')
+      def reduce_raw_pair(_production, _range, _tokens, theChildren)
+        key = theChildren[0].token.lexeme
+        value = if theChildren[1].kind_of?(Rley::PTree::TerminalNode)
+                  theChildren[1].token.lexeme
+                else
+                  theChildren[1]
+                end
+        [key, value]
+      end
+
+      # rule('range' => 'INT_LIT ELLIPSIS INT_LIT')
+      def reduce_bound_range(_production, _range, _tokens, theChildren)
+        low = theChildren[0].token.lexeme
+        high = theChildren[2].token.lexeme
+        case [low, high]
+          when %w[0 1]
+            :zero_or_one
+          when %w[1 1]
+            :exactly_one
+          else
+            Range.new(low.to_i, high.to_i)
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/notation/ast_node.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rley
+  module Notation
+    # Abstract class.
+    # Instances of its subclasses represent nodes of an abstract syntax tree
+    # that is the product of the parse of an input text.
+    class ASTNode
+      # @return [Rley::Lexical::Position] Position of the entry in the input stream.
+      attr_reader :position
+
+      # @return [Symbol]
+      attr_accessor :repetition
+
+      # @return [Hash]
+      attr_reader :annotation
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      def initialize(aPosition)
+        @position = aPosition
+        @repetition = :exactly_one
+        @annotation = {}
+      end
+
+      def annotation=(aMapping)
+        repeat_key = 'repeat'
+        @repetition = aMapping.delete(repeat_key) if aMapping.include?(repeat_key)
+        @annotation = aMapping
+      end
+
+      # Notification that the parsing has successfully completed
+      def done!
+        # Default: do nothing ...
+      end
+
+      # Abstract method (must be overriden in subclasses).
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        raise NotImplementedError
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/notation/ast_visitor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Rley
+  module Notation
+    class ASTVisitor
+      # Link to the top node to visit
+      attr_reader(:top)
+
+      # List of objects that subscribed to the visit event notification.
+      attr_reader(:subscribers)
+
+      # Build a visitor for the given top.
+      # @param aTop [Notation::ASTNode] the parse tree to visit.
+      def initialize(aTop)
+        raise StandardError if aTop.nil?
+
+        @top = aTop
+        @subscribers = []
+      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 top.
+      def start
+        top.accept(self)
+      end
+
+      # Visit event. The visitor is about to visit the ptree.
+      # @param aParseTree [Rley::PTree::ParseTree] the ptree to visit.
+      def start_visit_ptree(aParseTree)
+        broadcast(:before_ptree, aParseTree)
+      end
+
+      # Visit event. The visitor has completed the visit of the ptree.
+      # @param aParseTree [Rley::PTree::ParseTree] the visited ptree.
+      def end_visit_ptree(aParseTree)
+        broadcast(:after_ptree, aParseTree)
+      end
+
+      # Visit event. The visitor is about to visit a symbol node.
+      # @param aSymbolNode [Notation::SymbolNode] the symbol node to visit
+      def visit_symbol_node(aSymbolNode)
+        broadcast(:before_symbol_node, aSymbolNode, self)
+        broadcast(:after_symbol_node, aSymbolNode, self)
+      end
+
+      # Visit event. The visitor is about to visit a sequence node.
+      # @param aSequenceNode [Notation::SequenceNode] the sequence node to visit
+      def visit_sequence_node(aSequenceNode)
+        broadcast(:before_sequence_node, aSequenceNode, self)
+        traverse_subnodes(aSequenceNode)
+        broadcast(:after_sequence_node, aSequenceNode, self)
+      end
+
+      # Visit event. The visitor is about to visit a grouping node.
+      # @param aGroupingNode [Notation::GroupingNode] the grouping node to visit
+      def visit_grouping_node(aGroupingNode)
+        broadcast(:before_grouping_node, aGroupingNode, self)
+        traverse_subnodes(aGroupingNode) if aGroupingNode.repetition == :exactly_one
+        broadcast(:after_grouping_node, aGroupingNode, self)
+      end
+
+      private
+
+      # Visit event. The visitor is about to visit the subnodes of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      def traverse_subnodes(aParentNode)
+        subnodes = aParentNode.subnodes
+        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
+
+      # Visit event. The visitor is about to visit one given subnode of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      # @param index [integer] index of child subnode
+      def traverse_given_subnode(aParentNode, index)
+        subnode = aParentNode.subnodes[index]
+        broadcast(:before_given_subnode, aParentNode, subnode)
+
+        # Now, let's proceed with the visit of that subnode
+        subnode.accept(self)
+
+        broadcast(:after_given_subnode, aParentNode, subnode)
+      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
+  end # module
+end # module