X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/bc933ef16d171af4f27616649c7a99c77e9b75fe..dcd39f1d4ab0d2efa467406682175643c7c0ca1d:/tests/conflicts.at diff --git a/tests/conflicts.at b/tests/conflicts.at index 38f8f0e9..f455d1f5 100644 --- a/tests/conflicts.at +++ b/tests/conflicts.at @@ -1,20 +1,20 @@ # Exercising Bison on conflicts. -*- Autotest -*- -# Copyright (C) 2002 Free Software Foundation, Inc. -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2, or (at your option) -# any later version. +# Copyright (C) 2002, 2003, 2004, 2005, 2007, 2009, 2010 Free +# Software Foundation, Inc. +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. - +# # You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA -# 02111-1307, USA. +# along with this program. If not, see . AT_BANNER([[Conflicts.]]) @@ -37,7 +37,9 @@ exp: e 'e'; e: 'e' | /* Nothing. */; ]]) -AT_CHECK([bison input.y -o input.c]) +AT_BISON_CHECK([-o input.c input.y], 0, [], +[[input.y:4.9: warning: rule useless in parser due to conflicts: e: /* empty */ +]]) AT_CLEANUP @@ -48,37 +50,30 @@ AT_CLEANUP AT_SETUP([%nonassoc and eof]) -AT_DATA([input.y], +AT_DATA_GRAMMAR([input.y], [[ %{ -#include -/* We don't need a perfect malloc for these tests. */ -#undef malloc #include - -#if STDC_HEADERS -# include -#endif +#include +#include #define YYERROR_VERBOSE 1 static void yyerror (const char *msg) { fprintf (stderr, "%s\n", msg); - exit (1); } /* The current argument. */ -static const char *input = NULL; +static const char *input; static int yylex (void) { - /* No token stands for end of file. */ - if (input && *input) - return *input++; - else - return 0; + static size_t toknum; + if (! (toknum <= strlen (input))) + abort (); + return input[toknum++]; } %} @@ -94,37 +89,348 @@ expr: expr '<' expr int main (int argc, const char *argv[]) { - if (argc > 1) - input = argv[1]; + input = argc <= 1 ? "" : argv[1]; return yyparse (); } ]]) # Specify the output files to avoid problems on different file systems. -AT_CHECK([bison input.y -o input.c]) -AT_CHECK([$CC $CFLAGS $CPPFLAGS input.c -o input], 0, [], [ignore]) - -AT_CHECK([./input '0<0']) -# FIXME: This is an actual bug, but a new one, in the sense that -# no one has ever spotted it! The messages are *wrong*: there should -# be nothing there, it should be expected eof. -AT_CHECK([./input '0<0<0'], [1], [], - [parse error, unexpected '<', expecting '<' or '>' +AT_BISON_CHECK([-o input.c input.y]) +AT_COMPILE([input]) + +AT_PARSER_CHECK([./input '0<0']) +AT_PARSER_CHECK([./input '0<0<0'], [1], [], + [syntax error, unexpected '<' +]) + +AT_PARSER_CHECK([./input '0>0']) +AT_PARSER_CHECK([./input '0>0>0'], [1], [], + [syntax error, unexpected '>' +]) + +AT_PARSER_CHECK([./input '0<0>0'], [1], [], + [syntax error, unexpected '>' +]) + +# We must disable default reductions in inconsistent states in order to +# have an explicit list of all expected tokens. (However, unless we use +# canonical LR, lookahead sets are merged for different left contexts, +# so it is still possible to have extra incorrect tokens in the expected +# list. That just doesn't happen to be a problem for this test case.) + +AT_BISON_CHECK([-Dlr.default-reductions=consistent -o input.c input.y]) +AT_COMPILE([input]) + +AT_PARSER_CHECK([./input '0<0']) +AT_PARSER_CHECK([./input '0<0<0'], [1], [], + [syntax error, unexpected '<', expecting $end ]) -AT_CHECK([./input '0>0']) -AT_CHECK([./input '0>0>0'], [1], [], - [parse error, unexpected '>', expecting '<' or '>' +AT_PARSER_CHECK([./input '0>0']) +AT_PARSER_CHECK([./input '0>0>0'], [1], [], + [syntax error, unexpected '>', expecting $end ]) -AT_CHECK([./input '0<0>0'], [1], [], - [parse error, unexpected '>', expecting '<' or '>' +AT_PARSER_CHECK([./input '0<0>0'], [1], [], + [syntax error, unexpected '>', expecting $end ]) AT_CLEANUP +## -------------------------------------- ## +## %error-verbose and consistent errors. ## +## -------------------------------------- ## + +AT_SETUP([[%error-verbose and consistent errors]]) + +m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [ + +AT_BISON_OPTION_PUSHDEFS([$1]) + +m4_pushdef([AT_YYLEX_PROTOTYPE], +[AT_SKEL_CC_IF([[int yylex (yy::parser::semantic_type *lvalp)]], + [[int yylex (YYSTYPE *lvalp)]])]) + +AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y], +[AT_SKEL_JAVA_IF([[ + +%code imports { + import java.io.IOException; +}]], [[ + +%code {]AT_SKEL_CC_IF([[ + #include + #include ]], [[ + #include + #include + void yyerror (char const *msg);]])[ + ]AT_YYLEX_PROTOTYPE[; + #define USE(Var) +} + +]AT_SKEL_CC_IF([[%defines]], [[%define api.pure]])])[ + +]$1[ + +%error-verbose + +%% + +]$2[ + +]AT_SKEL_JAVA_IF([[%code lexer {]], [[%%]])[ + +/*--------. +| yylex. | +`--------*/]AT_SKEL_JAVA_IF([[ + +public String input = "]$3["; +public int index = 0; +public int yylex () +{ + if (index < input.length ()) + return input.charAt (index++); + else + return 0; +} +public Object getLVal () +{ + return new Integer(1); +}]], [[ + +]AT_YYLEX_PROTOTYPE[ +{ + static char const *input = "]$3["; + *lvalp = 1; + return *input++; +}]])[ + +/*----------. +| yyerror. | +`----------*/]AT_SKEL_JAVA_IF([[ + +public void yyerror (String msg) +{ + System.err.println (msg); +} + +}; + +%%]], [AT_SKEL_CC_IF([[ + +void +yy::parser::error (const yy::location &, std::string const &msg) +{ + std::cerr << msg << std::endl; +}]], [[ + +void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +}]])])[ + +/*-------. +| main. | +`-------*/]AT_SKEL_JAVA_IF([[ + +class input +{ + public static void main (String args[]) throws IOException + { + YYParser p = new YYParser (); + p.parse (); + } +}]], [AT_SKEL_CC_IF([[ + +int +main (void) +{ + yy::parser parser; + return parser.parse (); +}]], [[ + +int +main (void) +{ + return yyparse (); +}]])])[ +]]) + +AT_FULL_COMPILE([[input]]) + +m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']], + $5, [a], [[, expecting 'a']], + $5, [b], [[, expecting 'b']])]) + +AT_SKEL_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]], + [AT_PARSER_CHECK([[./input]], [[1]]]), +[[]], +[[syntax error, unexpected ]$4[]AT_EXPECTING[ +]]) + +m4_popdef([AT_EXPECTING]) +m4_popdef([AT_YYLEX_PROTOTYPE]) +AT_BISON_OPTION_POPDEFS + +]) + +m4_pushdef([AT_PREVIOUS_STATE_GRAMMAR], +[[%nonassoc 'a'; + +start: consistent-error-on-a-a 'a' ; + +consistent-error-on-a-a: + 'a' default-reduction + | 'a' default-reduction 'a' + | 'a' shift + ; + +default-reduction: /*empty*/ ; +shift: 'b' ; + +// Provide another context in which all rules are useful so that this +// test case looks a little more realistic. +start: 'b' consistent-error-on-a-a 'c' ; +]]) + +m4_pushdef([AT_PREVIOUS_STATE_INPUT], [[a]]) + +# Unfortunately, no expected tokens are reported even though 'b' can be +# accepted. Nevertheless, the main point of this test is to make sure +# that at least the unexpected token is reported. In a previous version +# of Bison, it wasn't reported because the error is detected in a +# consistent state with an error action, and that case always triggered +# the simple "syntax error" message. +# +# The point isn't to test IELR here, but state merging happens to +# complicate this example. +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %glr-parser]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %language "c++"]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %language "java"]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[end of input]], [[none]]) + +# Even canonical LR doesn't foresee the error for 'a'! +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %define lr.default-reductions consistent]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[ab]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %define lr.default-reductions accepting]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[ab]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[ab]]) + +m4_popdef([AT_PREVIOUS_STATE_GRAMMAR]) +m4_popdef([AT_PREVIOUS_STATE_INPUT]) + +m4_pushdef([AT_USER_ACTION_GRAMMAR], +[[%nonassoc 'a'; + +// If $$ = 0 here, then we know that the 'a' destructor is being invoked +// incorrectly for the 'b' set in the semantic action below. All 'a' +// tokens are returned by yylex, which sets $$ = 1. +%destructor { + if (!$$) + fprintf (stderr, "Wrong destructor.\n"); +} 'a'; + +// Rather than depend on an inconsistent state to induce reading a +// lookahead as in the previous grammar, just assign the lookahead in a +// semantic action. That lookahead isn't needed before either error +// action is encountered. In a previous version of Bison, this was a +// problem as it meant yychar was not translated into yytoken before +// either error action. The second error action thus invoked a +// destructor that it selected according to the incorrect yytoken. The +// first error action would have reported an incorrect unexpected token +// except that, due to the bug described in the previous grammar, the +// unexpected token was not reported at all. +start: error-reduce consistent-error 'a' { USE ($][3); } ; + +error-reduce: + 'a' 'a' consistent-reduction consistent-error 'a' + { USE (($][1, $][2, $][5)); } +| 'a' error + { USE ($][1); } +; + +consistent-reduction: /*empty*/ { + assert (yychar == ]AT_SKEL_CC_IF([[yyempty_]], [[YYEMPTY]])[); + yylval = 0; + yychar = 'b'; +} ; + +consistent-error: + 'a' { USE ($][1); } +| /*empty*/ %prec 'a' +; + +// Provide another context in which all rules are useful so that this +// test case looks a little more realistic. +start: 'b' consistent-error 'b' ; +]]) +m4_pushdef([AT_USER_ACTION_INPUT], [[aa]]) + +AT_CONSISTENT_ERRORS_CHECK([[]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [['b']], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%glr-parser]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [['b']], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%language "c++"]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [['b']], [[none]]) +# No Java test because yychar cannot be manipulated by users. + +AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions consistent]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [['b']], [[none]]) + +# Canonical LR doesn't foresee the error for 'a'! +AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions accepting]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [[$end]], [[a]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [[$end]], [[a]]) + +m4_popdef([AT_USER_ACTION_GRAMMAR]) +m4_popdef([AT_USER_ACTION_INPUT]) + +m4_popdef([AT_CONSISTENT_ERRORS_CHECK]) + +AT_CLEANUP + + + ## ------------------------- ## ## Unresolved SR Conflicts. ## ## ------------------------- ## @@ -139,18 +445,18 @@ AT_DATA([input.y], exp: exp OP exp | NUM; ]]) -AT_CHECK([bison input.y -o input.c --report=all], 0, [], -[input.y contains 1 shift/reduce conflict. +AT_BISON_CHECK([-o input.c --report=all input.y], 0, [], +[input.y: conflicts: 1 shift/reduce ]) # Check the contents of the report. AT_CHECK([cat input.output], [], -[[State 5 contains 1 shift/reduce conflict. +[[State 5 conflicts: 1 shift/reduce Grammar - 0 $axiom: exp $ + 0 $accept: exp $end 1 exp: exp OP exp 2 | NUM @@ -158,7 +464,7 @@ Grammar Terminals, with rules where they appear -$ (0) 0 +$end (0) 0 error (256) NUM (258) 2 OP (259) 1 @@ -166,7 +472,7 @@ OP (259) 1 Nonterminals, with rules where they appear -$axiom (5) +$accept (5) on left: 0 exp (6) on left: 1 2, on right: 0 1 @@ -174,96 +480,86 @@ exp (6) state 0 - $axiom -> . exp $ (rule 0) - exp -> . exp OP exp (rule 1) - exp -> . NUM (rule 2) - - NUM shift, and go to state 1 + 0 $accept: . exp $end + 1 exp: . exp OP exp + 2 | . NUM - exp go to state 2 + NUM shift, and go to state 1 + exp go to state 2 state 1 - exp -> NUM . (rule 2) - - $default reduce using rule 2 (exp) + 2 exp: NUM . + $default reduce using rule 2 (exp) state 2 - $axiom -> exp . $ (rule 0) - exp -> exp . OP exp (rule 1) - - $ shift, and go to state 3 - OP shift, and go to state 4 + 0 $accept: exp . $end + 1 exp: exp . OP exp + $end shift, and go to state 3 + OP shift, and go to state 4 state 3 - $axiom -> exp $ . (rule 0) + 0 $accept: exp $end . - $default accept + $default accept state 4 - exp -> . exp OP exp (rule 1) - exp -> exp OP . exp (rule 1) - exp -> . NUM (rule 2) - - NUM shift, and go to state 1 + 1 exp: . exp OP exp + 1 | exp OP . exp + 2 | . NUM - exp go to state 5 + NUM shift, and go to state 1 + exp go to state 5 state 5 - exp -> exp . OP exp [$, OP] (rule 1) - exp -> exp OP exp . [$, OP] (rule 1) - - OP shift, and go to state 4 - - OP [reduce using rule 1 (exp)] - $default reduce using rule 1 (exp) - + 1 exp: exp . OP exp + 1 | exp OP exp . [$end, OP] + OP shift, and go to state 4 + OP [reduce using rule 1 (exp)] + $default reduce using rule 1 (exp) ]]) AT_CLEANUP -## ------------------------- ## -## Unresolved SR Conflicts. ## -## ------------------------- ## -AT_SETUP([Unresolved SR Conflicts]) +## ----------------------- ## +## Resolved SR Conflicts. ## +## ----------------------- ## + +AT_SETUP([Resolved SR Conflicts]) AT_KEYWORDS([report]) AT_DATA([input.y], [[%token NUM OP +%left OP %% exp: exp OP exp | NUM; ]]) -AT_CHECK([bison input.y -o input.c --report=all], 0, [], -[input.y contains 1 shift/reduce conflict. -]) +AT_BISON_CHECK([-o input.c --report=all input.y]) # Check the contents of the report. AT_CHECK([cat input.output], [], -[[State 5 contains 1 shift/reduce conflict. +[[Grammar - -Grammar - - 0 $axiom: exp $ + 0 $accept: exp $end 1 exp: exp OP exp 2 | NUM @@ -271,7 +567,7 @@ Grammar Terminals, with rules where they appear -$ (0) 0 +$end (0) 0 error (256) NUM (258) 2 OP (259) 1 @@ -279,7 +575,7 @@ OP (259) 1 Nonterminals, with rules where they appear -$axiom (5) +$accept (5) on left: 0 exp (6) on left: 1 2, on right: 0 1 @@ -287,71 +583,62 @@ exp (6) state 0 - $axiom -> . exp $ (rule 0) - exp -> . exp OP exp (rule 1) - exp -> . NUM (rule 2) + 0 $accept: . exp $end + 1 exp: . exp OP exp + 2 | . NUM - NUM shift, and go to state 1 - - exp go to state 2 + NUM shift, and go to state 1 + exp go to state 2 state 1 - exp -> NUM . (rule 2) - - $default reduce using rule 2 (exp) + 2 exp: NUM . + $default reduce using rule 2 (exp) state 2 - $axiom -> exp . $ (rule 0) - exp -> exp . OP exp (rule 1) - - $ shift, and go to state 3 - OP shift, and go to state 4 + 0 $accept: exp . $end + 1 exp: exp . OP exp + $end shift, and go to state 3 + OP shift, and go to state 4 state 3 - $axiom -> exp $ . (rule 0) + 0 $accept: exp $end . - $default accept + $default accept state 4 - exp -> . exp OP exp (rule 1) - exp -> exp OP . exp (rule 1) - exp -> . NUM (rule 2) - - NUM shift, and go to state 1 + 1 exp: . exp OP exp + 1 | exp OP . exp + 2 | . NUM - exp go to state 5 + NUM shift, and go to state 1 + exp go to state 5 state 5 - exp -> exp . OP exp [$, OP] (rule 1) - exp -> exp OP exp . [$, OP] (rule 1) - - OP shift, and go to state 4 - - OP [reduce using rule 1 (exp)] - $default reduce using rule 1 (exp) - + 1 exp: exp . OP exp + 1 | exp OP exp . [$end, OP] + $default reduce using rule 1 (exp) + Conflict between rule 1 and token OP resolved as reduce (%left OP). ]]) AT_CLEANUP - ## -------------------------------- ## ## Defaulted Conflicted Reduction. ## ## -------------------------------- ## @@ -359,19 +646,19 @@ AT_CLEANUP # When there are RR conflicts, some rules are disabled. Usually it is # simply displayed as: # -# $ reduce using rule 3 (num) -# $ [reduce using rule 4 (id)] +# $end reduce using rule 3 (num) +# $end [reduce using rule 4 (id)] # # But when `reduce 3' is the default action, we'd produce: # -# $ [reduce using rule 4 (id)] +# $end [reduce using rule 4 (id)] # $default reduce using rule 3 (num) # # In this precise case (a reduction is masked by the default # reduction), we make the `reduce 3' explicit: # -# $ reduce using rule 3 (num) -# $ [reduce using rule 4 (id)] +# $end reduce using rule 3 (num) +# $end [reduce using rule 4 (id)] # $default reduce using rule 3 (num) # # Maybe that's not the best display, but then, please propose something @@ -388,18 +675,24 @@ id : '0'; %% ]]) -AT_CHECK([bison input.y -o input.c --report=all], 1, [], -[input.y contains 1 reduce/reduce conflict. -]) +AT_BISON_CHECK([-o input.c --report=all input.y], 0, [], +[[input.y: conflicts: 1 reduce/reduce +input.y:4.6-8: warning: rule useless in parser due to conflicts: id: '0' +]]) # Check the contents of the report. AT_CHECK([cat input.output], [], -[[State 1 contains 1 reduce/reduce conflict. +[[Rules useless in parser due to conflicts + + 4 id: '0' + + +State 1 conflicts: 1 reduce/reduce Grammar - 0 $axiom: exp $ + 0 $accept: exp $end 1 exp: num 2 | id @@ -411,14 +704,14 @@ Grammar Terminals, with rules where they appear -$ (0) 0 +$end (0) 0 '0' (48) 3 4 error (256) Nonterminals, with rules where they appear -$axiom (4) +$accept (4) on left: 0 exp (5) on left: 1 2, on right: 0 @@ -430,62 +723,55 @@ id (7) state 0 - $axiom -> . exp $ (rule 0) - exp -> . num (rule 1) - exp -> . id (rule 2) - num -> . '0' (rule 3) - id -> . '0' (rule 4) + 0 $accept: . exp $end + 1 exp: . num + 2 | . id + 3 num: . '0' + 4 id: . '0' - '0' shift, and go to state 1 - - exp go to state 2 - num go to state 3 - id go to state 4 + '0' shift, and go to state 1 + exp go to state 2 + num go to state 3 + id go to state 4 state 1 - num -> '0' . [$] (rule 3) - id -> '0' . [$] (rule 4) - - $ reduce using rule 3 (num) - $ [reduce using rule 4 (id)] - $default reduce using rule 3 (num) + 3 num: '0' . [$end] + 4 id: '0' . [$end] + $end reduce using rule 3 (num) + $end [reduce using rule 4 (id)] + $default reduce using rule 3 (num) state 2 - $axiom -> exp . $ (rule 0) - - $ shift, and go to state 5 + 0 $accept: exp . $end + $end shift, and go to state 5 state 3 - exp -> num . (rule 1) - - $default reduce using rule 1 (exp) + 1 exp: num . + $default reduce using rule 1 (exp) state 4 - exp -> id . (rule 2) - - $default reduce using rule 2 (exp) + 2 exp: id . + $default reduce using rule 2 (exp) state 5 - $axiom -> exp $ . (rule 0) - - $default accept - + 0 $accept: exp $end . + $default accept ]]) AT_CLEANUP @@ -506,9 +792,9 @@ AT_DATA([input.y], exp: exp OP exp | NUM; ]]) -AT_CHECK([bison input.y -o input.c], 1, [], -[input.y contains 1 shift/reduce conflict. -expected 0 shift/reduce conflicts +AT_BISON_CHECK([-o input.c input.y], 1, [], +[input.y: conflicts: 1 shift/reduce +input.y: expected 0 shift/reduce conflicts ]) AT_CLEANUP @@ -526,7 +812,7 @@ AT_DATA([input.y], exp: exp OP exp | NUM; ]]) -AT_CHECK([bison input.y -o input.c]) +AT_BISON_CHECK([-o input.c input.y]) AT_CLEANUP @@ -543,8 +829,479 @@ AT_DATA([input.y], exp: exp OP exp | NUM; ]]) -AT_CHECK([bison input.y -o input.c], 1, [], -[input.y contains 1 shift/reduce conflict. -expected 2 shift/reduce conflicts +AT_BISON_CHECK([-o input.c input.y], 1, [], +[input.y: conflicts: 1 shift/reduce +input.y: expected 2 shift/reduce conflicts ]) AT_CLEANUP + + +## ------------------------------- ## +## %expect with reduce conflicts. ## +## ------------------------------- ## + +AT_SETUP([%expect with reduce conflicts]) + +AT_DATA([input.y], +[[%expect 0 +%% +program: a 'a' | a a; +a: 'a'; +]]) + +AT_BISON_CHECK([-o input.c input.y], 1, [], +[input.y: conflicts: 1 reduce/reduce +input.y: expected 0 reduce/reduce conflicts +]) +AT_CLEANUP + + +## ------------------------- ## +## %prec with user strings. ## +## ------------------------- ## + +AT_SETUP([%prec with user string]) + +AT_DATA([[input.y]], +[[%% +exp: + "foo" %prec "foo" +; +]]) + +AT_BISON_CHECK([-o input.c input.y]) +AT_CLEANUP + + +## -------------------------------- ## +## %no-default-prec without %prec. ## +## -------------------------------- ## + +AT_SETUP([%no-default-prec without %prec]) + +AT_DATA([[input.y]], +[[%left '+' +%left '*' + +%% + +%no-default-prec; + +e: e '+' e + | e '*' e + | '0' + ; +]]) + +AT_BISON_CHECK([-o input.c input.y], 0, [], +[[input.y: conflicts: 4 shift/reduce +]]) +AT_CLEANUP + + +## ----------------------------- ## +## %no-default-prec with %prec. ## +## ----------------------------- ## + +AT_SETUP([%no-default-prec with %prec]) + +AT_DATA([[input.y]], +[[%left '+' +%left '*' + +%% + +%no-default-prec; + +e: e '+' e %prec '+' + | e '*' e %prec '*' + | '0' + ; +]]) + +AT_BISON_CHECK([-o input.c input.y]) +AT_CLEANUP + + +## --------------- ## +## %default-prec. ## +## --------------- ## + +AT_SETUP([%default-prec]) + +AT_DATA([[input.y]], +[[%left '+' +%left '*' + +%% + +%default-prec; + +e: e '+' e + | e '*' e + | '0' + ; +]]) + +AT_BISON_CHECK([-o input.c input.y]) +AT_CLEANUP + + +## ---------------------------------------------- ## +## Unreachable States After Conflict Resolution. ## +## ---------------------------------------------- ## + +AT_SETUP([[Unreachable States After Conflict Resolution]]) + +# If conflict resolution makes states unreachable, remove those states, report +# rules that are then unused, and don't report conflicts in those states. Test +# what happens when a nonterminal becomes useless as a result of state removal +# since that causes lalr.o's goto map to be rewritten. + +AT_DATA([[input.y]], +[[%output "input.c" +%left 'a' + +%% + +start: resolved_conflict 'a' reported_conflicts 'a' ; + +/* S/R conflict resolved as reduce, so the state with item + * (resolved_conflict: 'a' . unreachable1) and all it transition successors are + * unreachable, and the associated production is useless. */ +resolved_conflict: + 'a' unreachable1 + | %prec 'a' + ; + +/* S/R conflict that need not be reported since it is unreachable because of + * the previous conflict resolution. Nonterminal unreachable1 and all its + * productions are useless. */ +unreachable1: + 'a' unreachable2 + | + ; + +/* Likewise for a R/R conflict and nonterminal unreachable2. */ +unreachable2: | ; + +/* Make sure remaining S/R and R/R conflicts are still reported correctly even + * when their states are renumbered due to state removal. */ +reported_conflicts: + 'a' + | 'a' + | + ; + +]]) + +AT_BISON_CHECK([[--report=all input.y]], 0, [], +[[input.y: conflicts: 1 shift/reduce, 1 reduce/reduce +input.y:12.5-20: warning: rule useless in parser due to conflicts: resolved_conflict: 'a' unreachable1 +input.y:20.5-20: warning: rule useless in parser due to conflicts: unreachable1: 'a' unreachable2 +input.y:21.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */ +input.y:25.13: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ +input.y:25.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ +input.y:31.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a' +input.y:32.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */ +]]) + +AT_CHECK([[cat input.output]], 0, +[[Rules useless in parser due to conflicts + + 2 resolved_conflict: 'a' unreachable1 + + 4 unreachable1: 'a' unreachable2 + 5 | /* empty */ + + 6 unreachable2: /* empty */ + 7 | /* empty */ + + 9 reported_conflicts: 'a' + 10 | /* empty */ + + +State 4 conflicts: 1 shift/reduce +State 5 conflicts: 1 reduce/reduce + + +Grammar + + 0 $accept: start $end + + 1 start: resolved_conflict 'a' reported_conflicts 'a' + + 2 resolved_conflict: 'a' unreachable1 + 3 | /* empty */ + + 4 unreachable1: 'a' unreachable2 + 5 | /* empty */ + + 6 unreachable2: /* empty */ + 7 | /* empty */ + + 8 reported_conflicts: 'a' + 9 | 'a' + 10 | /* empty */ + + +Terminals, with rules where they appear + +$end (0) 0 +'a' (97) 1 2 4 8 9 +error (256) + + +Nonterminals, with rules where they appear + +$accept (4) + on left: 0 +start (5) + on left: 1, on right: 0 +resolved_conflict (6) + on left: 2 3, on right: 1 +unreachable1 (7) + on left: 4 5, on right: 2 +unreachable2 (8) + on left: 6 7, on right: 4 +reported_conflicts (9) + on left: 8 9 10, on right: 1 + + +state 0 + + 0 $accept: . start $end + 1 start: . resolved_conflict 'a' reported_conflicts 'a' + 2 resolved_conflict: . 'a' unreachable1 + 3 | . ['a'] + + $default reduce using rule 3 (resolved_conflict) + + start go to state 1 + resolved_conflict go to state 2 + + Conflict between rule 3 and token 'a' resolved as reduce (%left 'a'). + + +state 1 + + 0 $accept: start . $end + + $end shift, and go to state 3 + + +state 2 + + 1 start: resolved_conflict . 'a' reported_conflicts 'a' + + 'a' shift, and go to state 4 + + +state 3 + + 0 $accept: start $end . + + $default accept + + +state 4 + + 1 start: resolved_conflict 'a' . reported_conflicts 'a' + 8 reported_conflicts: . 'a' + 9 | . 'a' + 10 | . ['a'] + + 'a' shift, and go to state 5 + + 'a' [reduce using rule 10 (reported_conflicts)] + + reported_conflicts go to state 6 + + +state 5 + + 8 reported_conflicts: 'a' . ['a'] + 9 | 'a' . ['a'] + + 'a' reduce using rule 8 (reported_conflicts) + 'a' [reduce using rule 9 (reported_conflicts)] + $default reduce using rule 8 (reported_conflicts) + + +state 6 + + 1 start: resolved_conflict 'a' reported_conflicts . 'a' + + 'a' shift, and go to state 7 + + +state 7 + + 1 start: resolved_conflict 'a' reported_conflicts 'a' . + + $default reduce using rule 1 (start) +]]) + +AT_DATA([[input-keep.y]], +[[%define lr.keep-unreachable-states +]]) +AT_CHECK([[cat input.y >> input-keep.y]]) + +AT_BISON_CHECK([[input-keep.y]], 0, [], +[[input-keep.y: conflicts: 2 shift/reduce, 2 reduce/reduce +input-keep.y:22.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */ +input-keep.y:26.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */ +input-keep.y:32.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a' +input-keep.y:33.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */ +]]) + +AT_CLEANUP + + +## ------------------------------------------------------------ ## +## Solved conflicts report for multiple reductions in a state. ## +## ------------------------------------------------------------ ## + +AT_SETUP([[Solved conflicts report for multiple reductions in a state]]) + +# Used to lose earlier solved conflict messages even within a single S/R/R. + +AT_DATA([[input.y]], +[[%left 'a' +%right 'b' +%right 'c' +%right 'd' +%% +start: + 'a' + | empty_a 'a' + | 'b' + | empty_b 'b' + | 'c' + | empty_c1 'c' + | empty_c2 'c' + | empty_c3 'c' + ; +empty_a: %prec 'a' ; +empty_b: %prec 'b' ; +empty_c1: %prec 'c' ; +empty_c2: %prec 'c' ; +empty_c3: %prec 'd' ; +]]) +AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore]) +AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0, +[[state 0 + + 0 $accept: . start $end + 1 start: . 'a' + 2 | . empty_a 'a' + 3 | . 'b' + 4 | . empty_b 'b' + 5 | . 'c' + 6 | . empty_c1 'c' + 7 | . empty_c2 'c' + 8 | . empty_c3 'c' + 9 empty_a: . ['a'] + 10 empty_b: . [] + 11 empty_c1: . [] + 12 empty_c2: . [] + 13 empty_c3: . ['c'] + + 'b' shift, and go to state 1 + + 'c' reduce using rule 13 (empty_c3) + $default reduce using rule 9 (empty_a) + + start go to state 2 + empty_a go to state 3 + empty_b go to state 4 + empty_c1 go to state 5 + empty_c2 go to state 6 + empty_c3 go to state 7 + + Conflict between rule 9 and token 'a' resolved as reduce (%left 'a'). + Conflict between rule 10 and token 'b' resolved as shift (%right 'b'). + Conflict between rule 11 and token 'c' resolved as shift (%right 'c'). + Conflict between rule 12 and token 'c' resolved as shift (%right 'c'). + Conflict between rule 13 and token 'c' resolved as reduce ('c' < 'd'). + + +state 1 +]]) + +AT_CLEANUP + + +## ------------------------------------------------------------ ## +## %nonassoc error actions for multiple reductions in a state. ## +## ------------------------------------------------------------ ## + +# Used to abort when trying to resolve conflicts as %nonassoc error actions for +# multiple reductions in a state. + +# For a %nonassoc error action token, used to print the first remaining +# reduction on that token without brackets. + +AT_SETUP([[%nonassoc error actions for multiple reductions in a state]]) + +AT_DATA([[input.y]], +[[%nonassoc 'a' 'b' 'c' +%% +start: + 'a' + | empty_a 'a' + | 'b' + | empty_b 'b' + | 'c' + | empty_c1 'c' + | empty_c2 'c' + | empty_c3 'c' + ; +empty_a: %prec 'a' ; +empty_b: %prec 'b' ; +empty_c1: %prec 'c' ; +empty_c2: %prec 'c' ; +empty_c3: %prec 'c' ; +]]) + +AT_BISON_CHECK([[--report=all -o input.c input.y]], 0, [], [ignore]) +AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0, +[[state 0 + + 0 $accept: . start $end + 1 start: . 'a' + 2 | . empty_a 'a' + 3 | . 'b' + 4 | . empty_b 'b' + 5 | . 'c' + 6 | . empty_c1 'c' + 7 | . empty_c2 'c' + 8 | . empty_c3 'c' + 9 empty_a: . [] + 10 empty_b: . [] + 11 empty_c1: . [] + 12 empty_c2: . ['c'] + 13 empty_c3: . ['c'] + + 'a' error (nonassociative) + 'b' error (nonassociative) + 'c' error (nonassociative) + + 'c' [reduce using rule 12 (empty_c2)] + 'c' [reduce using rule 13 (empty_c3)] + + start go to state 1 + empty_a go to state 2 + empty_b go to state 3 + empty_c1 go to state 4 + empty_c2 go to state 5 + empty_c3 go to state 6 + + Conflict between rule 9 and token 'a' resolved as an error (%nonassoc 'a'). + Conflict between rule 10 and token 'b' resolved as an error (%nonassoc 'b'). + Conflict between rule 11 and token 'c' resolved as an error (%nonassoc 'c'). + + +state 1 +]]) +AT_CLEANUP