rley 0.7.06 → 0.8.01

data/lib/rley/sppf/sppf_node.rb

@@ -7,23 +7,22 @@ module Rley # This module is used as a namespace
     # Abstract class. The generalization for all kinds of nodes
     # occurring in a shared packed parse forest (SPPF).
     class SPPFNode
-    
-      # @return [Lexical::TokenRange] 
+      # @return [Lexical::TokenRange]
       # A range of token indices corresponding to this node.
       attr_reader(:range)
-      
+
       # Constructor
       # @param aRange [Lexical::TokenRange]
       def initialize(aRange)
         @range = Lexical::TokenRange.new(aRange)
       end
-      
-      # Return the origin, that is, the index of the 
+
+      # Return the origin, that is, the index of the
       # first token matched by this node.
       # @return [Integer]
-      def origin()
-        return range.low
-      end  
+      def origin
+        range.low
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/token_node.rb

@@ -25,14 +25,14 @@ module Rley # This module is used as a namespace
       # @param indentation [Integer]
       # @return [String]
       def to_string(indentation)
-        return "#{token.terminal.name}#{range.to_string(indentation)}"
+        "#{token.terminal.name}#{range.to_string(indentation)}"
       end
-      
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_terminal(self)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/syntax/{grammar_builder.rb → base_grammar_builder.rb}

@@ -13,17 +13,17 @@ module Rley # This module is used as a namespace
     # Builder GoF pattern. Builder builds a complex object
     #   (say, a grammar) from simpler objects (terminals and productions)
     #   and using a step by step approach.
-    class GrammarBuilder
+    class BaseGrammarBuilder
       # @return [Hash{String, GrmSymbol}] The mapping of grammar symbol names
       #   to the matching grammar symbol object.
       attr_reader(:symbols)
 
-      # @return [Array<Production>] The list of production rules for 
+      # @return [Array<Production>] The list of production rules for
       #   the grammar to build.
       attr_reader(:productions)
 
       # Creates a new grammar builder.
-      # @param aBlock [Proc] code block used to build the grammar. 
+      # @param aBlock [Proc] code block used to build the grammar.
       # @example Building a tiny English grammar
       #   builder = Rley::Syntax::GrammarBuilder.new do
       #     add_terminals('n', 'v', 'adj', 'det')
@@ -45,7 +45,7 @@ module Rley # This module is used as a namespace
       # @param aSymbolName [String] the name of a grammar symbol.
       # @return [GrmSymbol] the retrieved symbol object.
       def [](aSymbolName)
-        return symbols[aSymbolName]
+        symbols[aSymbolName]
       end
 
       # Add the given terminal symbols to the grammar of the language
@@ -55,6 +55,14 @@ module Rley # This module is used as a namespace
         new_symbs = build_symbols(Terminal, terminalSymbols)
         symbols.merge!(new_symbs)
       end
+      
+      # Add the given marker symbol to the grammar of the language
+      # @param aMarkerSymbol [Syntax::Marker] A mazker symbol
+      # @return [void]      
+      def add_marker(aMarkerSymbol)
+        new_symb = build_symbol(Marker, aMarkerSymbol)
+        symbols[aMarkerSymbol.name] = new_symb
+      end      
 
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => Array.
@@ -67,32 +75,32 @@ module Rley # This module is used as a namespace
       #   builder.rule('A' => ['a', 'A', 'c']) # 'rule' is a synonym
       #   builder.rule('A' => %w[a A  c]) # Use %w syntax for Array of String
       #   builder.rule 'A' => %w[a A  c]  # Call parentheses are optional
-      # @param aProductionRepr [Hash{String, Array<String>}] 
+      # @param aProductionRepr [Hash{String, Array<String>}]
       #   A Hash-based representation of a production.
       # @return [Production] The created Production instance
       def add_production(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
-          lhs = get_nonterminal(lhs_name)
+          lhs = get_grm_symbol(lhs_name)
           case rhs_repr
             when Array
-              rhs_members = rhs_repr.map { |name| get_nonterminal(name) }
+              rhs_members = rhs_repr.map { |name| get_grm_symbol(name) }
             when String
               rhs_lexemes = rhs_repr.scan(/\S+/)
-              rhs_members = rhs_lexemes.map { |name| get_nonterminal(name) }
+              rhs_members = rhs_lexemes.map { |name| get_grm_symbol(name) }
             when Terminal
               rhs_members = [rhs_repr]
           end
           new_prod = Production.new(lhs, rhs_members)
           productions << new_prod
         end
-        
+
         return productions.last
       end
 
       # Given the grammar symbols and productions added to the builder,
       # build the resulting grammar (if not yet done).
-      # @return [Grammar] the created grammar object.      
-      def grammar()
+      # @return [Grammar] the created grammar object.
+      def grammar
         unless @grammar
           raise StandardError, 'No symbol found for grammar' if symbols.empty?
           if productions.empty?
@@ -113,7 +121,7 @@ module Rley # This module is used as a namespace
           unused = all_terminals.reject { |a_term| in_use.include?(a_term) }
           unless unused.empty?
             suffix = "#{unused.map(&:name).join(', ')}."
-            raise StandardError, 'Useless terminal symbol(s): ' + suffix
+            raise StandardError, "Useless terminal symbol(s): #{suffix}"
           end
 
           @grammar = Grammar.new(productions.dup)
@@ -122,6 +130,20 @@ module Rley # This module is used as a namespace
         return @grammar
       end
 
+      # When a symbol, say symb, in a rhs is followed by a '+' modifier,
+      # then a rule will be generated with a lhs named symb + suffix_plus
+      def suffix_plus
+        '_plus'
+      end
+
+      def suffix_plus_more
+        'base_plus_more'
+      end
+
+      def suffix_plus_last
+        'base_plus_last'
+      end
+
       alias rule add_production
 
       private
@@ -149,24 +171,40 @@ module Rley # This module is used as a namespace
       # @param aSymbolArg [GrmSymbol-like or String]
       # @return [Array] list of grammar symbols
       def build_symbol(aClass, aSymbolArg)
-        a_symbol = if aSymbolArg.kind_of?(GrmSymbol)
-                      aSymbolArg
-                   else
-                      aClass.new(aSymbolArg)
-                   end
-
-        return a_symbol
+        if aSymbolArg.kind_of?(GrmSymbol)
+          aSymbolArg
+        else
+          aClass.new(aSymbolArg)
+        end
       end
 
       # Retrieve the non-terminal symbol with given name.
       # If it doesn't exist yet, then it is created on the fly.
       # @param aSymbolName [String] the name of the grammar symbol to retrieve
       # @return [NonTerminal]
-      def get_nonterminal(aSymbolName)
-        unless symbols.include? aSymbolName
-          symbols[aSymbolName] = NonTerminal.new(aSymbolName)
+      def get_grm_symbol(aSymbolName)
+        unless aSymbolName.end_with?('+') && aSymbolName.length > 1
+          name = aSymbolName
+        else
+          name = aSymbolName.chop
+          case aSymbolName[-1]
+            when '+'
+              name_modified = "#{name}#{suffix_plus}"
+              unless symbols.include? name_modified
+                symbols[name_modified] = NonTerminal.new(name_modified)
+                rule(name_modified => [name_modified, name]).as suffix_plus_more
+                rule(name_modified => name).as suffix_plus_last
+              end
+              name = name_modified
+            else
+              err_msg = "Unknown symbol modifier #{aSymbolName[-1]}"
+              raise NotImplementedError, err_msg
+          end
         end
-        return symbols[aSymbolName]
+
+        symbols[name] = NonTerminal.new(name) unless symbols.include? name
+
+        symbols[name]
       end
     end # class
   end # module

data/lib/rley/syntax/grammar.rb

@@ -48,13 +48,13 @@ module Rley # This module is used as a namespace
       end
 
       # @return [Array] The list of non-terminals in the grammar.
-      def non_terminals()
+      def non_terminals
         @non_terminals ||= symbols.select { |s| s.kind_of?(NonTerminal) }
       end
 
       # @return [Production] The start production of the grammar (i.e.
       #   the rule that specifies the syntax for the start symbol.
-      def start_production()
+      def start_production
         return rules[0]
       end
 
@@ -99,7 +99,7 @@ module Rley # This module is used as a namespace
       end
 
       # Perform some check of the grammar.
-      def diagnose()
+      def diagnose
         mark_undefined
         mark_generative
         compute_nullable
@@ -193,7 +193,7 @@ module Rley # This module is used as a namespace
 
       # For each non-terminal determine whether it is nullable or not.
       # A nullable nonterminal is a nonterminal that can match an empty string.
-      def compute_nullable()
+      def compute_nullable
         non_terminals.each { |nterm| nterm.nullable = false }
         nullable_sets = [direct_nullable]
 
@@ -236,7 +236,7 @@ module Rley # This module is used as a namespace
           nullables << prod.lhs
         end
 
-        return nullables
+        nullables
       end
 
       # For each prodction determine whether it is nullable or not.

data/lib/rley/syntax/grm_symbol.rb

@@ -5,7 +5,7 @@ module Rley # This module is used as a namespace
     # Abstract class for grammar symbols.
     # A grammar symbol is an element that appears in grammar rules.
     class GrmSymbol
-      # The name of the grammar symbol
+      # @return [String] The name of the grammar symbol
       attr_reader(:name)
 
       # An indicator that tells whether the grammar symbol can generate a
@@ -23,19 +23,19 @@ module Rley # This module is used as a namespace
 
       # The String representation of the grammar symbol
       # @return [String]
-      def to_s()
-        return name.to_s
+      def to_s
+        name.to_s
       end
 
       # @return [Boolean] true iff the symbol is a terminal
-      def terminal?()
+      def terminal?
         # Default implementation to override if necessary
-        return false
+        false
       end
 
       # @return [Boolean] true iff the symbol is generative.
-      def generative?()
-        return @generative
+      def generative?
+        @generative
       end
     end # class
   end # module

data/lib/rley/syntax/match_closest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rley # This module is used as a namespace
+  module Syntax # This module is used as a namespace
+    # A constraint that indicates that a given rhs member must
+    # match the closest given terminal symbol in that rhs
+    class MatchClosest
+      # @return [Integer] index of constrained symbol to match
+      attr_reader(:idx_symbol)
+      
+      # @return [String] name of closest preceding symbol to pair
+      attr_reader(:closest_symb)
+
+      # @return [NilClass, Array<Parser::ParseEntry>] set of entries with closest symbol
+      attr_accessor(:entries)
+      
+      # @param aSymbolSeq [Rley::Syntax::SymbolSeq] a sequence of grammar symbols
+      # @param idxSymbol [Integer] index of symbol
+      # @param nameClosest [String] Terminal symbol name
+      def initialize(aSymbolSeq, idxSymbol, nameClosest)
+        @idx_symbol = valid_idx_symbol(idxSymbol, aSymbolSeq)
+        @closest_symb = valid_name_closest(nameClosest)
+      end
+      
+      private
+      
+      # Check that the provided index is within plausible bounds
+      def valid_idx_symbol(idxSymbol, aSymbolSeq)
+        bounds = 0 .. aSymbolSeq.size - 1
+        err_msg_outbound = 'Index of symbol out of bound'
+        raise StandardError, err_msg_outbound unless bounds.include? idxSymbol
+        
+        idxSymbol
+      end
+      
+      def valid_name_closest(nameClosest)
+        nameClosest
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/syntax/non_terminal.rb

@@ -9,41 +9,35 @@ module Rley # This module is used as a namespace
     class NonTerminal < GrmSymbol
       # A non-terminal symbol is nullable if it can match an empty string.
       attr_writer(:nullable)
-      
+
       # A non-terminal symbol is undefined if no production rule in the grammar
       # has that non-terminal symbol in its left-hand side.
       attr_writer(:undefined)
-      
-      # A non-terminal symbol is unreachable if it cannot be reached (derived) 
+
+      # A non-terminal symbol is unreachable if it cannot be reached (derived)
       # from the start symbol.
       attr_writer(:unreachable)
 
-      # Constructor.
-      # @param aName [String] The name of the grammar symbol.
-      def initialize(aName)
-        super(aName)
-      end
-
       # @return [false/true] Return true if the symbol derives
       # the empty string. As non-terminal symbol is nullable when it can
       # can match to zero input token.
       # The "nullability" of a non-terminal can practically be determined once
       # all the production rules of the grammar are specified.
-      def nullable?()
+      def nullable?
         return @nullable
       end
-      
+
       # @return [false/true] Return true if the symbol doesn't appear
       # on the left-hand side of any production rule.
-      def undefined?()
+      def undefined?
         return @undefined
       end
-      
+
       # @return [false/true] Return true if the symbol cannot be derived
       # from the start symbol.
-      def unreachable?()
+      def unreachable?
         return @unreachable
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/syntax/production.rb

@@ -31,6 +31,9 @@ module Rley # This module is used as a namespace
       #   rhs members are nullable.
       attr_writer(:nullable)
 
+      # @return [Array<Syntax::MatchClosest>] A list of constraints between rhs members
+      attr_accessor(:constraints)
+
       # Provide common alternate names to lhs and rhs accessors
 
       alias body rhs
@@ -42,37 +45,38 @@ module Rley # This module is used as a namespace
       def initialize(aNonTerminal, theSymbols)
         @lhs = valid_lhs(aNonTerminal)
         @rhs = valid_rhs(theSymbols)
+        @constraints = []
       end
 
       # Is the rhs empty?
       # @return [Boolean] true if the rhs has no members.
-      def empty?()
-        return rhs.empty?
+      def empty?
+        rhs.empty?
       end
 
       # Return true iff the production is generative
-      def generative?()
-        if @generative.nil?
-        end
+      def generative?
+        # if @generative.nil?
+        # end
 
-        return @generative
+        @generative
       end
 
       # @return [Boolen] true iff the production is nullable
-      def nullable?()
-        return @nullable
+      def nullable?
+        @nullable
       end
 
       # Returns a string containing a human-readable representation of the
       # production.
       # @return [String]
-      def inspect()
+      def inspect
         result = +"#<#{self.class.name}:#{object_id}"
         result << " @name=\"#{name}\""
         result << " @lhs=#{lhs.name}"
         result << " @rhs=#{rhs.inspect}"
         result << " @generative=#{@generative}>"
-        return result
+        result
       end
 
       # A setter for the production name
@@ -81,6 +85,8 @@ module Rley # This module is used as a namespace
         @name = aName
       end
 
+      alias tag as
+
       private
 
       # Validation method. Return the validated input argument or