tests/conflicts.at

   1 # Exercising Bison on conflicts.                         -*- Autotest -*-
   2
   3 # Copyright (C) 2002-2005, 2007-2012 Free Software Foundation, Inc.
   4
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 AT_BANNER([[Conflicts.]])
  19
  20
  21 ## ---------------- ##
  22 ## S/R in initial.  ##
  23 ## ---------------- ##
  24
  25 # I once hacked Bison in such a way that it lost its reductions on the
  26 # initial state (because it was confusing it with the last state).  It
  27 # took me a while to strip down my failures to this simple case.  So
  28 # make sure it finds the s/r conflict below.
  29
  30 AT_SETUP([S/R in initial])
  31
  32 AT_DATA([[input.y]],
  33 [[%expect 1
  34 %%
  35 exp: e 'e';
  36 e: 'e' | /* Nothing. */;
  37 ]])
  38
  39 AT_BISON_CHECK([-o input.c input.y], 0, [],
  40 [[input.y:4.9: warning: rule useless in parser due to conflicts: e: /* empty */ [-Wother]
  41 ]])
  42
  43 AT_CLEANUP
  44
  45
  46 ## ------------------- ##
  47 ## %nonassoc and eof.  ##
  48 ## ------------------- ##
  49
  50 AT_SETUP([%nonassoc and eof])
  51
  52 AT_BISON_OPTION_PUSHDEFS
  53 AT_DATA_GRAMMAR([input.y],
  54 [[
  55 %{
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <assert.h>
  60
  61 #define YYERROR_VERBOSE 1
  62 ]AT_YYERROR_DEFINE[
  63 /* The current argument. */
  64 static const char *input;
  65
  66 static int
  67 yylex (void)
  68 {
  69   static size_t toknum;
  70   assert (toknum <= strlen (input));
  71   return input[toknum++];
  72 }
  73
  74 %}
  75
  76 %nonassoc '<' '>'
  77
  78 %%
  79 expr: expr '<' expr
  80     | expr '>' expr
  81     | '0'
  82     ;
  83 %%
  84 int
  85 main (int argc, const char *argv[])
  86 {
  87   input = argc <= 1 ? "" : argv[1];
  88   return yyparse ();
  89 }
  90 ]])
  91 AT_BISON_OPTION_POPDEFS
  92
  93 m4_pushdef([AT_NONASSOC_AND_EOF_CHECK],
  94 [AT_BISON_CHECK([$1[ -o input.c input.y]])
  95 AT_COMPILE([input])
  96
  97 m4_pushdef([AT_EXPECTING], [m4_if($2, [correct], [[, expecting $end]])])
  98
  99 AT_PARSER_CHECK([./input '0<0'])
 100 AT_PARSER_CHECK([./input '0<0<0'], [1], [],
 101          [syntax error, unexpected '<'AT_EXPECTING
 102 ])
 103
 104 AT_PARSER_CHECK([./input '0>0'])
 105 AT_PARSER_CHECK([./input '0>0>0'], [1], [],
 106          [syntax error, unexpected '>'AT_EXPECTING
 107 ])
 108
 109 AT_PARSER_CHECK([./input '0<0>0'], [1], [],
 110          [syntax error, unexpected '>'AT_EXPECTING
 111 ])
 112
 113 m4_popdef([AT_EXPECTING])])
 114
 115 # Expected token list is missing.
 116 AT_NONASSOC_AND_EOF_CHECK([], [[incorrect]])
 117
 118 # We must disable default reductions in inconsistent states in order to
 119 # have an explicit list of all expected tokens.
 120 AT_NONASSOC_AND_EOF_CHECK([[-Dlr.default-reduction=consistent]],
 121                           [[correct]])
 122
 123 # lr.default-reduction=consistent happens to work for this test case.
 124 # However, for other grammars, lookahead sets can be merged for
 125 # different left contexts, so it is still possible to have an incorrect
 126 # expected list.  Canonical LR is almost a general solution (that is, it
 127 # can fail only when %nonassoc is used), so make sure it gives the same
 128 # result as above.
 129 AT_NONASSOC_AND_EOF_CHECK([[-Dlr.type=canonical-lr]], [[correct]])
 130
 131 # parse.lac=full is a completely general solution that does not require
 132 # any of the above sacrifices.  Of course, it does not extend the
 133 # language-recognition power of LALR to (IE)LR, but it does ensure that
 134 # the reported list of expected tokens matches what the given parser
 135 # would have accepted in place of the unexpected token.
 136 AT_NONASSOC_AND_EOF_CHECK([[-Dparse.lac=full]], [[correct]])
 137
 138 m4_popdef([AT_NONASSOC_AND_EOF_CHECK])
 139
 140 AT_CLEANUP
 141
 142
 143
 144 ## ------------------------------------------- ##
 145 ## parse.error=verbose and consistent errors.  ##
 146 ## ------------------------------------------- ##
 147
 148 AT_SETUP([[parse.error=verbose and consistent errors]])
 149
 150 m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [
 151
 152 AT_BISON_OPTION_PUSHDEFS([$1])
 153
 154 m4_pushdef([AT_YYLEX_PROTOTYPE],
 155 [AT_SKEL_CC_IF([[int yylex (yy::parser::semantic_type *lvalp)]],
 156                [[int yylex (YYSTYPE *lvalp)]])])
 157
 158 AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
 159 [AT_SKEL_JAVA_IF([[
 160
 161 %code imports {
 162   import java.io.IOException;
 163 }]], [[
 164
 165 %code {]AT_SKEL_CC_IF([[
 166   #include <string>]], [[
 167   #include <assert.h>
 168   #include <stdio.h>
 169   ]AT_YYERROR_DECLARE])[
 170   ]AT_YYLEX_PROTOTYPE[;
 171   #define USE(Var)
 172 }
 173
 174 ]AT_SKEL_CC_IF([[%defines]], [[%define api.pure]])])[
 175
 176 ]$1[
 177
 178 %define parse.error verbose
 179
 180 %%
 181
 182 ]$2[
 183
 184 ]AT_SKEL_JAVA_IF([[%code lexer {]], [[%%]])[
 185
 186 /*--------.
 187 | yylex.  |
 188 `--------*/]AT_SKEL_JAVA_IF([[
 189
 190 public String input = "]$3[";
 191 public int index = 0;
 192 public int yylex ()
 193 {
 194   if (index < input.length ())
 195     return input.charAt (index++);
 196   else
 197     return 0;
 198 }
 199 public Object getLVal ()
 200 {
 201   return new Integer(1);
 202 }]], [[
 203
 204 ]AT_YYLEX_PROTOTYPE[
 205 {
 206   static char const *input = "]$3[";
 207   *lvalp = 1;
 208   return *input++;
 209 }]])[
 210 ]AT_YYERROR_DEFINE[
 211 ]AT_SKEL_JAVA_IF([[
 212 };
 213
 214 %%]])[
 215
 216 /*-------.
 217 | main.  |
 218 `-------*/]AT_SKEL_JAVA_IF([[
 219
 220 class input
 221 {
 222   public static void main (String args[]) throws IOException
 223   {
 224     YYParser p = new YYParser ();
 225     p.parse ();
 226   }
 227 }]], [AT_SKEL_CC_IF([[
 228
 229 int
 230 main (void)
 231 {
 232   yy::parser parser;
 233   return parser.parse ();
 234 }]], [[
 235
 236 int
 237 main (void)
 238 {
 239   return yyparse ();
 240 }]])])[
 241 ]])
 242
 243 AT_FULL_COMPILE([[input]])
 244
 245 m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
 246                                   $5, [a],  [[, expecting 'a']],
 247                                   $5, [b],  [[, expecting 'b']])])
 248
 249 AT_SKEL_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]],
 250                 [AT_PARSER_CHECK([[./input]], [[1]]]),
 251 [[]],
 252 [[syntax error, unexpected ]$4[]AT_EXPECTING[
 253 ]])
 254
 255 m4_popdef([AT_EXPECTING])
 256 m4_popdef([AT_YYLEX_PROTOTYPE])
 257 AT_BISON_OPTION_POPDEFS
 258
 259 ])
 260
 261 m4_pushdef([AT_PREVIOUS_STATE_GRAMMAR],
 262 [[%nonassoc 'a';
 263
 264 start: consistent-error-on-a-a 'a' ;
 265
 266 consistent-error-on-a-a:
 267     'a' default-reduction
 268   | 'a' default-reduction 'a'
 269   | 'a' shift
 270   ;
 271
 272 default-reduction: /*empty*/ ;
 273 shift: 'b' ;
 274
 275 // Provide another context in which all rules are useful so that this
 276 // test case looks a little more realistic.
 277 start: 'b' consistent-error-on-a-a 'c' ;
 278 ]])
 279
 280 m4_pushdef([AT_PREVIOUS_STATE_INPUT], [[a]])
 281
 282 # Unfortunately, no expected tokens are reported even though 'b' can be
 283 # accepted.  Nevertheless, the main point of this test is to make sure
 284 # that at least the unexpected token is reported.  In a previous version
 285 # of Bison, it wasn't reported because the error is detected in a
 286 # consistent state with an error action, and that case always triggered
 287 # the simple "syntax error" message.
 288 #
 289 # The point isn't to test IELR here, but state merging happens to
 290 # complicate this example.
 291 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr]],
 292                            [AT_PREVIOUS_STATE_GRAMMAR],
 293                            [AT_PREVIOUS_STATE_INPUT],
 294                            [[$end]], [[none]])
 295 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 296                              %glr-parser]],
 297                            [AT_PREVIOUS_STATE_GRAMMAR],
 298                            [AT_PREVIOUS_STATE_INPUT],
 299                            [[$end]], [[none]])
 300 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 301                              %language "c++"]],
 302                            [AT_PREVIOUS_STATE_GRAMMAR],
 303                            [AT_PREVIOUS_STATE_INPUT],
 304                            [[$end]], [[none]])
 305 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 306                              %language "java"]],
 307                            [AT_PREVIOUS_STATE_GRAMMAR],
 308                            [AT_PREVIOUS_STATE_INPUT],
 309                            [[end of input]], [[none]])
 310
 311 # Even canonical LR doesn't foresee the error for 'a'!
 312 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 313                              %define lr.default-reduction consistent]],
 314                            [AT_PREVIOUS_STATE_GRAMMAR],
 315                            [AT_PREVIOUS_STATE_INPUT],
 316                            [[$end]], [[ab]])
 317 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 318                              %define lr.default-reduction accepting]],
 319                            [AT_PREVIOUS_STATE_GRAMMAR],
 320                            [AT_PREVIOUS_STATE_INPUT],
 321                            [[$end]], [[ab]])
 322 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]],
 323                            [AT_PREVIOUS_STATE_GRAMMAR],
 324                            [AT_PREVIOUS_STATE_INPUT],
 325                            [[$end]], [[ab]])
 326
 327 # Only LAC gets it right.
 328 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr
 329                              %define parse.lac full]],
 330                            [AT_PREVIOUS_STATE_GRAMMAR],
 331                            [AT_PREVIOUS_STATE_INPUT],
 332                            [[$end]], [[b]])
 333 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
 334                              %define parse.lac full]],
 335                            [AT_PREVIOUS_STATE_GRAMMAR],
 336                            [AT_PREVIOUS_STATE_INPUT],
 337                            [[$end]], [[b]])
 338
 339 m4_popdef([AT_PREVIOUS_STATE_GRAMMAR])
 340 m4_popdef([AT_PREVIOUS_STATE_INPUT])
 341
 342 m4_pushdef([AT_USER_ACTION_GRAMMAR],
 343 [[%nonassoc 'a';
 344
 345 // If $$ = 0 here, then we know that the 'a' destructor is being invoked
 346 // incorrectly for the 'b' set in the semantic action below.  All 'a'
 347 // tokens are returned by yylex, which sets $$ = 1.
 348 %destructor {
 349   if (!$$)
 350     fprintf (stderr, "Wrong destructor.\n");
 351 } 'a';
 352
 353 // Rather than depend on an inconsistent state to induce reading a
 354 // lookahead as in the previous grammar, just assign the lookahead in a
 355 // semantic action.  That lookahead isn't needed before either error
 356 // action is encountered.  In a previous version of Bison, this was a
 357 // problem as it meant yychar was not translated into yytoken before
 358 // either error action.  The second error action thus invoked a
 359 // destructor that it selected according to the incorrect yytoken.  The
 360 // first error action would have reported an incorrect unexpected token
 361 // except that, due to the bug described in the previous grammar, the
 362 // unexpected token was not reported at all.
 363 start: error-reduce consistent-error 'a' { USE ($][3); } ;
 364
 365 error-reduce:
 366   'a' 'a' consistent-reduction consistent-error 'a'
 367   { USE (($][1, $][2, $][5)); }
 368 | 'a' error
 369   { USE ($][1); }
 370 ;
 371
 372 consistent-reduction: /*empty*/ {
 373   assert (yychar == YYEMPTY);
 374   yylval = 0;
 375   yychar = 'b';
 376 } ;
 377
 378 consistent-error:
 379   'a' { USE ($][1); }
 380 | /*empty*/ %prec 'a'
 381 ;
 382
 383 // Provide another context in which all rules are useful so that this
 384 // test case looks a little more realistic.
 385 start: 'b' consistent-error 'b' ;
 386 ]])
 387 m4_pushdef([AT_USER_ACTION_INPUT], [[aa]])
 388
 389 AT_CONSISTENT_ERRORS_CHECK([[]],
 390                            [AT_USER_ACTION_GRAMMAR],
 391                            [AT_USER_ACTION_INPUT],
 392                            [['b']], [[none]])
 393 AT_CONSISTENT_ERRORS_CHECK([[%glr-parser]],
 394                            [AT_USER_ACTION_GRAMMAR],
 395                            [AT_USER_ACTION_INPUT],
 396                            [['b']], [[none]])
 397 # No C++ or Java test because yychar cannot be manipulated by users.
 398
 399 AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reduction consistent]],
 400                            [AT_USER_ACTION_GRAMMAR],
 401                            [AT_USER_ACTION_INPUT],
 402                            [['b']], [[none]])
 403
 404 # Canonical LR doesn't foresee the error for 'a'!
 405 AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reduction accepting]],
 406                            [AT_USER_ACTION_GRAMMAR],
 407                            [AT_USER_ACTION_INPUT],
 408                            [[$end]], [[a]])
 409 AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]],
 410                            [AT_USER_ACTION_GRAMMAR],
 411                            [AT_USER_ACTION_INPUT],
 412                            [[$end]], [[a]])
 413
 414 AT_CONSISTENT_ERRORS_CHECK([[%define parse.lac full]],
 415                            [AT_USER_ACTION_GRAMMAR],
 416                            [AT_USER_ACTION_INPUT],
 417                            [['b']], [[none]])
 418 AT_CONSISTENT_ERRORS_CHECK([[%define parse.lac full
 419                              %define lr.default-reduction accepting]],
 420                            [AT_USER_ACTION_GRAMMAR],
 421                            [AT_USER_ACTION_INPUT],
 422                            [[$end]], [[none]])
 423
 424 m4_popdef([AT_USER_ACTION_GRAMMAR])
 425 m4_popdef([AT_USER_ACTION_INPUT])
 426
 427 m4_popdef([AT_CONSISTENT_ERRORS_CHECK])
 428
 429 AT_CLEANUP
 430
 431
 432
 433 ## ------------------------------------------------------- ##
 434 ## LAC: %nonassoc requires splitting canonical LR states.  ##
 435 ## ------------------------------------------------------- ##
 436
 437 # This test case demonstrates that, when %nonassoc is used, canonical
 438 # LR(1) parser table construction followed by conflict resolution
 439 # without further state splitting is not always sufficient to produce a
 440 # parser that can detect all syntax errors as soon as possible on one
 441 # token of lookahead.  However, LAC solves the problem completely even
 442 # with minimal LR parser tables.
 443
 444 AT_SETUP([[LAC: %nonassoc requires splitting canonical LR states]])
 445 AT_BISON_OPTION_PUSHDEFS
 446 AT_DATA_GRAMMAR([[input.y]],
 447 [[%code {
 448   #include <stdio.h>
 449   ]AT_YYERROR_DECLARE[
 450   ]AT_YYLEX_DECLARE[
 451 }
 452
 453 %error-verbose
 454 %nonassoc 'a'
 455
 456 %%
 457
 458 start:
 459   'a' problem 'a' // First context.
 460 | 'b' problem 'b' // Second context.
 461 | 'c' reduce-nonassoc // Just makes reduce-nonassoc useful.
 462 ;
 463
 464 problem:
 465   look reduce-nonassoc
 466 | look 'a'
 467 | look 'b'
 468 ;
 469
 470 // For the state reached after shifting the 'a' in these productions,
 471 // lookahead sets are the same in both the first and second contexts.
 472 // Thus, canonical LR reuses the same state for both contexts.  However,
 473 // the lookahead 'a' for the reduction "look: 'a'" later becomes an
 474 // error action only in the first context.  In order to immediately
 475 // detect the syntax error on 'a' here for only the first context, this
 476 // canonical LR state would have to be split into two states, and the
 477 // 'a' lookahead would have to be removed from only one of the states.
 478 look:
 479   'a' // Reduction lookahead set is always ['a', 'b'].
 480 | 'a' 'b'
 481 | 'a' 'c' // 'c' is forgotten as an expected token.
 482 ;
 483
 484 reduce-nonassoc: %prec 'a';
 485
 486 %%
 487 ]AT_YYERROR_DEFINE[
 488 ]AT_YYLEX_DEFINE(["aaa"])[
 489
 490 int
 491 main (void)
 492 {
 493   return yyparse ();
 494 }
 495 ]])
 496 AT_BISON_OPTION_POPDEFS
 497
 498 # Show canonical LR's failure.
 499 AT_BISON_CHECK([[-Dlr.type=canonical-lr -o input.c input.y]],
 500                [[0]], [[]],
 501 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 502 ]])
 503 AT_COMPILE([[input]])
 504 AT_PARSER_CHECK([[./input]], [[1]], [[]],
 505 [[syntax error, unexpected 'a', expecting 'b'
 506 ]])
 507
 508 # It's corrected by LAC.
 509 AT_BISON_CHECK([[-Dlr.type=canonical-lr -Dparse.lac=full \
 510                  -o input.c input.y]], [[0]], [[]],
 511 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 512 ]])
 513 AT_COMPILE([[input]])
 514 AT_PARSER_CHECK([[./input]], [[1]], [[]],
 515 [[syntax error, unexpected 'a', expecting 'b' or 'c'
 516 ]])
 517
 518 # IELR is sufficient when LAC is used.
 519 AT_BISON_CHECK([[-Dlr.type=ielr -Dparse.lac=full -o input.c input.y]],
 520                [[0]], [[]],
 521 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 522 ]])
 523 AT_COMPILE([[input]])
 524 AT_PARSER_CHECK([[./input]], [[1]], [[]],
 525 [[syntax error, unexpected 'a', expecting 'b' or 'c'
 526 ]])
 527
 528 AT_CLEANUP
 529
 530 ## ------------------------- ##
 531 ## Unresolved SR Conflicts.  ##
 532 ## ------------------------- ##
 533
 534 AT_SETUP([Unresolved SR Conflicts])
 535
 536 AT_KEYWORDS([report])
 537
 538 AT_DATA([input.y],
 539 [[%token NUM OP
 540 %%
 541 exp: exp OP exp | NUM;
 542 ]])
 543
 544 AT_BISON_CHECK([-o input.c --report=all input.y], 0, [],
 545 [[input.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
 546 ]])
 547
 548 # Check the contents of the report.
 549 AT_CHECK([cat input.output], [],
 550 [[State 5 conflicts: 1 shift/reduce
 551
 552
 553 Grammar
 554
 555     0 $accept: exp $end
 556
 557     1 exp: exp OP exp
 558     2    | NUM
 559
 560
 561 Terminals, with rules where they appear
 562
 563 $end (0) 0
 564 error (256)
 565 NUM (258) 2
 566 OP (259) 1
 567
 568
 569 Nonterminals, with rules where they appear
 570
 571 $accept (5)
 572     on left: 0
 573 exp (6)
 574     on left: 1 2, on right: 0 1
 575
 576
 577 state 0
 578
 579     0 $accept: . exp $end
 580     1 exp: . exp OP exp
 581     2    | . NUM
 582
 583     NUM  shift, and go to state 1
 584
 585     exp  go to state 2
 586
 587
 588 state 1
 589
 590     2 exp: NUM .
 591
 592     $default  reduce using rule 2 (exp)
 593
 594
 595 state 2
 596
 597     0 $accept: exp . $end
 598     1 exp: exp . OP exp
 599
 600     $end  shift, and go to state 3
 601     OP    shift, and go to state 4
 602
 603
 604 state 3
 605
 606     0 $accept: exp $end .
 607
 608     $default  accept
 609
 610
 611 state 4
 612
 613     1 exp: . exp OP exp
 614     1    | exp OP . exp
 615     2    | . NUM
 616
 617     NUM  shift, and go to state 1
 618
 619     exp  go to state 5
 620
 621
 622 state 5
 623
 624     1 exp: exp . OP exp
 625     1    | exp OP exp .  [$end, OP]
 626
 627     OP  shift, and go to state 4
 628
 629     OP        [reduce using rule 1 (exp)]
 630     $default  reduce using rule 1 (exp)
 631 ]])
 632
 633 AT_CLEANUP
 634
 635
 636
 637 ## ----------------------- ##
 638 ## Resolved SR Conflicts.  ##
 639 ## ----------------------- ##
 640
 641 AT_SETUP([Resolved SR Conflicts])
 642
 643 AT_KEYWORDS([report])
 644
 645 AT_DATA([input.y],
 646 [[%token NUM OP
 647 %left OP
 648 %%
 649 exp: exp OP exp | NUM;
 650 ]])
 651
 652 AT_BISON_CHECK([-o input.c --report=all input.y])
 653
 654 # Check the contents of the report.
 655 AT_CHECK([cat input.output], [],
 656 [[Grammar
 657
 658     0 $accept: exp $end
 659
 660     1 exp: exp OP exp
 661     2    | NUM
 662
 663
 664 Terminals, with rules where they appear
 665
 666 $end (0) 0
 667 error (256)
 668 NUM (258) 2
 669 OP (259) 1
 670
 671
 672 Nonterminals, with rules where they appear
 673
 674 $accept (5)
 675     on left: 0
 676 exp (6)
 677     on left: 1 2, on right: 0 1
 678
 679
 680 state 0
 681
 682     0 $accept: . exp $end
 683     1 exp: . exp OP exp
 684     2    | . NUM
 685
 686     NUM  shift, and go to state 1
 687
 688     exp  go to state 2
 689
 690
 691 state 1
 692
 693     2 exp: NUM .
 694
 695     $default  reduce using rule 2 (exp)
 696
 697
 698 state 2
 699
 700     0 $accept: exp . $end
 701     1 exp: exp . OP exp
 702
 703     $end  shift, and go to state 3
 704     OP    shift, and go to state 4
 705
 706
 707 state 3
 708
 709     0 $accept: exp $end .
 710
 711     $default  accept
 712
 713
 714 state 4
 715
 716     1 exp: . exp OP exp
 717     1    | exp OP . exp
 718     2    | . NUM
 719
 720     NUM  shift, and go to state 1
 721
 722     exp  go to state 5
 723
 724
 725 state 5
 726
 727     1 exp: exp . OP exp
 728     1    | exp OP exp .  [$end, OP]
 729
 730     $default  reduce using rule 1 (exp)
 731
 732     Conflict between rule 1 and token OP resolved as reduce (%left OP).
 733 ]])
 734
 735 AT_CLEANUP
 736
 737
 738 ## ---------------------- ##
 739 ## %precedence suffices.  ##
 740 ## ---------------------- ##
 741
 742 AT_SETUP([%precedence suffices])
 743
 744 AT_DATA([input.y],
 745 [[%precedence "then"
 746 %precedence "else"
 747 %%
 748 stmt:
 749   "if" cond "then" stmt
 750 | "if" cond "then" stmt "else" stmt
 751 | "stmt"
 752 ;
 753
 754 cond:
 755   "exp"
 756 ;
 757 ]])
 758
 759 AT_BISON_CHECK([-o input.c input.y])
 760
 761 AT_CLEANUP
 762
 763
 764 ## ------------------------------ ##
 765 ## %precedence does not suffice.  ##
 766 ## ------------------------------ ##
 767
 768 AT_SETUP([%precedence does not suffice])
 769
 770 AT_DATA([input.y],
 771 [[%precedence "then"
 772 %precedence "else"
 773 %%
 774 stmt:
 775   "if" cond "then" stmt
 776 | "if" cond "then" stmt "else" stmt
 777 | "stmt"
 778 ;
 779
 780 cond:
 781   "exp"
 782 | cond "then" cond
 783 ;
 784 ]])
 785
 786 AT_BISON_CHECK([-o input.c input.y], 0, [],
 787 [[input.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
 788 input.y:12.3-18: warning: rule useless in parser due to conflicts: cond: cond "then" cond [-Wother]
 789 ]])
 790
 791 AT_CLEANUP
 792
 793
 794 ## -------------------------------- ##
 795 ## Defaulted Conflicted Reduction.  ##
 796 ## -------------------------------- ##
 797
 798 # When there are RR conflicts, some rules are disabled.  Usually it is
 799 # simply displayed as:
 800 #
 801 #    $end           reduce using rule 3 (num)
 802 #    $end           [reduce using rule 4 (id)]
 803 #
 804 # But when `reduce 3' is the default action, we'd produce:
 805 #
 806 #    $end           [reduce using rule 4 (id)]
 807 #    $default    reduce using rule 3 (num)
 808 #
 809 # In this precise case (a reduction is masked by the default
 810 # reduction), we make the `reduce 3' explicit:
 811 #
 812 #    $end           reduce using rule 3 (num)
 813 #    $end           [reduce using rule 4 (id)]
 814 #    $default    reduce using rule 3 (num)
 815 #
 816 # Maybe that's not the best display, but then, please propose something
 817 # else.
 818
 819 AT_SETUP([Defaulted Conflicted Reduction])
 820 AT_KEYWORDS([report])
 821
 822 AT_DATA([input.y],
 823 [[%%
 824 exp: num | id;
 825 num: '0';
 826 id : '0';
 827 %%
 828 ]])
 829
 830 AT_BISON_CHECK([-o input.c --report=all input.y], 0, [],
 831 [[input.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
 832 input.y:4.6-8: warning: rule useless in parser due to conflicts: id: '0' [-Wother]
 833 ]])
 834
 835 # Check the contents of the report.
 836 AT_CHECK([cat input.output], [],
 837 [[Rules useless in parser due to conflicts
 838
 839     4 id: '0'
 840
 841
 842 State 1 conflicts: 1 reduce/reduce
 843
 844
 845 Grammar
 846
 847     0 $accept: exp $end
 848
 849     1 exp: num
 850     2    | id
 851
 852     3 num: '0'
 853
 854     4 id: '0'
 855
 856
 857 Terminals, with rules where they appear
 858
 859 $end (0) 0
 860 '0' (48) 3 4
 861 error (256)
 862
 863
 864 Nonterminals, with rules where they appear
 865
 866 $accept (4)
 867     on left: 0
 868 exp (5)
 869     on left: 1 2, on right: 0
 870 num (6)
 871     on left: 3, on right: 1
 872 id (7)
 873     on left: 4, on right: 2
 874
 875
 876 state 0
 877
 878     0 $accept: . exp $end
 879     1 exp: . num
 880     2    | . id
 881     3 num: . '0'
 882     4 id: . '0'
 883
 884     '0'  shift, and go to state 1
 885
 886     exp  go to state 2
 887     num  go to state 3
 888     id   go to state 4
 889
 890
 891 state 1
 892
 893     3 num: '0' .  [$end]
 894     4 id: '0' .  [$end]
 895
 896     $end      reduce using rule 3 (num)
 897     $end      [reduce using rule 4 (id)]
 898     $default  reduce using rule 3 (num)
 899
 900
 901 state 2
 902
 903     0 $accept: exp . $end
 904
 905     $end  shift, and go to state 5
 906
 907
 908 state 3
 909
 910     1 exp: num .
 911
 912     $default  reduce using rule 1 (exp)
 913
 914
 915 state 4
 916
 917     2 exp: id .
 918
 919     $default  reduce using rule 2 (exp)
 920
 921
 922 state 5
 923
 924     0 $accept: exp $end .
 925
 926     $default  accept
 927 ]])
 928
 929 AT_CLEANUP
 930
 931
 932
 933
 934 ## -------------------- ##
 935 ## %expect not enough.  ##
 936 ## -------------------- ##
 937
 938 AT_SETUP([%expect not enough])
 939
 940 AT_DATA([input.y],
 941 [[%token NUM OP
 942 %expect 0
 943 %%
 944 exp: exp OP exp | NUM;
 945 ]])
 946
 947 AT_BISON_CHECK([-o input.c input.y], 1, [],
 948 [[input.y: error: shift/reduce conflicts: 1 found, 0 expected
 949 ]])
 950 AT_CLEANUP
 951
 952
 953 ## --------------- ##
 954 ## %expect right.  ##
 955 ## --------------- ##
 956
 957 AT_SETUP([%expect right])
 958
 959 AT_DATA([input.y],
 960 [[%token NUM OP
 961 %expect 1
 962 %%
 963 exp: exp OP exp | NUM;
 964 ]])
 965
 966 AT_BISON_CHECK([-o input.c input.y])
 967 AT_CLEANUP
 968
 969
 970 ## ------------------ ##
 971 ## %expect too much.  ##
 972 ## ------------------ ##
 973
 974 AT_SETUP([%expect too much])
 975
 976 AT_DATA([input.y],
 977 [[%token NUM OP
 978 %expect 2
 979 %%
 980 exp: exp OP exp | NUM;
 981 ]])
 982
 983 AT_BISON_CHECK([-o input.c input.y], 1, [],
 984 [[input.y: error: shift/reduce conflicts: 1 found, 2 expected
 985 ]])
 986 AT_CLEANUP
 987
 988
 989 ## ------------------------------- ##
 990 ## %expect with reduce conflicts.  ##
 991 ## ------------------------------- ##
 992
 993 AT_SETUP([%expect with reduce conflicts])
 994
 995 AT_DATA([input.y],
 996 [[%expect 0
 997 %%
 998 program: a 'a' | a a;
 999 a: 'a';
1000 ]])
1001
1002 AT_BISON_CHECK([-o input.c input.y], 1, [],
1003 [[input.y: error: reduce/reduce conflicts: 1 found, 0 expected
1004 ]])
1005 AT_CLEANUP
1006
1007
1008 ## ------------------------- ##
1009 ## %prec with user strings.  ##
1010 ## ------------------------- ##
1011
1012 AT_SETUP([%prec with user string])
1013
1014 AT_DATA([[input.y]],
1015 [[%%
1016 exp:
1017   "foo" %prec "foo"
1018 ;
1019 ]])
1020
1021 AT_BISON_CHECK([-o input.c input.y])
1022 AT_CLEANUP
1023
1024
1025 ## -------------------------------- ##
1026 ## %no-default-prec without %prec.  ##
1027 ## -------------------------------- ##
1028
1029 AT_SETUP([%no-default-prec without %prec])
1030
1031 AT_DATA([[input.y]],
1032 [[%left '+'
1033 %left '*'
1034
1035 %%
1036
1037 %no-default-prec;
1038
1039 e:   e '+' e
1040    | e '*' e
1041    | '0'
1042    ;
1043 ]])
1044
1045 AT_BISON_CHECK([-o input.c input.y], 0, [],
1046 [[input.y: warning: 4 shift/reduce conflicts [-Wconflicts-sr]
1047 ]])
1048 AT_CLEANUP
1049
1050
1051 ## ----------------------------- ##
1052 ## %no-default-prec with %prec.  ##
1053 ## ----------------------------- ##
1054
1055 AT_SETUP([%no-default-prec with %prec])
1056
1057 AT_DATA([[input.y]],
1058 [[%left '+'
1059 %left '*'
1060
1061 %%
1062
1063 %no-default-prec;
1064
1065 e:   e '+' e %prec '+'
1066    | e '*' e %prec '*'
1067    | '0'
1068    ;
1069 ]])
1070
1071 AT_BISON_CHECK([-o input.c input.y])
1072 AT_CLEANUP
1073
1074
1075 ## --------------- ##
1076 ## %default-prec.  ##
1077 ## --------------- ##
1078
1079 AT_SETUP([%default-prec])
1080
1081 AT_DATA([[input.y]],
1082 [[%left '+'
1083 %left '*'
1084
1085 %%
1086
1087 %default-prec;
1088
1089 e:   e '+' e
1090    | e '*' e
1091    | '0'
1092    ;
1093 ]])
1094
1095 AT_BISON_CHECK([-o input.c input.y])
1096 AT_CLEANUP
1097
1098
1099 ## ---------------------------------------------- ##
1100 ## Unreachable States After Conflict Resolution.  ##
1101 ## ---------------------------------------------- ##
1102
1103 AT_SETUP([[Unreachable States After Conflict Resolution]])
1104
1105 # If conflict resolution makes states unreachable, remove those states, report
1106 # rules that are then unused, and don't report conflicts in those states.  Test
1107 # what happens when a nonterminal becomes useless as a result of state removal
1108 # since that causes lalr.o's goto map to be rewritten.
1109
1110 AT_DATA([[input.y]],
1111 [[%output "input.c"
1112 %left 'a'
1113
1114 %%
1115
1116 start: resolved_conflict 'a' reported_conflicts 'a' ;
1117
1118 /* S/R conflict resolved as reduce, so the state with item
1119  * (resolved_conflict: 'a' . unreachable1) and all it transition successors are
1120  * unreachable, and the associated production is useless.  */
1121 resolved_conflict:
1122     'a' unreachable1
1123   | %prec 'a'
1124   ;
1125
1126 /* S/R conflict that need not be reported since it is unreachable because of
1127  * the previous conflict resolution.  Nonterminal unreachable1 and all its
1128  * productions are useless.  */
1129 unreachable1:
1130     'a' unreachable2
1131   |
1132   ;
1133
1134 /* Likewise for a R/R conflict and nonterminal unreachable2.  */
1135 unreachable2: | ;
1136
1137 /* Make sure remaining S/R and R/R conflicts are still reported correctly even
1138  * when their states are renumbered due to state removal.  */
1139 reported_conflicts:
1140     'a'
1141   | 'a'
1142   |
1143   ;
1144
1145 ]])
1146
1147 AT_BISON_CHECK([[--report=all input.y]], 0, [],
1148 [[input.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
1149 input.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
1150 input.y:12.5-20: warning: rule useless in parser due to conflicts: resolved_conflict: 'a' unreachable1 [-Wother]
1151 input.y:20.5-20: warning: rule useless in parser due to conflicts: unreachable1: 'a' unreachable2 [-Wother]
1152 input.y:21.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */ [-Wother]
1153 input.y:25.13: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ [-Wother]
1154 input.y:25.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ [-Wother]
1155 input.y:31.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a' [-Wother]
1156 input.y:32.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */ [-Wother]
1157 ]])
1158
1159 AT_CHECK([[cat input.output]], 0,
1160 [[Rules useless in parser due to conflicts
1161
1162     2 resolved_conflict: 'a' unreachable1
1163
1164     4 unreachable1: 'a' unreachable2
1165     5             | /* empty */
1166
1167     6 unreachable2: /* empty */
1168     7             | /* empty */
1169
1170     9 reported_conflicts: 'a'
1171    10                   | /* empty */
1172
1173
1174 State 4 conflicts: 1 shift/reduce
1175 State 5 conflicts: 1 reduce/reduce
1176
1177
1178 Grammar
1179
1180     0 $accept: start $end
1181
1182     1 start: resolved_conflict 'a' reported_conflicts 'a'
1183
1184     2 resolved_conflict: 'a' unreachable1
1185     3                  | /* empty */
1186
1187     4 unreachable1: 'a' unreachable2
1188     5             | /* empty */
1189
1190     6 unreachable2: /* empty */
1191     7             | /* empty */
1192
1193     8 reported_conflicts: 'a'
1194     9                   | 'a'
1195    10                   | /* empty */
1196
1197
1198 Terminals, with rules where they appear
1199
1200 $end (0) 0
1201 'a' (97) 1 2 4 8 9
1202 error (256)
1203
1204
1205 Nonterminals, with rules where they appear
1206
1207 $accept (4)
1208     on left: 0
1209 start (5)
1210     on left: 1, on right: 0
1211 resolved_conflict (6)
1212     on left: 2 3, on right: 1
1213 unreachable1 (7)
1214     on left: 4 5, on right: 2
1215 unreachable2 (8)
1216     on left: 6 7, on right: 4
1217 reported_conflicts (9)
1218     on left: 8 9 10, on right: 1
1219
1220
1221 state 0
1222
1223     0 $accept: . start $end
1224     1 start: . resolved_conflict 'a' reported_conflicts 'a'
1225     2 resolved_conflict: . 'a' unreachable1
1226     3                  | .  ['a']
1227
1228     $default  reduce using rule 3 (resolved_conflict)
1229
1230     start              go to state 1
1231     resolved_conflict  go to state 2
1232
1233     Conflict between rule 3 and token 'a' resolved as reduce (%left 'a').
1234
1235
1236 state 1
1237
1238     0 $accept: start . $end
1239
1240     $end  shift, and go to state 3
1241
1242
1243 state 2
1244
1245     1 start: resolved_conflict . 'a' reported_conflicts 'a'
1246
1247     'a'  shift, and go to state 4
1248
1249
1250 state 3
1251
1252     0 $accept: start $end .
1253
1254     $default  accept
1255
1256
1257 state 4
1258
1259     1 start: resolved_conflict 'a' . reported_conflicts 'a'
1260     8 reported_conflicts: . 'a'
1261     9                   | . 'a'
1262    10                   | .  ['a']
1263
1264     'a'  shift, and go to state 5
1265
1266     'a'  [reduce using rule 10 (reported_conflicts)]
1267
1268     reported_conflicts  go to state 6
1269
1270
1271 state 5
1272
1273     8 reported_conflicts: 'a' .  ['a']
1274     9                   | 'a' .  ['a']
1275
1276     'a'       reduce using rule 8 (reported_conflicts)
1277     'a'       [reduce using rule 9 (reported_conflicts)]
1278     $default  reduce using rule 8 (reported_conflicts)
1279
1280
1281 state 6
1282
1283     1 start: resolved_conflict 'a' reported_conflicts . 'a'
1284
1285     'a'  shift, and go to state 7
1286
1287
1288 state 7
1289
1290     1 start: resolved_conflict 'a' reported_conflicts 'a' .
1291
1292     $default  reduce using rule 1 (start)
1293 ]])
1294
1295 AT_DATA([[input-keep.y]],
1296 [[%define lr.keep-unreachable-state
1297 ]])
1298 AT_CHECK([[cat input.y >> input-keep.y]])
1299
1300 AT_BISON_CHECK([[input-keep.y]], 0, [],
1301 [[input-keep.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
1302 input-keep.y: warning: 2 reduce/reduce conflicts [-Wconflicts-rr]
1303 input-keep.y:22.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */ [-Wother]
1304 input-keep.y:26.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ [-Wother]
1305 input-keep.y:32.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a' [-Wother]
1306 input-keep.y:33.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */ [-Wother]
1307 ]])
1308
1309 AT_CLEANUP
1310
1311
1312 ## ------------------------------------------------------------ ##
1313 ## Solved conflicts report for multiple reductions in a state.  ##
1314 ## ------------------------------------------------------------ ##
1315
1316 AT_SETUP([[Solved conflicts report for multiple reductions in a state]])
1317
1318 # Used to lose earlier solved conflict messages even within a single S/R/R.
1319
1320 AT_DATA([[input.y]],
1321 [[%left 'a'
1322 %right 'b'
1323 %right 'c'
1324 %right 'd'
1325 %%
1326 start:
1327     'a'
1328   | empty_a 'a'
1329   | 'b'
1330   | empty_b 'b'
1331   | 'c'
1332   | empty_c1 'c'
1333   | empty_c2 'c'
1334   | empty_c3 'c'
1335   ;
1336 empty_a: %prec 'a' ;
1337 empty_b: %prec 'b' ;
1338 empty_c1: %prec 'c' ;
1339 empty_c2: %prec 'c' ;
1340 empty_c3: %prec 'd' ;
1341 ]])
1342 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
1343 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
1344 [[state 0
1345
1346     0 $accept: . start $end
1347     1 start: . 'a'
1348     2      | . empty_a 'a'
1349     3      | . 'b'
1350     4      | . empty_b 'b'
1351     5      | . 'c'
1352     6      | . empty_c1 'c'
1353     7      | . empty_c2 'c'
1354     8      | . empty_c3 'c'
1355     9 empty_a: .  ['a']
1356    10 empty_b: .  []
1357    11 empty_c1: .  []
1358    12 empty_c2: .  []
1359    13 empty_c3: .  ['c']
1360
1361     'b'  shift, and go to state 1
1362
1363     'c'       reduce using rule 13 (empty_c3)
1364     $default  reduce using rule 9 (empty_a)
1365
1366     start     go to state 2
1367     empty_a   go to state 3
1368     empty_b   go to state 4
1369     empty_c1  go to state 5
1370     empty_c2  go to state 6
1371     empty_c3  go to state 7
1372
1373     Conflict between rule 9 and token 'a' resolved as reduce (%left 'a').
1374     Conflict between rule 10 and token 'b' resolved as shift (%right 'b').
1375     Conflict between rule 11 and token 'c' resolved as shift (%right 'c').
1376     Conflict between rule 12 and token 'c' resolved as shift (%right 'c').
1377     Conflict between rule 13 and token 'c' resolved as reduce ('c' < 'd').
1378
1379
1380 state 1
1381 ]])
1382
1383 AT_CLEANUP
1384
1385
1386 ## ------------------------------------------------------------ ##
1387 ## %nonassoc error actions for multiple reductions in a state.  ##
1388 ## ------------------------------------------------------------ ##
1389
1390 # Used to abort when trying to resolve conflicts as %nonassoc error actions for
1391 # multiple reductions in a state.
1392
1393 # For a %nonassoc error action token, used to print the first remaining
1394 # reduction on that token without brackets.
1395
1396 AT_SETUP([[%nonassoc error actions for multiple reductions in a state]])
1397
1398 AT_DATA([[input.y]],
1399 [[%nonassoc 'a' 'b' 'c'
1400 %%
1401 start:
1402     'a'
1403   | empty_a 'a'
1404   | 'b'
1405   | empty_b 'b'
1406   | 'c'
1407   | empty_c1 'c'
1408   | empty_c2 'c'
1409   | empty_c3 'c'
1410   ;
1411 empty_a: %prec 'a' ;
1412 empty_b: %prec 'b' ;
1413 empty_c1: %prec 'c' ;
1414 empty_c2: %prec 'c' ;
1415 empty_c3: %prec 'c' ;
1416 ]])
1417
1418 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
1419 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
1420 [[state 0
1421
1422     0 $accept: . start $end
1423     1 start: . 'a'
1424     2      | . empty_a 'a'
1425     3      | . 'b'
1426     4      | . empty_b 'b'
1427     5      | . 'c'
1428     6      | . empty_c1 'c'
1429     7      | . empty_c2 'c'
1430     8      | . empty_c3 'c'
1431     9 empty_a: .  []
1432    10 empty_b: .  []
1433    11 empty_c1: .  []
1434    12 empty_c2: .  ['c']
1435    13 empty_c3: .  ['c']
1436
1437     'a'  error (nonassociative)
1438     'b'  error (nonassociative)
1439     'c'  error (nonassociative)
1440
1441     'c'  [reduce using rule 12 (empty_c2)]
1442     'c'  [reduce using rule 13 (empty_c3)]
1443
1444     start     go to state 1
1445     empty_a   go to state 2
1446     empty_b   go to state 3
1447     empty_c1  go to state 4
1448     empty_c2  go to state 5
1449     empty_c3  go to state 6
1450
1451     Conflict between rule 9 and token 'a' resolved as an error (%nonassoc 'a').
1452     Conflict between rule 10 and token 'b' resolved as an error (%nonassoc 'b').
1453     Conflict between rule 11 and token 'c' resolved as an error (%nonassoc 'c').
1454
1455
1456 state 1
1457 ]])
1458 AT_CLEANUP
1459
1460
1461 ## -------------------- ##
1462 ## %expect-rr non GLR.  ##
1463 ## -------------------- ##
1464
1465 AT_SETUP([[%expect-rr non GLR]])
1466
1467 AT_DATA([[1.y]],
1468 [[%expect-rr 0
1469 %%
1470 exp: 'a'
1471 ]])
1472
1473 AT_BISON_CHECK([[1.y]], [[0]], [],
1474 [[1.y: warning: %expect-rr applies only to GLR parsers [-Wother]
1475 ]])
1476
1477 AT_DATA([[2.y]],
1478 [[%expect-rr 1
1479 %%
1480 exp: 'a' | 'a';
1481 ]])
1482
1483 AT_BISON_CHECK([[2.y]], [[0]], [],
1484 [[2.y: warning: %expect-rr applies only to GLR parsers [-Wother]
1485 2.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
1486 2.y:3.12-14: warning: rule useless in parser due to conflicts: exp: 'a' [-Wother]
1487 ]])
1488
1489 AT_CLEANUP
1490
1491
1492 ## ---------------------------------- ##
1493 ## -W versus %expect and %expect-rr.  ##
1494 ## ---------------------------------- ##
1495
1496 AT_SETUP([[-W versus %expect and %expect-rr]])
1497
1498 AT_DATA([[sr-rr.y]],
1499 [[%glr-parser
1500 %%
1501 start: 'a' | A 'a' | B 'a' ;
1502 A: ;
1503 B: ;
1504 ]])
1505 AT_DATA([[sr.y]],
1506 [[%glr-parser
1507 %%
1508 start: 'a' | A 'a' ;
1509 A: ;
1510 ]])
1511 AT_DATA([[rr.y]],
1512 [[%glr-parser
1513 %%
1514 start: A | B ;
1515 A: ;
1516 B: ;
1517 ]])
1518
1519 AT_BISON_CHECK([[sr-rr.y]], [[0]], [[]],
1520 [[sr-rr.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
1521 sr-rr.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
1522 ]])
1523 AT_BISON_CHECK([[-Wno-conflicts-sr sr-rr.y]], [[0]], [[]],
1524 [[sr-rr.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
1525 ]])
1526 AT_BISON_CHECK([[-Wno-conflicts-rr sr-rr.y]], [[0]], [[]],
1527 [[sr-rr.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
1528 ]])
1529
1530 [
1531 # This is piece of code is rather complex for a simple task: try every
1532 # combinaison of (0 or 1 real SR) x (0 or 1 real RR) x (don't %expect
1533 # or %expect 0, 1, or 2 SR) x (don't %expect-rr or %expect-rr 0, 1, or 2
1534 # RR).
1535
1536 # Number and types of genuine conflicts in the grammar.
1537 for gram in sr-rr sr rr; do
1538   # Number of expected s/r conflicts.
1539   for sr_exp_i in '' 0 1 2; do
1540     # Number of expected r/r conflicts.
1541     for rr_exp_i in '' 0 1 2; do
1542       test -z "$sr_exp_i" && test -z "$rr_exp_i" && continue
1543
1544       # Build grammar file.
1545       sr_exp=0
1546       rr_exp=0
1547       file=$gram
1548       directives=
1549       if test -n "$sr_exp_i"; then
1550         sr_exp=$sr_exp_i
1551         file=$file-expect-$sr_exp
1552         directives="%expect $sr_exp"
1553       fi
1554       if test -n "$rr_exp_i"; then
1555         rr_exp=$rr_exp_i
1556         file=$file-expect-rr-$rr_exp
1557         directives="$directives %expect-rr $rr_exp"
1558       fi
1559       file=$file.y
1560       echo "$directives" > $file
1561       cat $gram.y >> $file
1562
1563       # Number of found conflicts.
1564       case $gram in
1565         (sr)    sr_count=1; rr_count=0;;
1566         (rr)    sr_count=0; rr_count=1;;
1567         (sr-rr) sr_count=1; rr_count=1;;
1568       esac
1569
1570       # Update number of expected conflicts: if %expect is given then
1571       # %expect-rr defaults to 0, and vice-versa.  Leave empty if
1572       # nothing expected.
1573       case $sr_exp_i:$rr_exp_i in
1574         ?:) rr_exp_i=0;;
1575         :?) sr_exp_i=0;;
1576       esac
1577
1578       # Run tests.
1579       if test $sr_count -eq $sr_exp && test $rr_count -eq $rr_exp; then
1580         ]AT_BISON_CHECK([[-Wnone $file]])[
1581         ]AT_BISON_CHECK([[-Werror $file]])[
1582       else
1583         {
1584           if test -z "$sr_exp_i" && test "$sr_count" -ne 0; then
1585             echo "warning: $sr_count shift/reduce conflicts"
1586           elif test "$sr_exp_i" -ne "$sr_count"; then
1587             echo "error: shift/reduce conflicts: $sr_count found, $sr_exp_i expected"
1588           fi
1589           if test -z "$rr_exp_i" && test "$rr_count" -ne 0; then
1590             echo "warning: $rr_count reduce/reduce conflicts"
1591           elif test "$rr_exp_i" -ne "$rr_count"; then
1592             echo "error: reduce/reduce conflicts: $rr_count found, $rr_exp_i expected"
1593           fi
1594         } | sed -e "s/^/$file: /" > experr
1595         ]AT_BISON_CHECK([[-Wnone $file]], [[1]], [[]], [[experr]])[
1596         ]AT_BISON_CHECK([[-Werror $file]], [[1]], [[]], [[experr]])[
1597       fi
1598     done
1599   done
1600 done]
1601
1602 AT_CLEANUP