X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/2781dbd121848b23bfe6855cc001752471b74323..e4f0316ae096a728e62032fa33bc6c42cf4b6455:/tests/glr-regression.at?ds=sidebyside diff --git a/tests/glr-regression.at b/tests/glr-regression.at index c1252ea1..9e3cec79 100644 --- a/tests/glr-regression.at +++ b/tests/glr-regression.at @@ -240,7 +240,7 @@ AT_DATA_GRAMMAR([glr-regr3.y], #include static int MergeRule (int x0, int x1); -static void yyerror(char const * s); +static void yyerror (char const * s); int yylex (void); #define RULE(x) (1 << (x)) @@ -650,7 +650,7 @@ AT_DATA_GRAMMAR([glr-regr8.y], #include static void yyerror (char const *); static int yylex (void); - static void yyerror(const char *msg); + static void yyerror (char const *msg); %} %token T_CONSTANT @@ -684,9 +684,10 @@ OptSignalWord : /* empty */ %% -void yyerror(const char *msg) +void +yyerror (char const *msg) { - fprintf (stderr, "error\n"); + fprintf (stderr, "%s\n", msg); } static int lexIndex; @@ -856,14 +857,14 @@ yylex (void) int main (void) { - int index; - for (index = 0; index < GARBAGE_SIZE; index+=1) - garbage[index] = 108; + int i; + for (i = 0; i < GARBAGE_SIZE; i+=1) + garbage[i] = 108; return yyparse (); } ]]) -AT_CHECK([[bison -t -o glr-regr10.c glr-regr10.y]], 0, [], +AT_CHECK([[bison -o glr-regr10.c glr-regr10.y]], 0, [], [glr-regr10.y: conflicts: 1 reduce/reduce ]) AT_COMPILE([glr-regr10]) @@ -929,7 +930,7 @@ main (void) } ]]) -AT_CHECK([[bison -t -o glr-regr11.c glr-regr11.y]], 0, [], +AT_CHECK([[bison -o glr-regr11.c glr-regr11.y]], 0, [], [glr-regr11.y: conflicts: 1 reduce/reduce ]) AT_COMPILE([glr-regr11]) @@ -940,34 +941,75 @@ AT_CLEANUP ## ------------------------------------------------------------------------- ## -## Leaked merged semantic value if user action cuts parse. ## +## Leaked semantic values if user action cuts parse. ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Leaked merged semantic value if user action cuts parse]) +AT_SETUP([Leaked semantic values if user action cuts parse]) AT_DATA_GRAMMAR([glr-regr12.y], [[ %glr-parser %union { int dummy; } -%type start -%destructor { has_value = 0; } start +%token PARENT_RHS_AFTER +%type parent_rhs_before merged PARENT_RHS_AFTER +%destructor { parent_rhs_before_value = 0; } parent_rhs_before +%destructor { merged_value = 0; } merged +%destructor { parent_rhs_after_value = 0; } PARENT_RHS_AFTER %{ # include static int merge (YYSTYPE, YYSTYPE); static void yyerror (char const *); static int yylex (void); - static int has_value = 0; + static int parent_rhs_before_value = 0; + static int merged_value = 0; + static int parent_rhs_after_value = 0; # define USE(val) %} %% start: - %merge { has_value = 1; USE ($$); } - | %merge { USE ($$); YYACCEPT; } + alt1 %dprec 1 + | alt2 %dprec 2 + ; + +alt1: + PARENT_RHS_AFTER { + USE ($1); + parent_rhs_after_value = 0; + } + ; + +alt2: + parent_rhs_before merged PARENT_RHS_AFTER { + USE (($1, $2, $3)); + parent_rhs_before_value = 0; + merged_value = 0; + parent_rhs_after_value = 0; + } ; +parent_rhs_before: + { + USE ($$); + parent_rhs_before_value = 1; + } + ; + +merged: + %merge { + USE ($$); + merged_value = 1; + } + | cut %merge { + USE ($$); + merged_value = 1; + } + ; + +cut: { YYACCEPT; } ; + %% static int @@ -987,24 +1029,38 @@ yyerror (char const *msg) static int yylex (void) { - return 0; + static int const input[] = { PARENT_RHS_AFTER, 0 }; + static const int *inputp = input; + if (*inputp == PARENT_RHS_AFTER) + parent_rhs_after_value = 1; + return *inputp++; } int main (void) { int exit_status = yyparse (); - if (has_value) + if (parent_rhs_before_value) { - fprintf (stderr, "Destructor not called.\n"); - return 1; + fprintf (stderr, "`parent_rhs_before' destructor not called.\n"); + exit_status = 1; + } + if (merged_value) + { + fprintf (stderr, "`merged' destructor not called.\n"); + exit_status = 1; + } + if (parent_rhs_after_value) + { + fprintf (stderr, "`PARENT_RHS_AFTER' destructor not called.\n"); + exit_status = 1; } return exit_status; } ]]) -AT_CHECK([[bison -t -o glr-regr12.c glr-regr12.y]], 0, [], -[glr-regr12.y: conflicts: 1 reduce/reduce +AT_CHECK([[bison -o glr-regr12.c glr-regr12.y]], 0, [], +[glr-regr12.y: conflicts: 1 shift/reduce, 1 reduce/reduce ]) AT_COMPILE([glr-regr12]) @@ -1015,7 +1071,8 @@ AT_CLEANUP ## ------------------------------------------------------------------------- ## ## Incorrect lookahead during deterministic GLR. See ## -## . ## +## and ## +## . ## ## ------------------------------------------------------------------------- ## AT_SETUP([Incorrect lookahead during deterministic GLR]) @@ -1026,7 +1083,8 @@ AT_DATA_GRAMMAR([glr-regr13.y], - Defaulted state with initial yychar: yychar == YYEMPTY. - Nondefaulted state: yychar != YYEMPTY. - Defaulted state after lookahead: yychar != YYEMPTY. - - Defaulted state after shift: yychar == YYEMPTY. */ + - Defaulted state after shift: yychar == YYEMPTY. + - User action changing the lookahead. */ %{ #include @@ -1044,7 +1102,7 @@ AT_DATA_GRAMMAR([glr-regr13.y], %% start: - defstate_init defstate_shift 'b' { + defstate_init defstate_shift 'b' change_lookahead 'a' { USE ($3); print_look_ahead ("start <- defstate_init defstate_shift 'b'"); } @@ -1074,6 +1132,11 @@ nondefstate: print_look_ahead ("nondefstate <- 'b'"); } ; +change_lookahead: + { + yychar = 'a'; + } + ; %% @@ -1087,11 +1150,11 @@ static int yylex (void) { static char const *input = "ab"; - static int index = 0; + static int i = 0; yylloc.first_line = yylloc.last_line = 1; - yylloc.first_column = yylloc.last_column = index+1; - yylval.value = input[index] + 'A' - 'a'; - return input[index++]; + yylloc.first_column = yylloc.last_column = i + 1; + yylval.value = input[i] + 'A' - 'a'; + return input[i++]; } static void @@ -1123,7 +1186,7 @@ main (void) } ]]) -AT_CHECK([[bison -t -o glr-regr13.c glr-regr13.y]], 0, [], []) +AT_CHECK([[bison -o glr-regr13.c glr-regr13.y]], 0, [], []) AT_COMPILE([glr-regr13]) AT_CHECK([[./glr-regr13]], 0, @@ -1151,17 +1214,17 @@ AT_SETUP([Incorrect lookahead during nondeterministic GLR]) AT_DATA_GRAMMAR([glr-regr14.y], [[ /* Tests: - - Conflicting actions (split-off parse, which copies lookahead status, + - Conflicting actions (split-off parse, which copies lookahead need, which is necessarily yytrue) and nonconflicting actions (non-split-off parse) for nondefaulted state: yychar != YYEMPTY. - - Merged deferred actions (lookahead status and RHS from different stack + - Merged deferred actions (lookahead need and RHS from different stack than the target state) and nonmerged deferred actions (same stack). - Defaulted state after lookahead: yychar != YYEMPTY. - Defaulted state after shift: yychar == YYEMPTY. - - yychar != YYEMPTY but lookahead status is yyfalse (a previous stack has + - yychar != YYEMPTY but lookahead need is yyfalse (a previous stack has seen the lookahead but current stack has not). - Exceeding stack capacity (stack explosion), and thus reallocating - lookahead status array. + lookahead need array. Note that it does not seem possible to see the initial yychar value during nondeterministic operation since: - In order to preserve the initial yychar, only defaulted states may be @@ -1193,8 +1256,7 @@ start: } ; -/* When merging the 2 deferred actions, the lookahead statuses are - different. */ +/* When merging the 2 deferred actions, the lookahead needs are different. */ merge: nonconflict1 'a' 'b' nonconflict2 %dprec 1 { USE ($2); USE ($3); @@ -1232,7 +1294,7 @@ defstate_look: } ; -/* yychar != YYEMPTY but lookahead status is yyfalse. */ +/* yychar != YYEMPTY but lookahead need is yyfalse. */ defstate_shift: { print_look_ahead ("defstate_shift <- empty string"); @@ -1294,11 +1356,11 @@ static int yylex (void) { static char const *input = "abcdddd"; - static int index = 0; + static int i = 0; yylloc.first_line = yylloc.last_line = 1; - yylloc.first_column = yylloc.last_column = index+1; - yylval.value = input[index] + 'A' - 'a'; - return input[index++]; + yylloc.first_column = yylloc.last_column = i + 1; + yylval.value = input[i] + 'A' - 'a'; + return input[i++]; } static void @@ -1337,7 +1399,7 @@ main (void) } ]]) -AT_CHECK([[bison -t -o glr-regr14.c glr-regr14.y]], 0, [], +AT_CHECK([[bison -o glr-regr14.c glr-regr14.y]], 0, [], [glr-regr14.y: conflicts: 3 reduce/reduce ]) AT_COMPILE([glr-regr14]) @@ -1358,3 +1420,244 @@ start <- merge 'c' stack_explosion: ], []) AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Leaked semantic values when reporting ambiguity. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Leaked semantic values when reporting ambiguity]) + +AT_DATA_GRAMMAR([glr-regr15.y], +[[ +%glr-parser +%destructor { parent_rhs_before_value = 0; } parent_rhs_before + +%{ +# include + static void yyerror (char const *); + static int yylex (void); + static int parent_rhs_before_value = 0; +# define USE(val) +%} + +%% + +start: + alt1 %dprec 1 + | alt2 %dprec 2 + ; + +/* This stack must be merged into the other stacks *last* (added at the + beginning of the semantic options list) so that yyparse will choose to clean + it up rather than the tree for which some semantic actions have been + performed. Thus, if yyreportAmbiguity longjmp's to yyparse, the values from + those other trees are not cleaned up. */ +alt1: ; + +alt2: + parent_rhs_before ambiguity { + USE ($1); + parent_rhs_before_value = 0; + } + ; + +parent_rhs_before: + { + USE ($$); + parent_rhs_before_value = 1; + } + ; + +ambiguity: ambiguity1 | ambiguity2 ; +ambiguity1: ; +ambiguity2: ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + return 0; +} + +int +main (void) +{ + int exit_status = yyparse () != 1; + if (parent_rhs_before_value) + { + fprintf (stderr, "`parent_rhs_before' destructor not called.\n"); + exit_status = 1; + } + return exit_status; +} +]]) + +AT_CHECK([[bison -o glr-regr15.c glr-regr15.y]], 0, [], +[glr-regr15.y: conflicts: 2 reduce/reduce +]) +AT_COMPILE([glr-regr15]) + +AT_CHECK([[./glr-regr15]], 0, [], +[syntax is ambiguous +]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Leaked lookahead after nondeterministic parse syntax error. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Leaked lookahead after nondeterministic parse syntax error]) +AT_DATA_GRAMMAR([glr-regr16.y], +[[ +%glr-parser +%destructor { lookahead_value = 0; } 'b' + +%{ +# include + static void yyerror (char const *); + static int yylex (void); + static int lookahead_value = 0; +# define USE(val) +%} + +%% + +start: alt1 'a' | alt2 'a' ; +alt1: ; +alt2: ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + static char const *input = "ab"; + if (*input == 'b') + lookahead_value = 1; + return *input++; +} + +int +main (void) +{ + int exit_status = yyparse () != 1; + if (lookahead_value) + { + fprintf (stderr, "Lookahead destructor not called.\n"); + exit_status = 1; + } + return exit_status; +} +]]) + +AT_CHECK([[bison -o glr-regr16.c glr-regr16.y]], 0, [], +[glr-regr16.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr16]) + +AT_CHECK([[./glr-regr16]], 0, [], +[syntax error +]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Uninitialized location when reporting ambiguity. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Uninitialized location when reporting ambiguity]) +AT_DATA_GRAMMAR([glr-regr17.y], +[[ +%glr-parser +%locations +%pure-parser +%error-verbose + +%union { int dummy; } + +%{ + static void yyerror (YYLTYPE *, char const *); + static int yylex (YYSTYPE *, YYLTYPE *); +%} + +%initial-action { + @$.first_line = 1; + @$.first_column = 1; + @$.last_line = 1; + @$.last_column = 1; +} + +%% + +/* Tests the case of an empty RHS that has inherited the location of the + previous nonterminal, which is unresolved. That location is reported as the + last position of the ambiguity. */ +start: ambig1 empty1 | ambig2 empty2 ; + +/* Tests multiple levels of yyresolveLocations recursion. */ +ambig1: sub_ambig1 | sub_ambig2 ; +ambig2: sub_ambig1 | sub_ambig2 ; + +/* Tests the case of a non-empty RHS as well as the case of an empty RHS that + has inherited the initial location. The empty RHS's location is reported as + the first position in the ambiguity. */ +sub_ambig1: empty1 'a' 'b' ; +sub_ambig2: empty2 'a' 'b' ; +empty1: ; +empty2: ; + +%% + +static void +yyerror (YYLTYPE *locp, char const *msg) +{ + fprintf (stderr, "Error at %d.%d-%d.%d: %s.\n", locp->first_line, + locp->first_column, locp->last_line, locp->last_column, msg); +} + +static int +yylex (YYSTYPE *lvalp, YYLTYPE *llocp) +{ + static char const input[] = "ab"; + static char const *inputp = input; + lvalp->dummy = 0; + llocp->first_line = llocp->last_line = 2; + llocp->first_column = inputp - input + 1; + llocp->last_column = llocp->first_column + 1; + return *inputp++; +} + +int +main (void) +{ + return yyparse () != 1; +} +]]) + +AT_CHECK([[bison -o glr-regr17.c glr-regr17.y]], 0, [], +[glr-regr17.y: conflicts: 3 reduce/reduce +]) +AT_COMPILE([glr-regr17]) + +AT_CHECK([[./glr-regr17]], 0, [], +[Error at 1.1-2.3: syntax is ambiguous. +]) + +AT_CLEANUP