wip

lib/lrama/grammar.rb

@@ -489,8 +489,8 @@ def replace_token_with_symbol
         rule.lhs = token_to_symbol(rule._lhs) if rule._lhs
 
         rule.rhs = rule._rhs.map do |t|
-          token_to_symbol(t)
-        end
+          token_to_symbol(t) unless t.is_a?(Lrama::Lexer::Token::Parameterizing)
+        end.compact
       end
     end
 

lib/lrama/grammar/parameterizing_rules/builder.rb

@@ -32,11 +32,14 @@ def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
 
         def build
           validate_key!
+
           rules = inside_rules
-          unless rules.empty?
-            @token.args.first.s_value = rules.last.lhs.s_value
-          end
-          rules << RULES[@key].new(@token, @rule_counter, @lhs, @user_code, @precedence_sym, @line).build
+          s_value = if rules.empty?
+                      @token.args.first.s_value
+                    else
+                      rules.last._lhs.s_value
+                    end
+          rules << RULES[@key].new(@token.args, s_value, @rule_counter, @lhs, @user_code, @precedence_sym, @line).build
           rules.flatten
         end
 

lib/lrama/grammar/parameterizing_rules/builder/base.rb

@@ -3,9 +3,10 @@ class Grammar
     class ParameterizingRules
       class Builder
         class Base
-          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
-            @args = token.args
+          def initialize(args, s_value, rule_counter, lhs, user_code, precedence_sym, line)
+            @args = args
             @token = @args.first
+            @s_value = s_value
             @rule_counter = rule_counter
             @lhs = lhs
             @user_code = user_code

lib/lrama/grammar/parameterizing_rules/builder/list.rb

@@ -7,7 +7,7 @@ def build
             validate_argument_number!
 
             rules = []
-            list_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
+            list_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@s_value}")
             rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [list_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)

lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb

@@ -7,7 +7,7 @@ def build
             validate_argument_number!
 
             rules = []
-            nonempty_list_token = Lrama::Lexer::Token::Ident.new(s_value: "nonempty_list_#{@token.s_value}")
+            nonempty_list_token = Lrama::Lexer::Token::Ident.new(s_value: "nonempty_list_#{@s_value}")
             rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [nonempty_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: nonempty_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: nonempty_list_token, _rhs: [nonempty_list_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)

lib/lrama/grammar/parameterizing_rules/builder/option.rb

@@ -7,7 +7,7 @@ def build
             validate_argument_number!
 
             rules = []
-            option_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@token.s_value}")
+            option_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@s_value}")
             rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [option_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: option_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: option_token, _rhs: [@token], token_code: @ser_code, precedence_sym: @precedence_sym, lineno: @line)

lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb

@@ -14,7 +14,7 @@ def build
             validate_argument_number!
 
             rules = []
-            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@token.s_value}")
+            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@s_value}")
             rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)

lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb

@@ -14,7 +14,7 @@ def build
             validate_argument_number!
 
             rules = []
-            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
+            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@s_value}")
             rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [separated_list_token, @separator, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)

lib/lrama/grammar/rule_builder.rb

@@ -83,7 +83,7 @@ def build_rules
 
         # Expand Parameterizing rules
         if tokens.any? {|r| r.is_a?(Lrama::Lexer::Token::Parameterizing) }
-          @rules = @parameterizing_rules
+          @rules = parameterizing_rules
           @midrule_action_rules = []
         else
           rule = Rule.new(

parser.y

@@ -366,9 +366,7 @@ rule
   parameterizing_rules: IDENTIFIER parameterizing_suffix
                           {
                             token = Lrama::Lexer::Token::Parameterizing.new(s_value: val[1], location: @lexer.location, args: [val[0]])
-                            builder = val[0]
-                            builder.add_rhs(token)
-                            result = builder
+                            result = token
                           }
                       | IDENTIFIER "(" parameterizing_rule ")"
                           {
@@ -378,9 +376,7 @@ rule
                       | IDENTIFIER "(" symbol "," symbol ")"
                           {
                             token = Lrama::Lexer::Token::Parameterizing.new(s_value: val[0].s_value, location: @lexer.location, args: [val[2], val[4]])
-                            builder = val[0]
-                            builder.add_rhs(token)
-                            result = builder
+                            result = token
                           }
 
   parameterizing_rule: parameterizing_rules

spec/lrama/parser_spec.rb

@@ -1058,10 +1058,10 @@
         grammar = Lrama::Parser.new(y, path).parse
 
         expect(grammar.nterms.sort_by(&:number)).to eq([
-          Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 5, tag: nil, term: false, token_id: 0, nullable: false),
-          Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 1, nullable: true),
-          Sym.new(id: T::Ident.new(s_value: "list_number"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 2, nullable: true),
-          Sym.new(id: T::Ident.new(s_value: "option_list_number"), alias_name: nil, number: 8, tag: nil, term: false, token_id: 3, nullable: true),
+          Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 4, tag: nil, term: false, token_id: 0, nullable: false),
+          Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 5, tag: nil, term: false, token_id: 1, nullable: true),
+          Sym.new(id: T::Ident.new(s_value: "list_number"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 2, nullable: true),
+          Sym.new(id: T::Ident.new(s_value: "option_list_number"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 3, nullable: true),
         ])
 
         expect(grammar.rules).to eq([
@@ -1075,7 +1075,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("YYEOF"),
-            lineno: 21,
+            lineno: 20,
           ),
           Rule.new(
             id: 1,
@@ -1086,7 +1086,7 @@
             token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 21,
+            lineno: 20,
           ),
           Rule.new(
             id: 2,
@@ -1095,7 +1095,7 @@
             token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 21,
+            lineno: 20,
           ),
           Rule.new(
             id: 3,
@@ -1107,36 +1107,36 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("number"),
-            lineno: 21,
+            lineno: 20,
           ),
           Rule.new(
             id: 4,
-            lhs: grammar.find_symbol_by_s_value!("alias"),
+            lhs: grammar.find_symbol_by_s_value!("program"),
             rhs: [
-              grammar.find_symbol_by_s_value!("list_number_alias"),
+              grammar.find_symbol_by_s_value!("option_list_number")
             ],
+            token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 24,
+            lineno: 20,
           ),
           Rule.new(
             id: 5,
-            lhs: grammar.find_symbol_by_s_value!("list_number_alias"),
+            lhs: grammar.find_symbol_by_s_value!("option_list_number"),
             rhs: [],
+            token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 24,
+            lineno: 20,
           ),
           Rule.new(
             id: 6,
-            lhs: grammar.find_symbol_by_s_value!("list_number_alias"),
-            rhs: [
-              grammar.find_symbol_by_s_value!("list_number_alias"),
-              grammar.find_symbol_by_s_value!("number_alias"),
-            ],
-            nullable: false,
-            precedence_sym: grammar.find_symbol_by_s_value!("number_alias"),
-            lineno: 24,
+            lhs: grammar.find_symbol_by_s_value!("option_list_number"),
+            rhs: [],
+            token_code: nil,
+            nullable: true,
+            precedence_sym: nil,
+            lineno: 20,
           ),
         ])
       end