mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
e2688cd96e
(yyuserMerge): Provide a default case if b4_mergers is empty. * tests/cxx-type.at (_AT_TEST_GLR_CXXTYPES): Define YYSTACKEXPANDABLE. * tests/glr-regression.at (Improper handling of embedded actions and dollar(-N) in GLR parsers): YYSTYPE is char *, not char const *, so that strcpy ($$, ...) works.
328 lines
6.5 KiB
Plaintext
328 lines
6.5 KiB
Plaintext
# Checking GLR Parsing: Regression Tests -*- Autotest -*-
|
|
# Copyright (C) 2002, 2003, 2005 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);
|
|
int 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 ();
|
|
}
|
|
|
|
int
|
|
yyerror (char const *msg)
|
|
{
|
|
fprintf (stderr, "%s\n", msg);
|
|
exit (4);
|
|
}
|
|
|
|
|
|
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 *
|
|
#define yyfalse 0
|
|
#define yytrue 1
|
|
|
|
#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'
|
|
| 's' var_list 't' 'e'
|
|
{ printf ("Varlist: '%s'\n", $2); }
|
|
| 's' var 't' var_printer 'x'
|
|
;
|
|
|
|
var:
|
|
'V'
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
var_list:
|
|
var
|
|
{ $$ = $1; }
|
|
| var ',' var_list
|
|
{
|
|
$$ = malloc (strlen ($1) + 1 + strlen ($3) + 1);
|
|
strcpy ($$, $1);
|
|
strcat ($$, ",");
|
|
strcat ($$, $3);
|
|
}
|
|
;
|
|
|
|
var_printer: 'v'
|
|
{ printf ("Variable: '%s'\n", $-1); }
|
|
|
|
%%
|
|
|
|
FILE *yyin = NULL;
|
|
|
|
int
|
|
yylex (void)
|
|
{
|
|
char buf[50];
|
|
switch (fscanf (yyin, " %1[a-z,]", buf)) {
|
|
case 1:
|
|
return buf[0];
|
|
case EOF:
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
if (fscanf (yyin, "%49s", buf) != 1)
|
|
abort ();
|
|
if (sizeof buf - 1 <= strlen (buf))
|
|
abort ();
|
|
yylval = malloc (strlen (buf) + 1);
|
|
strcpy (yylval, buf);
|
|
return 'V';
|
|
}
|
|
|
|
void
|
|
yyerror (char const *s)
|
|
{ printf ("%s\n", s);
|
|
}
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
yyin = stdin;
|
|
if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 1;
|
|
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 *yyin = NULL;
|
|
|
|
int P[] = { P1, P2 };
|
|
int O[] = { O1, O2 };
|
|
int T[] = { T1, T2, T3, T4 };
|
|
|
|
int yylex (void)
|
|
{
|
|
char inp[3];
|
|
if (fscanf (yyin, "%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[]) {
|
|
yyin = stdin;
|
|
if (argc == 2 && !(yyin = fopen (argv[1], "r"))) return 1;
|
|
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
|