tests/conflicts.at

   1 # Exercising Bison on conflicts.                         -*- Autotest -*-
   2
   3 # Copyright (C) 2002, 2003, 2004, 2005, 2007, 2009 Free Software
   4 # Foundation, Inc.
   5
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 AT_BANNER([[Conflicts.]])
  20
  21
  22 ## ---------------- ##
  23 ## S/R in initial.  ##
  24 ## ---------------- ##
  25
  26 # I once hacked Bison in such a way that it lost its reductions on the
  27 # initial state (because it was confusing it with the last state).  It
  28 # took me a while to strip down my failures to this simple case.  So
  29 # make sure it finds the s/r conflict below.
  30
  31 AT_SETUP([S/R in initial])
  32
  33 AT_DATA([[input.y]],
  34 [[%expect 1
  35 %%
  36 exp: e 'e';
  37 e: 'e' | /* Nothing. */;
  38 ]])
  39
  40 AT_BISON_CHECK([-o input.c input.y], 0, [],
  41 [[input.y:4.9: warning: rule useless in parser due to conflicts: e: /* empty */
  42 ]])
  43
  44 AT_CLEANUP
  45
  46
  47 ## ------------------- ##
  48 ## %nonassoc and eof.  ##
  49 ## ------------------- ##
  50
  51 AT_SETUP([%nonassoc and eof])
  52
  53 AT_DATA_GRAMMAR([input.y],
  54 [[
  55 %{
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59
  60 #define YYERROR_VERBOSE 1
  61 static void
  62 yyerror (const char *msg)
  63 {
  64   fprintf (stderr, "%s\n", msg);
  65 }
  66
  67 /* The current argument. */
  68 static const char *input;
  69
  70 static int
  71 yylex (void)
  72 {
  73   static size_t toknum;
  74   if (! (toknum <= strlen (input)))
  75     abort ();
  76   return input[toknum++];
  77 }
  78
  79 %}
  80
  81 %nonassoc '<' '>'
  82
  83 %%
  84 expr: expr '<' expr
  85     | expr '>' expr
  86     | '0'
  87     ;
  88 %%
  89 int
  90 main (int argc, const char *argv[])
  91 {
  92   input = argc <= 1 ? "" : argv[1];
  93   return yyparse ();
  94 }
  95 ]])
  96
  97 # Specify the output files to avoid problems on different file systems.
  98 AT_BISON_CHECK([-o input.c input.y])
  99 AT_COMPILE([input])
 100
 101 AT_PARSER_CHECK([./input '0<0'])
 102 AT_PARSER_CHECK([./input '0<0<0'], [1], [],
 103          [syntax error, unexpected '<'
 104 ])
 105
 106 AT_PARSER_CHECK([./input '0>0'])
 107 AT_PARSER_CHECK([./input '0>0>0'], [1], [],
 108          [syntax error, unexpected '>'
 109 ])
 110
 111 AT_PARSER_CHECK([./input '0<0>0'], [1], [],
 112          [syntax error, unexpected '>'
 113 ])
 114
 115 # We must disable default reductions in inconsistent states in order to
 116 # have an explicit list of all expected tokens.  (However, unless we use
 117 # canonical LR, lookahead sets are merged for different left contexts,
 118 # so it is still possible to have extra incorrect tokens in the expected
 119 # list.  That just doesn't happen to be a problem for this test case.)
 120
 121 AT_BISON_CHECK([-Dlr.default-reductions=consistent -o input.c input.y])
 122 AT_COMPILE([input])
 123
 124 AT_PARSER_CHECK([./input '0<0'])
 125 AT_PARSER_CHECK([./input '0<0<0'], [1], [],
 126          [syntax error, unexpected '<', expecting $end
 127 ])
 128
 129 AT_PARSER_CHECK([./input '0>0'])
 130 AT_PARSER_CHECK([./input '0>0>0'], [1], [],
 131          [syntax error, unexpected '>', expecting $end
 132 ])
 133
 134 AT_PARSER_CHECK([./input '0<0>0'], [1], [],
 135          [syntax error, unexpected '>', expecting $end
 136 ])
 137
 138 AT_CLEANUP
 139
 140
 141
 142 ## ------------------------- ##
 143 ## Unresolved SR Conflicts.  ##
 144 ## ------------------------- ##
 145
 146 AT_SETUP([Unresolved SR Conflicts])
 147
 148 AT_KEYWORDS([report])
 149
 150 AT_DATA([input.y],
 151 [[%token NUM OP
 152 %%
 153 exp: exp OP exp | NUM;
 154 ]])
 155
 156 AT_BISON_CHECK([-o input.c --report=all input.y], 0, [],
 157 [input.y: conflicts: 1 shift/reduce
 158 ])
 159
 160 # Check the contents of the report.
 161 AT_CHECK([cat input.output], [],
 162 [[State 5 conflicts: 1 shift/reduce
 163
 164
 165 Grammar
 166
 167     0 $accept: exp $end
 168
 169     1 exp: exp OP exp
 170     2    | NUM
 171
 172
 173 Terminals, with rules where they appear
 174
 175 $end (0) 0
 176 error (256)
 177 NUM (258) 2
 178 OP (259) 1
 179
 180
 181 Nonterminals, with rules where they appear
 182
 183 $accept (5)
 184     on left: 0
 185 exp (6)
 186     on left: 1 2, on right: 0 1
 187
 188
 189 state 0
 190
 191     0 $accept: . exp $end
 192     1 exp: . exp OP exp
 193     2    | . NUM
 194
 195     NUM  shift, and go to state 1
 196
 197     exp  go to state 2
 198
 199
 200 state 1
 201
 202     2 exp: NUM .
 203
 204     $default  reduce using rule 2 (exp)
 205
 206
 207 state 2
 208
 209     0 $accept: exp . $end
 210     1 exp: exp . OP exp
 211
 212     $end  shift, and go to state 3
 213     OP    shift, and go to state 4
 214
 215
 216 state 3
 217
 218     0 $accept: exp $end .
 219
 220     $default  accept
 221
 222
 223 state 4
 224
 225     1 exp: . exp OP exp
 226     1    | exp OP . exp
 227     2    | . NUM
 228
 229     NUM  shift, and go to state 1
 230
 231     exp  go to state 5
 232
 233
 234 state 5
 235
 236     1 exp: exp . OP exp
 237     1    | exp OP exp .  [$end, OP]
 238
 239     OP  shift, and go to state 4
 240
 241     OP        [reduce using rule 1 (exp)]
 242     $default  reduce using rule 1 (exp)
 243 ]])
 244
 245 AT_CLEANUP
 246
 247
 248
 249 ## ----------------------- ##
 250 ## Resolved SR Conflicts.  ##
 251 ## ----------------------- ##
 252
 253 AT_SETUP([Resolved SR Conflicts])
 254
 255 AT_KEYWORDS([report])
 256
 257 AT_DATA([input.y],
 258 [[%token NUM OP
 259 %left OP
 260 %%
 261 exp: exp OP exp | NUM;
 262 ]])
 263
 264 AT_BISON_CHECK([-o input.c --report=all input.y])
 265
 266 # Check the contents of the report.
 267 AT_CHECK([cat input.output], [],
 268 [[Grammar
 269
 270     0 $accept: exp $end
 271
 272     1 exp: exp OP exp
 273     2    | NUM
 274
 275
 276 Terminals, with rules where they appear
 277
 278 $end (0) 0
 279 error (256)
 280 NUM (258) 2
 281 OP (259) 1
 282
 283
 284 Nonterminals, with rules where they appear
 285
 286 $accept (5)
 287     on left: 0
 288 exp (6)
 289     on left: 1 2, on right: 0 1
 290
 291
 292 state 0
 293
 294     0 $accept: . exp $end
 295     1 exp: . exp OP exp
 296     2    | . NUM
 297
 298     NUM  shift, and go to state 1
 299
 300     exp  go to state 2
 301
 302
 303 state 1
 304
 305     2 exp: NUM .
 306
 307     $default  reduce using rule 2 (exp)
 308
 309
 310 state 2
 311
 312     0 $accept: exp . $end
 313     1 exp: exp . OP exp
 314
 315     $end  shift, and go to state 3
 316     OP    shift, and go to state 4
 317
 318
 319 state 3
 320
 321     0 $accept: exp $end .
 322
 323     $default  accept
 324
 325
 326 state 4
 327
 328     1 exp: . exp OP exp
 329     1    | exp OP . exp
 330     2    | . NUM
 331
 332     NUM  shift, and go to state 1
 333
 334     exp  go to state 5
 335
 336
 337 state 5
 338
 339     1 exp: exp . OP exp
 340     1    | exp OP exp .  [$end, OP]
 341
 342     $default  reduce using rule 1 (exp)
 343
 344     Conflict between rule 1 and token OP resolved as reduce (%left OP).
 345 ]])
 346
 347 AT_CLEANUP
 348
 349
 350 ## -------------------------------- ##
 351 ## Defaulted Conflicted Reduction.  ##
 352 ## -------------------------------- ##
 353
 354 # When there are RR conflicts, some rules are disabled.  Usually it is
 355 # simply displayed as:
 356 #
 357 #    $end           reduce using rule 3 (num)
 358 #    $end           [reduce using rule 4 (id)]
 359 #
 360 # But when `reduce 3' is the default action, we'd produce:
 361 #
 362 #    $end           [reduce using rule 4 (id)]
 363 #    $default    reduce using rule 3 (num)
 364 #
 365 # In this precise case (a reduction is masked by the default
 366 # reduction), we make the `reduce 3' explicit:
 367 #
 368 #    $end           reduce using rule 3 (num)
 369 #    $end           [reduce using rule 4 (id)]
 370 #    $default    reduce using rule 3 (num)
 371 #
 372 # Maybe that's not the best display, but then, please propose something
 373 # else.
 374
 375 AT_SETUP([Defaulted Conflicted Reduction])
 376 AT_KEYWORDS([report])
 377
 378 AT_DATA([input.y],
 379 [[%%
 380 exp: num | id;
 381 num: '0';
 382 id : '0';
 383 %%
 384 ]])
 385
 386 AT_BISON_CHECK([-o input.c --report=all input.y], 0, [],
 387 [[input.y: conflicts: 1 reduce/reduce
 388 input.y:4.6-8: warning: rule useless in parser due to conflicts: id: '0'
 389 ]])
 390
 391 # Check the contents of the report.
 392 AT_CHECK([cat input.output], [],
 393 [[Rules useless in parser due to conflicts
 394
 395     4 id: '0'
 396
 397
 398 State 1 conflicts: 1 reduce/reduce
 399
 400
 401 Grammar
 402
 403     0 $accept: exp $end
 404
 405     1 exp: num
 406     2    | id
 407
 408     3 num: '0'
 409
 410     4 id: '0'
 411
 412
 413 Terminals, with rules where they appear
 414
 415 $end (0) 0
 416 '0' (48) 3 4
 417 error (256)
 418
 419
 420 Nonterminals, with rules where they appear
 421
 422 $accept (4)
 423     on left: 0
 424 exp (5)
 425     on left: 1 2, on right: 0
 426 num (6)
 427     on left: 3, on right: 1
 428 id (7)
 429     on left: 4, on right: 2
 430
 431
 432 state 0
 433
 434     0 $accept: . exp $end
 435     1 exp: . num
 436     2    | . id
 437     3 num: . '0'
 438     4 id: . '0'
 439
 440     '0'  shift, and go to state 1
 441
 442     exp  go to state 2
 443     num  go to state 3
 444     id   go to state 4
 445
 446
 447 state 1
 448
 449     3 num: '0' .  [$end]
 450     4 id: '0' .  [$end]
 451
 452     $end      reduce using rule 3 (num)
 453     $end      [reduce using rule 4 (id)]
 454     $default  reduce using rule 3 (num)
 455
 456
 457 state 2
 458
 459     0 $accept: exp . $end
 460
 461     $end  shift, and go to state 5
 462
 463
 464 state 3
 465
 466     1 exp: num .
 467
 468     $default  reduce using rule 1 (exp)
 469
 470
 471 state 4
 472
 473     2 exp: id .
 474
 475     $default  reduce using rule 2 (exp)
 476
 477
 478 state 5
 479
 480     0 $accept: exp $end .
 481
 482     $default  accept
 483 ]])
 484
 485 AT_CLEANUP
 486
 487
 488
 489
 490 ## -------------------- ##
 491 ## %expect not enough.  ##
 492 ## -------------------- ##
 493
 494 AT_SETUP([%expect not enough])
 495
 496 AT_DATA([input.y],
 497 [[%token NUM OP
 498 %expect 0
 499 %%
 500 exp: exp OP exp | NUM;
 501 ]])
 502
 503 AT_BISON_CHECK([-o input.c input.y], 1, [],
 504 [input.y: conflicts: 1 shift/reduce
 505 input.y: expected 0 shift/reduce conflicts
 506 ])
 507 AT_CLEANUP
 508
 509
 510 ## --------------- ##
 511 ## %expect right.  ##
 512 ## --------------- ##
 513
 514 AT_SETUP([%expect right])
 515
 516 AT_DATA([input.y],
 517 [[%token NUM OP
 518 %expect 1
 519 %%
 520 exp: exp OP exp | NUM;
 521 ]])
 522
 523 AT_BISON_CHECK([-o input.c input.y])
 524 AT_CLEANUP
 525
 526
 527 ## ------------------ ##
 528 ## %expect too much.  ##
 529 ## ------------------ ##
 530
 531 AT_SETUP([%expect too much])
 532
 533 AT_DATA([input.y],
 534 [[%token NUM OP
 535 %expect 2
 536 %%
 537 exp: exp OP exp | NUM;
 538 ]])
 539
 540 AT_BISON_CHECK([-o input.c input.y], 1, [],
 541 [input.y: conflicts: 1 shift/reduce
 542 input.y: expected 2 shift/reduce conflicts
 543 ])
 544 AT_CLEANUP
 545
 546
 547 ## ------------------------------- ##
 548 ## %expect with reduce conflicts.  ##
 549 ## ------------------------------- ##
 550
 551 AT_SETUP([%expect with reduce conflicts])
 552
 553 AT_DATA([input.y],
 554 [[%expect 0
 555 %%
 556 program: a 'a' | a a;
 557 a: 'a';
 558 ]])
 559
 560 AT_BISON_CHECK([-o input.c input.y], 1, [],
 561 [input.y: conflicts: 1 reduce/reduce
 562 input.y: expected 0 reduce/reduce conflicts
 563 ])
 564 AT_CLEANUP
 565
 566
 567 ## ------------------------- ##
 568 ## %prec with user strings.  ##
 569 ## ------------------------- ##
 570
 571 AT_SETUP([%prec with user string])
 572
 573 AT_DATA([[input.y]],
 574 [[%%
 575 exp:
 576   "foo" %prec "foo"
 577 ;
 578 ]])
 579
 580 AT_BISON_CHECK([-o input.c input.y])
 581 AT_CLEANUP
 582
 583
 584 ## -------------------------------- ##
 585 ## %no-default-prec without %prec.  ##
 586 ## -------------------------------- ##
 587
 588 AT_SETUP([%no-default-prec without %prec])
 589
 590 AT_DATA([[input.y]],
 591 [[%left '+'
 592 %left '*'
 593
 594 %%
 595
 596 %no-default-prec;
 597
 598 e:   e '+' e
 599    | e '*' e
 600    | '0'
 601    ;
 602 ]])
 603
 604 AT_BISON_CHECK([-o input.c input.y], 0, [],
 605 [[input.y: conflicts: 4 shift/reduce
 606 ]])
 607 AT_CLEANUP
 608
 609
 610 ## ----------------------------- ##
 611 ## %no-default-prec with %prec.  ##
 612 ## ----------------------------- ##
 613
 614 AT_SETUP([%no-default-prec with %prec])
 615
 616 AT_DATA([[input.y]],
 617 [[%left '+'
 618 %left '*'
 619
 620 %%
 621
 622 %no-default-prec;
 623
 624 e:   e '+' e %prec '+'
 625    | e '*' e %prec '*'
 626    | '0'
 627    ;
 628 ]])
 629
 630 AT_BISON_CHECK([-o input.c input.y])
 631 AT_CLEANUP
 632
 633
 634 ## --------------- ##
 635 ## %default-prec.  ##
 636 ## --------------- ##
 637
 638 AT_SETUP([%default-prec])
 639
 640 AT_DATA([[input.y]],
 641 [[%left '+'
 642 %left '*'
 643
 644 %%
 645
 646 %default-prec;
 647
 648 e:   e '+' e
 649    | e '*' e
 650    | '0'
 651    ;
 652 ]])
 653
 654 AT_BISON_CHECK([-o input.c input.y])
 655 AT_CLEANUP
 656
 657
 658 ## ---------------------------------------------- ##
 659 ## Unreachable States After Conflict Resolution.  ##
 660 ## ---------------------------------------------- ##
 661
 662 AT_SETUP([[Unreachable States After Conflict Resolution]])
 663
 664 # If conflict resolution makes states unreachable, remove those states, report
 665 # rules that are then unused, and don't report conflicts in those states.  Test
 666 # what happens when a nonterminal becomes useless as a result of state removal
 667 # since that causes lalr.o's goto map to be rewritten.
 668
 669 AT_DATA([[input.y]],
 670 [[%output "input.c"
 671 %left 'a'
 672
 673 %%
 674
 675 start: resolved_conflict 'a' reported_conflicts 'a' ;
 676
 677 /* S/R conflict resolved as reduce, so the state with item
 678  * (resolved_conflict: 'a' . unreachable1) and all it transition successors are
 679  * unreachable, and the associated production is useless.  */
 680 resolved_conflict:
 681     'a' unreachable1
 682   | %prec 'a'
 683   ;
 684
 685 /* S/R conflict that need not be reported since it is unreachable because of
 686  * the previous conflict resolution.  Nonterminal unreachable1 and all its
 687  * productions are useless.  */
 688 unreachable1:
 689     'a' unreachable2
 690   |
 691   ;
 692
 693 /* Likewise for a R/R conflict and nonterminal unreachable2.  */
 694 unreachable2: | ;
 695
 696 /* Make sure remaining S/R and R/R conflicts are still reported correctly even
 697  * when their states are renumbered due to state removal.  */
 698 reported_conflicts:
 699     'a'
 700   | 'a'
 701   |
 702   ;
 703
 704 ]])
 705
 706 AT_BISON_CHECK([[--report=all input.y]], 0, [],
 707 [[input.y: conflicts: 1 shift/reduce, 1 reduce/reduce
 708 input.y:12.5-20: warning: rule useless in parser due to conflicts: resolved_conflict: 'a' unreachable1
 709 input.y:20.5-20: warning: rule useless in parser due to conflicts: unreachable1: 'a' unreachable2
 710 input.y:21.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
 711 input.y:25.13: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
 712 input.y:25.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
 713 input.y:31.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
 714 input.y:32.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
 715 ]])
 716
 717 AT_CHECK([[cat input.output]], 0,
 718 [[Rules useless in parser due to conflicts
 719
 720     2 resolved_conflict: 'a' unreachable1
 721
 722     4 unreachable1: 'a' unreachable2
 723     5             | /* empty */
 724
 725     6 unreachable2: /* empty */
 726     7             | /* empty */
 727
 728     9 reported_conflicts: 'a'
 729    10                   | /* empty */
 730
 731
 732 State 4 conflicts: 1 shift/reduce
 733 State 5 conflicts: 1 reduce/reduce
 734
 735
 736 Grammar
 737
 738     0 $accept: start $end
 739
 740     1 start: resolved_conflict 'a' reported_conflicts 'a'
 741
 742     2 resolved_conflict: 'a' unreachable1
 743     3                  | /* empty */
 744
 745     4 unreachable1: 'a' unreachable2
 746     5             | /* empty */
 747
 748     6 unreachable2: /* empty */
 749     7             | /* empty */
 750
 751     8 reported_conflicts: 'a'
 752     9                   | 'a'
 753    10                   | /* empty */
 754
 755
 756 Terminals, with rules where they appear
 757
 758 $end (0) 0
 759 'a' (97) 1 2 4 8 9
 760 error (256)
 761
 762
 763 Nonterminals, with rules where they appear
 764
 765 $accept (4)
 766     on left: 0
 767 start (5)
 768     on left: 1, on right: 0
 769 resolved_conflict (6)
 770     on left: 2 3, on right: 1
 771 unreachable1 (7)
 772     on left: 4 5, on right: 2
 773 unreachable2 (8)
 774     on left: 6 7, on right: 4
 775 reported_conflicts (9)
 776     on left: 8 9 10, on right: 1
 777
 778
 779 state 0
 780
 781     0 $accept: . start $end
 782     1 start: . resolved_conflict 'a' reported_conflicts 'a'
 783     2 resolved_conflict: . 'a' unreachable1
 784     3                  | .  ['a']
 785
 786     $default  reduce using rule 3 (resolved_conflict)
 787
 788     start              go to state 1
 789     resolved_conflict  go to state 2
 790
 791     Conflict between rule 3 and token 'a' resolved as reduce (%left 'a').
 792
 793
 794 state 1
 795
 796     0 $accept: start . $end
 797
 798     $end  shift, and go to state 3
 799
 800
 801 state 2
 802
 803     1 start: resolved_conflict . 'a' reported_conflicts 'a'
 804
 805     'a'  shift, and go to state 4
 806
 807
 808 state 3
 809
 810     0 $accept: start $end .
 811
 812     $default  accept
 813
 814
 815 state 4
 816
 817     1 start: resolved_conflict 'a' . reported_conflicts 'a'
 818     8 reported_conflicts: . 'a'
 819     9                   | . 'a'
 820    10                   | .  ['a']
 821
 822     'a'  shift, and go to state 5
 823
 824     'a'  [reduce using rule 10 (reported_conflicts)]
 825
 826     reported_conflicts  go to state 6
 827
 828
 829 state 5
 830
 831     8 reported_conflicts: 'a' .  ['a']
 832     9                   | 'a' .  ['a']
 833
 834     'a'       reduce using rule 8 (reported_conflicts)
 835     'a'       [reduce using rule 9 (reported_conflicts)]
 836     $default  reduce using rule 8 (reported_conflicts)
 837
 838
 839 state 6
 840
 841     1 start: resolved_conflict 'a' reported_conflicts . 'a'
 842
 843     'a'  shift, and go to state 7
 844
 845
 846 state 7
 847
 848     1 start: resolved_conflict 'a' reported_conflicts 'a' .
 849
 850     $default  reduce using rule 1 (start)
 851 ]])
 852
 853 AT_DATA([[input-keep.y]],
 854 [[%define lr.keep-unreachable-states
 855 ]])
 856 AT_CHECK([[cat input.y >> input-keep.y]])
 857
 858 AT_BISON_CHECK([[input-keep.y]], 0, [],
 859 [[input-keep.y: conflicts: 2 shift/reduce, 2 reduce/reduce
 860 input-keep.y:22.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
 861 input-keep.y:26.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
 862 input-keep.y:32.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
 863 input-keep.y:33.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
 864 ]])
 865
 866 AT_CLEANUP
 867
 868
 869 ## ------------------------------------------------------------ ##
 870 ## Solved conflicts report for multiple reductions in a state.  ##
 871 ## ------------------------------------------------------------ ##
 872
 873 AT_SETUP([[Solved conflicts report for multiple reductions in a state]])
 874
 875 # Used to lose earlier solved conflict messages even within a single S/R/R.
 876
 877 AT_DATA([[input.y]],
 878 [[%left 'a'
 879 %right 'b'
 880 %right 'c'
 881 %right 'd'
 882 %%
 883 start:
 884     'a'
 885   | empty_a 'a'
 886   | 'b'
 887   | empty_b 'b'
 888   | 'c'
 889   | empty_c1 'c'
 890   | empty_c2 'c'
 891   | empty_c3 'c'
 892   ;
 893 empty_a: %prec 'a' ;
 894 empty_b: %prec 'b' ;
 895 empty_c1: %prec 'c' ;
 896 empty_c2: %prec 'c' ;
 897 empty_c3: %prec 'd' ;
 898 ]])
 899 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
 900 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
 901 [[state 0
 902
 903     0 $accept: . start $end
 904     1 start: . 'a'
 905     2      | . empty_a 'a'
 906     3      | . 'b'
 907     4      | . empty_b 'b'
 908     5      | . 'c'
 909     6      | . empty_c1 'c'
 910     7      | . empty_c2 'c'
 911     8      | . empty_c3 'c'
 912     9 empty_a: .  ['a']
 913    10 empty_b: .  []
 914    11 empty_c1: .  []
 915    12 empty_c2: .  []
 916    13 empty_c3: .  ['c']
 917
 918     'b'  shift, and go to state 1
 919
 920     'c'       reduce using rule 13 (empty_c3)
 921     $default  reduce using rule 9 (empty_a)
 922
 923     start     go to state 2
 924     empty_a   go to state 3
 925     empty_b   go to state 4
 926     empty_c1  go to state 5
 927     empty_c2  go to state 6
 928     empty_c3  go to state 7
 929
 930     Conflict between rule 9 and token 'a' resolved as reduce (%left 'a').
 931     Conflict between rule 10 and token 'b' resolved as shift (%right 'b').
 932     Conflict between rule 11 and token 'c' resolved as shift (%right 'c').
 933     Conflict between rule 12 and token 'c' resolved as shift (%right 'c').
 934     Conflict between rule 13 and token 'c' resolved as reduce ('c' < 'd').
 935
 936
 937 state 1
 938 ]])
 939
 940 AT_CLEANUP
 941
 942
 943 ## ------------------------------------------------------------ ##
 944 ## %nonassoc error actions for multiple reductions in a state.  ##
 945 ## ------------------------------------------------------------ ##
 946
 947 # Used to abort when trying to resolve conflicts as %nonassoc error actions for
 948 # multiple reductions in a state.
 949
 950 # For a %nonassoc error action token, used to print the first remaining
 951 # reduction on that token without brackets.
 952
 953 AT_SETUP([[%nonassoc error actions for multiple reductions in a state]])
 954
 955 AT_DATA([[input.y]],
 956 [[%nonassoc 'a' 'b' 'c'
 957 %%
 958 start:
 959     'a'
 960   | empty_a 'a'
 961   | 'b'
 962   | empty_b 'b'
 963   | 'c'
 964   | empty_c1 'c'
 965   | empty_c2 'c'
 966   | empty_c3 'c'
 967   ;
 968 empty_a: %prec 'a' ;
 969 empty_b: %prec 'b' ;
 970 empty_c1: %prec 'c' ;
 971 empty_c2: %prec 'c' ;
 972 empty_c3: %prec 'c' ;
 973 ]])
 974
 975 AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore])
 976 AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0,
 977 [[state 0
 978
 979     0 $accept: . start $end
 980     1 start: . 'a'
 981     2      | . empty_a 'a'
 982     3      | . 'b'
 983     4      | . empty_b 'b'
 984     5      | . 'c'
 985     6      | . empty_c1 'c'
 986     7      | . empty_c2 'c'
 987     8      | . empty_c3 'c'
 988     9 empty_a: .  []
 989    10 empty_b: .  []
 990    11 empty_c1: .  []
 991    12 empty_c2: .  ['c']
 992    13 empty_c3: .  ['c']
 993
 994     'a'  error (nonassociative)
 995     'b'  error (nonassociative)
 996     'c'  error (nonassociative)
 997
 998     'c'  [reduce using rule 12 (empty_c2)]
 999     'c'  [reduce using rule 13 (empty_c3)]
1000
1001     start     go to state 1
1002     empty_a   go to state 2
1003     empty_b   go to state 3
1004     empty_c1  go to state 4
1005     empty_c2  go to state 5
1006     empty_c3  go to state 6
1007
1008     Conflict between rule 9 and token 'a' resolved as an error (%nonassoc 'a').
1009     Conflict between rule 10 and token 'b' resolved as an error (%nonassoc 'b').
1010     Conflict between rule 11 and token 'c' resolved as an error (%nonassoc 'c').
1011
1012
1013 state 1
1014 ]])
1015 AT_CLEANUP