rley 0.7.06 → 0.8.01

data/lib/rley/gfg/item_vertex.rb

@@ -40,33 +40,33 @@ module Rley # This module is used as a namespace
       # The label of this vertex.
       # It is the same as the label of the corresponding dotted item.
       # @return [String] Label for this vertex
-      def label()
-        return dotted_item.to_s
+      def label
+        dotted_item.to_s
       end
 
       # Returns true if the dotted item has a dot at the end of the production.
       # @return [Boolean]
-      def complete?()
-        return dotted_item.reduce_item?
+      def complete?
+        dotted_item.reduce_item?
       end
 
       # Return the symbol before the dot.
       # @return [Syntax::GrmSymbol, NilClass] Previous symbol otherwise nil.
-      def prev_symbol()
-        return dotted_item.prev_symbol
+      def prev_symbol
+        dotted_item.prev_symbol
       end
 
       # Return the symbol after the dot.
       # @return [Syntax::GrmSymbol, NilClass] Next grammar symbol otherwise nil.
-      def next_symbol()
-        return dotted_item.next_symbol
+      def next_symbol
+        @next_symbol ||= dotted_item.next_symbol
       end
 
       # Return the non-terminal symbol at the left-hand side of the production
       # @return [Syntax::GrmSymbol]
       #   The non-terminal symbol at left side of production.
-      def lhs()
-        return dotted_item.lhs
+      def lhs
+        dotted_item.lhs
       end
     end # class
   end # module

data/lib/rley/gfg/non_terminal_vertex.rb

@@ -5,7 +5,7 @@ require_relative 'vertex'
 module Rley # This module is used as a namespace
   module GFG # This module is used as a namespace
     # Abstract class.
-    # Represents a specialized vertex in a grammar flow graph 
+    # Represents a specialized vertex in a grammar flow graph
     # 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):
@@ -14,20 +14,20 @@ module Rley # This module is used as a namespace
       # The non-terminal symbol associated to the vertex
       # @return [Syntax::NonTerminal]
       attr_reader :non_terminal
-      
+
       # Constructor to specialize in subclasses.
       # @param aNonTerminal [Syntax::NonTerminal]
       def initialize(aNonTerminal)
         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
+        anEdge
       end
     end # class
   end # module

data/lib/rley/gfg/scan_edge.rb

@@ -17,7 +17,7 @@ module Rley # This module is used as a namespace
         @terminal = aTerminal
       end
 
-      def to_s()
+      def to_s
         " -#{terminal}-> #{successor.label}"
       end
     end # class

data/lib/rley/gfg/shortcut_edge.rb

@@ -12,12 +12,12 @@ module Rley # This module is used as a namespace
       attr_reader :nonterminal
 
       def initialize(thePredecessor, theSuccessor)
-        @successor = theSuccessor
+        super(nil, theSuccessor)
         @nonterminal = thePredecessor.next_symbol
         thePredecessor.shortcut = self
       end
 
-      def to_s()
+      def to_s
         " -#{nonterminal}-> #{successor.label}"
       end
     end # class

data/lib/rley/gfg/start_vertex.rb

@@ -5,19 +5,15 @@ require_relative 'non_terminal_vertex'
 module Rley # This module is used as a namespace
   module GFG # This module is used as a namespace
     # TODO: change definition.
-    # Represents a specialized vertex in a grammar flow graph 
+    # Represents a specialized vertex in a grammar flow graph
     # that is associated to a given non-terminal symbol.
     # Responsibilities (in addition to inherited ones):
     # - Know its related non-terminal symbol
     class StartVertex < NonTerminalVertex
-      def initialize(aNonTerminal)
-        super(aNonTerminal)
-      end
-
       # @return [String]
-      def label()
-        return ".#{non_terminal}"
-      end       
+      def label
+        ".#{non_terminal}"
+      end
     end # class
   end # module
 end # module

data/lib/rley/gfg/vertex.rb

@@ -10,60 +10,65 @@ module Rley # This module is used as a namespace
       # The edges linking the successor vertices to this one.
       # @return [Array<Edge>] The edge(s) linking this vertex to successor(s)
       attr_reader :edges
-      
+
+      # Return the object id in string format
+      # @return [String]
+      attr_reader :oid_str
+
       # Constructor to extend in subclasses.
-      def initialize()
+      def initialize
         @edges = []
+        @oid_str = object_id.to_s
       end
-      
-      # Add an graph edge to this vertex.
-      # @param anEdge [Edge] the edge to be added.
-      def add_edge(anEdge)
-        arrow = check_add_edge(anEdge)
-        edges << arrow
-      end
-      
-      # Determine if the vertex corresponds to an dotted item that has 
+
+      # Determine if the vertex corresponds to an dotted item that has
       # its dot at the end of a production (i.e. is a reduced item).
       # @return [Boolean] true iff vertex corresponds to reduced item.
-      def complete?()
-        return false # Default implementation
+      def complete?
+        false # Default implementation
       end
-      
-      # Returns a string containing a human-readable representation of the 
+
+      # Returns a string containing a human-readable representation of the
       # vertex.
       # @return [String]
-      def inspect()
+      def inspect
         result = +'#<'
         result << selfie
         edges.each { |e| result << e.inspect }
         result << specific_inspect
         result << '>'
-        
-        return result
+
+        result
       end
-      
-      # Returns a string containing a human-readable representation of the 
+
+      # Returns a string containing a human-readable representation of the
       # vertex without the edges.
-      # @return [String]      
-      def selfie()
+      # @return [String]
+      def selfie
         result = +"#{self.class.name}:#{object_id}"
         result << %( label="#{label}")
-        return result
+        result
       end
-      
+
       # Retrieve the grammar symbol before the dot.
       # @return [GrmSymbol, NilClass] The symbol or otherwise nil.
-      def prev_symbol()
-        return nil # Default implementation
-      end      
-      
+      def prev_symbol
+        nil # Default implementation
+      end
+
       # Retrieve the grammar symbol after the dot.
-      # @return [GrmSymbol, NilClass] The symbol or otherwise nil. 
-      def next_symbol()
-        return nil # Default implementation
+      # @return [GrmSymbol, NilClass] The symbol or otherwise nil.
+      def next_symbol
+        nil # Default implementation
+      end
+
+      # Add an graph edge to this vertex.
+      # @param anEdge [Edge] the edge to be added.
+      def add_edge(anEdge)
+        arrow = check_add_edge(anEdge)
+        edges << arrow
       end
-      
+
       protected
 
       # Validation method for adding an outgoing edge to the vertex.
@@ -71,14 +76,13 @@ module Rley # This module is used as a namespace
       # unless this method is overridden in subclasses
       def check_add_edge(anEdge)
         raise StandardError, 'At most one edge accepted' unless edges.empty?
-        
-        return anEdge
+
+        anEdge
+      end
+
+      def specific_inspect
+        ''
       end
-      
-      def specific_inspect()
-        return ''
-      end      
-      
     end # class
   end # module
 end # module

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/lexical/token_range.rb

@@ -2,13 +2,13 @@
 
 module Rley # This module is used as a namespace
   module Lexical # This module is used as a namespace
-    # A token range (also called an extent) represents an interval 
+    # A token range (also called an extent) represents an interval
     # of token positions that is matched by a given grammar symbol.
     # For instance consider the expression E: 3 + 11,
     # let's assume that the integer literal '3' is the fifth input token and
     # that the '+' and '11' tokens are respectively at position 6 and 7;
     # then the token range associated with E is [5, 7]
-    # While the parse tree/forest is being constructed the boundaries of the 
+    # While the parse tree/forest is being constructed the boundaries of the
     # token range can be temporarily undefined (= set to nil)
     class TokenRange
       # The index of the lower bound of token range
@@ -47,8 +47,8 @@ module Rley # This module is used as a namespace
       end
 
       # true when both bounds aren't nil.
-      def bounded?()
-        return !(low.nil? || high.nil?)
+      def bounded?
+        !(low.nil? || high.nil?)
       end
 
       # Conditional assign
@@ -73,8 +73,8 @@ module Rley # This module is used as a namespace
       def to_string(_indentation)
         low_text = low.nil? ? '?' : low.to_s
         high_text = high.nil? ? '?' : high.to_s
-        
-        return "[#{low_text}, #{high_text}]"
+
+        "[#{low_text}, #{high_text}]"
       end
 
       private

data/lib/rley/notation/all_notation_nodes.rb

@@ -0,0 +1,2 @@
+require_relative 'grouping_node'
+require_relative 'symbol_node'

data/lib/rley/notation/ast_builder.rb

@@ -0,0 +1,191 @@
+# 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
+
+      # Create a new AST builder instance.
+      # @param theTokens [Array<Rley::Lexical::Token>] The sequence of input tokens.
+      def initialize(theTokens)
+        super(theTokens)
+      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 ['0', '1']
+            :zero_or_one
+          when ['1', '1']
+            :exactly_one
+          else
+            Range.new(low.to_i, high.to_i)
+        end
+      end
+    end # class
+  end # module
+end # module