X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/f9315de5a470cb492502c8fbcadafca3a47abd33..b7691f15bdefaabbc246ea9b1855189a8d1cc318:/tests/glr-regression.at diff --git a/tests/glr-regression.at b/tests/glr-regression.at index 91768a19..3e6d0351 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 @@ -120,9 +120,7 @@ AT_DATA_GRAMMAR([glr-regr2a.y], /* Reported by S. Eken */ %{ - #define YYSTYPE char const * - #define yyfalse 0 - #define yytrue 1 + #define YYSTYPE char * #include #include @@ -140,9 +138,11 @@ command: 's' var 't' { printf ("Variable: '%s'\n", $2); } 'v' 'x' 'q' + { free ($2); } | 's' var_list 't' 'e' - { printf ("Varlist: '%s'\n", $2); } + { printf ("Varlist: '%s'\n", $2); free ($2); } | 's' var 't' var_printer 'x' + { free ($2); } ; var: @@ -155,10 +155,10 @@ var_list: { $$ = $1; } | var ',' var_list { - char *s = (char *) malloc (strlen ($1) + 1 + strlen ($3) + 1); - strcpy (s, $1); + char *s = (char *) realloc ($1, strlen ($1) + 1 + strlen ($3) + 1); strcat (s, ","); strcat (s, $3); + free ($3); $$ = s; } ; @@ -168,14 +168,14 @@ var_printer: 'v' %% -FILE *yyin = NULL; +FILE *input = NULL; int yylex (void) { char buf[50]; char *s; - switch (fscanf (yyin, " %1[a-z,]", buf)) { + switch (fscanf (input, " %1[a-z,]", buf)) { case 1: return buf[0]; case EOF: @@ -183,7 +183,7 @@ yylex (void) default: break; } - if (fscanf (yyin, "%49s", buf) != 1) + if (fscanf (input, "%49s", buf) != 1) return 0; if (sizeof buf - 1 <= strlen (buf)) abort (); @@ -201,8 +201,8 @@ yyerror (char const *s) int main (int argc, char **argv) { - yyin = stdin; - if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 3; + input = stdin; + if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3; return yyparse (); } ]]) @@ -290,7 +290,7 @@ static void yyerror(char const * s) { fprintf(stderr,"error: %s\n",s); } -FILE *yyin = NULL; +FILE *input = NULL; int P[] = { P1, P2 }; int O[] = { O1, O2 }; @@ -299,7 +299,7 @@ int T[] = { T1, T2, T3, T4 }; int yylex (void) { char inp[3]; - if (fscanf (yyin, "%2s", inp) == EOF) + if (fscanf (input, "%2s", inp) == EOF) return 0; switch (inp[0]) { @@ -311,8 +311,8 @@ int yylex (void) } int main(int argc, char* argv[]) { - yyin = stdin; - if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 3; + input = stdin; + if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3; return yyparse (); } ]]) @@ -329,16 +329,16 @@ 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]) AT_DATA_GRAMMAR([glr-regr4.y], -[[%union { char *ptr; } +[[ +%union { char *ptr; } %type S A A1 A2 B %glr-parser @@ -347,7 +347,7 @@ AT_DATA_GRAMMAR([glr-regr4.y], #include #include static char *merge (YYSTYPE, YYSTYPE); - static char *make_value (char *, char *); + static char *make_value (char const *, char const *); static void yyerror (char const *); static int yylex (void); %} @@ -386,10 +386,11 @@ main (void) } static char * -make_value (char *parent, char *child) +make_value (char const *parent, char const *child) { char const format[] = "%s <- %s"; - char *value = malloc (strlen (parent) + strlen (child) + sizeof format); + char *value = + (char *) malloc (strlen (parent) + strlen (child) + sizeof format); sprintf (value, format, parent, child); return value; } @@ -398,7 +399,8 @@ static char * merge (YYSTYPE s1, YYSTYPE s2) { char const format[] = "merge{ %s and %s }"; - char *value = malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format); + char *value = + (char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format); sprintf (value, format, s1.ptr, s2.ptr); return value; } @@ -406,7 +408,7 @@ merge (YYSTYPE s1, YYSTYPE s2) static void yyerror (char const *msg) { - printf ("%s\n", msg); + fprintf (stderr, "%s\n", msg); } ]]) @@ -420,3 +422,938 @@ AT_CHECK([[./glr-regr4]], 0, ]], []) AT_CLEANUP + + +## -------------------------------------------------------------------------- ## +## User destructor for unresolved GLR semantic value. See ## +## . ## +## -------------------------------------------------------------------------- ## + +AT_SETUP([User destructor for unresolved GLR semantic value]) + +AT_DATA_GRAMMAR([glr-regr5.y], +[[ +%{ + #include + #include + static void yyerror (char const *); + static int yylex (void); + enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */ +%} + +%glr-parser +%union { int value; } +%type start + +%destructor { + if ($$ != MAGIC_VALUE) + { + fprintf (stderr, "Bad destructor call.\n"); + exit (EXIT_FAILURE); + } +} start + +%% + +start: + 'a' { $$ = MAGIC_VALUE; } + | 'a' { $$ = MAGIC_VALUE; } + ; + +%% + +static int +yylex (void) +{ + static char const *input = "a"; + return *input++; +} + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +int +main (void) +{ + return yyparse () != 1; +} +]]) + +AT_CHECK([[bison -o glr-regr5.c glr-regr5.y]], 0, [], +[glr-regr5.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr5]) + +AT_CHECK([[./glr-regr5]], 0, [], +[syntax is ambiguous +]) + +AT_CLEANUP + + +## -------------------------------------------------------------------------- ## +## User destructor after an error during a split parse. See ## +## . ## +## -------------------------------------------------------------------------- ## + +AT_SETUP([User destructor after an error during a split parse]) + +AT_DATA_GRAMMAR([glr-regr6.y], +[[ +%{ + #include + #include + static void yyerror (char const *); + static int yylex (void); +%} + +%glr-parser +%union { int value; } +%type 'a' + +%destructor { + printf ("Destructor called.\n"); +} 'a' + +%% + +start: 'a' | 'a' ; + +%% + +static int +yylex (void) +{ + static char const *input = "a"; + return *input++; +} + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +int +main (void) +{ + return yyparse () != 1; +} +]]) + +AT_CHECK([[bison -o glr-regr6.c glr-regr6.y]], 0, [], +[glr-regr6.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr6]) + +AT_CHECK([[./glr-regr6]], 0, +[Destructor called. +], +[syntax is ambiguous +]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Duplicated user destructor for lookahead. See ## +## . ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Duplicated user destructor for lookahead]) + +AT_DATA_GRAMMAR([glr-regr7.y], +[[ +%{ + #include + #include + static void yyerror (char const *); + static int yylex (void); + #define YYSTACKEXPANDABLE 0 +%} + +%glr-parser +%union { int *count; } +%type 'a' + +%destructor { + if ((*$$)++) + fprintf (stderr, "Destructor called on same value twice.\n"); +} 'a' + +%% + +start: + stack1 start + | stack2 start + | /* empty */ + ; +stack1: 'a' ; +stack2: 'a' ; + +%% + +static int +yylex (void) +{ + yylval.count = (int *) malloc (sizeof (int)); + if (!yylval.count) + { + fprintf (stderr, "Test inconclusive.\n"); + exit (EXIT_FAILURE); + } + *yylval.count = 0; + return 'a'; +} + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +int +main (void) +{ + return yyparse (); +} +]]) + +AT_CHECK([[bison -o glr-regr7.c glr-regr7.y]], 0, [], +[glr-regr7.y: conflicts: 2 reduce/reduce +]) +AT_COMPILE([glr-regr7]) + +AT_CHECK([[./glr-regr7]], 2, [], +[memory exhausted +]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Incorrect default location for empty right-hand sides. Adapted from bug ## +## report by Claudia Hermann. ## +## See http://lists.gnu.org/archive/html/bug-bison/2005-10/msg00069.html and ## +## http://lists.gnu.org/archive/html/bug-bison/2005-10/msg00072.html ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR]) + +AT_DATA_GRAMMAR([glr-regr8.y], +[[ +%{ + #include + #include + static void yyerror (char const *); + static int yylex (void); + static void yyerror(const char *msg); +%} + +%token T_CONSTANT +%token T_PORT +%token T_SIGNAL + +%glr-parser + +%% + + +PortClause : T_PORT InterfaceDeclaration T_PORT + { printf("%d/%d - %d/%d - %d/%d\n", + @1.first_column, @1.last_column, + @2.first_column, @2.last_column, + @3.first_column, @3.last_column); } + ; + +InterfaceDeclaration : OptConstantWord %dprec 1 + | OptSignalWord %dprec 2 + ; + +OptConstantWord : /* empty */ + | T_CONSTANT + ; + +OptSignalWord : /* empty */ + { printf("empty: %d/%d\n", @$.first_column, @$.last_column); } + | T_SIGNAL + ; + +%% + +void yyerror(const char *msg) +{ + fprintf (stderr, "error\n"); +} + +static int lexIndex; + +int yylex (void) +{ + lexIndex += 1; + switch (lexIndex) + { + case 1: + yylloc.first_column = 1; + yylloc.last_column = 9; + return T_PORT; + case 2: + yylloc.first_column = 13; + yylloc.last_column = 17; + return T_PORT; + default: + return 0; + } +} + +int +main (void) +{ + yyparse(); + return 0; +} +]]) + +AT_CHECK([[bison -o glr-regr8.c glr-regr8.y]], 0, [], +[glr-regr8.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr8]) + +AT_CHECK([[./glr-regr8]], 0, +[empty: 9/9 +1/9 - 9/9 - 13/17 +], +[]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## No users destructors if stack 0 deleted. See ## +## . ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([No users destructors if stack 0 deleted]) + +AT_DATA_GRAMMAR([glr-regr9.y], +[[ +%{ +# include +# include + static void yyerror (char const *); + static int yylex (void); +# define YYSTACKEXPANDABLE 0 + static int tokens = 0; + static int destructors = 0; +# define USE(Var) +%} + +%glr-parser +%union { int dummy; } +%type 'a' + +%destructor { + destructors += 1; +} 'a' + +%% + +start: + ambig0 'a' { destructors += 2; USE ($2); } + | ambig1 start { destructors += 1; } + | ambig2 start { destructors += 1; } + ; + +ambig0: 'a' ; +ambig1: 'a' ; +ambig2: 'a' ; + +%% + +static int +yylex (void) +{ + tokens += 1; + return 'a'; +} + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +int +main (void) +{ + int exit_status; + exit_status = yyparse (); + if (tokens != destructors) + { + fprintf (stderr, "Tokens = %d, Destructors = %d\n", tokens, destructors); + return 1; + } + return !exit_status; +} +]]) + +AT_CHECK([[bison -o glr-regr9.c glr-regr9.y]], 0, [], +[glr-regr9.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr9]) + +AT_CHECK([[./glr-regr9]], 0, [], +[memory exhausted +]) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Corrupted semantic options if user action cuts parse. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Corrupted semantic options if user action cuts parse]) + +AT_DATA_GRAMMAR([glr-regr10.y], +[[ +%{ +# include + static void yyerror (char const *); + static int yylex (void); + #define GARBAGE_SIZE 50 + static char garbage[GARBAGE_SIZE]; +%} + +%glr-parser +%union { char *ptr; } +%type start + +%% + +start: + %dprec 2 { $$ = garbage; YYACCEPT; } + | %dprec 1 { $$ = garbage; YYACCEPT; } + ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + return 0; +} + +int +main (void) +{ + int index; + for (index = 0; index < GARBAGE_SIZE; index+=1) + garbage[index] = 108; + return yyparse (); +} +]]) + +AT_CHECK([[bison -t -o glr-regr10.c glr-regr10.y]], 0, [], +[glr-regr10.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr10]) + +AT_CHECK([[./glr-regr10]], 0, [], []) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Undesirable destructors if user action cuts parse. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Undesirable destructors if user action cuts parse]) + +AT_DATA_GRAMMAR([glr-regr11.y], +[[ +%{ +# include + static void yyerror (char const *); + static int yylex (void); + static int destructors = 0; +# define USE(val) +%} + +%glr-parser +%union { int dummy; } +%type 'a' +%destructor { destructors += 1; } 'a' + +%% + +start: + 'a' %dprec 2 { USE ($1); destructors += 1; YYACCEPT; } + | 'a' %dprec 1 { USE ($1); destructors += 1; YYACCEPT; } + ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + static char const *input = "a"; + return *input++; +} + +int +main (void) +{ + int exit_status = yyparse (); + if (destructors != 1) + { + fprintf (stderr, "Destructor calls: %d\n", destructors); + return 1; + } + return exit_status; +} +]]) + +AT_CHECK([[bison -t -o glr-regr11.c glr-regr11.y]], 0, [], +[glr-regr11.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr11]) + +AT_CHECK([[./glr-regr11]], 0, [], []) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Leaked merged semantic value if user action cuts parse. ## +## ------------------------------------------------------------------------- ## + +AT_SETUP([Leaked merged semantic value if user action cuts parse]) + +AT_DATA_GRAMMAR([glr-regr12.y], +[[ +%glr-parser +%union { int dummy; } +%type start +%destructor { has_value = 0; } start + +%{ +# include + static int merge (YYSTYPE, YYSTYPE); + static void yyerror (char const *); + static int yylex (void); + static int has_value = 0; +# define USE(val) +%} + +%% + +start: + %merge { has_value = 1; USE ($$); } + | %merge { USE ($$); YYACCEPT; } + ; + +%% + +static int +merge (YYSTYPE s1, YYSTYPE s2) +{ + /* Not invoked. */ + char dummy = s1.dummy + s2.dummy; + return dummy; +} + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + return 0; +} + +int +main (void) +{ + int exit_status = yyparse (); + if (has_value) + { + fprintf (stderr, "Destructor not called.\n"); + return 1; + } + return exit_status; +} +]]) + +AT_CHECK([[bison -t -o glr-regr12.c glr-regr12.y]], 0, [], +[glr-regr12.y: conflicts: 1 reduce/reduce +]) +AT_COMPILE([glr-regr12]) + +AT_CHECK([[./glr-regr12]], 0, [], []) + +AT_CLEANUP + + +## ------------------------------------------------------------------------- ## +## Incorrect lookahead during deterministic GLR. See ## +## . ## +## ------------------------------------------------------------------------- ## + +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. */ + +%{ + #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' { + 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'"); + } + ; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex (void) +{ + static char const *input = "ab"; + static int index = 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++]; +} + +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 -t -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 index = 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++]; +} + +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 -t -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