rley 0.8.00 → 0.8.05

data/lib/rley/notation/grammar_builder.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require 'set'
+
 require_relative 'parser'
 require_relative 'ast_visitor'
 require_relative '../syntax/match_closest'
 
 module Rley # This module is used as a namespace
   module Notation # This module is used as a namespace
+    # Structure used for production rules that are implicitly generated by Rley
+    RawRule = Struct.new(:lhs, :rhs, :tag, :simple, :constraints)
+
     # Builder GoF pattern. Builder builds a complex object
     #   (say, a grammar) from simpler objects (terminals and productions)
     #   and using a step by step approach.
@@ -25,15 +29,18 @@ module Rley # This module is used as a namespace
       #   the grammar to build.
       attr_reader(:productions)
 
+      # @return [Hash{String, String}] The synthesized raw productions
+      attr_reader(:synthetized)
+
       # Creates a new grammar builder.
       # @param aBlock [Proc] code block used to build the grammar.
       # @example Building a tiny English grammar
-      #   builder = Rley::Syntax::GrammarBuilder.new do
+      #   builder = Rley::Notation::GrammarBuilder.new do
       #     add_terminals('n', 'v', 'adj', 'det')
-      #     rule 'S' => %w[NP VP]
-      #     rule 'VP' => %w[v NP]
-      #     rule 'NP' => %w[det n]
-      #     rule 'NP' => %w[adj NP]
+      #     rule 'S' => 'NP VP'
+      #     rule 'VP' => 'v NP'
+      #     rule 'NP' => 'det n'
+      #     rule 'NP' => 'adj NP'
       #   end
       #   tiny_eng = builder.grammar
       def initialize(&aBlock)
@@ -41,8 +48,12 @@ module Rley # This module is used as a namespace
         @productions = []
         @parser = Notation::Parser.new
         @visitor2rhs = {}
+        @synthetized = {}
 
-        instance_exec(&aBlock) if block_given?
+        if block_given?
+          instance_exec(&aBlock)
+          grammar_complete!
+        end
       end
 
       # Retrieve a grammar symbol from its name.
@@ -61,6 +72,14 @@ module Rley # This module is used as a namespace
         symbols.merge!(new_symbs)
       end
 
+      # Add the given marker symbol to the grammar of the language
+      # @param aMarkerSymbol [String] A mazker symbol
+      # @return [void]
+      def add_marker(aMarkerSymbol)
+        new_symb = build_symbol(Syntax::Marker, aMarkerSymbol)
+        symbols[new_symb.name] = new_symb
+      end
+
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => String.
       #   Where the key is the name of the non-terminal appearing in the
@@ -204,7 +223,7 @@ module Rley # This module is used as a namespace
       end
 
       ##################################
-      # AST visit notification events
+      # RGN's AST visit notification events
       # ################################
       def after_symbol_node(aSymbolNode, aVisitor)
         symb_name = aSymbolNode.name
@@ -215,9 +234,9 @@ module Rley # This module is used as a namespace
           # implicitly called: rule('symb_name_qmark' => '').tag suffix_qmark_none
           name_modified = "#{symb_name}#{suffix_qmark}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{symb_name}" ).tag suffix_qmark_one
-            rule(name_modified => '').tag suffix_qmark_none
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, symb_name, suffix_qmark_one)
+            add_raw_rule(name_modified, '', suffix_qmark_none)
           end
           symb_name = name_modified
 
@@ -226,21 +245,21 @@ module Rley # This module is used as a namespace
           # implicitly called: rule('symb_name_star' => '').tag suffix_star_none
           name_modified = "#{symb_name}#{suffix_star}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_star_more
-            rule(name_modified => '').tag suffix_star_none
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_star_more)
+            add_raw_rule(name_modified, [], suffix_star_none)
           end
           symb_name = name_modified
 
         when :exactly_one
           # Do nothing
 
-        when  :one_or_more
+        when :one_or_more
           name_modified = "#{symb_name}#{suffix_plus}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_plus_more
-            rule(name_modified => symb_name).tag suffix_plus_one
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_plus_more)
+            add_raw_rule(name_modified, symb_name, suffix_plus_one)
           end
           symb_name = name_modified
         else
@@ -254,6 +273,7 @@ module Rley # This module is used as a namespace
       def after_sequence_node(aSequenceNode, _visitor)
         aSequenceNode.subnodes.each_with_index do |sn, i|
           next if sn.annotation.empty?
+
           matching = sn.annotation['match_closest']
           aSequenceNode.constraints << Syntax::MatchClosest.new(aSequenceNode, i, matching)
         end
@@ -264,10 +284,9 @@ module Rley # This module is used as a namespace
         symb_name = sequence_name(aGroupingNode)
 
         unless symbols.include?(symb_name) || aGroupingNode.repetition == :exactly_one
-          symbols[symb_name] = Syntax::NonTerminal.new(symb_name)
-          simple_rule(symb_name => serialize_sequence(aGroupingNode) ).tag 'return_children'
-          prod = productions.last
-          prod.constraints = aGroupingNode.constraints
+          add_nonterminal(symb_name)
+          rhs = serialize_sequence(aGroupingNode)
+          add_raw_rule(symb_name, rhs, 'return_children', true, aGroupingNode.constraints)
         end
         name_modified = "#{symb_name}#{repetition2suffix(aGroupingNode.repetition)}"
 
@@ -276,18 +295,18 @@ module Rley # This module is used as a namespace
           # implicitly called: rule('symb_name_qmark' => 'symb_name_qmark').tag suffix_qmark_one
           # implicitly called: rule('symb_name_qmark' => '').tag suffix_qmark_none
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            simple_rule(name_modified => symb_name).tag suffix_qmark_one
-            simple_rule(name_modified => []).tag suffix_qmark_none
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, symb_name, suffix_qmark_one, true)
+            add_raw_rule(name_modified, [], suffix_qmark_none, true)
           end
 
         when :zero_or_more
           # implicitly called: rule('symb_name_star' => 'symb_name_star symb_name').tag suffix_star_more
           # implicitly called: rule('symb_name_star' => '').tag suffix_star_none
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_star_more
-            rule(name_modified => '').tag suffix_star_none
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_star_more)
+            add_raw_rule(name_modified, '', suffix_star_none)
           end
 
         when :exactly_one
@@ -295,9 +314,9 @@ module Rley # This module is used as a namespace
 
         when :one_or_more
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_plus_more
-            rule(name_modified => symb_name).tag suffix_plus_one
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_plus_more)
+            add_raw_rule(name_modified, symb_name, suffix_plus_one)
           end
         else
           raise StandardError, 'Unhandled multiplicity'
@@ -309,8 +328,18 @@ module Rley # This module is used as a namespace
         end
       end
 
+      # A notification to the builderobject that the programmer
+      # has completed the entry of terminals and production rules
+      def grammar_complete!
+        process_raw_rules
+      end
+
       private
 
+      def add_nonterminal(aName)
+        symbols[aName] = Syntax::NonTerminal.new(aName)
+      end
+
       def simple_rule(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
           lhs = get_grm_symbol(lhs_name)
@@ -324,7 +353,7 @@ module Rley # This module is used as a namespace
           members = rhs.map do |name|
             if name.end_with?('?', '*', '+')
               modifier = name[-1]
-              suffix = modifier2suffix(aModifier)
+              suffix = modifier2suffix(modifier)
               get_grm_symbol("#{name.chop}#{suffix}")
             else
               get_grm_symbol(name)
@@ -420,7 +449,7 @@ module Rley # This module is used as a namespace
         end
       end
 
-      def node_decorated_name(aNdoe)
+      def node_decorated_name(aNode)
         base_name = node_base_name(aNode)
         suffix = repetition2suffix(aNode.repetition)
 
@@ -438,12 +467,37 @@ module Rley # This module is used as a namespace
             text << sequence_name(sn)
           end
 
-          suffix = suffix = repetition2suffix(sn.repetition)
+          suffix = repetition2suffix(sn.repetition)
           text << suffix
         end
 
         text.strip
       end
+
+      def add_raw_rule(aSymbol, aRHS, aTag, simplified = false, constraints = [])
+        raw_rule = RawRule.new(aSymbol, aRHS, aTag, simplified, constraints)
+        if synthetized.include?(aSymbol)
+          @synthetized[aSymbol] << raw_rule
+        else
+          @synthetized[aSymbol] = [raw_rule]
+        end
+      end
+
+      def process_raw_rules
+        until synthetized.empty? do
+          raw_rules = synthetized.delete(synthetized.keys.first)
+          raw_rules.each do |raw|
+            new_prod = nil
+            if raw.simple
+              new_prod = simple_rule(raw.lhs => raw.rhs)
+            else
+              new_prod = rule(raw.lhs => raw.rhs)
+            end
+            new_prod.tag(raw.tag)
+            new_prod.constraints = raw.constraints
+          end
+        end
+      end
     end # class
   end # module
 end # module

data/lib/rley/notation/grouping_node.rb

@@ -5,7 +5,7 @@ require_relative 'sequence_node'
 module Rley
   module Notation
     # A syntax node representing an expression bracketed by parentheses.
-    class GroupingNode < SequenceNode      
+    class GroupingNode < SequenceNode
       # @param aPosition [Rley::Lexical::Position] Start position.
       # @param sequence [Array<ASTNode>] sequence of AST nodes
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated

data/lib/rley/notation/parser.rb

@@ -1,56 +1,56 @@
-# frozen_string_literal: true
-
-require_relative 'tokenizer'
-require_relative 'grammar'
-require_relative 'ast_builder'
-
-module Rley
-  module Notation
-    # A Lox parser that produce concrete parse trees.
-    # Concrete parse trees are the default kind of parse tree
-    # generated by the Rley library.
-    # They consist of two node types only:
-    # - NonTerminalNode
-    # - TerminalNode
-    # A NonTerminalNode has zero or more child nodes (called subnodes)
-    # A TerminalNode is leaf node, that is, it has no child node.
-    # While concrete parse tree nodes can be generated out of the box,
-    # they have the following drawbacks:
-    # - Generic node classes that aren't always suited for the needs of
-    #     the language being processing.
-    # - Concrete parse tree tend to be deeply nested, which may complicate
-    #   further processing.
-    class Parser
-      # @return [Rley::Engine] A facade object for the Rley parsing library
-      attr_reader(:engine)
-
-      def initialize
-        # Create a Rley facade object
-        @engine = Rley::Engine.new do |cfg|
-          cfg.diagnose = true
-          cfg.repr_builder = Notation::ASTBuilder
-        end
-
-        # Step 1. Load RGN grammar
-        @engine.use_grammar(Rley::Notation::RGNGrammar)
-      end
-
-      # Parse the given Lox program into a parse tree.
-      # @param source [String] Lox program to parse
-      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
-      def parse(source)
-        lexer = Tokenizer.new(source)
-        result = engine.parse(lexer.tokens)
-
-        unless result.success?
-          # Stop if the parse failed...
-          line1 = "Parsing failed\n"
-          line2 = "Reason: #{result.failure_reason.message}"
-          raise SyntaxError, line1 + line2
-        end
-
-        return engine.convert(result) # engine.to_ptree(result)
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'tokenizer'
+require_relative 'grammar'
+require_relative 'ast_builder'
+
+module Rley
+  module Notation
+    # A Lox parser that produce concrete parse trees.
+    # Concrete parse trees are the default kind of parse tree
+    # generated by the Rley library.
+    # They consist of two node types only:
+    # - NonTerminalNode
+    # - TerminalNode
+    # A NonTerminalNode has zero or more child nodes (called subnodes)
+    # A TerminalNode is leaf node, that is, it has no child node.
+    # While concrete parse tree nodes can be generated out of the box,
+    # they have the following drawbacks:
+    # - Generic node classes that aren't always suited for the needs of
+    #     the language being processing.
+    # - Concrete parse tree tend to be deeply nested, which may complicate
+    #   further processing.
+    class Parser
+      # @return [Rley::Engine] A facade object for the Rley parsing library
+      attr_reader(:engine)
+
+      def initialize
+        # Create a Rley facade object
+        @engine = Rley::Engine.new do |cfg|
+          cfg.diagnose = true
+          cfg.repr_builder = Notation::ASTBuilder
+        end
+
+        # Step 1. Load RGN grammar
+        @engine.use_grammar(Rley::Notation::RGNGrammar)
+      end
+
+      # Parse the given Lox program into a parse tree.
+      # @param source [String] Lox program to parse
+      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
+      def parse(source)
+        lexer = Tokenizer.new(source)
+        result = engine.parse(lexer.tokens)
+
+        unless result.success?
+          # Stop if the parse failed...
+          line1 = "Parsing failed\n"
+          line2 = "Reason: #{result.failure_reason.message}"
+          raise SyntaxError, line1 + line2
+        end
+
+        return engine.convert(result) # engine.to_ptree(result)
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/notation/sequence_node.rb

@@ -8,16 +8,16 @@ module Rley
     class SequenceNode < ASTNode
       # @return [Array<ASTNode>]
       attr_reader :subnodes
-      
+
       attr_accessor :constraints
-      
+
       # @param aPosition [Rley::Lexical::Position] Start position.
       # @param sequence [Array<ASTNode>] sequence of AST nodes
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated
       def initialize(aPosition, sequence, theRepetition = nil)
         super(aPosition)
         @subnodes = sequence
-        repetition=(theRepetition) if theRepetition
+        self.repetition = theRepetition if theRepetition
         @constraints = []
       end
 

data/lib/rley/notation/symbol_node.rb

@@ -8,14 +8,14 @@ module Rley
     class SymbolNode < ASTNode
       # @return [String] name of grammar symbol
       attr_reader :name
-      
+
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param aName [String] name of grammar symbol
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated
       def initialize(aPosition, aName, theRepetition = nil)
         super(aPosition)
         @name = aName
-        repetition=(theRepetition) if theRepetition
+        self.repetition = theRepetition if theRepetition
       end
 
       # Abstract method (must be overriden in subclasses).

data/lib/rley/notation/tokenizer.rb

@@ -35,11 +35,11 @@ module Rley
         '*' => 'STAR',
         '..' => 'ELLIPSIS'
       }.freeze
-      
+
       # Here are all the implemented Rley notation keywords
       @@keywords = %w[
         match_closest repeat
-      ].map { |x| [x, x] }.to_h      
+      ].map { |x| [x, x] }.to_h
 
       # Constructor. Initialize a tokenizer for Lox input.
       # @param source [String] Lox text to tokenize.
@@ -84,7 +84,7 @@ module Rley
           token = build_token(@@lexeme2name[curr_ch], scanner.getch)
         elsif '?*+,'.include? curr_ch # modifier character
           # modifiers without prefix text are symbols
-          symb = ws_found ? 'SYMBOL' : @@lexeme2name[curr_ch] 
+          symb = ws_found ? 'SYMBOL' : @@lexeme2name[curr_ch]
           token = build_token(symb, scanner.getch)
         elsif (lexeme = scanner.scan(/\.\./))
           # One or two special character tokens
@@ -114,7 +114,6 @@ module Rley
           col = scanner.pos - lex_length - @line_start + 1
           pos = Rley::Lexical::Position.new(@lineno, col)
           token = Rley::Lexical::Token.new(aLexeme.dup, aSymbolName, pos)
-
         rescue StandardError => e
           puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
           raise e
@@ -148,21 +147,10 @@ module Rley
             when "\n"
               next_line
               literal << special
-            # when '\\'
-              # ch = scanner.scan(/./)
-              # next unless ch
-
-              # escaped = @@escape_chars[ch]
-              # if escaped
-                # literal << escaped
-              # else
-                # literal << ch
-              # end
             end
           end
         end
         pos = Rley::Lexical::Position.new(line, column_start)
-        lexeme = scanner.string[scan_pos - 1..scanner.pos - 1]
         Rley::Lexical::Token.new(literal, 'STR_LIT', pos)
       end
 

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -126,16 +126,47 @@ module Rley # This module is used as a namespace
 
       # Standard method for handling one or more modifier: symbol+
       # rule('symbol_plus' => 'symbol_plus symbol')
-      def reduce_base_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
+      # def reduce_base_plus_more(_production, _range, _tokens, theChildren)
+        # theChildren[0] << theChildren[1]
+      # end
 
       # Standard rule method handling one or more modifier: symbol+
       # rule('symbol_plus' => 'symbol')
-      def reduce_base_plus_last(_production, _range, _tokens, theChildren)
+      # def reduce_base_plus_last(_production, _range, _tokens, theChildren)
+        # [theChildren[0]]
+      # end
+
+      # Implicit rule generated for * modifier
+      # rule('X') => 'X item'.as '_star_more'
+      def reduce__star_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[1]
+        theChildren[0]
+      end
+
+      # Implicit rule generated for * modifier
+      # rule('X') => ''.as '_star_none'
+      def reduce__star_none(_production, _range, _tokens, _children)
+        []
+      end
+
+      # Implicit rule generated for + modifier
+      # rule('X') => 'X item'.as '_plus_more'
+      def reduce__plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[1]
+        theChildren[0]
+      end
+
+      # Implicit rule generated for + modifier
+      # rule('X') => 'item'.as '_plus_one'
+      def reduce__plus_one(_production, _range, _tokens, theChildren)
         [theChildren[0]]
       end
 
+      # Implicit rule generated for + modifier
+      # rule('X') => 'item'.as '_plus_one'
+      def reduce_return_children(_production, _range, _tokens, theChildren)
+        theChildren
+      end
     end # class
   end # module
 end # module

data/lib/rley/parser/gfg_chart.rb

@@ -20,7 +20,7 @@ module Rley # This module is used as a namespace
       # @param aGFGraph [GFG::GrmFlowGraph] The GFG for the grammar in use.
       def initialize(aGFGraph)
         @sets = [ParseEntrySet.new]
-        @constraints = [[]]        
+        @constraints = [[]]
         push_entry(aGFGraph.start_vertex, 0, 0, :start_rule)
       end
 
@@ -174,7 +174,7 @@ module Rley # This module is used as a namespace
             when :before # terminal before dot
               term_name = criteria[keyword]
               if e.dotted_entry? && e.vertex.dotted_item.position > -2
-                found << e if e.prev_symbol&.name == criteria[keyword]
+                found << e if e.prev_symbol&.name == term_name
               end
           end
         end
@@ -209,12 +209,13 @@ module Rley # This module is used as a namespace
           first_entry = sets[i][0]
           prev_symbol = first_entry.prev_symbol
           break if prev_symbol.name == aConstraint.closest_symb
+
           i -= 1
-          break if i < 0
+          break if i.negative?
         end
 
         # Retrieve all entries of the kind: closest_symb .
-        if i > 0
+        if i.positive?
           entries = sets[i].entries.select do |en|
             if en.prev_symbol
               en.prev_symbol.name == aConstraint.closest_symb

data/lib/rley/parser/gfg_earley_parser.rb

@@ -51,7 +51,7 @@ module Rley # This module is used as a namespace
         result.chart[index].each do |entry|
           # Is entry of the form? [A => alpha . B beta, k]...
           next_symbol = entry.next_symbol
-          if next_symbol&.kind_of?(Syntax::NonTerminal)
+          if next_symbol.kind_of?(Syntax::NonTerminal)
             # ...apply the Call rule
             call_rule(result, entry, index)
           end

data/lib/rley/syntax/base_grammar_builder.rb

@@ -3,8 +3,6 @@
 require 'set'
 require_relative 'terminal'
 require_relative 'non_terminal'
-require_relative 'literal'
-require_relative 'verbatim_symbol'
 require_relative 'production'
 require_relative 'grammar'
 
@@ -56,6 +54,14 @@ module Rley # This module is used as a namespace
         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.
       #   Where the key is the name of the non-terminal appearing in the

data/lib/rley/syntax/match_closest.rb

@@ -7,13 +7,13 @@ module Rley # This module is used as a namespace
     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
@@ -21,18 +21,18 @@ module Rley # This module is used as a namespace
         @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
+        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

data/lib/rley.rb

@@ -6,7 +6,7 @@
 
 require_relative './rley/constants'
 require_relative './rley/interface'
-require_relative './rley/lexical/token'
+require_relative './rley/lexical/literal'
 require_relative './rley/parser/gfg_earley_parser'
 require_relative './rley/parse_rep/ast_base_builder'
 require_relative './rley/parse_tree_visitor'