X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/3b8378825ea8c3d2cae8c615a9ebf1f679730895..d243e0241f79eed2b231fa9066a47f9daaafa82d:/tests/conflicts.at diff --git a/tests/conflicts.at b/tests/conflicts.at index f455d1f5..599d708b 100644 --- a/tests/conflicts.at +++ b/tests/conflicts.at @@ -1,7 +1,6 @@ # Exercising Bison on conflicts. -*- Autotest -*- -# Copyright (C) 2002, 2003, 2004, 2005, 2007, 2009, 2010 Free -# Software Foundation, Inc. +# Copyright (C) 2002-2005, 2007-2012 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 @@ -94,56 +93,62 @@ main (int argc, const char *argv[]) } ]]) -# Specify the output files to avoid problems on different file systems. -AT_BISON_CHECK([-o input.c input.y]) +m4_pushdef([AT_NONASSOC_AND_EOF_CHECK], +[AT_BISON_CHECK([$1[ -o input.c input.y]]) AT_COMPILE([input]) +m4_pushdef([AT_EXPECTING], [m4_if($2, [correct], [[, expecting $end]])]) + AT_PARSER_CHECK([./input '0<0']) AT_PARSER_CHECK([./input '0<0<0'], [1], [], - [syntax error, unexpected '<' + [syntax error, unexpected '<'AT_EXPECTING ]) AT_PARSER_CHECK([./input '0>0']) AT_PARSER_CHECK([./input '0>0>0'], [1], [], - [syntax error, unexpected '>' + [syntax error, unexpected '>'AT_EXPECTING ]) AT_PARSER_CHECK([./input '0<0>0'], [1], [], - [syntax error, unexpected '>' + [syntax error, unexpected '>'AT_EXPECTING ]) -# 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.) +m4_popdef([AT_EXPECTING])]) -AT_BISON_CHECK([-Dlr.default-reductions=consistent -o input.c input.y]) -AT_COMPILE([input]) +# Expected token list is missing. +AT_NONASSOC_AND_EOF_CHECK([], [[incorrect]]) -AT_PARSER_CHECK([./input '0<0']) -AT_PARSER_CHECK([./input '0<0<0'], [1], [], - [syntax error, unexpected '<', expecting $end -]) - -AT_PARSER_CHECK([./input '0>0']) -AT_PARSER_CHECK([./input '0>0>0'], [1], [], - [syntax error, unexpected '>', expecting $end -]) - -AT_PARSER_CHECK([./input '0<0>0'], [1], [], - [syntax error, unexpected '>', expecting $end -]) +# We must disable default reductions in inconsistent states in order to +# have an explicit list of all expected tokens. +AT_NONASSOC_AND_EOF_CHECK([[-Dlr.default-reductions=consistent]], + [[correct]]) + +# lr.default-reductions=consistent happens to work for this test case. +# However, for other grammars, lookahead sets can be merged for +# different left contexts, so it is still possible to have an incorrect +# expected list. Canonical LR is almost a general solution (that is, it +# can fail only when %nonassoc is used), so make sure it gives the same +# result as above. +AT_NONASSOC_AND_EOF_CHECK([[-Dlr.type=canonical-lr]], [[correct]]) + +# parse.lac=full is a completely general solution that does not require +# any of the above sacrifices. Of course, it does not extend the +# language-recognition power of LALR to (IE)LR, but it does ensure that +# the reported list of expected tokens matches what the given parser +# would have accepted in place of the unexpected token. +AT_NONASSOC_AND_EOF_CHECK([[-Dparse.lac=full]], [[correct]]) + +m4_popdef([AT_NONASSOC_AND_EOF_CHECK]) AT_CLEANUP -## -------------------------------------- ## -## %error-verbose and consistent errors. ## -## -------------------------------------- ## +## ------------------------------------------- ## +## parse.error=verbose and consistent errors. ## +## ------------------------------------------- ## -AT_SETUP([[%error-verbose and consistent errors]]) +AT_SETUP([[parse.error=verbose and consistent errors]]) m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [ @@ -161,7 +166,6 @@ AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y], }]], [[ %code {]AT_SKEL_CC_IF([[ - #include #include ]], [[ #include #include @@ -174,7 +178,7 @@ AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y], ]$1[ -%error-verbose +%define parse.error verbose %% @@ -221,7 +225,7 @@ public void yyerror (String msg) %%]], [AT_SKEL_CC_IF([[ void -yy::parser::error (const yy::location &, std::string const &msg) +yy::parser::error (std::string const &msg) { std::cerr << msg << std::endl; }]], [[ @@ -343,6 +347,18 @@ AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]], [AT_PREVIOUS_STATE_INPUT], [[$end]], [[ab]]) +# Only LAC gets it right. +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr + %define parse.lac full]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[b]]) +AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr + %define parse.lac full]], + [AT_PREVIOUS_STATE_GRAMMAR], + [AT_PREVIOUS_STATE_INPUT], + [[$end]], [[b]]) + m4_popdef([AT_PREVIOUS_STATE_GRAMMAR]) m4_popdef([AT_PREVIOUS_STATE_INPUT]) @@ -377,7 +393,7 @@ error-reduce: ; consistent-reduction: /*empty*/ { - assert (yychar == ]AT_SKEL_CC_IF([[yyempty_]], [[YYEMPTY]])[); + assert (yychar == YYEMPTY); yylval = 0; yychar = 'b'; } ; @@ -401,11 +417,7 @@ 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. +# No C++ or Java test because yychar cannot be manipulated by users. AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions consistent]], [AT_USER_ACTION_GRAMMAR], @@ -422,6 +434,16 @@ AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]], [AT_USER_ACTION_INPUT], [[$end]], [[a]]) +AT_CONSISTENT_ERRORS_CHECK([[%define parse.lac full]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [['b']], [[none]]) +AT_CONSISTENT_ERRORS_CHECK([[%define parse.lac full + %define lr.default-reductions accepting]], + [AT_USER_ACTION_GRAMMAR], + [AT_USER_ACTION_INPUT], + [[$end]], [[none]]) + m4_popdef([AT_USER_ACTION_GRAMMAR]) m4_popdef([AT_USER_ACTION_INPUT]) @@ -431,6 +453,113 @@ AT_CLEANUP +## ------------------------------------------------------- ## +## LAC: %nonassoc requires splitting canonical LR states. ## +## ------------------------------------------------------- ## + +# This test case demonstrates that, when %nonassoc is used, canonical +# LR(1) parser table construction followed by conflict resolution +# without further state splitting is not always sufficient to produce a +# parser that can detect all syntax errors as soon as possible on one +# token of lookahead. However, LAC solves the problem completely even +# with minimal LR parser tables. + +AT_SETUP([[LAC: %nonassoc requires splitting canonical LR states]]) + +AT_DATA_GRAMMAR([[input.y]], +[[%code { + #include + void yyerror (char const *); + int yylex (void); +} + +%error-verbose +%nonassoc 'a' + +%% + +start: + 'a' problem 'a' // First context. +| 'b' problem 'b' // Second context. +| 'c' reduce-nonassoc // Just makes reduce-nonassoc useful. +; + +problem: + look reduce-nonassoc +| look 'a' +| look 'b' +; + +// For the state reached after shifting the 'a' in these productions, +// lookahead sets are the same in both the first and second contexts. +// Thus, canonical LR reuses the same state for both contexts. However, +// the lookahead 'a' for the reduction "look: 'a'" later becomes an +// error action only in the first context. In order to immediately +// detect the syntax error on 'a' here for only the first context, this +// canonical LR state would have to be split into two states, and the +// 'a' lookahead would have to be removed from only one of the states. +look: + 'a' // Reduction lookahead set is always ['a', 'b']. +| 'a' 'b' +| 'a' 'c' // 'c' is forgotten as an expected token. +; + +reduce-nonassoc: %prec 'a'; + +%% + +void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +int +yylex (void) +{ + char const *input = "aaa"; + return *input++; +} + +int +main (void) +{ + return yyparse (); +} +]]) + +# Show canonical LR's failure. +AT_BISON_CHECK([[-Dlr.type=canonical-lr -o input.c input.y]], + [[0]], [[]], +[[input.y: conflicts: 2 shift/reduce +]]) +AT_COMPILE([[input]]) +AT_PARSER_CHECK([[./input]], [[1]], [[]], +[[syntax error, unexpected 'a', expecting 'b' +]]) + +# It's corrected by LAC. +AT_BISON_CHECK([[-Dlr.type=canonical-lr -Dparse.lac=full \ + -o input.c input.y]], [[0]], [[]], +[[input.y: conflicts: 2 shift/reduce +]]) +AT_COMPILE([[input]]) +AT_PARSER_CHECK([[./input]], [[1]], [[]], +[[syntax error, unexpected 'a', expecting 'b' or 'c' +]]) + +# IELR is sufficient when LAC is used. +AT_BISON_CHECK([[-Dlr.type=ielr -Dparse.lac=full -o input.c input.y]], + [[0]], [[]], +[[input.y: conflicts: 2 shift/reduce +]]) +AT_COMPILE([[input]]) +AT_PARSER_CHECK([[./input]], [[1]], [[]], +[[syntax error, unexpected 'a', expecting 'b' or 'c' +]]) + +AT_CLEANUP + ## ------------------------- ## ## Unresolved SR Conflicts. ## ## ------------------------- ## @@ -639,6 +768,62 @@ state 5 AT_CLEANUP +## ---------------------- ## +## %precedence suffices. ## +## ---------------------- ## + +AT_SETUP([%precedence suffices]) + +AT_DATA([input.y], +[[%precedence "then" +%precedence "else" +%% +stmt: + "if" cond "then" stmt +| "if" cond "then" stmt "else" stmt +| "stmt" +; + +cond: + "exp" +; +]]) + +AT_BISON_CHECK([-o input.c input.y]) + +AT_CLEANUP + + +## ------------------------------ ## +## %precedence does not suffice. ## +## ------------------------------ ## + +AT_SETUP([%precedence does not suffice]) + +AT_DATA([input.y], +[[%precedence "then" +%precedence "else" +%% +stmt: + "if" cond "then" stmt +| "if" cond "then" stmt "else" stmt +| "stmt" +; + +cond: + "exp" +| cond "then" cond +; +]]) + +AT_BISON_CHECK([-o input.c input.y], 0, [], +[[input.y: conflicts: 1 shift/reduce +input.y:12.3-18: warning: rule useless in parser due to conflicts: cond: cond "then" cond +]]) + +AT_CLEANUP + + ## -------------------------------- ## ## Defaulted Conflicted Reduction. ## ## -------------------------------- ## @@ -1208,7 +1393,7 @@ AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0, 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) @@ -1305,3 +1490,104 @@ AT_CHECK([[cat input.output | sed -n '/^state 0$/,/^state 1$/p']], 0, state 1 ]]) AT_CLEANUP + + +## --------------------------------- ## +## -W versus %expect and %expect-rr ## +## --------------------------------- ## + +AT_SETUP([[-W versus %expect and %expect-rr]]) + +AT_DATA([[sr-rr.y]], +[[%glr-parser +%% +start: 'a' | A 'a' | B 'a' ; +A: ; +B: ; +]]) +AT_DATA([[sr.y]], +[[%glr-parser +%% +start: 'a' | A 'a' ; +A: ; +]]) +AT_DATA([[rr.y]], +[[%glr-parser +%% +start: A | B ; +A: ; +B: ; +]]) + +AT_BISON_CHECK([[sr-rr.y]], [[0]], [[]], +[[sr-rr.y: conflicts: 1 shift/reduce, 1 reduce/reduce +]]) +AT_BISON_CHECK([[-Wno-conflicts-sr sr-rr.y]], [[0]], [[]], +[[sr-rr.y: conflicts: 1 reduce/reduce +]]) +AT_BISON_CHECK([[-Wno-conflicts-rr sr-rr.y]], [[0]], [[]], +[[sr-rr.y: conflicts: 1 shift/reduce +]]) + +[for gram in sr-rr sr rr; do + for sr_exp_i in '' 0 1 2; do + for rr_exp_i in '' 0 1 2; do + test -z "$sr_exp_i" && test -z "$rr_exp_i" && continue + + # Build grammar file. + sr_exp=0 + rr_exp=0 + file=$gram + directives= + if test -n "$sr_exp_i"; then + sr_exp=$sr_exp_i + file=$file-expect-$sr_exp + directives="%expect $sr_exp" + fi + if test -n "$rr_exp_i"; then + rr_exp=$rr_exp_i + file=$file-expect-rr-$rr_exp + directives="$directives %expect-rr $rr_exp" + fi + file=$file.y + echo "$directives" > $file + cat $gram.y >> $file + + # Count actual conflicts. + conflicts= + sr_count=0 + rr_count=0 + if test $gram = sr || test $gram = sr-rr; then + conflicts="1 shift/reduce" + sr_count=1 + fi + if test $gram = rr || test $gram = sr-rr; then + if test -n "$conflicts"; then + conflicts="$conflicts, " + fi + conflicts="${conflicts}1 reduce/reduce" + rr_count=1 + fi + + # Run tests. + if test $sr_count -eq $sr_exp && test $rr_count -eq $rr_exp; then + ]AT_BISON_CHECK([[-Wnone $file]])[ + ]AT_BISON_CHECK([[-Werror $file]])[ + else + echo "$file: conflicts: $conflicts" > experr + if test $sr_count -ne $sr_exp; then + if test $sr_exp -ne 1; then s=s; else s= ; fi + echo "$file: expected $sr_exp shift/reduce conflict$s" >> experr + fi + if test $rr_count -ne $rr_exp; then + if test $rr_exp -ne 1; then s=s; else s= ; fi + echo "$file: expected $rr_exp reduce/reduce conflict$s" >> experr + fi + ]AT_BISON_CHECK([[-Wnone $file]], [[1]], [[]], [[experr]])[ + ]AT_BISON_CHECK([[-Werror $file]], [[1]], [[]], [[experr]])[ + fi + done + done +done] + +AT_CLEANUP