rley 0.7.08 → 0.8.00

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

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,113 @@
+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      

data/lib/rley/notation/grammar.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../syntax/base_grammar_builder'
+
+module Rley
+  module Notation
+    ########################################
+    # Syntax for right-hand side of production rules
+    builder = Rley::Syntax::BaseGrammarBuilder.new do
+      add_terminals('LEFT_PAREN', 'RIGHT_PAREN') # For '(', ')' grouping delimiters
+      add_terminals('LEFT_BRACE', 'RIGHT_BRACE') # For '{', '}' annotation delimiters
+      add_terminals('QUESTION_MARK', 'STAR', 'PLUS') # For postfix quantifiers
+      add_terminals('COMMA', 'ELLIPSIS')
+
+      add_terminals('STR_LIT') # For string literal values
+      add_terminals('INT_LIT') # For integer literal values
+      add_terminals('SYMBOL') # Grammar symbols
+      add_terminals('KEY') # Key literal
+
+      rule('notation' => 'rhs')
+      rule('rhs' => 'member_seq').tag 'sequence'
+      rule('rhs' => [])
+      rule('member_seq' => 'member_seq member').tag 'more_members'
+      rule('member_seq' => 'member').tag 'one_member'
+      rule('member' => 'strait_member')
+      rule('member' => 'quantified_member')
+      rule('strait_member' => 'base_member')
+      rule('strait_member' => 'base_member annotation').tag 'annotated_member'
+      rule('base_member' => 'SYMBOL').tag 'symbol'
+      rule('base_member' => 'LEFT_PAREN member_seq RIGHT_PAREN').tag 'grouping'
+      rule('quantified_member' => 'base_member quantifier').tag 'quantified_member'
+      rule('quantifier' => 'QUESTION_MARK').tag 'question_mark'
+      rule('quantifier' => 'STAR').tag 'star'
+      rule('quantifier' => 'PLUS').tag 'plus'
+      rule('annotation' => 'LEFT_BRACE mapping RIGHT_BRACE').tag 'annotation'
+      rule('mapping' => 'mapping COMMA key_value').tag 'more_pairs'
+      rule('mapping' => 'key_value').tag 'one_pair'
+      rule('key_value' => 'KEY value').tag 'raw_pair'
+      rule('value' => 'STR_LIT')
+      rule('value' => 'INT_LIT')
+      rule('value' => 'range')
+      rule('range' => 'INT_LIT ELLIPSIS INT_LIT').tag 'bound_range'
+      rule('range' => 'INT_LIT ELLIPSIS')
+    end
+
+    # And now build the Rley Grammar Notation (RGN) grammar...
+    RGNGrammar = builder.grammar
+  end # module
+end # module

data/lib/rley/notation/grammar_builder.rb

@@ -0,0 +1,451 @@
+# 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
+    # 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
+      # @return [Hash{String, GrmSymbol}] The mapping of grammar symbol names
+      #   to the matching grammar symbol object.
+      attr_reader(:symbols)
+
+      # @return [Notation::Parser] Parser for the right-side of productions
+      attr_reader(:parser)
+
+      # @return [Hash{ASTVisitor, Array}]
+      attr_reader(:visitor2rhs)
+
+      # @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.
+      # @example Building a tiny English grammar
+      #   builder = Rley::Syntax::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]
+      #   end
+      #   tiny_eng = builder.grammar
+      def initialize(&aBlock)
+        @symbols = {}
+        @productions = []
+        @parser = Notation::Parser.new
+        @visitor2rhs = {}
+
+        instance_exec(&aBlock) if block_given?
+      end
+
+      # Retrieve a grammar symbol from its name.
+      # Raise an exception if not found.
+      # @param aSymbolName [String] the name of a grammar symbol.
+      # @return [GrmSymbol] the retrieved symbol object.
+      def [](aSymbolName)
+        symbols[aSymbolName]
+      end
+
+      # Add the given terminal symbols to the grammar of the language
+      # @param terminalSymbols [String or Terminal] 1..* terminal symbols.
+      # @return [void]
+      def add_terminals(*terminalSymbols)
+        new_symbs = build_symbols(Syntax::Terminal, terminalSymbols)
+        symbols.merge!(new_symbs)
+      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
+      #   left side of the rule.
+      #   The value is a sequence of grammar symbol names (optionally quantified).
+      # The rule is created and inserted in the grammar.
+      # @example Equivalent call syntax
+      #   builder.add_production('A' => 'a  A c)
+      #   builder.rule('A' => 'a A  c]) # 'rule' is a synonym
+      # @param aProductionRepr [Hash{String, 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_grm_symbol(lhs_name)
+          rhs = rhs_repr.kind_of?(Array) && rhs_repr.empty? ? '' : rhs_repr.strip
+          constraints = []
+          if rhs.empty?
+            rhs_members = []
+          else
+            ast = parser.parse(rhs)
+            visitor = ASTVisitor.new(ast)
+            visitor2rhs[visitor] = []
+            visitor.subscribe(self)
+            visitor.start
+            root_node = ast.root
+            constraints = root_node.constraints unless root_node.kind_of?(SymbolNode)
+
+            rhs_members = visitor2rhs.delete(visitor)
+          end
+          new_prod = Syntax::Production.new(lhs, rhs_members)
+          new_prod.constraints = constraints
+          productions << new_prod
+        end
+
+        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
+        unless @grammar
+          raise StandardError, 'No symbol found for grammar' if symbols.empty?
+          if productions.empty?
+            raise StandardError, 'No production found for grammar'
+          end
+
+          # Check that each terminal appears at least in a rhs of a production
+          all_terminals = symbols.values.select do |a_symb|
+            a_symb.kind_of?(Syntax::Terminal)
+          end
+          in_use = Set.new
+          productions.each do |prod|
+            prod.rhs.members.each do |symb|
+              in_use << symb if symb.kind_of?(Syntax::Terminal)
+            end
+          end
+
+          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}"
+          end
+
+          @grammar = Syntax::Grammar.new(productions.dup)
+        end
+
+        @grammar
+      end
+
+      alias rule add_production
+
+      # 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
+      # implicitly called: rule('declaration_star' => 'declaration_star declaration').tag suffix_star_more
+      # implicitly called: rule('declaration_star' => '').tag suffix_star_last
+      def suffix_qmark
+        '_qmark'
+      end
+
+      def suffix_qmark_one
+        '_qmark_one'
+      end
+
+      def suffix_qmark_none
+        '_qmark_none'
+      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
+      # implicitly called: rule('declaration_star' => 'declaration_star declaration').tag suffix_star_more
+      # implicitly called: rule('declaration_star' => '').tag suffix_star_last
+      def suffix_star
+        '_star'
+      end
+
+      def suffix_star_more
+        '_star_more'
+      end
+
+      def suffix_star_none
+        '_star_none'
+      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
+      # implicitly called: rule('digit_plus' => 'digit_plus digit').tag suffix_plus_more
+      # implicitly called: rule('digit_plus' => 'digit').tag suffix_plus_last
+      def suffix_plus
+        '_plus'
+      end
+
+      def suffix_plus_more
+        '_plus_more'
+      end
+
+      def suffix_plus_one
+        '_plus_one'
+      end
+
+      def repetition2suffix(aRepetition)
+        mapping = {
+          zero_or_one: suffix_qmark,
+          zero_or_more: suffix_star,
+          exactly_one: '',
+          one_or_more: suffix_plus
+        }
+
+        mapping[aRepetition]
+      end
+
+      def modifier2suffix(aModifier)
+        mapping = {
+          '?' => suffix_qmark,
+          '*' => suffix_star,
+          '+' => suffix_plus
+        }
+
+        mapping[aModifier]
+      end
+
+      ##################################
+      # AST visit notification events
+      # ################################
+      def after_symbol_node(aSymbolNode, aVisitor)
+        symb_name = aSymbolNode.name
+
+        case aSymbolNode.repetition
+        when :zero_or_one
+          # implicitly called: rule('symb_name_qmark' => 'symb_name_qmark').tag suffix_qmark_one
+          # 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
+          end
+          symb_name = name_modified
+
+        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
+          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
+          end
+          symb_name = name_modified
+
+        when :exactly_one
+          # Do nothing
+
+        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
+          end
+          symb_name = name_modified
+        else
+          raise StandardError, 'Unhandled multiplicity'
+        end
+
+        symb = get_grm_symbol(symb_name)
+        visitor2rhs[aVisitor] << symb
+      end
+
+      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
+      end
+
+      def after_grouping_node(aGroupingNode, aVisitor)
+        after_sequence_node(aGroupingNode, aVisitor)
+        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
+        end
+        name_modified = "#{symb_name}#{repetition2suffix(aGroupingNode.repetition)}"
+
+        case aGroupingNode.repetition
+        when :zero_or_one
+          # 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
+          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
+          end
+
+        when :exactly_one
+          # Do nothing
+
+        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
+          end
+        else
+          raise StandardError, 'Unhandled multiplicity'
+        end
+
+        unless aGroupingNode.repetition == :exactly_one
+          symb = get_grm_symbol(name_modified)
+          visitor2rhs[aVisitor] << symb
+        end
+      end
+
+      private
+
+      def simple_rule(aProductionRepr)
+        aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
+          lhs = get_grm_symbol(lhs_name)
+
+          if rhs_repr.kind_of?(String)
+            rhs = rhs_repr.strip.scan(/\S+/)
+          else
+            rhs = rhs_repr
+          end
+
+          members = rhs.map do |name|
+            if name.end_with?('?', '*', '+')
+              modifier = name[-1]
+              suffix = modifier2suffix(aModifier)
+              get_grm_symbol("#{name.chop}#{suffix}")
+            else
+              get_grm_symbol(name)
+            end
+          end
+          new_prod = Syntax::Production.new(lhs, members)
+          productions << new_prod
+        end
+
+        productions.last
+      end
+
+      # Add the given grammar symbols.
+      # @param aClass [Class] The class of grammar symbols to instantiate.
+      # @param theSymbols [Array] array of elements are treated as follows:
+      #   if the element is already a grammar symbol, then it added as is,
+      #   otherwise it is considered as the name of a grammar symbol
+      # of the specified class to build.
+      def build_symbols(aClass, theSymbols)
+        symbs = {}
+        theSymbols.each do |s|
+          new_symbol = build_symbol(aClass, s)
+          symbs[new_symbol.name] = new_symbol
+        end
+
+        symbs
+      end
+
+      # If the argument is already a grammar symbol object then it is
+      # returned as is. Otherwise, the argument is treated as a name
+      # for a new instance of the given class.
+      # @param aClass [Class] The class of grammar symbols to instantiate
+      # @param aSymbolArg [GrmSymbol-like or String]
+      # @return [Array] list of grammar symbols
+      def build_symbol(aClass, aSymbolArg)
+        if aSymbolArg.kind_of?(Syntax::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_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[name] = Syntax::NonTerminal.new(name) unless symbols.include? name
+
+        symbols[name]
+      end
+
+      def sequence_name(aSequenceNode)
+        subnode_names = +''
+        aSequenceNode.subnodes.each do |subn|
+          case subn
+          when SymbolNode
+            subnode_names << "_#{subn.name}"
+          when SequenceNode
+            subnode_names << "_#{sequence_name(subn)}"
+          end
+          suffix = repetition2suffix(subn.repetition)
+          subnode_names << suffix
+        end
+
+        "seq#{subnode_names}"
+      end
+
+      def node_base_name(aNode)
+        if aNode.kind_of?(SymbolNode)
+          aNode.name
+        else
+          sequence_name(aNode)
+        end
+      end
+
+      def node_decorated_name(aNdoe)
+        base_name = node_base_name(aNode)
+        suffix = repetition2suffix(aNode.repetition)
+
+        "#{base_name}#{suffix}"
+      end
+
+      def serialize_sequence(aSequenceNode)
+        text = +''
+        aSequenceNode.subnodes.each do |sn|
+          text << ' '
+          case sn
+          when SymbolNode
+            text << sn.name
+          when SequenceNode
+            text << sequence_name(sn)
+          end
+
+          suffix = suffix = repetition2suffix(sn.repetition)
+          text << suffix
+        end
+
+        text.strip
+      end
+    end # class
+  end # module
+end # module
+
+# End of file