X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b7691f15bdefaabbc246ea9b1855189a8d1cc318..5a43d4184f2318c02b6ba87656559e8b5bb424ef:/tests/glr-regression.at?ds=sidebyside diff --git a/tests/glr-regression.at b/tests/glr-regression.at index 3e6d0351..178d72bc 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, 2006 Free Software Foundation, Inc. +# Copyright (C) 2002, 2003, 2005, 2006, 2007 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 @@ -30,6 +30,7 @@ AT_DATA_GRAMMAR([glr-regr1.y], %{ #include +#include #define YYSTYPE int static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1); @@ -82,7 +83,10 @@ yylex (void) { for (;;) { - int ch = getchar (); + int ch; + if (feof (stdin)) + abort (); + ch = getchar (); if (ch == EOF) return 0; else if (ch == 'B' || ch == 'P') @@ -95,7 +99,7 @@ AT_CHECK([[bison -o glr-regr1.c glr-regr1.y]], 0, [], [glr-regr1.y: conflicts: 1 shift/reduce ]) AT_COMPILE([glr-regr1]) -AT_CHECK([[echo BPBPB | ./glr-regr1]], 0, +AT_PARSER_CHECK([[echo BPBPB | ./glr-regr1]], 0, [[E -> 'B' E -> 'B' E -> E 'P' E @@ -168,13 +172,15 @@ var_printer: 'v' %% -FILE *input = NULL; +FILE *input; int yylex (void) { char buf[50]; char *s; + if (feof (stdin)) + abort (); switch (fscanf (input, " %1[a-z,]", buf)) { case 1: return buf[0]; @@ -212,13 +218,14 @@ AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [], ]) AT_COMPILE([glr-regr2a]) -AT_CHECK([[echo s VARIABLE_1 t v x q | ./glr-regr2a]], 0, +AT_PARSER_CHECK([[echo s VARIABLE_1 t v x q | ./glr-regr2a]], 0, [[Variable: 'VARIABLE_1' ]], []) -AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], 0, +AT_PARSER_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], +0, [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2' ]]) -AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0, +AT_PARSER_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0, [[Variable: 'VARIABLE_3' ]], []) @@ -237,10 +244,11 @@ AT_DATA_GRAMMAR([glr-regr3.y], %{ #include +#include #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)) @@ -299,6 +307,8 @@ int T[] = { T1, T2, T3, T4 }; int yylex (void) { char inp[3]; + if (feof (stdin)) + abort (); if (fscanf (input, "%2s", inp) == EOF) return 0; switch (inp[0]) @@ -322,7 +332,8 @@ AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [], ]) AT_COMPILE([glr-regr3]) -AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], 0, +AT_PARSER_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], +0, [[Result: 1c04 ]], []) @@ -350,6 +361,8 @@ AT_DATA_GRAMMAR([glr-regr4.y], static char *make_value (char const *, char const *); static void yyerror (char const *); static int yylex (void); + static char *ptrs[100]; + static char **ptrs_next = ptrs; %} %% @@ -375,21 +388,27 @@ B: 'a' { $$ = make_value ("B", "'a'"); } ; static int yylex (void) { - static char const *input = "a"; - return *input++; + static char const input[] = "a"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); + return input[toknum++]; } int main (void) { - return yyparse (); + int status = yyparse (); + while (ptrs_next != ptrs) + free (*--ptrs_next); + return status; } static char * make_value (char const *parent, char const *child) { char const format[] = "%s <- %s"; - char *value = + char *value = *ptrs_next++ = (char *) malloc (strlen (parent) + strlen (child) + sizeof format); sprintf (value, format, parent, child); return value; @@ -399,7 +418,7 @@ static char * merge (YYSTYPE s1, YYSTYPE s2) { char const format[] = "merge{ %s and %s }"; - char *value = + char *value = *ptrs_next++ = (char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format); sprintf (value, format, s1.ptr, s2.ptr); return value; @@ -417,7 +436,7 @@ AT_CHECK([[bison -o glr-regr4.c glr-regr4.y]], 0, [], ]) AT_COMPILE([glr-regr4]) -AT_CHECK([[./glr-regr4]], 0, +AT_PARSER_CHECK([[./glr-regr4]], 0, [[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' } ]], []) @@ -465,8 +484,11 @@ start: static int yylex (void) { - static char const *input = "a"; - return *input++; + static char const input[] = "a"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); + return input[toknum++]; } static void @@ -487,7 +509,7 @@ AT_CHECK([[bison -o glr-regr5.c glr-regr5.y]], 0, [], ]) AT_COMPILE([glr-regr5]) -AT_CHECK([[./glr-regr5]], 0, [], +AT_PARSER_CHECK([[./glr-regr5]], 0, [], [syntax is ambiguous ]) @@ -527,8 +549,11 @@ start: 'a' | 'a' ; static int yylex (void) { - static char const *input = "a"; - return *input++; + static char const input[] = "a"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); + return input[toknum++]; } static void @@ -549,7 +574,7 @@ AT_CHECK([[bison -o glr-regr6.c glr-regr6.y]], 0, [], ]) AT_COMPILE([glr-regr6]) -AT_CHECK([[./glr-regr6]], 0, +AT_PARSER_CHECK([[./glr-regr6]], 0, [Destructor called. ], [syntax is ambiguous @@ -573,14 +598,19 @@ AT_DATA_GRAMMAR([glr-regr7.y], static void yyerror (char const *); static int yylex (void); #define YYSTACKEXPANDABLE 0 + typedef struct count_node { + int count; + struct count_node *prev; + } count_node; + static count_node *tail; %} %glr-parser -%union { int *count; } -%type 'a' +%union { count_node *node; } +%type 'a' %destructor { - if ((*$$)++) + if ($$->count++) fprintf (stderr, "Destructor called on same value twice.\n"); } 'a' @@ -599,13 +629,15 @@ stack2: 'a' ; static int yylex (void) { - yylval.count = (int *) malloc (sizeof (int)); - if (!yylval.count) + yylval.node = (count_node*) malloc (sizeof *yylval.node); + if (!yylval.node) { fprintf (stderr, "Test inconclusive.\n"); exit (EXIT_FAILURE); } - *yylval.count = 0; + yylval.node->count = 0; + yylval.node->prev = tail; + tail = yylval.node; return 'a'; } @@ -618,7 +650,14 @@ yyerror (char const *msg) int main (void) { - return yyparse (); + int status = yyparse (); + while (tail) + { + count_node *prev = tail->prev; + free (tail); + tail = prev; + } + return status; } ]]) @@ -627,7 +666,7 @@ AT_CHECK([[bison -o glr-regr7.c glr-regr7.y]], 0, [], ]) AT_COMPILE([glr-regr7]) -AT_CHECK([[./glr-regr7]], 2, [], +AT_PARSER_CHECK([[./glr-regr7]], 2, [], [memory exhausted ]) @@ -650,7 +689,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 +723,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; @@ -696,6 +736,8 @@ int yylex (void) lexIndex += 1; switch (lexIndex) { + default: + abort (); case 1: yylloc.first_column = 1; yylloc.last_column = 9; @@ -704,7 +746,7 @@ int yylex (void) yylloc.first_column = 13; yylloc.last_column = 17; return T_PORT; - default: + case 3: return 0; } } @@ -722,7 +764,7 @@ AT_CHECK([[bison -o glr-regr8.c glr-regr8.y]], 0, [], ]) AT_COMPILE([glr-regr8]) -AT_CHECK([[./glr-regr8]], 0, +AT_PARSER_CHECK([[./glr-regr8]], 0, [empty: 9/9 1/9 - 9/9 - 13/17 ], @@ -805,7 +847,7 @@ AT_CHECK([[bison -o glr-regr9.c glr-regr9.y]], 0, [], ]) AT_COMPILE([glr-regr9]) -AT_CHECK([[./glr-regr9]], 0, [], +AT_PARSER_CHECK([[./glr-regr9]], 0, [], [memory exhausted ]) @@ -821,6 +863,7 @@ AT_SETUP([Corrupted semantic options if user action cuts parse]) AT_DATA_GRAMMAR([glr-regr10.y], [[ %{ +# include # include static void yyerror (char const *); static int yylex (void); @@ -850,25 +893,28 @@ yyerror (char const *msg) static int yylex (void) { + static int called; + if (called++) + abort (); return 0; } 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]) -AT_CHECK([[./glr-regr10]], 0, [], []) +AT_PARSER_CHECK([[./glr-regr10]], 0, [], []) AT_CLEANUP @@ -912,8 +958,11 @@ yyerror (char const *msg) static int yylex (void) { - static char const *input = "a"; - return *input++; + static char const input[] = "a"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); + return input[toknum++]; } int @@ -929,45 +978,86 @@ 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]) -AT_CHECK([[./glr-regr11]], 0, [], []) +AT_PARSER_CHECK([[./glr-regr11]], 0, [], []) 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,35 +1077,52 @@ yyerror (char const *msg) static int yylex (void) { - return 0; + static int const input[] = { PARENT_RHS_AFTER, 0 }; + static size_t toknum; + if (! (toknum < sizeof input / sizeof *input)) + abort (); + if (input[toknum] == PARENT_RHS_AFTER) + parent_rhs_after_value = 1; + return input[toknum++]; } 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_PARSER_CHECK([[./glr-regr12]], 0, [], []) AT_CLEANUP ## ------------------------------------------------------------------------- ## ## Incorrect lookahead during deterministic GLR. See ## -## . ## +## and ## +## . ## ## ------------------------------------------------------------------------- ## AT_SETUP([Incorrect lookahead during deterministic GLR]) @@ -1026,13 +1133,14 @@ 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 static void yyerror (char const *); static int yylex (void); - static void print_look_ahead (char const *); + static void print_lookahead (char const *); #define USE(value) %} @@ -1044,34 +1152,39 @@ 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'"); + print_lookahead ("start <- defstate_init defstate_shift 'b'"); } ; defstate_init: { - print_look_ahead ("defstate_init <- empty string"); + print_lookahead ("defstate_init <- empty string"); } ; defstate_shift: nondefstate defstate_look 'a' { USE ($3); - print_look_ahead ("defstate_shift <- nondefstate defstate_look 'a'"); + print_lookahead ("defstate_shift <- nondefstate defstate_look 'a'"); } ; defstate_look: { - print_look_ahead ("defstate_look <- empty string"); + print_lookahead ("defstate_look <- empty string"); } ; nondefstate: { - print_look_ahead ("nondefstate <- empty string"); + print_lookahead ("nondefstate <- empty string"); } | 'b' { USE ($1); - print_look_ahead ("nondefstate <- 'b'"); + print_lookahead ("nondefstate <- 'b'"); + } + ; +change_lookahead: + { + yychar = 'a'; } ; @@ -1086,16 +1199,18 @@ yyerror (char const *msg) static int yylex (void) { - static char const *input = "ab"; - static int index = 0; + static char const input[] = "ab"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); 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 = toknum + 1; + yylval.value = input[toknum] + 'A' - 'a'; + return input[toknum++]; } static void -print_look_ahead (char const *reduction) +print_lookahead (char const *reduction) { printf ("%s:\n yychar=", reduction); if (yychar == YYEMPTY) @@ -1123,10 +1238,10 @@ 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, +AT_PARSER_CHECK([[./glr-regr13]], 0, [defstate_init <- empty string: yychar=YYEMPTY nondefstate <- empty string: @@ -1172,10 +1287,11 @@ AT_DATA_GRAMMAR([glr-regr14.y], %union { char value; } %{ + #include #include static void yyerror (char const *); static int yylex (void); - static void print_look_ahead (char const *); + static void print_lookahead (char const *); static char merge (union YYSTYPE, union YYSTYPE); #define USE(value) %} @@ -1189,7 +1305,7 @@ AT_DATA_GRAMMAR([glr-regr14.y], start: merge 'c' stack_explosion { USE ($2); USE ($3); - print_look_ahead ("start <- merge 'c' stack_explosion"); + print_lookahead ("start <- merge 'c' stack_explosion"); } ; @@ -1197,44 +1313,44 @@ start: merge: nonconflict1 'a' 'b' nonconflict2 %dprec 1 { USE ($2); USE ($3); - print_look_ahead ("merge <- nonconflict1 'a' 'b' nonconflict2"); + print_lookahead ("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'" + print_lookahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'" " defstate_shift"); } ; nonconflict1: { - print_look_ahead ("nonconflict1 <- empty string"); + print_lookahead ("nonconflict1 <- empty string"); } ; nonconflict2: { - print_look_ahead ("nonconflict2 <- empty string"); + print_lookahead ("nonconflict2 <- empty string"); } | 'a' { USE ($1); - print_look_ahead ("nonconflict2 <- 'a'"); + print_lookahead ("nonconflict2 <- 'a'"); } ; conflict: { - print_look_ahead ("conflict <- empty string"); + print_lookahead ("conflict <- empty string"); } ; defstate_look: { - print_look_ahead ("defstate_look <- empty string"); + print_lookahead ("defstate_look <- empty string"); } ; /* yychar != YYEMPTY but lookahead need is yyfalse. */ defstate_shift: { - print_look_ahead ("defstate_shift <- empty string"); + print_lookahead ("defstate_shift <- empty string"); } ; @@ -1292,16 +1408,18 @@ yyerror (char const *msg) static int yylex (void) { - static char const *input = "abcdddd"; - static int index = 0; + static char const input[] = "abcdddd"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); 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 = toknum + 1; + yylval.value = input[toknum] + 'A' - 'a'; + return input[toknum++]; } static void -print_look_ahead (char const *reduction) +print_lookahead (char const *reduction) { printf ("%s:\n yychar=", reduction); if (yychar == YYEMPTY) @@ -1336,12 +1454,12 @@ 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]) -AT_CHECK([[./glr-regr14]], 0, +AT_PARSER_CHECK([[./glr-regr14]], 0, [conflict <- empty string: yychar='a', yylval='A', yylloc=(1,1),(1,1) defstate_look <- empty string: @@ -1357,3 +1475,316 @@ 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) +{ + static int called; + if (called++) + abort (); + 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_PARSER_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"; + static size_t toknum; + if (! (toknum < sizeof input)) + abort (); + if (input[toknum] == 'b') + lookahead_value = 1; + return input[toknum++]; +} + +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_PARSER_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 size_t toknum; + if (! (toknum < sizeof input)) + abort (); + lvalp->dummy = 0; + llocp->first_line = llocp->last_line = 2; + llocp->first_column = toknum + 1; + llocp->last_column = llocp->first_column + 1; + return input[toknum++]; +} + +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_PARSER_CHECK([[./glr-regr17]], 0, [], +[Error at 1.1-2.3: syntax is ambiguous. +]) + +AT_CLEANUP + + +## -------------------------------------------------------------## +## Missed %merge type warnings when LHS type is declared later. ## +## -------------------------------------------------------------## + +AT_SETUP([Missed %merge type warnings when LHS type is declared later]) +AT_DATA_GRAMMAR([glr-regr18.y], +[[%glr-parser + +%{ + #include + static void yyerror (char const *); + static int yylex (); +%} + +%union { + int type1; + int type2; + int type3; +} + +%% + +sym1: sym2 %merge { $$ = $1; } ; +sym2: sym3 %merge { $$ = $1; } ; +sym3: %merge { $$ = 0; } ; + +%type sym1; +%type sym2; +%type sym3; + +%% + +static void +yyerror (char const *msg) +{ + fprintf (stderr, "%s\n", msg); +} + +static int +yylex () +{ + static int called; + if (called++) + abort (); + return 0; +} + +int +main (void) +{ + return yyparse (); +} +]]) + +AT_CHECK([[bison -o glr-regr18.c glr-regr18.y]], 1, [], +[glr-regr18.y:26.18-24: result type clash on merge function `merge': != +glr-regr18.y:25.18-24: previous declaration +glr-regr18.y:27.13-19: result type clash on merge function `merge': != +glr-regr18.y:26.18-24: previous declaration +]) + +AT_CLEANUP