Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-14 06:43:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
520181ab91c52ca991b5f96ba1488319368a4214
bison/tests/glr-regression.at
Joel E. Denny 520181ab91 Don't leak semantic values for parent RHS when a user action cuts the 
parser, and clean up related code a bit.
* tests/glr-regression.at (Leaked merged semantic value if user action
cuts parse) Rename to...
(Leaked semantic values if user action cuts parse) ... this.  Add check
for leaked parent RHS values.
* data/glr.c (yydestroyGLRState): In debugging output, distinguish
between an unresolved state (non-empty chain of semantic options) and
an incomplete one (signaled by an empty chain).
(yyresolveStates): Document the interface.  Move all manipulation of an
successfully or unsuccessfully resolved yyGLRState to...
(yyresolveValue): ... here so that yyresolveValue always leaves a
yyGLRState with consistent data and thus is easier to understand.
Remove the yyvalp and yylocp parameters since they are always just
taken from the yys parameter.  When reporting a discarded merged value
in debugging output, note that it is incompletely merged.  Document the
interface.
(yyresolveAction): If resolving any of the RHS states fails, destroy
them all rather than leaking them.  Thus, as long as user actions are
written to clean up the RHS correctly, yyresolveAction always cleans up
the RHS of a semantic option.  Document the interface.
2006-03-02 01:35:15 +00:00

1423 lines
28 KiB
Plaintext
Raw Blame History

# Checking GLR Parsing: Regression Tests -*- Autotest -*-
# 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
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.
AT_BANNER([[GLR Regression Tests]])
## --------------------------- ##
## Badly Collapsed GLR States. ##
## --------------------------- ##
AT_SETUP([Badly Collapsed GLR States])
AT_DATA_GRAMMAR([glr-regr1.y],
[[/* Regression Test: Improper state compression */
/* Reported by Scott McPeak */
%{
#include <stdio.h>
#define YYSTYPE int
static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
int yylex (void);
void yyerror (char const *msg);
%}
%glr-parser
/* -------- productions ------ */
%%
StartSymbol: E { $$=0; } %merge <exprMerge>
;
E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); } %merge <exprMerge>
| 'B' { $$=2; printf("E -> 'B'\n"); } %merge <exprMerge>
;
/* ---------- C code ----------- */
%%
static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1)
{
(void) x0;
(void) x1;
printf ("<OR>\n");
return 0;
}
int
main (void)
{
return yyparse ();
}
void
yyerror (char const *msg)
{
fprintf (stderr, "%s\n", msg);
}
int
yylex (void)
{
for (;;)
{
int ch = getchar ();
if (ch == EOF)
return 0;
else if (ch == 'B' || ch == 'P')
return ch;
}
}
]])
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,
[[E -> 'B'
E -> 'B'
E -> E 'P' E
E -> 'B'
E -> E 'P' E
E -> 'B'
E -> E 'P' E
E -> E 'P' E
<OR>
]], [])
AT_CLEANUP
## ------------------------------------------------------------ ##
## Improper handling of embedded actions and $-N in GLR parsers ##
## ------------------------------------------------------------ ##
AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers])
AT_DATA_GRAMMAR([glr-regr2a.y],
[[/* Regression Test: Improper handling of embedded actions and $-N */
/* Reported by S. Eken */
%{
#define YYSTYPE char *
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int yylex (void);
void yyerror (char const *);
%}
%glr-parser
%%
command:
's' var 't'
{ printf ("Variable: '%s'\n", $2); }
'v' 'x' 'q'
{ free ($2); }
| 's' var_list 't' 'e'
{ printf ("Varlist: '%s'\n", $2); free ($2); }
| 's' var 't' var_printer 'x'
{ free ($2); }
;
var:
'V'
{ $$ = $1; }
;
var_list:
var
{ $$ = $1; }
| var ',' var_list
{
char *s = (char *) realloc ($1, strlen ($1) + 1 + strlen ($3) + 1);
strcat (s, ",");
strcat (s, $3);
free ($3);
$$ = s;
}
;
var_printer: 'v'
{ printf ("Variable: '%s'\n", $-1); }
%%
FILE *input = NULL;
int
yylex (void)
{
char buf[50];
char *s;
switch (fscanf (input, " %1[a-z,]", buf)) {
case 1:
return buf[0];
case EOF:
return 0;
default:
break;
}
if (fscanf (input, "%49s", buf) != 1)
return 0;
if (sizeof buf - 1 <= strlen (buf))
abort ();
s = (char *) malloc (strlen (buf) + 1);
strcpy (s, buf);
yylval = s;
return 'V';
}
void
yyerror (char const *s)
{ printf ("%s\n", s);
}
int
main (int argc, char **argv)
{
input = stdin;
if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
return yyparse ();
}
]])
AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [],
[glr-regr2a.y: conflicts: 2 shift/reduce
])
AT_COMPILE([glr-regr2a])
AT_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,
[[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
]])
AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
[[Variable: 'VARIABLE_3'
]], [])
AT_CLEANUP
## ------------------------------------------------------------ ##
## Improper merging of GLR delayed action sets ##
## ------------------------------------------------------------ ##
AT_SETUP([Improper merging of GLR delayed action sets])
AT_DATA_GRAMMAR([glr-regr3.y],
[[/* Regression Test: Improper merging of GLR delayed action sets. */
/* Reported by M. Rosien */
%{
#include <stdio.h>
#include <stdarg.h>
static int MergeRule (int x0, int x1);
static void yyerror (char const * s);
int yylex (void);
#define RULE(x) (1 << (x))
%}
%glr-parser
%token BAD_CHAR
%token P1 P2 T1 T2 T3 T4 O1 O2
%%
S : P1 T4 O2 NT6 P2 { printf ("Result: %x\n", $4); }
;
NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); } %merge<MergeRule>
;
NT2 : NT1 { $$ = RULE(3); } %merge<MergeRule>
| P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
;
NT3 : T3 { $$ = RULE(5); } %merge<MergeRule>
| P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
;
NT4 : NT3 { $$ = RULE(7); } %merge<MergeRule>
| NT2 { $$ = RULE(8); } %merge<MergeRule>
| P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
;
NT5 : NT4 { $$ = RULE(10); } %merge<MergeRule>
;
NT6 : P1 NT1 O1 T3 P2 { $$ = RULE(11) | $2; } %merge<MergeRule>
| NT5 { $$ = RULE(12) | $1; } %merge<MergeRule>
;
%%
static int MergeRule (int x0, int x1) {
return x0 | x1;
}
static void yyerror(char const * s) {
fprintf(stderr,"error: %s\n",s);
}
FILE *input = NULL;
int P[] = { P1, P2 };
int O[] = { O1, O2 };
int T[] = { T1, T2, T3, T4 };
int yylex (void)
{
char inp[3];
if (fscanf (input, "%2s", inp) == EOF)
return 0;
switch (inp[0])
{
case 'p': return P[inp[1] - '1'];
case 't': return T[inp[1] - '1'];
case 'o': return O[inp[1] - '1'];
}
return BAD_CHAR;
}
int main(int argc, char* argv[]) {
input = stdin;
if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
return yyparse ();
}
]])
AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [],
[glr-regr3.y: conflicts: 1 shift/reduce, 1 reduce/reduce
])
AT_COMPILE([glr-regr3])
AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], 0,
[[Result: 1c04
]], [])
AT_CLEANUP
## ------------------------------------------------------------------------- ##
## Duplicate representation of merged trees. See ##
## <http://lists.gnu.org/archive/html/help-bison/2005-07/msg00013.html>. ##
## ------------------------------------------------------------------------- ##
AT_SETUP([Duplicate representation of merged trees])
AT_DATA_GRAMMAR([glr-regr4.y],
[[
%union { char *ptr; }
%type <ptr> S A A1 A2 B
%glr-parser
%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char *merge (YYSTYPE, YYSTYPE);
static char *make_value (char const *, char const *);
static void yyerror (char const *);
static int yylex (void);
%}
%%
tree: S { printf ("%s\n", $1); } ;
S:
A %merge<merge> { $$ = make_value ("S", $1); }
| B %merge<merge> { $$ = make_value ("S", $1); }
;
A:
A1 %merge<merge> { $$ = make_value ("A", $1); }
| A2 %merge<merge> { $$ = make_value ("A", $1); }
;
A1: 'a' { $$ = make_value ("A1", "'a'"); } ;
A2: 'a' { $$ = make_value ("A2", "'a'"); } ;
B: 'a' { $$ = make_value ("B", "'a'"); } ;
%%
static int
yylex (void)
{
static char const *input = "a";
return *input++;
}
int
main (void)
{
return yyparse ();
}
static char *
make_value (char const *parent, char const *child)
{
char const format[] = "%s <- %s";
char *value =
(char *) malloc (strlen (parent) + strlen (child) + sizeof format);
sprintf (value, format, parent, child);
return value;
}
static char *
merge (YYSTYPE s1, YYSTYPE s2)
{
char const format[] = "merge{ %s and %s }";
char *value =
(char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format);
sprintf (value, format, s1.ptr, s2.ptr);
return value;
}
static void
yyerror (char const *msg)
{
fprintf (stderr, "%s\n", msg);
}
]])
AT_CHECK([[bison -o glr-regr4.c glr-regr4.y]], 0, [],
[glr-regr4.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr4])
AT_CHECK([[./glr-regr4]], 0,
[[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
]], [])
AT_CLEANUP
## -------------------------------------------------------------------------- ##
## User destructor for unresolved GLR semantic value. See ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00016.html>. ##
## -------------------------------------------------------------------------- ##
AT_SETUP([User destructor for unresolved GLR semantic value])
AT_DATA_GRAMMAR([glr-regr5.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
static void yyerror (char const *);
static int yylex (void);
enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
%}
%glr-parser
%union { int value; }
%type <value> 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 ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00029.html>. ##
## -------------------------------------------------------------------------- ##
AT_SETUP([User destructor after an error during a split parse])
AT_DATA_GRAMMAR([glr-regr6.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
static void yyerror (char const *);
static int yylex (void);
%}
%glr-parser
%union { int value; }
%type <value> '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 ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00035.html>. ##
## ------------------------------------------------------------------------- ##
AT_SETUP([Duplicated user destructor for lookahead])
AT_DATA_GRAMMAR([glr-regr7.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
static void yyerror (char const *);
static int yylex (void);
#define YYSTACKEXPANDABLE 0
%}
%glr-parser
%union { int *count; }
%type <count> '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 <stdio.h>
#include <stdlib.h>
static void yyerror (char const *);
static int yylex (void);
static void yyerror (char const *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 (char const *msg)
{
fprintf (stderr, "%s\n", msg);
}
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 ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-09/msg00109.html>. ##
## ------------------------------------------------------------------------- ##
AT_SETUP([No users destructors if stack 0 deleted])
AT_DATA_GRAMMAR([glr-regr9.y],
[[
%{
# include <stdio.h>
# include <stdlib.h>
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 <dummy> '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 <stdio.h>
static void yyerror (char const *);
static int yylex (void);
#define GARBAGE_SIZE 50
static char garbage[GARBAGE_SIZE];
%}
%glr-parser
%union { char *ptr; }
%type <ptr> 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 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, [],
[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 <stdlib.h>
static void yyerror (char const *);
static int yylex (void);
static int destructors = 0;
# define USE(val)
%}
%glr-parser
%union { int dummy; }
%type <int> '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 semantic values 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; }
%token PARENT_RHS_AFTER
%type <dummy> 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 <stdlib.h>
static int merge (YYSTYPE, YYSTYPE);
static void yyerror (char const *);
static int yylex (void);
static int parent_rhs_before_value = 0;
static int merged_value = 0;
static int parent_rhs_after_value = 0;
# define USE(val)
%}
%%
start:
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<merge> {
USE ($$);
merged_value = 1;
}
| cut %merge<merge> {
USE ($$);
merged_value = 1;
}
;
cut: { 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)
{
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 (parent_rhs_before_value)
{
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 shift/reduce, 1 reduce/reduce
])
AT_COMPILE([glr-regr12])
AT_CHECK([[./glr-regr12]], 0, [], [])
AT_CLEANUP
## ------------------------------------------------------------------------- ##
## Incorrect lookahead during deterministic GLR. See ##
## <http://lists.gnu.org/archive/html/help-bison/2005-07/msg00017.html> and ##
## <http://lists.gnu.org/archive/html/bison-patches/2006-01/msg00060.html>. ##
## ------------------------------------------------------------------------- ##
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 <stdio.h>
static void yyerror (char const *);
static int yylex (void);
static void print_look_ahead (char const *);
#define USE(value)
%}
%union { char value; }
%type <value> '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 -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 <stdio.h>
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 <value> '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<merge> { $$ = $2; }
| alt2 stack_explosion %merge<merge> { $$ = $2; }
| alt3 stack_explosion %merge<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 -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
Reference in New Issue View Git Blame Copy Permalink