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 */
  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-reductions=consistent]],
 121                           [[correct]])
 122
 123 # lr.default-reductions=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-reductions 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-reductions 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-reductions 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-reductions 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-reductions 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: conflicts: 2 shift/reduce
 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: conflicts: 2 shift/reduce
 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: conflicts: 2 shift/reduce
 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: conflicts: 1 shift/reduce
 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: conflicts: 1 shift/reduce
 788 input.y:12.3-18: warning: rule useless in parser due to conflicts: cond: cond "then" cond
 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: conflicts: 1 reduce/reduce
 832 input.y:4.6-8: warning: rule useless in parser due to conflicts: id: '0'
 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: conflicts: 1 shift/reduce
 949 input.y: expected 0 shift/reduce conflicts
 950 ])
 951 AT_CLEANUP
 952
 953
 954 ## --------------- ##
 955 ## %expect right.  ##
 956 ## --------------- ##
 957
 958 AT_SETUP([%expect right])
 959
 960 AT_DATA([input.y],
 961 [[%token NUM OP
 962 %expect 1
 963 %%
 964 exp: exp OP exp | NUM;
 965 ]])
 966
 967 AT_BISON_CHECK([-o input.c input.y])
 968 AT_CLEANUP
 969
 970
 971 ## ------------------ ##
 972 ## %expect too much.  ##
 973 ## ------------------ ##
 974
 975 AT_SETUP([%expect too much])
 976
 977 AT_DATA([input.y],
 978 [[%token NUM OP
 979 %expect 2
 980 %%
 981 exp: exp OP exp | NUM;
 982 ]])
 983
 984 AT_BISON_CHECK([-o input.c input.y], 1, [],
 985 [input.y: conflicts: 1 shift/reduce
 986 input.y: expected 2 shift/reduce conflicts
 987 ])
 988 AT_CLEANUP
 989
 990
 991 ## ------------------------------- ##
 992 ## %expect with reduce conflicts.  ##
 993 ## ------------------------------- ##
 994
 995 AT_SETUP([%expect with reduce conflicts])
 996
 997 AT_DATA([input.y],
 998 [[%expect 0
 999 %%
1000 program: a 'a' | a a;
1001 a: 'a';
1002 ]])
1003
1004 AT_BISON_CHECK([-o input.c input.y], 1, [],
1005 [input.y: conflicts: 1 reduce/reduce
1006 input.y: expected 0 reduce/reduce conflicts
1007 ])
1008 AT_CLEANUP
1009
1010
1011 ## ------------------------- ##
1012 ## %prec with user strings.  ##
1013 ## ------------------------- ##
1014
1015 AT_SETUP([%prec with user string])
1016
1017 AT_DATA([[input.y]],
1018 [[%%
1019 exp:
1020   "foo" %prec "foo"
1021 ;
1022 ]])
1023
1024 AT_BISON_CHECK([-o input.c input.y])
1025 AT_CLEANUP
1026
1027
1028 ## -------------------------------- ##
1029 ## %no-default-prec without %prec.  ##
1030 ## -------------------------------- ##
1031
1032 AT_SETUP([%no-default-prec without %prec])
1033
1034 AT_DATA([[input.y]],
1035 [[%left '+'
1036 %left '*'
1037
1038 %%
1039
1040 %no-default-prec;
1041
1042 e:   e '+' e
1043    | e '*' e
1044    | '0'
1045    ;
1046 ]])
1047
1048 AT_BISON_CHECK([-o input.c input.y], 0, [],
1049 [[input.y: conflicts: 4 shift/reduce
1050 ]])
1051 AT_CLEANUP
1052
1053
1054 ## ----------------------------- ##
1055 ## %no-default-prec with %prec.  ##
1056 ## ----------------------------- ##
1057
1058 AT_SETUP([%no-default-prec with %prec])
1059
1060 AT_DATA([[input.y]],
1061 [[%left '+'
1062 %left '*'
1063
1064 %%
1065
1066 %no-default-prec;
1067
1068 e:   e '+' e %prec '+'
1069    | e '*' e %prec '*'
1070    | '0'
1071    ;
1072 ]])
1073
1074 AT_BISON_CHECK([-o input.c input.y])
1075 AT_CLEANUP
1076
1077
1078 ## --------------- ##
1079 ## %default-prec.  ##
1080 ## --------------- ##
1081
1082 AT_SETUP([%default-prec])
1083
1084 AT_DATA([[input.y]],
1085 [[%left '+'
1086 %left '*'
1087
1088 %%
1089
1090 %default-prec;
1091
1092 e:   e '+' e
1093    | e '*' e
1094    | '0'
1095    ;
1096 ]])
1097
1098 AT_BISON_CHECK([-o input.c input.y])
1099 AT_CLEANUP
1100
1101
1102 ## ---------------------------------------------- ##
1103 ## Unreachable States After Conflict Resolution.  ##
1104 ## ---------------------------------------------- ##
1105
1106 AT_SETUP([[Unreachable States After Conflict Resolution]])
1107
1108 # If conflict resolution makes states unreachable, remove those states, report
1109 # rules that are then unused, and don't report conflicts in those states.  Test
1110 # what happens when a nonterminal becomes useless as a result of state removal
1111 # since that causes lalr.o's goto map to be rewritten.
1112
1113 AT_DATA([[input.y]],
1114 [[%output "input.c"
1115 %left 'a'
1116
1117 %%
1118
1119 start: resolved_conflict 'a' reported_conflicts 'a' ;
1120
1121 /* S/R conflict resolved as reduce, so the state with item
1122  * (resolved_conflict: 'a' . unreachable1) and all it transition successors are
1123  * unreachable, and the associated production is useless.  */
1124 resolved_conflict:
1125     'a' unreachable1
1126   | %prec 'a'
1127   ;
1128
1129 /* S/R conflict that need not be reported since it is unreachable because of
1130  * the previous conflict resolution.  Nonterminal unreachable1 and all its
1131  * productions are useless.  */
1132 unreachable1:
1133     'a' unreachable2
1134   |
1135   ;
1136
1137 /* Likewise for a R/R conflict and nonterminal unreachable2.  */
1138 unreachable2: | ;
1139
1140 /* Make sure remaining S/R and R/R conflicts are still reported correctly even
1141  * when their states are renumbered due to state removal.  */
1142 reported_conflicts:
1143     'a'
1144   | 'a'
1145   |
1146   ;
1147
1148 ]])
1149
1150 AT_BISON_CHECK([[--report=all input.y]], 0, [],
1151 [[input.y: conflicts: 1 shift/reduce, 1 reduce/reduce
1152 input.y:12.5-20: warning: rule useless in parser due to conflicts: resolved_conflict: 'a' unreachable1
1153 input.y:20.5-20: warning: rule useless in parser due to conflicts: unreachable1: 'a' unreachable2
1154 input.y:21.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
1155 input.y:25.13: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
1156 input.y:25.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
1157 input.y:31.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
1158 input.y:32.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
1159 ]])
1160
1161 AT_CHECK([[cat input.output]], 0,
1162 [[Rules useless in parser due to conflicts
1163
1164     2 resolved_conflict: 'a' unreachable1
1165
1166     4 unreachable1: 'a' unreachable2
1167     5             | /* empty */
1168
1169     6 unreachable2: /* empty */
1170     7             | /* empty */
1171
1172     9 reported_conflicts: 'a'
1173    10                   | /* empty */
1174
1175
1176 State 4 conflicts: 1 shift/reduce
1177 State 5 conflicts: 1 reduce/reduce
1178
1179
1180 Grammar
1181
1182     0 $accept: start $end
1183
1184     1 start: resolved_conflict 'a' reported_conflicts 'a'
1185
1186     2 resolved_conflict: 'a' unreachable1
1187     3                  | /* empty */
1188
1189     4 unreachable1: 'a' unreachable2
1190     5             | /* empty */
1191
1192     6 unreachable2: /* empty */
1193     7             | /* empty */
1194
1195     8 reported_conflicts: 'a'
1196     9                   | 'a'
1197    10                   | /* empty */
1198
1199
1200 Terminals, with rules where they appear
1201
1202 $end (0) 0
1203 'a' (97) 1 2 4 8 9
1204 error (256)
1205
1206
1207 Nonterminals, with rules where they appear
1208
1209 $accept (4)
1210     on left: 0
1211 start (5)
1212     on left: 1, on right: 0
1213 resolved_conflict (6)
1214     on left: 2 3, on right: 1
1215 unreachable1 (7)
1216     on left: 4 5, on right: 2
1217 unreachable2 (8)
1218     on left: 6 7, on right: 4
1219 reported_conflicts (9)
1220     on left: 8 9 10, on right: 1
1221
1222
1223 state 0
1224
1225     0 $accept: . start $end
1226     1 start: . resolved_conflict 'a' reported_conflicts 'a'
1227     2 resolved_conflict: . 'a' unreachable1
1228     3                  | .  ['a']
1229
1230     $default  reduce using rule 3 (resolved_conflict)
1231
1232     start              go to state 1
1233     resolved_conflict  go to state 2
1234
1235     Conflict between rule 3 and token 'a' resolved as reduce (%left 'a').
1236
1237
1238 state 1
1239
1240     0 $accept: start . $end
1241
1242     $end  shift, and go to state 3
1243
1244
1245 state 2
1246
1247     1 start: resolved_conflict . 'a' reported_conflicts 'a'
1248
1249     'a'  shift, and go to state 4
1250
1251
1252 state 3
1253
1254     0 $accept: start $end .
1255
1256     $default  accept
1257
1258
1259 state 4
1260
1261     1 start: resolved_conflict 'a' . reported_conflicts 'a'
1262     8 reported_conflicts: . 'a'
1263     9                   | . 'a'
1264    10                   | .  ['a']
1265
1266     'a'  shift, and go to state 5
1267
1268     'a'  [reduce using rule 10 (reported_conflicts)]
1269
1270     reported_conflicts  go to state 6
1271
1272
1273 state 5
1274
1275     8 reported_conflicts: 'a' .  ['a']
1276     9                   | 'a' .  ['a']
1277
1278     'a'       reduce using rule 8 (reported_conflicts)
1279     'a'       [reduce using rule 9 (reported_conflicts)]
1280     $default  reduce using rule 8 (reported_conflicts)
1281
1282
1283 state 6
1284
1285     1 start: resolved_conflict 'a' reported_conflicts . 'a'
1286
1287     'a'  shift, and go to state 7
1288
1289
1290 state 7
1291
1292     1 start: resolved_conflict 'a' reported_conflicts 'a' .
1293
1294     $default  reduce using rule 1 (start)
1295 ]])
1296
1297 AT_DATA([[input-keep.y]],
1298 [[%define lr.keep-unreachable-states
1299 ]])
1300 AT_CHECK([[cat input.y >> input-keep.y]])
1301
1302 AT_BISON_CHECK([[input-keep.y]], 0, [],
1303 [[input-keep.y: conflicts: 2 shift/reduce, 2 reduce/reduce
1304 input-keep.y:22.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
1305 input-keep.y:26.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
1306 input-keep.y:32.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
1307 input-keep.y:33.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
1308 ]])
1309
1310 AT_CLEANUP
1311
1312
1313 ## ------------------------------------------------------------ ##
1314 ## Solved conflicts report for multiple reductions in a state.  ##
1315 ## ------------------------------------------------------------ ##
1316
1317 AT_SETUP([[Solved conflicts report for multiple reductions in a state]])
1318
1319 # Used to lose earlier solved conflict messages even within a single S/R/R.
1320
1321 AT_DATA([[input.y]],
1322 [[%left 'a'
1323 %right 'b'
1324 %right 'c'
1325 %right 'd'
1326 %%
1327 start:
1328     'a'
1329   | empty_a 'a'
1330   | 'b'
1331   | empty_b 'b'
1332   | 'c'
1333   | empty_c1 'c'
1334   | empty_c2 'c'
1335   | empty_c3 'c'
1336   ;
1337 empty_a: %prec 'a' ;
1338 empty_b: %prec 'b' ;
1339 empty_c1: %prec 'c' ;
1340 empty_c2: %prec 'c' ;
1341 empty_c3: %prec 'd' ;
1342 ]])
1343 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
1344 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
1345 [[state 0
1346
1347     0 $accept: . start $end
1348     1 start: . 'a'
1349     2      | . empty_a 'a'
1350     3      | . 'b'
1351     4      | . empty_b 'b'
1352     5      | . 'c'
1353     6      | . empty_c1 'c'
1354     7      | . empty_c2 'c'
1355     8      | . empty_c3 'c'
1356     9 empty_a: .  ['a']
1357    10 empty_b: .  []
1358    11 empty_c1: .  []
1359    12 empty_c2: .  []
1360    13 empty_c3: .  ['c']
1361
1362     'b'  shift, and go to state 1
1363
1364     'c'       reduce using rule 13 (empty_c3)
1365     $default  reduce using rule 9 (empty_a)
1366
1367     start     go to state 2
1368     empty_a   go to state 3
1369     empty_b   go to state 4
1370     empty_c1  go to state 5
1371     empty_c2  go to state 6
1372     empty_c3  go to state 7
1373
1374     Conflict between rule 9 and token 'a' resolved as reduce (%left 'a').
1375     Conflict between rule 10 and token 'b' resolved as shift (%right 'b').
1376     Conflict between rule 11 and token 'c' resolved as shift (%right 'c').
1377     Conflict between rule 12 and token 'c' resolved as shift (%right 'c').
1378     Conflict between rule 13 and token 'c' resolved as reduce ('c' < 'd').
1379
1380
1381 state 1
1382 ]])
1383
1384 AT_CLEANUP
1385
1386
1387 ## ------------------------------------------------------------ ##
1388 ## %nonassoc error actions for multiple reductions in a state.  ##
1389 ## ------------------------------------------------------------ ##
1390
1391 # Used to abort when trying to resolve conflicts as %nonassoc error actions for
1392 # multiple reductions in a state.
1393
1394 # For a %nonassoc error action token, used to print the first remaining
1395 # reduction on that token without brackets.
1396
1397 AT_SETUP([[%nonassoc error actions for multiple reductions in a state]])
1398
1399 AT_DATA([[input.y]],
1400 [[%nonassoc 'a' 'b' 'c'
1401 %%
1402 start:
1403     'a'
1404   | empty_a 'a'
1405   | 'b'
1406   | empty_b 'b'
1407   | 'c'
1408   | empty_c1 'c'
1409   | empty_c2 'c'
1410   | empty_c3 'c'
1411   ;
1412 empty_a: %prec 'a' ;
1413 empty_b: %prec 'b' ;
1414 empty_c1: %prec 'c' ;
1415 empty_c2: %prec 'c' ;
1416 empty_c3: %prec 'c' ;
1417 ]])
1418
1419 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
1420 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
1421 [[state 0
1422
1423     0 $accept: . start $end
1424     1 start: . 'a'
1425     2      | . empty_a 'a'
1426     3      | . 'b'
1427     4      | . empty_b 'b'
1428     5      | . 'c'
1429     6      | . empty_c1 'c'
1430     7      | . empty_c2 'c'
1431     8      | . empty_c3 'c'
1432     9 empty_a: .  []
1433    10 empty_b: .  []
1434    11 empty_c1: .  []
1435    12 empty_c2: .  ['c']
1436    13 empty_c3: .  ['c']
1437
1438     'a'  error (nonassociative)
1439     'b'  error (nonassociative)
1440     'c'  error (nonassociative)
1441
1442     'c'  [reduce using rule 12 (empty_c2)]
1443     'c'  [reduce using rule 13 (empty_c3)]
1444
1445     start     go to state 1
1446     empty_a   go to state 2
1447     empty_b   go to state 3
1448     empty_c1  go to state 4
1449     empty_c2  go to state 5
1450     empty_c3  go to state 6
1451
1452     Conflict between rule 9 and token 'a' resolved as an error (%nonassoc 'a').
1453     Conflict between rule 10 and token 'b' resolved as an error (%nonassoc 'b').
1454     Conflict between rule 11 and token 'c' resolved as an error (%nonassoc 'c').
1455
1456
1457 state 1
1458 ]])
1459 AT_CLEANUP
1460
1461
1462 ## --------------------------------- ##
1463 ## -W versus %expect and %expect-rr  ##
1464 ## --------------------------------- ##
1465
1466 AT_SETUP([[-W versus %expect and %expect-rr]])
1467
1468 AT_DATA([[sr-rr.y]],
1469 [[%glr-parser
1470 %%
1471 start: 'a' | A 'a' | B 'a' ;
1472 A: ;
1473 B: ;
1474 ]])
1475 AT_DATA([[sr.y]],
1476 [[%glr-parser
1477 %%
1478 start: 'a' | A 'a' ;
1479 A: ;
1480 ]])
1481 AT_DATA([[rr.y]],
1482 [[%glr-parser
1483 %%
1484 start: A | B ;
1485 A: ;
1486 B: ;
1487 ]])
1488
1489 AT_BISON_CHECK([[sr-rr.y]], [[0]], [[]],
1490 [[sr-rr.y: conflicts: 1 shift/reduce, 1 reduce/reduce
1491 ]])
1492 AT_BISON_CHECK([[-Wno-conflicts-sr sr-rr.y]], [[0]], [[]],
1493 [[sr-rr.y: conflicts: 1 reduce/reduce
1494 ]])
1495 AT_BISON_CHECK([[-Wno-conflicts-rr sr-rr.y]], [[0]], [[]],
1496 [[sr-rr.y: conflicts: 1 shift/reduce
1497 ]])
1498
1499 [for gram in sr-rr sr rr; do
1500   for sr_exp_i in '' 0 1 2; do
1501     for rr_exp_i in '' 0 1 2; do
1502       test -z "$sr_exp_i" && test -z "$rr_exp_i" && continue
1503
1504       # Build grammar file.
1505       sr_exp=0
1506       rr_exp=0
1507       file=$gram
1508       directives=
1509       if test -n "$sr_exp_i"; then
1510         sr_exp=$sr_exp_i
1511         file=$file-expect-$sr_exp
1512         directives="%expect $sr_exp"
1513       fi
1514       if test -n "$rr_exp_i"; then
1515         rr_exp=$rr_exp_i
1516         file=$file-expect-rr-$rr_exp
1517         directives="$directives %expect-rr $rr_exp"
1518       fi
1519       file=$file.y
1520       echo "$directives" > $file
1521       cat $gram.y >> $file
1522
1523       # Count actual conflicts.
1524       conflicts=
1525       sr_count=0
1526       rr_count=0
1527       if test $gram = sr || test $gram = sr-rr; then
1528         conflicts="1 shift/reduce"
1529         sr_count=1
1530       fi
1531       if test $gram = rr || test $gram = sr-rr; then
1532         if test -n "$conflicts"; then
1533           conflicts="$conflicts, "
1534         fi
1535         conflicts="${conflicts}1 reduce/reduce"
1536         rr_count=1
1537       fi
1538
1539       # Run tests.
1540       if test $sr_count -eq $sr_exp && test $rr_count -eq $rr_exp; then
1541         ]AT_BISON_CHECK([[-Wnone $file]])[
1542         ]AT_BISON_CHECK([[-Werror $file]])[
1543       else
1544         echo "$file: conflicts: $conflicts" > experr
1545         if test $sr_count -ne $sr_exp; then
1546           if test $sr_exp -ne 1; then s=s; else s= ; fi
1547           echo "$file: expected $sr_exp shift/reduce conflict$s" >> experr
1548         fi
1549         if test $rr_count -ne $rr_exp; then
1550           if test $rr_exp -ne 1; then s=s; else s= ; fi
1551           echo "$file: expected $rr_exp reduce/reduce conflict$s" >> experr
1552         fi
1553         ]AT_BISON_CHECK([[-Wnone $file]], [[1]], [[]], [[experr]])[
1554         ]AT_BISON_CHECK([[-Werror $file]], [[1]], [[]], [[experr]])[
1555       fi
1556     done
1557   done
1558 done]
1559
1560 AT_CLEANUP