Fix failed integration test for user defined parameterizing rules

lib/lrama/grammar/parameterizing_rule_builder.rb

@@ -15,7 +15,7 @@ def build_rules(token, rule_counter, lhs_tag, line)
         lhs = lhs_token(token)
         rules = []
         @rhs.each do |rhs|
-          rules << Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: [rhs_token(token, rhs)].compact, lhs_tag: lhs_tag, token_code: rhs.user_code, precedence_sym: rhs.precedence_sym, lineno: line)
+          rules << Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: rhs_token(token, rhs), lhs_tag: lhs_tag, token_code: rhs.user_code, precedence_sym: rhs.precedence_sym, lineno: line)
         end
         ParameterizingRule.new(rules: rules, token: lhs)
       end
@@ -33,12 +33,14 @@ def lhs_token(token)
       end
 
       def rhs_token(token, rhs)
-        return nil unless rhs.symbol
-        term = rhs.symbol
-        @args.each_with_index do |arg, index|
-          term = token.args[index] if arg.s_value == rhs.symbol.s_value
-        end
-        term
+        rhs.symbols.map do |sym|
+          idx = @args.index { |arg| arg.s_value == sym.s_value }
+          if idx.nil?
+            sym
+          else
+            token.args[idx]
+          end
+        end.compact
       end
     end
   end

lib/lrama/grammar/parameterizing_rule_rhs_builder.rb

@@ -1,10 +1,10 @@
 module Lrama
   class Grammar
     class ParameterizingRuleRhsBuilder
-      attr_accessor :symbol, :user_code, :precedence_sym
+      attr_accessor :symbols, :user_code, :precedence_sym
 
       def initialize
-        @symbol = nil
+        @symbols = []
         @user_code = nil
         @precedence_sym = nil
       end

parser.y

@@ -238,7 +238,7 @@ rule
               token = val[1]
               token.alias_name = val[2]
               builder = val[0]
-              builder.symbol = token
+              builder.symbols << token
               result = builder
             }
           | rule_rhs "{"

sig/lrama/grammar/parameterizing_rule_builder.rbs

@@ -14,7 +14,7 @@ module Lrama
 
       def validate_argument_number!: (Lexer::Token::Parameterizing token) -> void
       def lhs_token: (Lexer::Token::Parameterizing token) -> Lexer::Token
-      def rhs_token: (Lexer::Token::Parameterizing token, Grammar::ParameterizingRuleRhsBuilder rhs) -> Lexer::Token?
+      def rhs_token: (Lexer::Token::Parameterizing token, Grammar::ParameterizingRuleRhsBuilder rhs) -> Array[Lexer::Token]
     end
   end
 end

sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs

@@ -1,7 +1,7 @@
 module Lrama
   class Grammar
     class ParameterizingRuleRhsBuilder
-      attr_reader symbol: Lexer::Token?
+      attr_reader symbols: Array[Lexer::Token]
       attr_reader user_code: Lexer::Token::UserCode?
       attr_reader precedence_sym: Lexer::Token?
 

spec/fixtures/integration/user_defined_parameterizing_rules.l

@@ -0,0 +1,53 @@
+%option noinput nounput noyywrap never-interactive yylineno bison-bridge bison-locations
+
+%{
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "user_defined_parameterizing_rules.h"
+
+int yycolumn = 0;
+
+#define YY_USER_ACTION \
+    yylloc->first_line = yylloc->last_line = yylineno; \
+    yylloc->first_column = yycolumn; \
+    yylloc->last_column = yycolumn + yyleng; \
+    yycolumn += yyleng; \
+
+%}
+
+ODD  [13579]
+EVEN [02468]
+
+%%
+
+{ODD} {
+    yylval->num = atoi(yytext);
+    return ODD;
+}
+
+{EVEN} {
+    yylval->num = atoi(yytext);
+    return EVEN;
+}
+
+[;] {
+    return yytext[0];
+}
+
+[\n|\r\n] {
+    return(YYEOF);
+}
+
+[[:space:]] {}
+
+<<EOF>> {
+    return(YYEOF);
+}
+
+. {
+    fprintf(stderr, "Illegal character '%s'\n", yytext);
+    return(YYEOF);
+}
+
+%%

spec/fixtures/integration/user_defined_parameterizing_rules.y

@@ -0,0 +1,56 @@
+%{
+
+#define YYDEBUG 1
+
+#include <stdio.h>
+
+#include "user_defined_parameterizing_rules.h"
+#include "user_defined_parameterizing_rules-lexer.h"
+
+static int yyerror(YYLTYPE *loc, const char *str);
+
+%}
+
+%expect 0
+
+%union {
+    int num;
+}
+
+%token <num> ODD EVEN
+
+%rule pair(X, Y): X Y { printf("(%d, %d)\n", $1, $2); }
+                ;
+
+%%
+
+program: stmts
+       ;
+
+stmts: separated_list(';', stmt)
+     ;
+
+stmt: pair(ODD, EVEN) { printf("pair odd even\n"); }
+    | pair(EVEN, ODD) { printf("pair even odd\n"); }
+    ;
+
+%%
+
+static int yyerror(YYLTYPE *loc, const char *str) {
+    fprintf(stderr, "parse error: %s\\n", str);
+    return 0;
+}
+
+int main(int argc, char *argv[]) {
+    yydebug = 1;
+
+    if (argc == 2) {
+        yy_scan_string(argv[1]);
+    }
+
+    if (yyparse()) {
+        fprintf(stderr, "syntax error\n");
+        return 1;
+    }
+    return 0;
+}

spec/fixtures/parameterizing_rules/user_defined.y

@@ -28,11 +28,15 @@ static int yyerror(YYLTYPE *loc, const char *str);
                       | X
                       ;
 
+%rule pair(X, Y): X ',' Y { printf("(%d, %d)\n", $1, $2); }
+                ;
+
 %%
 
 program         : defined_option(number) <i>
                 | multi_args(number, string)
                 | multi_args(number, number)
+                | pair(number, string) { printf("pair odd even\n"); }
                 ;
 
 %%

spec/lrama/integration_spec.rb

@@ -76,6 +76,18 @@ def generate_object(grammar_file_path, c_path, obj_path, command_args: [])
     end
   end
 
+  describe "user defined parameterizing rules" do
+    it "prints messages corresponding to rules" do
+      expected = <<~STR
+        (0, 1)
+        pair even odd
+        (1, 0)
+        pair odd even
+      STR
+      test_parser("user_defined_parameterizing_rules", "0 1 ; 1 0", expected)
+    end
+  end
+
   describe "%printer" do
     it "prints messages" do
       expected = <<~STR.chomp

spec/lrama/parser_spec.rb

@@ -1222,11 +1222,12 @@
         grammar = Lrama::Parser.new(y, path).parse
 
         expect(grammar.nterms.sort_by(&:number)).to match_symbols([
-          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: "defined_option_number"), alias_name: nil, number: 7, tag: T::Tag.new(s_value: "<i>"), term: false, token_id: 2, nullable: true),
-          Sym.new(id: T::Ident.new(s_value: "multi_args_number_string"), alias_name: nil, number: 8, tag: nil, term: false, token_id: 3, nullable: false),
-          Sym.new(id: T::Ident.new(s_value: "multi_args_number_number"), alias_name: nil, number: 9, tag: nil, term: false, token_id: 4, nullable: false)
+          Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 0, nullable: false),
+          Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 1, nullable: true),
+          Sym.new(id: T::Ident.new(s_value: "defined_option_number"), alias_name: nil, number: 8, tag: T::Tag.new(s_value: "<i>"), term: false, token_id: 2, nullable: true),
+          Sym.new(id: T::Ident.new(s_value: "multi_args_number_string"), alias_name: nil, number: 9, tag: nil, term: false, token_id: 3, nullable: false),
+          Sym.new(id: T::Ident.new(s_value: "multi_args_number_number"), alias_name: nil, number: 10, tag: nil, term: false, token_id: 4, nullable: false),
+          Sym.new(id: T::Ident.new(s_value: "pair_number_string"), alias_name: nil, number: 11, tag: nil, term: false, token_id: 5, nullable: false),
         ])
 
         expect(grammar.rules).to eq([
@@ -1240,7 +1241,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("YYEOF"),
-            lineno: 33,
+            lineno: 36,
           ),
           Rule.new(
             id: 1,
@@ -1250,7 +1251,7 @@
             token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 33,
+            lineno: 36,
           ),
           Rule.new(
             id: 2,
@@ -1262,7 +1263,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("number"),
-            lineno: 33,
+            lineno: 36,
           ),
           Rule.new(
             id: 3,
@@ -1273,7 +1274,7 @@
             token_code: nil,
             nullable: true,
             precedence_sym: nil,
-            lineno: 33,
+            lineno: 36,
           ),
           Rule.new(
             id: 4,
@@ -1285,7 +1286,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("number"),
-            lineno: 34,
+            lineno: 37,
           ),
           Rule.new(
             id: 5,
@@ -1297,7 +1298,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("string"),
-            lineno: 34,
+            lineno: 37,
           ),
           Rule.new(
             id: 6,
@@ -1309,7 +1310,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: nil,
-            lineno: 34,
+            lineno: 37,
           ),
           Rule.new(
             id: 7,
@@ -1321,7 +1322,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("number"),
-            lineno: 35,
+            lineno: 38,
           ),
           Rule.new(
             id: 8,
@@ -1333,7 +1334,7 @@
             token_code: nil,
             nullable: false,
             precedence_sym: grammar.find_symbol_by_s_value!("number"),
-            lineno: 35,
+            lineno: 38,
           ),
           Rule.new(
             id: 9,
@@ -1345,7 +1346,33 @@
             token_code: nil,
             nullable: false,
             precedence_sym: nil,
-            lineno: 35,
+            lineno: 38,
+          ),
+          Rule.new(
+            id: 10,
+            lhs: grammar.find_symbol_by_s_value!("pair_number_string"),
+            rhs: [
+              grammar.find_symbol_by_s_value!("number"),
+              grammar.find_symbol_by_number!(5),
+              grammar.find_symbol_by_s_value!("string"),
+            ],
+            lhs_tag: nil,
+            token_code: T::UserCode.new(s_value: " printf(\"(%d, %d)\\n\", $1, $2); "),
+            nullable: false,
+            precedence_sym: grammar.find_symbol_by_s_value!("string"),
+            lineno: 39,
+          ),
+          Rule.new(
+            id: 11,
+            lhs: grammar.find_symbol_by_s_value!("program"),
+            rhs: [
+              grammar.find_symbol_by_s_value!("pair_number_string"),
+            ],
+            lhs_tag: nil,
+            token_code: T::UserCode.new(s_value: " printf(\"pair odd even\\n\"); "),
+            nullable: false,
+            precedence_sym: nil,
+            lineno: 39,
           ),
         ])
       end