rley 0.7.08 → 0.8.00

data/lib/rley/parser/gfg_parsing.rb

@@ -280,8 +280,8 @@ module Rley # This module is used as a namespace
 
       def apply_rule(antecedentEntry, aVertex, anOrigin, aPosition, aRuleId)
         consequent = push_entry(aVertex, anOrigin, aPosition, aRuleId)
-
-        antecedence[consequent] << antecedentEntry
+        if consequent
+          antecedence[consequent] << antecedentEntry
 
 =begin
         # Invariant checks
@@ -319,7 +319,9 @@ module Rley # This module is used as a namespace
             end
         end
 =end
-        consequent.add_antecedent(antecedentEntry)
+          consequent.add_antecedent(antecedentEntry)
+        end
+
         consequent
       end
 

data/lib/rley/parser/parse_entry_set.rb

@@ -82,7 +82,7 @@ module Rley # This module is used as a namespace
 
         # Group parse entries by lhs symbol and origin
         groupings = complete_entries.group_by do |entry|
-          entry.vertex.dotted_rule.lhs.object_id.to_s
+          entry.vertex.dotted_item.lhs.object_id.to_s
         end
 
         # Retain the groups having more than one element.

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

@@ -13,7 +13,7 @@ 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)
@@ -72,13 +72,13 @@ module Rley # This module is used as a namespace
       # @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
@@ -122,6 +122,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 +163,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
-        symbols[aSymbolName]
+
+        symbols[name] = NonTerminal.new(name) unless symbols.include? name
+
+        symbols[name]
       end
     end # class
   end # module

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

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/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,6 +45,7 @@ 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?
@@ -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

data/spec/rley/engine_spec.rb

@@ -35,9 +35,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       it 'should build grammar' do
         subject.build_grammar do
           add_terminals('a', 'b', 'c')
-          add_production('S' => ['A'])
-          add_production('A' => %w[a A c])
-          add_production('A' => ['b'])
+          add_production('S' => 'A')
+          add_production('A' => 'a A c')
+          add_production('A' => 'b')
         end
 
         expect(subject.grammar).to be_kind_of(Rley::Syntax::Grammar)
@@ -71,9 +71,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     def add_sample_grammar(anEngine)
       anEngine.build_grammar do
         add_terminals('a', 'b', 'c')
-        add_production('S' => ['A'])
-        add_production('A' => %w[a A c])
-        add_production('A' => ['b'])
+        add_production('S' => 'A')
+        add_production('A' => 'a A c')
+        add_production('A' => 'b')
       end
     end
 

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -112,7 +112,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should handle empty productions' do
-            builder = Rley::Syntax::GrammarBuilder.new
+            builder = Rley::Syntax::BaseGrammarBuilder.new
             builder.add_terminals('a')
             builder.add_production('S' => 'A')
             builder.add_production('A' => 'a')
@@ -162,7 +162,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         let(:problematic_grammar) do
           # Based on grammar example in book
           # C. Fisher, R. LeBlanc, "Crafting a Compiler"; page 98
-          builder = Rley::Syntax::GrammarBuilder.new
+          builder = Rley::Syntax::BaseGrammarBuilder.new
           builder.add_terminals('a', 'b', 'c')
           builder.add_production('S' => 'A')
           builder.add_production('S' => 'B')

data/spec/rley/notation/grammar_builder_spec.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/notation/grammar_builder'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Notation # Open this namespace to avoid module qualifier prefixes
+    describe GrammarBuilder do
+      context 'Initialization without argument:' do
+        it 'could be created without argument' do
+          expect { GrammarBuilder.new }.not_to raise_error
+        end
+
+        it 'should have no grammar symbols at start' do
+            expect(subject.symbols).to be_empty
+        end
+
+        it 'should have no productions at start' do
+            expect(subject.productions).to be_empty
+        end
+      end # context
+
+      context 'Initialization with argument:' do
+        it 'could be created with a block argument' do
+          expect do
+            GrammarBuilder.new { nil }
+          end.not_to raise_error
+        end
+
+        it 'could have grammar symbols from block argument' do
+          instance = GrammarBuilder.new do
+            add_terminals('a', 'b', 'c')
+          end
+          expect(instance.symbols.size).to eq(3)
+        end
+
+        it 'should have no productions at start' do
+            expect(subject.productions).to be_empty
+        end
+      end # context
+
+      context 'Adding symbols:' do
+        it 'should build terminals from their names' do
+          subject.add_terminals('a', 'b', 'c')
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['a'].name).to eq('a')
+          expect(subject.symbols['b']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['b'].name).to eq('b')
+          expect(subject.symbols['c']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['c'].name).to eq('c')
+        end
+
+        it 'should accept already built terminals' do
+          a = Syntax::Terminal.new('a')
+          b = Syntax::VerbatimSymbol.new('b')
+          c = Syntax::Literal.new('c', /c/)
+
+          subject.add_terminals(a, b, c)
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to eq(a)
+          expect(subject.symbols['b']).to eq(b)
+          expect(subject.symbols['c']).to eq(c)
+        end
+      end # context
+
+      context 'Adding productions:' do
+        subject do
+          instance = GrammarBuilder.new
+          instance.add_terminals('a', 'b', 'c')
+          instance
+        end
+
+        it 'should add a valid production' do
+          # Case of a rhs representation that consists of one name only
+          expect { subject.add_production('S' => 'A') }.not_to raise_error
+          expect(subject.productions.size).to eq(1)
+          new_prod = subject.productions[0]
+          expect(new_prod.lhs).to eq(subject['S'])
+          expect(new_prod.rhs[0]).not_to be_nil
+          expect(new_prod.rhs[0]).to eq(subject['A'])
+
+          # Case of rhs with multiple symbols
+          subject.add_production('A' => 'a A c')
+          expect(subject.productions.size).to eq(2)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect_rhs = [subject['a'], subject['A'], subject['c']]
+          expect(new_prod.rhs.members).to eq(expect_rhs)
+
+          # GrammarBuilder#rule is an alias of add_production
+          subject.rule('A' => 'b')
+          expect(subject.productions.size).to eq(3)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect(new_prod.rhs[0]).to eq(subject['b'])
+        end
+
+        it 'should accept annotated terminals' do
+          subject.rule('A' => "a b {match_closest: 'IF' } c")
+          expect(subject.productions.size).to eq(1)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect(new_prod.rhs[0].name).to eq('a')
+          expect(new_prod.rhs[0]).to eq(subject['a'])
+          expect(new_prod.rhs[1].name).to eq('b')
+          expect(new_prod.rhs[2].name).to eq('c')
+          expect(new_prod.constraints.size).to eq(1)
+          expect(new_prod.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(new_prod.constraints[0].idx_symbol).to eq(1) # b is on position 1
+          expect(new_prod.constraints[0].closest_symb).to eq('IF')
+        end
+
+        it "should support optional symbol" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('LPAREN', 'RPAREN')
+
+          instance.add_production('argument_list' => 'LPAREN arguments? RPAREN')
+
+          # implicitly called: rule('arguments_qmark' => 'arguments').tag suffix_qmark_one
+          # implicitly called: rule('arguments_qmark' => '').tag suffix_qmark_none
+          expect(instance.productions.size).to eq(3)
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'arguments_qmark' }
+          expect(prod_star.size).to eq(2)
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('argument_list')
+          expect(last_prod.rhs.members[1].name).to eq('arguments_qmark')
+        end
+
+        it "should support Kleene's star" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('EOF')
+
+          instance.add_production('program' => 'declaration* EOF')
+
+          # implicitly called: rule('declaration_star' => 'declaration_star declaration').tag suffix_star_more
+          # implicitly called: rule('declaration_star' => '').tag suffix_star_last
+          expect(instance.productions.size).to eq(3)
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'declaration_star' }
+          expect(prod_star.size).to eq(2)
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('program')
+          expect(last_prod.rhs.members[0].name).to eq('declaration_star')
+        end
+
+        it "should support symbols decorated with Kleene's plus" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('plus', 'minus', 'digit')
+
+          instance.add_production('integer' => 'value')
+          instance.add_production('integer' => 'sign value')
+          instance.add_production('sign' => 'plus')
+          instance.add_production('sign' => 'minus')
+          expect(instance.productions.size).to eq(4)
+          instance.add_production('value' => 'digit+')
+
+          # implicitly called: rule('digit_plus' => 'digit_plus digit').tag suffix_plus_more
+          # implicitly called: rule('digit_plus' => 'digit').tag suffix_plus_last
+          expect(instance.productions.size).to eq(7) # Two additional rules generated
+          prod_plus = instance.productions.select { |prod| prod.lhs.name == 'digit_plus' }
+          expect(prod_plus.size).to eq(2)
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('value')
+          expect(last_prod.rhs.members[0].name).to eq('digit_plus')
+        end
+
+        it "should support optional grouping" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('EQUAL', 'IDENTIFIER', 'VAR')
+
+          instance.add_production('var_decl' => 'VAR IDENTIFIER (EQUAL expression)?')
+
+          # implicitly called: rule('seq_EQUAL_expression' => 'EQUAL expression').tag 'return_children'
+          # implicitly called: rule('seq_EQUAL_expression_qmark' => 'seq_EQUAL_expression').tag suffix_qmark_one
+          # implicitly called: rule('seq_EQUAL_expression_qmark' => '').tag suffix_qmark_none
+          expect(instance.productions.size).to eq(4)
+          (p0, p1, p2) = instance.productions[0..2]
+          expect(p0.lhs.name).to eq('seq_EQUAL_expression')
+          expect(p0.rhs[0].name).to eq('EQUAL')
+          expect(p0.rhs[1].name).to eq('expression')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_EQUAL_expression_qmark')
+          expect(p1.rhs[0].name).to eq('seq_EQUAL_expression')
+          expect(p1.name).to eq('_qmark_one')
+
+          expect(p2.lhs.name).to eq('seq_EQUAL_expression_qmark')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_qmark_none')
+
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('var_decl')
+          expect(last_prod.rhs.members[2].name).to eq('seq_EQUAL_expression_qmark')
+        end
+
+        it "should support grouping with star modifier" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('OR')
+
+          instance.add_production('logic_or' => 'logic_and (OR logic_and)*')
+
+          # implicitly called: rule('seq_OR_logic_and' => 'OR logic_and').tag 'return_children'
+          # implicitly called: rule('seq_EQUAL_expression_star' => 'seq_EQUAL_expression_star seq_EQUAL_expression').tag suffix_star_more
+          # implicitly called: rule('seq_EQUAL_expression_star' => '').tag suffix_star_none
+          expect(instance.productions.size).to eq(4)
+          (p0, p1, p2) = instance.productions[0..2]
+          expect(p0.lhs.name).to eq('seq_OR_logic_and')
+          expect(p0.rhs[0].name).to eq('OR')
+          expect(p0.rhs[1].name).to eq('logic_and')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_OR_logic_and_star')
+          expect(p1.rhs[0].name).to eq('seq_OR_logic_and_star')
+          expect(p1.rhs[1].name).to eq('seq_OR_logic_and')
+          expect(p1.name).to eq('_star_more')
+
+          expect(p2.lhs.name).to eq('seq_OR_logic_and_star')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_star_none')
+
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('logic_or')
+          expect(last_prod.rhs.members[1].name).to eq('seq_OR_logic_and_star')
+        end
+
+        it "should support grouping with plus modifier" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('POINT TO SEMI_COLON')
+
+          instance.add_production('path' => 'POINT (TO POINT)+ SEMI_COLON')
+
+          # implicitly called: rule('seq_TO_POINT' => 'TO POINT').tag 'return_children'
+          # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT_plus seq_TO_POINT').tag suffix_plus_more
+          # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT').tag suffix_plus_one
+          expect(instance.productions.size).to eq(4)
+          (p0, p1, p2) = instance.productions[0..2]
+          expect(p0.lhs.name).to eq('seq_TO_POINT')
+          expect(p0.rhs[0].name).to eq('TO')
+          expect(p0.rhs[1].name).to eq('POINT')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_TO_POINT_plus')
+          expect(p1.rhs[0].name).to eq('seq_TO_POINT_plus')
+          expect(p1.rhs[1].name).to eq('seq_TO_POINT')
+          expect(p1.name).to eq('_plus_more')
+
+          expect(p2.lhs.name).to eq('seq_TO_POINT_plus')
+          expect(p2.rhs[0].name).to eq('seq_TO_POINT')
+          expect(p2.name).to eq('_plus_one')
+
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('path')
+          expect(last_prod.rhs.members[1].name).to eq('seq_TO_POINT_plus')
+        end
+
+        it "should support grouping with nested annotation" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('IF ELSE LPAREN RPAREN')
+          st = "IF LPAREN expr RPAREN stmt (ELSE { match_closest: 'IF' } stmt)?"
+          instance.add_production('if_stmt' => st)
+
+          # implicitly called: rule('seq_ELSE_stmt' => 'ELSE stmt').tag 'return_children'
+          # implicitly called: rule('seq_ELSE_stmt_qmark' => 'seq_ELSE_stmt ').tag suffix_plus_more
+          # implicitly called: rule('seq_ELSE_stmt_qmark' => '').tag suffix_plus_one
+          expect(instance.productions.size).to eq(4)
+          (p0, p1, p2) = instance.productions[0..2]
+          expect(p0.lhs.name).to eq('seq_ELSE_stmt')
+          expect(p0.rhs[0].name).to eq('ELSE')
+          expect(p0.rhs[1].name).to eq('stmt')
+          expect(p0.name).to eq('return_children')
+          expect(p0.constraints.size). to eq(1)
+          expect(p0.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(p0.constraints[0].idx_symbol).to eq(0) # ELSE is on position 0
+          expect(p0.constraints[0].closest_symb).to eq('IF')
+
+          expect(p1.lhs.name).to eq('seq_ELSE_stmt_qmark')
+          expect(p1.rhs[0].name).to eq('seq_ELSE_stmt')
+          expect(p1.name).to eq('_qmark_one')
+
+          expect(p2.lhs.name).to eq('seq_ELSE_stmt_qmark')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_qmark_none')
+
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('if_stmt')
+          expect(last_prod.rhs.members[5].name).to eq('seq_ELSE_stmt_qmark')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file