X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/d659304d0a57e470f5f73ac49eb6d11bc14dd5bf..e4f0316ae096a728e62032fa33bc6c42cf4b6455:/tests/glr-regression.at?ds=sidebyside diff --git a/tests/glr-regression.at b/tests/glr-regression.at index b1e91180..9e3cec79 100644 --- a/tests/glr-regression.at +++ b/tests/glr-regression.at @@ -1,5 +1,5 @@ # Checking GLR Parsing: Regression Tests -*- Autotest -*- -# Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc. +# Copyright (C) 2002, 2003, 2005, 2006 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 @@ -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)) @@ -329,11 +329,10 @@ AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], 0, AT_CLEANUP -## ---------------------------------------------------------------------- ## -## Duplicate representation of merged trees ## -## Thanks to Joel E. Denny for this test; see ## -## . ## -## ---------------------------------------------------------------------- ## +## ------------------------------------------------------------------------- ## +## Duplicate representation of merged trees. See ## +## . ## +## ------------------------------------------------------------------------- ## AT_SETUP([Duplicate representation of merged trees]) @@ -425,11 +424,10 @@ AT_CHECK([[./glr-regr4]], 0, AT_CLEANUP -## ------------------------------------------------------------------------- ## -## User destructor for unresolved GLR semantic value ## -## Thanks to Joel E. Denny for this test; see ## -## . ## -## ------------------------------------------------------------------------- ## +## -------------------------------------------------------------------------- ## +## User destructor for unresolved GLR semantic value. See ## +## . ## +## -------------------------------------------------------------------------- ## AT_SETUP([User destructor for unresolved GLR semantic value]) @@ -496,11 +494,10 @@ AT_CHECK([[./glr-regr5]], 0, [], AT_CLEANUP -## ------------------------------------------------------------------------- ## -## User destructor after an error during a split parse ## -## Thanks to Joel E. Denny for this test; see ## -## . ## -## ------------------------------------------------------------------------- ## +## -------------------------------------------------------------------------- ## +## User destructor after an error during a split parse. See ## +## . ## +## -------------------------------------------------------------------------- ## AT_SETUP([User destructor after an error during a split parse]) @@ -562,8 +559,7 @@ AT_CLEANUP ## ------------------------------------------------------------------------- ## -## Duplicated user destructor for lookahead ## -## Thanks to Joel E. Denny for this test; see ## +## Duplicated user destructor for lookahead. See ## ## . ## ## ------------------------------------------------------------------------- ## @@ -654,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 @@ -688,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; @@ -736,8 +733,7 @@ AT_CLEANUP ## ------------------------------------------------------------------------- ## -## No users destructors if stack 0 deleted ## -## Thanks to Joel E. Denny for this test; see ## +## No users destructors if stack 0 deleted. See ## ## . ## ## ------------------------------------------------------------------------- ## @@ -821,7 +817,7 @@ AT_CLEANUP ## Corrupted semantic options if user action cuts parse. ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Corrupted semantic options if user action cuts parse.]) +AT_SETUP([Corrupted semantic options if user action cuts parse]) AT_DATA_GRAMMAR([glr-regr10.y], [[ @@ -861,14 +857,14 @@ yylex (void) int main (void) { - int index; - for (index = 0; index < GARBAGE_SIZE; index+=1) - garbage[index] = 132; + 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]) @@ -882,7 +878,7 @@ AT_CLEANUP ## Undesirable destructors if user action cuts parse. ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Undesirable destructors if user action cuts parse.]) +AT_SETUP([Undesirable destructors if user action cuts parse]) AT_DATA_GRAMMAR([glr-regr11.y], [[ @@ -934,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]) @@ -945,41 +941,83 @@ 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 merge (YYSTYPE s1, YYSTYPE s2) { /* Not invoked. */ - return 0; + char dummy = s1.dummy + s2.dummy; + return dummy; } static void @@ -991,27 +1029,635 @@ 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]) AT_CHECK([[./glr-regr12]], 0, [], []) AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Incorrect lookahead during deterministic GLR. See ## +## and ## +## . ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Incorrect lookahead during deterministic GLR]) + +AT_DATA_GRAMMAR([glr-regr13.y], +[[ +/* Tests: + - Defaulted state with initial yychar: yychar == YYEMPTY. + - Nondefaulted state: yychar != YYEMPTY. + - Defaulted state after lookahead: yychar != YYEMPTY. + - Defaulted state after shift: yychar == YYEMPTY. + - User action changing the lookahead. */ + +%{ + #include + static void yyerror (char const *); + static int yylex (void); + static void print_look_ahead (char const *); + #define USE(value) +%} + +%union { char value; } +%type 'a' 'b' +%glr-parser +%locations + +%% + +start: + defstate_init defstate_shift 'b' change_lookahead 'a' { + USE ($3); + print_look_ahead ("start <- defstate_init defstate_shift 'b'"); + } + ; +defstate_init: + { + print_look_ahead ("defstate_init <- empty string"); + } + ; +defstate_shift: + nondefstate defstate_look 'a' { + USE ($3); + print_look_ahead ("defstate_shift <- nondefstate defstate_look 'a'"); + } + ; +defstate_look: + { + print_look_ahead ("defstate_look <- empty string"); + } + ; +nondefstate: + { + print_look_ahead ("nondefstate <- empty string"); + } + | 'b' { + USE ($1); + print_look_ahead ("nondefstate <- 'b'"); + } + ; +change_lookahead: + { + yychar = 'a'; + } + ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + static char const *input = "ab"; + static int i = 0; + yylloc.first_line = yylloc.last_line = 1; + yylloc.first_column = yylloc.last_column = i + 1; + yylval.value = input[i] + 'A' - 'a'; + return input[i++]; +} + +static void +print_look_ahead (char const *reduction) +{ + printf ("%s:\n yychar=", reduction); + if (yychar == YYEMPTY) + printf ("YYEMPTY"); + else if (yychar == YYEOF) + printf ("YYEOF"); + else + { + printf ("'%c', yylval='", yychar); + if (yylval.value > ' ') + printf ("%c", yylval.value); + printf ("', yylloc=(%d,%d),(%d,%d)", + yylloc.first_line, yylloc.first_column, + yylloc.last_line, yylloc.last_column); + } + printf ("\n"); +} + +int +main (void) +{ + yychar = '#'; /* Not a token in the grammar. */ + yylval.value = '!'; + return yyparse (); +} +]]) + +AT_CHECK([[bison -o glr-regr13.c glr-regr13.y]], 0, [], []) +AT_COMPILE([glr-regr13]) + +AT_CHECK([[./glr-regr13]], 0, +[defstate_init <- empty string: + yychar=YYEMPTY +nondefstate <- empty string: + yychar='a', yylval='A', yylloc=(1,1),(1,1) +defstate_look <- empty string: + yychar='a', yylval='A', yylloc=(1,1),(1,1) +defstate_shift <- nondefstate defstate_look 'a': + yychar=YYEMPTY +start <- defstate_init defstate_shift 'b': + yychar=YYEMPTY +], []) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Incorrect lookahead during nondeterministic GLR. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Incorrect lookahead during nondeterministic GLR]) + +AT_DATA_GRAMMAR([glr-regr14.y], +[[ +/* Tests: + - 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 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 need is yyfalse (a previous stack has + seen the lookahead but current stack has not). + - Exceeding stack capacity (stack explosion), and thus reallocating + 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 + entered. + - If only defaulted states are entered, there are no conflicts, so + nondeterministic operation does not start. */ + +%union { char value; } + +%{ + #include + static void yyerror (char const *); + static int yylex (void); + static void print_look_ahead (char const *); + static char merge (union YYSTYPE, union YYSTYPE); + #define USE(value) +%} + +%type 'a' 'b' 'c' 'd' stack_explosion +%glr-parser +%locations + +%% + +start: + merge 'c' stack_explosion { + USE ($2); USE ($3); + print_look_ahead ("start <- merge 'c' stack_explosion"); + } + ; + +/* When merging the 2 deferred actions, the lookahead needs are different. */ +merge: + nonconflict1 'a' 'b' nonconflict2 %dprec 1 { + USE ($2); USE ($3); + print_look_ahead ("merge <- nonconflict1 'a' 'b' nonconflict2"); + } + | conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2 { + USE ($3); USE ($5); + print_look_ahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'" + " defstate_shift"); + } + ; + +nonconflict1: + { + print_look_ahead ("nonconflict1 <- empty string"); + } + ; +nonconflict2: + { + print_look_ahead ("nonconflict2 <- empty string"); + } + | 'a' { + USE ($1); + print_look_ahead ("nonconflict2 <- 'a'"); + } + ; +conflict: + { + print_look_ahead ("conflict <- empty string"); + } + ; +defstate_look: + { + print_look_ahead ("defstate_look <- empty string"); + } + ; + +/* yychar != YYEMPTY but lookahead need is yyfalse. */ +defstate_shift: + { + print_look_ahead ("defstate_shift <- empty string"); + } + ; + +stack_explosion: + { $$ = '\0'; } + | alt1 stack_explosion %merge { $$ = $2; } + | alt2 stack_explosion %merge { $$ = $2; } + | alt3 stack_explosion %merge { $$ = $2; } + ; +alt1: + 'd' no_look { + USE ($1); + if (yychar != 'd' && yychar != YYEOF) + { + fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); + } + } + ; +alt2: + 'd' no_look { + USE ($1); + if (yychar != 'd' && yychar != YYEOF) + { + fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); + } + } + ; +alt3: + 'd' no_look { + USE ($1); + if (yychar != 'd' && yychar != YYEOF) + { + fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); + } + } + ; +no_look: + { + if (yychar != YYEMPTY) + { + fprintf (stderr, + "Found lookahead where shouldn't during stack explosion.\n"); + } + } + ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + static char const *input = "abcdddd"; + static int i = 0; + yylloc.first_line = yylloc.last_line = 1; + yylloc.first_column = yylloc.last_column = i + 1; + yylval.value = input[i] + 'A' - 'a'; + return input[i++]; +} + +static void +print_look_ahead (char const *reduction) +{ + printf ("%s:\n yychar=", reduction); + if (yychar == YYEMPTY) + printf ("YYEMPTY"); + else if (yychar == YYEOF) + printf ("YYEOF"); + else + { + printf ("'%c', yylval='", yychar); + if (yylval.value > ' ') + printf ("%c", yylval.value); + printf ("', yylloc=(%d,%d),(%d,%d)", + yylloc.first_line, yylloc.first_column, + yylloc.last_line, yylloc.last_column); + } + printf ("\n"); +} + +static char +merge (union YYSTYPE s1, union YYSTYPE s2) +{ + char dummy = s1.value + s2.value; + return dummy; +} + +int +main (void) +{ + yychar = '#'; /* Not a token in the grammar. */ + yylval.value = '!'; + return yyparse (); +} +]]) + +AT_CHECK([[bison -o glr-regr14.c glr-regr14.y]], 0, [], +[glr-regr14.y: conflicts: 3 reduce/reduce +]) +AT_COMPILE([glr-regr14]) + +AT_CHECK([[./glr-regr14]], 0, +[conflict <- empty string: + yychar='a', yylval='A', yylloc=(1,1),(1,1) +defstate_look <- empty string: + yychar='a', yylval='A', yylloc=(1,1),(1,1) +nonconflict2 <- empty string: + yychar='b', yylval='B', yylloc=(1,2),(1,2) +defstate_shift <- empty string: + yychar=YYEMPTY +merge <- conflict defstate_look 'a' nonconflict2 'b' defstate_shift: + yychar=YYEMPTY +start <- merge 'c' stack_explosion: + yychar=YYEOF +], []) + +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