# 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.
+# Copyright (C) 2002-2003, 2005-2007, 2009-2012 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 3 of the License, 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.
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
AT_BANNER([[GLR Regression Tests]])
AT_SETUP([Badly Collapsed GLR States])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr1.y],
[[/* Regression Test: Improper state compression */
/* Reported by Scott McPeak */
%{
#include <stdio.h>
#include <stdlib.h>
+#include <assert.h>
#define YYSTYPE int
static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
-int yylex (void);
-void yyerror (char const *msg);
+]AT_YYERROR_DECLARE[
+]AT_YYLEX_DECLARE[
%}
return 0;
}
+const char *input = NULL;
+
int
-main (void)
+main (int argc, const char* argv[])
{
+ assert (argc == 2);
+ input = argv[1];
return yyparse ();
}
-void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
int
yylex (void)
{
- for (;;)
- {
- int ch;
- if (feof (stdin))
- abort ();
- ch = getchar ();
- if (ch == EOF)
- return 0;
- else if (ch == 'B' || ch == 'P')
- return ch;
- }
+ return *input++;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr1.c glr-regr1.y]], 0, [],
+AT_BISON_CHECK([[-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([[./glr-regr1 BPBPB]], 0,
[[E -> 'B'
E -> 'B'
E -> E 'P' E
AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr2a.y],
[[/* Regression Test: Improper handling of embedded actions and $-N */
/* Reported by S. Eken */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
- int yylex (void);
- void yyerror (char const *);
+ #include <assert.h>
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
%}
%glr-parser
{ printf ("Variable: '%s'\n", $-1); }
%%
-
+]AT_YYERROR_DEFINE[
FILE *input;
int
{
char buf[50];
char *s;
- if (feof (stdin))
- abort ();
- switch (fscanf (input, " %1[a-z,]", buf)) {
+ assert (!feof (stdin));
+ switch (fscanf (input, " %1[a-z,]", buf))
+ {
case 1:
return buf[0];
case EOF:
}
if (fscanf (input, "%49s", buf) != 1)
return 0;
- if (sizeof buf - 1 <= strlen (buf))
- abort ();
+ assert (strlen (buf) < sizeof buf - 1);
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 ();
+ if (argc == 2 && !(input = fopen (argv[1], "r")))
+ return 3;
+ int res = yyparse ();
+ if (argc == 2 && fclose (input))
+ return 4;
+ return res;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [],
+AT_BISON_CHECK([[-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,
+AT_DATA([input1.txt],
+[[s VARIABLE_1 t v x q
+]])
+AT_PARSER_CHECK([[./glr-regr2a input1.txt]], 0,
[[Variable: 'VARIABLE_1'
-]], [])
-AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], 0,
+]])
+
+AT_DATA([input2.txt],
+[[s VARIABLE_1 , ANOTHER_VARIABLE_2 t e
+]])
+AT_PARSER_CHECK([[./glr-regr2a input2.txt]],
+0,
[[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
]])
-AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
+
+AT_DATA([input3.txt],
+[[s VARIABLE_3 t v x
+]])
+AT_PARSER_CHECK([[./glr-regr2a input3.txt]], 0,
[[Variable: 'VARIABLE_3'
-]], [])
+]])
AT_CLEANUP
AT_SETUP([Improper merging of GLR delayed action sets])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr3.y],
[[/* Regression Test: Improper merging of GLR delayed action sets. */
/* Reported by M. Rosien */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
+#include <assert.h>
static int MergeRule (int x0, int x1);
-static void yyerror (char const * s);
-int yylex (void);
+]AT_YYERROR_DECLARE[
+]AT_YYLEX_DECLARE[
#define RULE(x) (1 << (x))
%%
-static int MergeRule (int x0, int x1) {
+static int
+MergeRule (int x0, int x1)
+{
return x0 | x1;
}
+]AT_YYERROR_DEFINE[
-static void yyerror(char const * s) {
- fprintf(stderr,"error: %s\n",s);
-}
-
-FILE *input = NULL;
+FILE *input = YY_NULL;
int P[] = { P1, P2 };
int O[] = { O1, O2 };
int yylex (void)
{
char inp[3];
- if (feof (stdin))
- abort ();
+ assert (!feof (stdin));
if (fscanf (input, "%2s", inp) == EOF)
return 0;
switch (inp[0])
return BAD_CHAR;
}
-int main(int argc, char* argv[]) {
+int
+main(int argc, char* argv[])
+{
input = stdin;
- if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
- return yyparse ();
+ if (argc == 2 && !(input = fopen (argv[1], "r")))
+ return 3;
+ int res = yyparse ();
+ if (argc == 2 && fclose (input))
+ return 4;
+ return res;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [],
+AT_BISON_CHECK([[-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,
+AT_DATA([input.txt],
+[[p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2
+]])
+AT_PARSER_CHECK([[./glr-regr3 input.txt]],
+0,
[[Result: 1c04
-]], [])
+]])
AT_CLEANUP
AT_SETUP([Duplicate representation of merged trees])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr4.y],
[[
%union { char *ptr; }
#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);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
+ static char *ptrs[100];
+ static char **ptrs_next = ptrs;
%}
%%
B: 'a' { $$ = make_value ("B", "'a'"); } ;
%%
-
-static int
-yylex (void)
-{
- static char const input[] = "a";
- static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
- return input[toknum++];
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE(["a"])[
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;
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;
}
-
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr4.c glr-regr4.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr4.c glr-regr4.y]], 0, [],
[glr-regr4.y: conflicts: 1 reduce/reduce
])
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' }
]], [])
AT_SETUP([User destructor for unresolved GLR semantic value])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr5.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
%}
;
%%
-
-static int
-yylex (void)
-{
- static char const input[] = "a";
- static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
- return input[toknum++];
-}
-
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYLEX_DEFINE(["a"])[
+]AT_YYERROR_DEFINE[
int
main (void)
{
return yyparse () != 1;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr5.c glr-regr5.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr5.c glr-regr5.y]], 0, [],
[glr-regr5.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr5])
-AT_CHECK([[./glr-regr5]], 0, [],
+AT_PARSER_CHECK([[./glr-regr5]], 0, [],
[syntax is ambiguous
])
AT_SETUP([User destructor after an error during a split parse])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr6.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
%}
%glr-parser
start: 'a' | 'a' ;
%%
-
-static int
-yylex (void)
-{
- static char const input[] = "a";
- static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
- return input[toknum++];
-}
-
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE(["a"])[
int
main (void)
{
return yyparse () != 1;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr6.c glr-regr6.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr6.c glr-regr6.y]], 0, [],
[glr-regr6.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr6])
-AT_CHECK([[./glr-regr6]], 0,
+AT_PARSER_CHECK([[./glr-regr6]], 0,
[Destructor called.
],
[syntax is ambiguous
AT_SETUP([Duplicated user destructor for lookahead])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr7.y],
[[
%{
#include <stdio.h>
#include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
#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 <count> 'a'
+%union { count_node *node; }
+%type <node> 'a'
%destructor {
- if ((*$$)++)
+ if ($$->count++)
fprintf (stderr, "Destructor called on same value twice.\n");
} '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';
}
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
int
main (void)
{
- return yyparse ();
+ int status = yyparse ();
+ while (tail)
+ {
+ count_node *prev = tail->prev;
+ free (tail);
+ tail = prev;
+ }
+ return status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr7.c glr-regr7.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr7.c glr-regr7.y]], 0, [],
[glr-regr7.y: conflicts: 2 reduce/reduce
])
AT_COMPILE([glr-regr7])
-AT_CHECK([[./glr-regr7]], 2, [],
+AT_PARSER_CHECK([[./glr-regr7]], 2, [],
[memory exhausted
])
AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR])
+AT_BISON_OPTION_PUSHDEFS
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);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
%}
%token T_CONSTANT
%%
-void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
static int lexIndex;
int yylex (void)
return 0;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr8.c glr-regr8.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr8.c glr-regr8.y]], 0, [],
[glr-regr8.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr8])
-AT_CHECK([[./glr-regr8]], 0,
+AT_PARSER_CHECK([[./glr-regr8]], 0,
[empty: 9/9
1/9 - 9/9 - 13/17
],
AT_SETUP([No users destructors if stack 0 deleted])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr9.y],
[[
%{
# include <stdio.h>
# include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
# define YYSTACKEXPANDABLE 0
static int tokens = 0;
static int destructors = 0;
return 'a';
}
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
int
main (void)
{
return !exit_status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr9.c glr-regr9.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr9.c glr-regr9.y]], 0, [],
[glr-regr9.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr9])
-AT_CHECK([[./glr-regr9]], 0, [],
+AT_PARSER_CHECK([[./glr-regr9]], 0, [],
[memory exhausted
])
AT_SETUP([Corrupted semantic options if user action cuts parse])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr10.y],
[[
%{
# include <stdlib.h>
# include <stdio.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
#define GARBAGE_SIZE 50
static char garbage[GARBAGE_SIZE];
%}
;
%%
-
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
-static int
-yylex (void)
-{
- static int called;
- if (called++)
- abort ();
- return 0;
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE[
int
main (void)
return yyparse ();
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr10.c glr-regr10.y]], 0, [],
+AT_BISON_CHECK([[-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
AT_SETUP([Undesirable destructors if user action cuts parse])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr11.y],
[[
%{
# include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static int destructors = 0;
# define USE(val)
%}
%%
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
-static int
-yylex (void)
-{
- static char const input[] = "a";
- static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
- return input[toknum++];
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE(["a"])[
int
main (void)
return exit_status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr11.c glr-regr11.y]], 0, [],
+AT_BISON_CHECK([[-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
AT_SETUP([Leaked semantic values if user action cuts parse])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr12.y],
[[
%glr-parser
%{
# include <stdlib.h>
+# include <assert.h>
static int merge (YYSTYPE, YYSTYPE);
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static int parent_rhs_before_value = 0;
static int merged_value = 0;
static int parent_rhs_after_value = 0;
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 size_t toknum;
- if (! (toknum < sizeof input / sizeof *input))
- abort ();
- if (input[toknum] == PARENT_RHS_AFTER)
- parent_rhs_after_value = 1;
- return input[toknum++];
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE([{ PARENT_RHS_AFTER, 0 }],
+ [if (res == PARENT_RHS_AFTER)
+ parent_rhs_after_value = 1;])[
int
main (void)
return exit_status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr12.c glr-regr12.y]], 0, [],
+AT_BISON_CHECK([[-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
AT_SETUP([Incorrect lookahead during deterministic GLR])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr13.y],
[[
/* Tests:
%{
#include <stdio.h>
- static void yyerror (char const *);
- static int yylex (void);
+ #include <assert.h>
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static void print_lookahead (char const *);
#define USE(value)
%}
%%
-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 ();
- yylloc.first_line = yylloc.last_line = 1;
- yylloc.first_column = yylloc.last_column = toknum + 1;
- yylval.value = input[toknum] + 'A' - 'a';
- return input[toknum++];
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE(["ab"],
+ [yylval.value = res + 'A' - 'a'])[
static void
print_lookahead (char const *reduction)
return yyparse ();
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr13.c glr-regr13.y]], 0, [], [])
+AT_BISON_CHECK([[-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:
AT_SETUP([Incorrect lookahead during nondeterministic GLR])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr14.y],
[[
/* Tests:
%{
#include <stdlib.h>
#include <stdio.h>
- static void yyerror (char const *);
- static int yylex (void);
+ #include <assert.h>
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static void print_lookahead (char const *);
static char merge (union YYSTYPE, union YYSTYPE);
#define USE(value)
%%
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
+]AT_YYERROR_DEFINE[
static int
yylex (void)
{
static char const input[] = "abcdddd";
static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
+ assert (toknum < sizeof input);
yylloc.first_line = yylloc.last_line = 1;
yylloc.first_column = yylloc.last_column = toknum + 1;
yylval.value = input[toknum] + 'A' - 'a';
return yyparse ();
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr14.c glr-regr14.y]], 0, [],
+AT_BISON_CHECK([[-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:
AT_SETUP([Leaked semantic values when reporting ambiguity])
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr15.y],
[[
%glr-parser
%{
# include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static int parent_rhs_before_value = 0;
# define USE(val)
%}
ambiguity2: ;
%%
-
-static void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
-static int
-yylex (void)
-{
- static int called;
- if (called++)
- abort ();
- return 0;
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE[
int
main (void)
return exit_status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr15.c glr-regr15.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr15.c glr-regr15.y]], 0, [],
[glr-regr15.y: conflicts: 2 reduce/reduce
])
AT_COMPILE([glr-regr15])
-AT_CHECK([[./glr-regr15]], 0, [],
+AT_PARSER_CHECK([[./glr-regr15]], 0, [],
[syntax is ambiguous
])
## ------------------------------------------------------------------------- ##
AT_SETUP([Leaked lookahead after nondeterministic parse syntax error])
+
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr16.y],
[[
%glr-parser
%{
# include <stdlib.h>
- static void yyerror (char const *);
- static int yylex (void);
+# include <assert.h>
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
static int lookahead_value = 0;
# define USE(val)
%}
%%
-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++];
-}
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE(["ab"],
+ [if (res == 'b')
+ lookahead_value = 1])[
int
main (void)
return exit_status;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr16.c glr-regr16.y]], 0, [],
+AT_BISON_CHECK([[-o glr-regr16.c glr-regr16.y]], 0, [],
[glr-regr16.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr16])
-AT_CHECK([[./glr-regr16]], 0, [],
+AT_PARSER_CHECK([[./glr-regr16]], 0, [],
[syntax error
])
## ------------------------------------------------------------------------- ##
AT_SETUP([Uninitialized location when reporting ambiguity])
+
+AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations %define api.pure])
+
AT_DATA_GRAMMAR([glr-regr17.y],
[[
%glr-parser
%locations
-%pure-parser
+%define api.pure
%error-verbose
%union { int dummy; }
%{
- static void yyerror (YYLTYPE *, char const *);
- static int yylex (YYSTYPE *, YYLTYPE *);
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
%}
-%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
empty2: ;
%%
+# include <assert.h>
-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);
-}
-
+]AT_YYERROR_DEFINE[
static int
yylex (YYSTYPE *lvalp, YYLTYPE *llocp)
{
static char const input[] = "ab";
static size_t toknum;
- if (! (toknum < sizeof input))
- abort ();
+ assert (toknum < sizeof input);
lvalp->dummy = 0;
llocp->first_line = llocp->last_line = 2;
llocp->first_column = toknum + 1;
return yyparse () != 1;
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr17.c glr-regr17.y]], 0, [],
+AT_BISON_CHECK([[-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_PARSER_CHECK([[./glr-regr17]], 0, [],
+[1.1-2.2: syntax is ambiguous
])
AT_CLEANUP
## -------------------------------------------------------------##
AT_SETUP([Missed %merge type warnings when LHS type is declared later])
+
+AT_BISON_OPTION_PUSHDEFS
AT_DATA_GRAMMAR([glr-regr18.y],
[[%glr-parser
%{
#include <stdlib.h>
- static void yyerror (char const *);
- static int yylex ();
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
%}
%union {
%type <type3> sym3;
%%
-
-static void
-yyerror (char const *msg)
+]AT_YYERROR_DEFINE[
+]AT_YYLEX_DEFINE[
+int
+main (void)
{
- fprintf (stderr, "%s\n", msg);
+ return yyparse ();
}
+]])
+AT_BISON_OPTION_POPDEFS
-static int
-yylex ()
-{
- static int called;
- if (called++)
- abort ();
- return 0;
-}
+AT_BISON_CHECK([[-o glr-regr18.c glr-regr18.y]], 1, [],
+[glr-regr18.y:26.18-24: error: result type clash on merge function 'merge': <type2> != <type1>
+glr-regr18.y:25.18-24: previous declaration
+glr-regr18.y:27.13-19: error: result type clash on merge function 'merge': <type3> != <type2>
+glr-regr18.y:26.18-24: previous declaration
+])
+
+AT_CLEANUP
+
+
+## ------------------- ##
+## Ambiguity reports. ##
+## ------------------- ##
+
+AT_SETUP([Ambiguity reports])
+
+AT_BISON_OPTION_PUSHDEFS
+AT_DATA_GRAMMAR([input.y],
+[[
+%{
+ #include <stdio.h>
+ #include <stdlib.h>
+ ]AT_YYERROR_DECLARE[
+ ]AT_YYLEX_DECLARE[
+%}
+
+%debug
+%glr-parser
+%%
+start:
+ 'a' b 'c' d
+| 'a' b 'c' d
+;
+b: 'b';
+d: /* nada. */;
+%%
+]AT_YYLEX_DEFINE(["abc"])[
+]AT_YYERROR_DEFINE[
int
main (void)
{
- return yyparse ();
+ yydebug = 1;
+ return !!yyparse ();
}
]])
+AT_BISON_OPTION_POPDEFS
-AT_CHECK([[bison -o glr-regr18.c glr-regr18.y]], 1, [],
-[glr-regr18.y:28.18-24: result type clash on merge function `merge': <type2> != <type1>
-glr-regr18.y:27.18-24: previous declaration
-glr-regr18.y:29.13-19: result type clash on merge function `merge': <type3> != <type2>
-glr-regr18.y:28.18-24: previous declaration
+AT_BISON_CHECK([[-o input.c input.y]], 0, [],
+[input.y: conflicts: 1 reduce/reduce
+])
+AT_COMPILE([input])
+
+AT_PARSER_CHECK([[./input]], 1, [],
+[Starting parse
+Entering state 0
+Reading a token: Next token is token 'a' ()
+Shifting token 'a' ()
+Entering state 1
+Reading a token: Next token is token 'b' ()
+Shifting token 'b' ()
+Entering state 3
+Reducing stack 0 by rule 3 (line 25):
+ $1 = token 'b' ()
+-> $$ = nterm b ()
+Entering state 4
+Reading a token: Next token is token 'c' ()
+Shifting token 'c' ()
+Entering state 6
+Reducing stack 0 by rule 4 (line 26):
+-> $$ = nterm d ()
+Entering state 7
+Reading a token: Now at end of input.
+Stack 0 Entering state 7
+Now at end of input.
+Splitting off stack 1 from 0.
+Reduced stack 1 by rule #2; action deferred. Now in state 2.
+Stack 1 Entering state 2
+Now at end of input.
+Reduced stack 0 by rule #1; action deferred. Now in state 2.
+Merging stack 0 into stack 1.
+Stack 1 Entering state 2
+Now at end of input.
+Removing dead stacks.
+Rename stack 1 -> 0.
+On stack 0, shifting token $end ()
+Stack 0 now in state #5
+Ambiguity detected.
+Option 1,
+ start -> <Rule 1, tokens 1 .. 3>
+ 'a' <tokens 1 .. 1>
+ b <tokens 2 .. 2>
+ 'c' <tokens 3 .. 3>
+ d <empty>
+
+Option 2,
+ start -> <Rule 2, tokens 1 .. 3>
+ 'a' <tokens 1 .. 1>
+ b <tokens 2 .. 2>
+ 'c' <tokens 3 .. 3>
+ d <empty>
+
+syntax is ambiguous
+Cleanup: popping token $end ()
+Cleanup: popping unresolved nterm start ()
+Cleanup: popping nterm d ()
+Cleanup: popping token 'c' ()
+Cleanup: popping nterm b ()
+Cleanup: popping token 'a' ()
])
AT_CLEANUP
projects / bison.git / blobdiff