1 # Checking GLR Parsing: Regression Tests -*- Autotest -*-
3 # Copyright (C) 2002-2003, 2005-2007, 2009-2015, 2018-2021 Free Software
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program. If not, see <https://www.gnu.org/licenses/>.
19 AT_BANNER([[GLR Regression Tests]])
21 # You might wonder what's the point of having names different for each
22 # test case. When some endlessly loop, it is nice to see their "name"
27 # Wrap the C++ parser in a C-like function interface.
28 m4_pushdef([AT_YYPARSE_DEFINE],
33 ]AT_NAMESPACE[::]AT_PARSER_CLASS[ p;]AT_DEBUG_IF([[
34 int debug = !!getenv ("YYDEBUG");
35 p.set_debug_level (debug);]])[
41 # AT_PRINT_LOOKAHEAD_DECLARE
42 # --------------------------
43 m4_define([AT_PRINT_LOOKAHEAD_DECLARE],
46 print_lookahead (int yytoken, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
47 char const *reduction);
48 #define PRINT_LOOKAHEAD(Msg) \
49 print_lookahead (yytoken, &yylval, &yylloc, Msg)
52 print_lookahead (int yychr, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
53 char const *reduction);
54 #define PRINT_LOOKAHEAD(Msg) \
55 print_lookahead (yychar, &yylval, &yylloc, Msg)
58 # AT_PRINT_LOOKAHEAD_DEFINE
59 # -------------------------
60 m4_define([AT_PRINT_LOOKAHEAD_DEFINE],
63 print_lookahead (int yytoken, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
64 char const *reduction)
67 print_lookahead (int yychr, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
68 char const *reduction)
72 // We use -2 and 0 to avoid this warning:
74 // glr-regr13.y:114:53: error: enumeral and non-enumeral type in conditional expression [-Werror=extra]
75 // 114 | : yytoken == yy::parser::symbol_kind::S_YYEOF ? yy::parser::token::YYEOF
76 // | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
77 // 115 | : yytoken == yy::parser::yytranslate_ ('a') ? 'a'
78 // | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
79 // 116 | : yytoken == yy::parser::yytranslate_ ('b') ? 'b'
80 // | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
84 = yytoken == yy::parser::symbol_kind::S_YYEMPTY ? -2
85 : yytoken == yy::parser::symbol_kind::S_YYEOF ? 0
86 : yytoken == yy::parser::yytranslate_ ('a') ? 'a'
87 : yytoken == yy::parser::yytranslate_ ('b') ? 'b'
90 printf ("%s:\n yychar=", reduction);
91 if (yychr == ]AT_TOKEN([YYEMPTY])[)
93 else if (yychr == ]AT_TOKEN([YYEOF])[)
97 printf ("'%c', yylval='", yychr);
98 if (yylvalp->value > ' ')
99 printf ("%c", yylvalp->value);
100 printf ("', yylloc=(%d,%d),(%d,%d)",
101 yyllocp->]AT_FIRST_LINE[, yyllocp->]AT_FIRST_COLUMN[,
102 yyllocp->]AT_LAST_LINE[, yyllocp->]AT_LAST_COLUMN[);
109 ## ---------------------------- ##
110 ## Badly Collapsed GLR States. ##
111 ## ---------------------------- ##
113 m4_pushdef([AT_TEST],
114 [AT_SETUP([Badly Collapsed GLR States: $1])
116 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
117 AT_KEYWORDS([%merge])
119 AT_DATA_GRAMMAR([glr-regr1.y],
120 [[/* Regression Test: Improper state compression */
121 /* Reported by Scott McPeak */
123 %define api.value.type {int}
128 static ]AT_YYSTYPE[ exprMerge (]AT_YYSTYPE[ x0, ]AT_YYSTYPE[ x1);
139 /* -------- productions ------ */
142 StartSymbol: E { $$=0; } %merge <exprMerge>
145 E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); } %merge <exprMerge>
146 | 'B' { $$=2; printf("E -> 'B'\n"); } %merge <exprMerge>
151 /* ---------- C code ----------- */
154 static ]AT_YYSTYPE[ exprMerge (]AT_YYSTYPE[ x0, ]AT_YYSTYPE[ x1)
165 const char *input = YY_NULLPTR;
174 main (int argc, const char* argv[])
176 assert (argc == 2); (void) argc;
178 if (getenv ("YYDEBUG"))
184 AT_FULL_COMPILE([glr-regr1])
185 AT_PARSER_CHECK([[glr-regr1 BPBPB]], 0,
197 AT_BISON_OPTION_POPDEFS
201 AT_TEST([%skeleton "glr.c"])
202 AT_TEST([%skeleton "glr.cc"])
203 AT_TEST([%skeleton "glr2.cc"])
209 ## -------------------------------------------------------------- ##
210 ## Improper handling of embedded actions and $-N in GLR parsers. ##
211 ## -------------------------------------------------------------- ##
213 m4_pushdef([AT_TEST],
214 [AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers: $1])
216 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
218 AT_DATA_GRAMMAR([glr-regr2a.y],
219 [[/* Regression Test: Improper handling of embedded actions and $-N */
220 /* Reported by S. Eken */
222 %define api.value.type {char *}
243 { printf ("Variable: '%s'\n", $][2); }
246 | 's' var_list 't' 'e'
247 { printf ("Varlist: '%s'\n", $][2); free ($][2); }
248 | 's' var 't' var_printer 'x'
262 char *s = YY_CAST (char *, realloc ($][1, strlen ($][1) + 1 + strlen ($][3) + 1));
271 { printf ("Variable: '%s'\n", $-1); }
281 assert (!feof (stdin));
282 switch (fscanf (input, " %1[a-z,]", buf))
289 if (fscanf (input, "%49s", buf) != 1)
294 assert (strlen (buf) < sizeof buf - 1);
295 s = YY_CAST (char *, malloc (strlen (buf) + 1));
307 main (int argc, char **argv)
311 if (argc == 2 && !(input = fopen (argv[1], "r")))
313 if (getenv ("YYDEBUG"))
316 if (argc == 2 && fclose (input))
322 AT_FULL_COMPILE([glr-regr2a],,,,[-rall])
324 AT_DATA([input1.txt],
325 [[s VARIABLE_1 t v x q
327 AT_PARSER_CHECK([[glr-regr2a input1.txt]], 0,
328 [[Variable: 'VARIABLE_1'
331 AT_DATA([input2.txt],
332 [[s VARIABLE_1 , ANOTHER_VARIABLE_2 t e
334 AT_PARSER_CHECK([[glr-regr2a input2.txt]],
336 [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
339 AT_DATA([input3.txt],
342 AT_PARSER_CHECK([[glr-regr2a input3.txt]], 0,
343 [[Variable: 'VARIABLE_3'
346 AT_BISON_OPTION_POPDEFS
350 AT_TEST([%skeleton "glr.c"])
351 AT_TEST([%skeleton "glr.cc"])
352 AT_TEST([%skeleton "glr2.cc"])
357 ## --------------------------------------------- ##
358 ## Improper merging of GLR delayed action sets. ##
359 ## --------------------------------------------- ##
361 m4_pushdef([AT_TEST],
362 [AT_SETUP([Improper merging of GLR delayed action sets: $1])
363 AT_KEYWORDS([%merge])
365 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
367 AT_DATA_GRAMMAR([glr-regr3.y],
368 [[/* Regression Test: Improper merging of GLR delayed action sets. */
369 /* Reported by M. Rosien */
375 static int MergeRule (int x0, int x1);
379 #define RULE(x) (1 << (x))
391 %token P1 P2 T1 T2 T3 T4 O1 O2
395 S : P1 T4 O2 NT6 P2 { printf ("Result: %x\n", $][4); }
398 NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); } %merge<MergeRule>
401 NT2 : NT1 { $$ = RULE(3); } %merge<MergeRule>
402 | P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
405 NT3 : T3 { $$ = RULE(5); } %merge<MergeRule>
406 | P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
409 NT4 : NT3 { $$ = RULE(7); } %merge<MergeRule>
410 | NT2 { $$ = RULE(8); } %merge<MergeRule>
411 | P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
414 NT5 : NT4 { $$ = RULE(10); } %merge<MergeRule>
417 NT6 : P1 NT1 O1 T3 P2 { $$ = RULE(11) | $][2; } %merge<MergeRule>
418 | NT5 { $$ = RULE(12) | $][1; } %merge<MergeRule>
424 MergeRule (int x0, int x1)
430 FILE *input = YY_NULLPTR;
432 int P[] = { ]AT_TOKEN([P1])[, ]AT_TOKEN([P2])[ };
433 int O[] = { ]AT_TOKEN([O1])[, ]AT_TOKEN([O2])[ };
434 int T[] = { ]AT_TOKEN([T1])[, ]AT_TOKEN([T2])[, ]AT_TOKEN([T3])[, ]AT_TOKEN([T4])[ };
440 assert (!feof (stdin));
441 if (fscanf (input, "%2s", inp) == EOF)
445 case 'p': return P[inp[1] - '1'];
446 case 't': return T[inp[1] - '1'];
447 case 'o': return O[inp[1] - '1'];
449 return ]AT_TOKEN([BAD_CHAR])[;
455 main (int argc, char* argv[])
459 if (argc == 2 && !(input = fopen (argv[1], "r")))
461 if (getenv ("YYDEBUG"))
464 if (argc == 2 && fclose (input))
470 AT_FULL_COMPILE([glr-regr3],,,,[-rall])
473 [[p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2
475 AT_PARSER_CHECK([[glr-regr3 input.txt]],
480 AT_BISON_OPTION_POPDEFS
484 AT_TEST([%skeleton "glr.c"])
485 AT_TEST([%skeleton "glr.cc"])
486 AT_TEST([%skeleton "glr2.cc"])
491 ## ------------------------------------------------------------ ##
492 ## Duplicate representation of merged trees. See ##
493 ## <https://lists.gnu.org/r/help-bison/2005-07/msg00013.html>. ##
494 ## ------------------------------------------------------------ ##
496 m4_pushdef([AT_TEST],
497 [AT_SETUP([Duplicate representation of merged trees: $1])
498 AT_KEYWORDS([%merge])
500 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
502 AT_DATA_GRAMMAR([glr-regr4.y],
506 %type <]AT_VALUE_UNION_IF([char*], [ptr])[> S A A1 A2 B
513 static char *merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
514 static char *make_value (char const *, char const *);
517 static char *ptrs[100];
518 static char **ptrs_next = ptrs;
523 tree: S { printf ("%s\n", $][1); } ;
525 S : A %merge<merge> { $$ = make_value ("S", $][1); }
526 | B %merge<merge> { $$ = make_value ("S", $][1); }
529 A : A1 %merge<merge> { $$ = make_value ("A", $][1); }
530 | A2 %merge<merge> { $$ = make_value ("A", $][1); }
533 A1: 'a' { $$ = make_value ("A1", "'a'"); } ;
534 A2: 'a' { $$ = make_value ("A2", "'a'"); } ;
535 B: 'a' { $$ = make_value ("B", "'a'"); } ;
540 ]AT_YYLEX_DEFINE(["a"])[
546 if (getenv ("YYDEBUG"))
549 while (ptrs_next != ptrs)
555 make_value (char const *parent, char const *child)
557 char const format[] = "%s <- %s";
558 char *value = *ptrs_next++ =
559 YY_CAST (char *, malloc (strlen (parent) + strlen (child) + sizeof format));
560 sprintf (value, format, parent, child);
565 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
567 char const format[] = "merge{ %s and %s }";]AT_VALUE_UNION_IF([[
568 char *res = *ptrs_next++ =
569 YY_CAST (char *, malloc (strlen (s1.S) + strlen (s2.S) + sizeof format));
570 sprintf (res, format, s1.S, s2.S);]], [[
571 char *res = *ptrs_next++ =
572 YY_CAST (char *, malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format));
573 sprintf (res, format, s1.ptr, s2.ptr);]])[
578 AT_FULL_COMPILE([glr-regr4],,,,[-rall])
580 AT_PARSER_CHECK([[glr-regr4]], 0,
581 [[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
584 AT_BISON_OPTION_POPDEFS
588 AT_TEST([%union { char *ptr; } %skeleton "glr.c"])
589 AT_TEST([%union { char *ptr; } %skeleton "glr.cc"])
590 AT_TEST([%union { char *ptr; } %skeleton "glr2.cc"])
592 AT_TEST([%define api.value.type union %skeleton "glr.c"])
593 AT_TEST([%define api.value.type union %skeleton "glr.cc"])
594 AT_TEST([%define api.value.type union %skeleton "glr2.cc"])
599 ## --------------------------------------------------------------- ##
600 ## User destructor for unresolved GLR semantic value. See ##
601 ## <https://lists.gnu.org/r/bison-patches/2005-08/msg00016.html>. ##
602 ## --------------------------------------------------------------- ##
604 m4_pushdef([AT_TEST],
605 [AT_SETUP([User destructor for unresolved GLR semantic value: $1])
607 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
608 AT_DATA_GRAMMAR([glr-regr5.y],
613 enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
623 %union { int value; }
627 if ($$ != MAGIC_VALUE)
629 fprintf (stderr, "Bad destructor call.\n");
637 'a' { $$ = MAGIC_VALUE; }
638 | 'a' { $$ = MAGIC_VALUE; }
643 ]AT_YYLEX_DEFINE(["a"])[
647 AT_FULL_COMPILE([glr-regr5],,,, [-rall])
649 AT_PARSER_CHECK([[glr-regr5]], 1, [],
652 start -> <Rule 1, tokens 1 .. 1>
656 start -> <Rule 2, tokens 1 .. 1>
662 AT_BISON_OPTION_POPDEFS
666 AT_TEST([%skeleton "glr.c"])
667 AT_TEST([%skeleton "glr.cc"])
668 AT_TEST([%skeleton "glr2.cc"])
674 ## --------------------------------------------------------------- ##
675 ## User destructor after an error during a split parse. See ##
676 ## <https://lists.gnu.org/r/bison-patches/2005-08/msg00029.html>. ##
677 ## --------------------------------------------------------------- ##
679 m4_pushdef([AT_TEST],
680 [AT_SETUP([User destructor after an error during a split parse: $1])
682 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
683 AT_DATA_GRAMMAR([glr-regr6.y],
696 %union { int value; }
700 printf ("Destructor called.\n");
709 ]AT_YYLEX_DEFINE(["a"])[
713 AT_FULL_COMPILE([glr-regr6],,,, [-rall])
715 AT_PARSER_CHECK([[glr-regr6]], 1,
720 start -> <Rule 1, tokens 1 .. 1>
724 start -> <Rule 2, tokens 1 .. 1>
730 AT_BISON_OPTION_POPDEFS
734 AT_TEST([%skeleton "glr.c"])
735 AT_TEST([%skeleton "glr.cc"])
736 AT_TEST([%skeleton "glr2.cc"])
742 ## --------------------------------------------------------------- ##
743 ## Duplicated user destructor for lookahead. See ##
744 ## <https://lists.gnu.org/r/bison-patches/2005-08/msg00035.html>. ##
745 ## --------------------------------------------------------------- ##
747 m4_pushdef([AT_TEST],
748 [AT_SETUP([Duplicated user destructor for lookahead: $1])
750 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
752 AT_DATA_GRAMMAR([glr-regr7.y],
755 typedef struct count_node {
757 struct count_node *prev;
764 #define YYSTACKEXPANDABLE 0
765 static count_node *tail;
774 %union { count_node *node; }
779 fprintf (stderr, "Destructor called on same value twice.\n");
797 ]AT_VAL[.node = YY_CAST (count_node*, malloc (sizeof *]AT_VAL[.node));
800 fprintf (stderr, "Test inconclusive.\n");
803 ]AT_VAL[.node->count = 0;
804 ]AT_VAL[.node->prev = tail;
805 tail = ]AT_VAL[.node;
816 if (getenv ("YYDEBUG"))
821 count_node *prev = tail->prev;
829 AT_FULL_COMPILE([glr-regr7],,,, [-rall])
831 AT_PARSER_CHECK([[glr-regr7]], 2, [],
835 AT_BISON_OPTION_POPDEFS
839 AT_TEST([%skeleton "glr.c"])
840 AT_TEST([%skeleton "glr.cc"])
841 AT_TEST([%skeleton "glr2.cc"])
847 ## ------------------------------------------------------------------------- ##
848 ## Incorrect default location for empty right-hand sides. Adapted from bug ##
849 ## report by Claudia Hermann. ##
850 ## See https://lists.gnu.org/r/bug-bison/2005-10/msg00069.html and ##
851 ## https://lists.gnu.org/r/bug-bison/2005-10/msg00072.html ##
852 ## ------------------------------------------------------------------------- ##
854 m4_pushdef([AT_TEST],
855 [AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR: $1])
857 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
859 AT_DATA_GRAMMAR([glr-regr8.y],
879 PortClause : T_PORT InterfaceDeclaration T_PORT
880 { printf("%d/%d - %d/%d - %d/%d\n",
881 @1.]AT_FIRST_COLUMN[, @1.]AT_LAST_COLUMN[,
882 @2.]AT_FIRST_COLUMN[, @2.]AT_LAST_COLUMN[,
883 @3.]AT_FIRST_COLUMN[, @3.]AT_LAST_COLUMN[); }
886 InterfaceDeclaration : OptConstantWord %dprec 1
887 | OptSignalWord %dprec 2
890 OptConstantWord : %empty
894 OptSignalWord : %empty
895 { printf("empty: %d/%d\n", @$.]AT_FIRST_COLUMN[, @$.]AT_LAST_COLUMN[); }
913 ]AT_LOC_FIRST_COLUMN[ = 1;
914 ]AT_LOC_LAST_COLUMN[ = 9;
915 return ]AT_TOKEN([T_PORT])[;
917 ]AT_LOC_FIRST_COLUMN[ = 13;
918 ]AT_LOC_LAST_COLUMN[ = 17;
919 return ]AT_TOKEN([T])[_PORT;
928 AT_FULL_COMPILE([glr-regr8],,,, [-rall])
930 AT_PARSER_CHECK([[glr-regr8]], 0,
936 AT_BISON_OPTION_POPDEFS
940 AT_TEST([%skeleton "glr.c"])
941 AT_TEST([%skeleton "glr.cc"])
942 AT_TEST([%skeleton "glr2.cc"])
948 ## --------------------------------------------------------------- ##
949 ## No users destructors if stack 0 deleted. See ##
950 ## <https://lists.gnu.org/r/bison-patches/2005-09/msg00109.html>. ##
951 ## --------------------------------------------------------------- ##
953 m4_pushdef([AT_TEST],
954 [AT_SETUP([No users destructors if stack 0 deleted: $1])
956 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
957 AT_DATA_GRAMMAR([glr-regr9.y],
962 # define YYSTACKEXPANDABLE 0
963 static int tokens = 0;
964 static int destructors = 0;
974 %union { int dummy; }
984 ambig0 'a' { destructors += 2; USE ($][2); }
985 | ambig1 start { destructors += 1; }
986 | ambig2 start { destructors += 1; }
1009 if (getenv ("YYDEBUG"))
1011 status = yyparse ();
1012 if (tokens != destructors)
1014 fprintf (stderr, "Tokens = %d, Destructors = %d\n", tokens, destructors);
1021 AT_FULL_COMPILE([glr-regr9],,,, [-rall])
1023 # Exit 2: memory exhausted.
1024 AT_PARSER_CHECK([[glr-regr9]], 2, [],
1028 AT_BISON_OPTION_POPDEFS
1032 AT_TEST([%skeleton "glr.c"])
1033 AT_TEST([%skeleton "glr.cc"])
1034 AT_TEST([%skeleton "glr2.cc"])
1036 m4_popdef([AT_TEST])
1040 ## ------------------------------------------------------ ##
1041 ## Corrupted semantic options if user action cuts parse. ##
1042 ## ------------------------------------------------------ ##
1044 m4_pushdef([AT_TEST],
1045 [AT_SETUP([Corrupted semantic options if user action cuts parse: $1])
1047 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1048 AT_DATA_GRAMMAR([glr-regr10.y],
1051 ]AT_YYERROR_DECLARE[
1053 #define GARBAGE_SIZE 50
1054 static char garbage[GARBAGE_SIZE];
1057 %define parse.assert
1063 %union { char *ptr; }
1069 %dprec 2 { $$ = garbage; YYACCEPT; }
1070 | %dprec 1 { $$ = garbage; YYACCEPT; }
1082 for (i = 0; i < GARBAGE_SIZE; i+=1)
1084 if (getenv ("YYDEBUG"))
1090 AT_FULL_COMPILE([glr-regr10],,,, [-rall])
1092 AT_PARSER_CHECK([[glr-regr10]], 0, [], [])
1094 AT_BISON_OPTION_POPDEFS
1098 AT_TEST([%skeleton "glr.c"])
1099 AT_TEST([%skeleton "glr.cc"])
1100 AT_TEST([%skeleton "glr2.cc"])
1102 m4_popdef([AT_TEST])
1106 ## --------------------------------------------------- ##
1107 ## Undesirable destructors if user action cuts parse. ##
1108 ## --------------------------------------------------- ##
1110 m4_pushdef([AT_TEST],
1111 [AT_SETUP([Undesirable destructors if user action cuts parse: $1])
1113 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1114 AT_DATA_GRAMMAR([glr-regr11.y],
1117 ]AT_YYERROR_DECLARE[
1119 static int destructors = 0;
1123 %define parse.assert
1129 %union { int dummy; }
1131 %destructor { destructors += 1; } 'a'
1136 'a' %dprec 2 { USE ($][1); destructors += 1; YYACCEPT; }
1137 | 'a' %dprec 1 { USE ($][1); destructors += 1; YYACCEPT; }
1144 ]AT_YYLEX_DEFINE(["a"])[
1150 if (getenv ("YYDEBUG"))
1152 status = yyparse ();
1153 if (destructors != 1)
1155 fprintf (stderr, "Destructor calls: %d\n", destructors);
1162 AT_FULL_COMPILE([glr-regr11],,,, [-rall])
1164 AT_PARSER_CHECK([[glr-regr11]], 0, [], [])
1166 AT_BISON_OPTION_POPDEFS
1170 AT_TEST([%skeleton "glr.c"])
1171 AT_TEST([%skeleton "glr.cc"])
1172 AT_TEST([%skeleton "glr2.cc"])
1174 m4_popdef([AT_TEST])
1178 ## -------------------------------------------------- ##
1179 ## Leaked semantic values if user action cuts parse. ##
1180 ## -------------------------------------------------- ##
1182 m4_pushdef([AT_TEST],
1183 [AT_SETUP([Leaked semantic values if user action cuts parse: $1])
1184 AT_KEYWORDS([%merge])
1186 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1187 AT_DATA_GRAMMAR([glr-regr12.y],
1189 %define parse.assert
1196 %union { int dummy; }
1197 %token PARENT_RHS_AFTER
1198 %type <dummy> parent_rhs_before merged PARENT_RHS_AFTER
1199 %destructor { parent_rhs_before_value = 0; } parent_rhs_before
1200 %destructor { merged_value = 0; } merged
1201 %destructor { parent_rhs_after_value = 0; } PARENT_RHS_AFTER
1204 # include <assert.h>
1205 static int merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
1206 ]AT_YYERROR_DECLARE[
1208 static int parent_rhs_before_value = 0;
1209 static int merged_value = 0;
1210 static int parent_rhs_after_value = 0;
1224 parent_rhs_after_value = 0;
1229 parent_rhs_before merged PARENT_RHS_AFTER {
1230 USE (($][1, $][2, $][3));
1231 parent_rhs_before_value = 0;
1233 parent_rhs_after_value = 0;
1240 parent_rhs_before_value = 1;
1249 | cut %merge<merge> {
1255 cut: { YYACCEPT; } ;
1260 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
1263 return s1.dummy + s2.dummy;
1268 ]AT_YYLEX_DEFINE([{ ]AT_TOKEN([PARENT_RHS_AFTER])[, 0 }],
1269 [if (res == ]AT_TOKEN([PARENT_RHS_AFTER])[)
1270 parent_rhs_after_value = 1;])[
1276 if (getenv ("YYDEBUG"))
1278 status = yyparse ();
1279 if (parent_rhs_before_value)
1281 fprintf (stderr, "'parent_rhs_before' destructor not called.\n");
1286 fprintf (stderr, "'merged' destructor not called.\n");
1289 if (parent_rhs_after_value)
1291 fprintf (stderr, "'PARENT_RHS_AFTER' destructor not called.\n");
1298 AT_FULL_COMPILE([glr-regr12],,,, [-rall])
1300 AT_PARSER_CHECK([[glr-regr12]], 0, [], [])
1302 AT_BISON_OPTION_POPDEFS
1306 AT_TEST([%skeleton "glr.c"])
1307 AT_TEST([%skeleton "glr.cc"])
1308 AT_TEST([%skeleton "glr2.cc"])
1310 m4_popdef([AT_TEST])
1314 ## --------------------------------------------------------------- ##
1315 ## Incorrect lookahead during deterministic GLR. See ##
1316 ## <https://lists.gnu.org/r/help-bison/2005-07/msg00017.html> and ##
1317 ## <https://lists.gnu.org/r/bison-patches/2006-01/msg00060.html>. ##
1318 ## --------------------------------------------------------------- ##
1320 m4_pushdef([AT_TEST],
1321 [AT_SETUP([Incorrect lookahead during deterministic GLR: $1])
1323 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1324 AT_DATA_GRAMMAR([glr-regr13.y],
1327 - Defaulted state with initial yychar: yychar == YYEMPTY.
1328 - Nondefaulted state: yychar != YYEMPTY.
1329 - Defaulted state after lookahead: yychar != YYEMPTY.
1330 - Defaulted state after shift: yychar == YYEMPTY.
1331 - User action changing the lookahead. */
1335 ]AT_YYERROR_DECLARE[
1337 ]AT_PRINT_LOOKAHEAD_DECLARE[
1341 %define parse.assert
1347 %union { char value; }
1348 %type <value> 'a' 'b'
1353 defstate_init defstate_shift 'b' change_lookahead 'a'
1356 PRINT_LOOKAHEAD ("start <- defstate_init defstate_shift 'b'");
1363 PRINT_LOOKAHEAD ("defstate_init <- empty string");
1368 nondefstate defstate_look 'a'
1371 PRINT_LOOKAHEAD ("defstate_shift <- nondefstate defstate_look 'a'");
1378 PRINT_LOOKAHEAD ("defstate_look <- empty string");
1385 PRINT_LOOKAHEAD ("nondefstate <- empty string");
1390 PRINT_LOOKAHEAD ("nondefstate <- 'b'");
1397 ]AT_GLR2_CC_IF([[yytoken = yy::parser::yytranslate_ ('a')]], [[yychar = 'a']])[;
1405 ]AT_PRINT_LOOKAHEAD_DEFINE[
1406 ]AT_YYLEX_DEFINE(["ab"],
1407 []AT_VAL[.value = YY_CAST (char, res + 'A' - 'a')])[
1413 yychar = '#'; /* Not a token in the grammar. */
1416 if (getenv ("YYDEBUG"))
1422 AT_FULL_COMPILE([glr-regr13],,,, [-rall])
1424 AT_PARSER_CHECK([[glr-regr13]], 0,
1425 [defstate_init <- empty string:
1427 nondefstate <- empty string:
1428 yychar='a', yylval='A', yylloc=(1,1),(1,1)
1429 defstate_look <- empty string:
1430 yychar='a', yylval='A', yylloc=(1,1),(1,1)
1431 defstate_shift <- nondefstate defstate_look 'a':
1433 start <- defstate_init defstate_shift 'b':
1437 AT_BISON_OPTION_POPDEFS
1441 AT_TEST([%skeleton "glr.c"])
1442 AT_TEST([%skeleton "glr.cc"])
1443 AT_TEST([%skeleton "glr2.cc"])
1445 m4_popdef([AT_TEST])
1449 ## ------------------------------------------------- ##
1450 ## Incorrect lookahead during nondeterministic GLR. ##
1451 ## ------------------------------------------------- ##
1453 m4_pushdef([AT_TEST],
1454 [AT_SETUP([Incorrect lookahead during nondeterministic GLR: $1])
1455 AT_KEYWORDS([%merge])
1457 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1459 AT_DATA_GRAMMAR([glr-regr14.y],
1462 - Conflicting actions (split-off parse, which copies lookahead need,
1463 which is necessarily yytrue) and nonconflicting actions (non-split-off
1464 parse) for nondefaulted state: yychar != YYEMPTY.
1465 - Merged deferred actions (lookahead need and RHS from different stack
1466 than the target state) and nonmerged deferred actions (same stack).
1467 - Defaulted state after lookahead: yychar != YYEMPTY.
1468 - Defaulted state after shift: yychar == YYEMPTY.
1469 - yychar != YYEMPTY but lookahead need is yyfalse (a previous stack has
1470 seen the lookahead but current stack has not).
1471 - Exceeding stack capacity (stack explosion), and thus reallocating
1472 lookahead need array.
1473 Note that it does not seem possible to see the initial yychar value during
1474 nondeterministic operation since:
1475 - In order to preserve the initial yychar, only defaulted states may be
1477 - If only defaulted states are entered, there are no conflicts, so
1478 nondeterministic operation does not start. */
1480 %define parse.assert
1482 %type <value> 'a' 'b' 'c' 'd' stack_explosion
1489 %union { char value; }
1493 ]AT_YYERROR_DECLARE[
1495 ]AT_PRINT_LOOKAHEAD_DECLARE[
1496 static char merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
1503 merge 'c' stack_explosion
1505 USE ($][2); USE ($][3);
1506 PRINT_LOOKAHEAD ("start <- merge 'c' stack_explosion");
1510 /* When merging the 2 deferred actions, the lookahead needs are different. */
1512 nonconflict1 'a' 'b' nonconflict2 %dprec 1
1514 USE ($][2); USE ($][3);
1515 PRINT_LOOKAHEAD ("merge <- nonconflict1 'a' 'b' nonconflict2");
1517 | conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2
1519 USE ($][3); USE ($][5);
1520 PRINT_LOOKAHEAD ("merge <- conflict defstate_look 'a' nonconflict2 'b'"
1528 PRINT_LOOKAHEAD ("nonconflict1 <- empty string");
1535 PRINT_LOOKAHEAD ("nonconflict2 <- empty string");
1540 PRINT_LOOKAHEAD ("nonconflict2 <- 'a'");
1547 PRINT_LOOKAHEAD ("conflict <- empty string");
1554 PRINT_LOOKAHEAD ("defstate_look <- empty string");
1558 /* yychar != YYEMPTY but lookahead need is yyfalse. */
1562 PRINT_LOOKAHEAD ("defstate_shift <- empty string");
1567 %empty { $$ = '\0'; }
1568 | alt1 stack_explosion %merge<merge> { $$ = $][2; }
1569 | alt2 stack_explosion %merge<merge> { $$ = $][2; }
1570 | alt3 stack_explosion %merge<merge> { $$ = $][2; }
1578 [[yytoken != yy::parser::yytranslate_ ('d') && yytoken != symbol_kind::S_YYEOF]],
1579 [[yychar != 'd' && yychar != ]AT_GLR2_CC_IF([token::])[YYEOF]])[)
1580 PRINT_LOOKAHEAD ("Incorrect lookahead during stack explosion.");
1589 [[yytoken != yy::parser::yytranslate_ ('d') && yytoken != symbol_kind::S_YYEOF]],
1590 [[yychar != 'd' && yychar != ]AT_GLR2_CC_IF([token::])[YYEOF]])[)
1591 PRINT_LOOKAHEAD ("Incorrect lookahead during stack explosion.");
1600 [[yytoken != yy::parser::yytranslate_ ('d') && yytoken != symbol_kind::S_YYEOF]],
1601 [[yychar != 'd' && yychar != ]AT_GLR2_CC_IF([token::])[YYEOF]])[)
1602 PRINT_LOOKAHEAD ("Incorrect lookahead during stack explosion.");
1610 [[yytoken != symbol_kind::S_YYEMPTY]],
1611 [[yychar != ]AT_GLR2_CC_IF([token::])[YYEMPTY]])[)
1612 PRINT_LOOKAHEAD ("Found lookahead where shouldn't during stack explosion.");
1620 ]AT_PRINT_LOOKAHEAD_DEFINE[
1622 ]AT_YYLEX_PROTOTYPE[
1625 static char const input[] = "abcdddd";
1626 static int toknum = 0;
1627 assert (toknum < YY_CAST (int, sizeof input));
1628 ]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1;
1629 ]AT_LOC_FIRST_COLUMN[ = ]AT_LOC_LAST_COLUMN[ = toknum + 1;
1630 ]AT_VAL[.value = YY_CAST (char, input[toknum] + 'A' - 'a');
1631 return input[toknum++];
1635 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
1637 return YY_CAST (char, s1.value + s2.value);
1644 yychar = '#'; /* Not a token in the grammar. */
1647 if (getenv ("YYDEBUG"))
1653 AT_FULL_COMPILE([glr-regr14],,,, [-rall])
1655 AT_PARSER_CHECK([[glr-regr14]], 0,
1656 [conflict <- empty string:
1657 yychar='a', yylval='A', yylloc=(1,1),(1,1)
1658 defstate_look <- empty string:
1659 yychar='a', yylval='A', yylloc=(1,1),(1,1)
1660 nonconflict2 <- empty string:
1661 yychar='b', yylval='B', yylloc=(1,2),(1,2)
1662 defstate_shift <- empty string:
1664 merge <- conflict defstate_look 'a' nonconflict2 'b' defstate_shift:
1666 start <- merge 'c' stack_explosion:
1670 AT_BISON_OPTION_POPDEFS
1674 AT_TEST([%skeleton "glr.c"])
1675 AT_TEST([%skeleton "glr.cc"])
1676 AT_TEST([%skeleton "glr2.cc"])
1678 m4_popdef([AT_TEST])
1682 ## ------------------------------------------------- ##
1683 ## Leaked semantic values when reporting ambiguity. ##
1684 ## ------------------------------------------------- ##
1686 m4_pushdef([AT_TEST],
1687 [AT_SETUP([Leaked semantic values when reporting ambiguity: $1])
1689 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1691 AT_DATA_GRAMMAR([glr-regr15.y],
1693 %define parse.assert
1700 %destructor { parent_rhs_before_value = 0; } parent_rhs_before
1703 ]AT_YYERROR_DECLARE[
1705 static int parent_rhs_before_value = 0;
1716 /* This stack must be merged into the other stacks *last* (added at the
1717 beginning of the semantic options list) so that yyparse will choose to clean
1718 it up rather than the tree for which some semantic actions have been
1719 performed. Thus, if yyreportAmbiguity longjmp's to yyparse, the values from
1720 those other trees are not cleaned up. */
1724 parent_rhs_before ambiguity {
1726 parent_rhs_before_value = 0;
1733 parent_rhs_before_value = 1;
1737 ambiguity: ambiguity1 | ambiguity2 ;
1750 if (getenv ("YYDEBUG"))
1752 status = yyparse () != 1;
1753 if (parent_rhs_before_value)
1755 fprintf (stderr, "'parent_rhs_before' destructor not called.\n");
1762 AT_FULL_COMPILE([glr-regr15],,,, [-rall])
1764 AT_PARSER_CHECK([[glr-regr15]], 0, [],
1765 [Ambiguity detected.
1767 ambiguity -> <Rule 6, empty>
1768 ambiguity1 -> <Rule 8, empty>
1771 ambiguity -> <Rule 7, empty>
1772 ambiguity2 -> <Rule 9, empty>
1777 AT_BISON_OPTION_POPDEFS
1781 AT_TEST([%skeleton "glr.c"])
1782 AT_TEST([%skeleton "glr.cc"])
1783 AT_TEST([%skeleton "glr2.cc"])
1785 m4_popdef([AT_TEST])
1789 ## ------------------------------------------------------------ ##
1790 ## Leaked lookahead after nondeterministic parse syntax error. ##
1791 ## ------------------------------------------------------------ ##
1793 m4_pushdef([AT_TEST],
1794 [AT_SETUP([Leaked lookahead after nondeterministic parse syntax error: $1])
1796 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1797 AT_DATA_GRAMMAR([glr-regr16.y],
1799 %define parse.assert
1806 %destructor { lookahead_value = 0; } 'b'
1809 # include <assert.h>
1810 ]AT_YYERROR_DECLARE[
1812 static int lookahead_value = 0;
1818 start: alt1 'a' | alt2 'a' ;
1826 ]AT_YYLEX_DEFINE(["ab"],
1828 lookahead_value = 1])[
1834 if (getenv ("YYDEBUG"))
1836 status = yyparse () != 1;
1837 if (lookahead_value)
1839 fprintf (stderr, "Lookahead destructor not called.\n");
1846 AT_FULL_COMPILE([glr-regr16],,,, [-rall])
1848 AT_PARSER_CHECK([[glr-regr16]], 0, [],
1852 AT_BISON_OPTION_POPDEFS
1856 AT_TEST([%skeleton "glr.c"])
1857 AT_TEST([%skeleton "glr.cc"])
1858 AT_TEST([%skeleton "glr2.cc"])
1860 m4_popdef([AT_TEST])
1864 ## ------------------------------------------------- ##
1865 ## Uninitialized location when reporting ambiguity. ##
1866 ## ------------------------------------------------- ##
1868 m4_pushdef([AT_TEST],
1869 [AT_SETUP([Uninitialized location when reporting ambiguity: $1])
1871 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1873 AT_DATA_GRAMMAR([glr-regr17.y],
1875 %define parse.assert
1882 %define parse.error verbose
1884 %union { int dummy; }
1887 ]AT_YYERROR_DECLARE[
1893 /* Tests the case of an empty RHS that has inherited the location of the
1894 previous nonterminal, which is unresolved. That location is reported as the
1895 last position of the ambiguity. */
1896 start: ambig1 empty1 | ambig2 empty2 ;
1898 /* Tests multiple levels of yyresolveLocations recursion. */
1899 ambig1: sub_ambig1 | sub_ambig2 ;
1900 ambig2: sub_ambig1 | sub_ambig2 ;
1902 /* Tests the case of a non-empty RHS as well as the case of an empty RHS that
1903 has inherited the initial location. The empty RHS's location is reported as
1904 the first position in the ambiguity. */
1905 sub_ambig1: empty1 'a' 'b' ;
1906 sub_ambig2: empty2 'a' 'b' ;
1911 # include <assert.h>
1915 ]AT_YYLEX_PROTOTYPE[
1917 static char const input[] = "ab";
1918 static int toknum = 0;
1920 assert (toknum < YY_CAST (int, sizeof input));
1922 ]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 2;
1923 ]AT_LOC_FIRST_COLUMN[ = toknum + 1;
1924 ]AT_LOC_LAST_COLUMN[ = ]AT_LOC_FIRST_COLUMN[ + 1;
1925 return input[toknum++];
1931 AT_FULL_COMPILE([glr-regr17],,,, [-rall])
1933 AT_PARSER_CHECK([[glr-regr17]], 1, [],
1934 [Ambiguity detected.
1936 start -> <Rule 1, tokens 1 .. 2>
1937 ambig1 -> <Rule 4, tokens 1 .. 2>
1938 sub_ambig2 -> <Rule 8, tokens 1 .. 2>
1939 empty2 -> <Rule 10, empty>
1942 empty1 -> <Rule 9, empty>
1945 start -> <Rule 2, tokens 1 .. 2>
1946 ambig2 -> <Rule 6, tokens 1 .. 2>
1947 sub_ambig2 -> <Rule 8, tokens 1 .. 2>
1948 empty2 -> <Rule 10, empty>
1951 empty2 -> <Rule 10, empty>
1953 1.1-2.2: syntax is ambiguous
1956 AT_BISON_OPTION_POPDEFS
1960 AT_TEST([%skeleton "glr.c" %define api.pure])
1961 AT_TEST([%skeleton "glr.cc"])
1962 AT_TEST([%skeleton "glr2.cc"])
1964 m4_popdef([AT_TEST])
1968 ## ------------------------------------------------------------- ##
1969 ## Missed %merge type warnings when LHS type is declared later. ##
1970 ## ------------------------------------------------------------- ##
1972 m4_pushdef([AT_TEST],
1973 [AT_SETUP([Missed %merge type warnings when LHS type is declared later: $1])
1974 AT_KEYWORDS([%merge])
1976 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1977 AT_DATA_GRAMMAR([glr-regr18.y],
1978 [[%define parse.assert
1984 ]AT_YYERROR_DECLARE[
1994 // In C++ we need one more line for the line numbers to match.
1998 sym1: sym2 %merge<merge> { $$ = $][1; } ;
1999 sym2: sym3 %merge<merge> { $$ = $][1; } ;
2000 sym3: %merge<merge> { $$ = 0; } ;
2012 AT_BISON_CHECK([[-o glr-regr18.c -rall -fcaret glr-regr18.y]], 1, [],
2013 [[glr-regr18.y:30.18-24: error: result type clash on merge function 'merge': <type2> != <type1>
2014 30 | sym2: sym3 %merge<merge> { $$ = $][1; } ;
2016 glr-regr18.y:29.18-24: note: previous declaration
2017 29 | sym1: sym2 %merge<merge> { $$ = $][1; } ;
2019 glr-regr18.y:31.13-19: error: result type clash on merge function 'merge': <type3> != <type1>
2020 31 | sym3: %merge<merge> { $$ = 0; } ;
2022 glr-regr18.y:29.18-24: note: previous declaration
2023 29 | sym1: sym2 %merge<merge> { $$ = $][1; } ;
2027 AT_BISON_OPTION_POPDEFS
2031 AT_TEST([%skeleton "glr.c"])
2032 AT_TEST([%skeleton "glr.cc"])
2033 AT_TEST([%skeleton "glr2.cc"])
2035 m4_popdef([AT_TEST])
2039 ## ------------------- ##
2040 ## Ambiguity reports. ##
2041 ## ------------------- ##
2043 m4_pushdef([AT_TEST],
2044 [AT_SETUP([Ambiguity reports: $1])
2046 AT_BISON_OPTION_PUSHDEFS([%glr-parser %debug $1])
2047 AT_DATA_GRAMMAR([input.y],
2049 ]AT_YYERROR_DECLARE[
2053 %define parse.assert
2061 // In C++ we need two more lines for the line numbers in the trace to match.
2073 ]AT_YYLEX_DEFINE(["abc"])[
2077 AT_FULL_COMPILE([input])
2079 AT_PARSER_CHECK([[input --debug]], 1, [],
2083 Next token is token 'a' ()
2084 Shifting token 'a' ()
2087 Next token is token 'b' ()
2088 Shifting token 'b' ()
2090 Reducing stack 0 by rule 3 (line 30):
2092 -> $][$ = nterm b ()
2095 Next token is token 'c' ()
2096 Shifting token 'c' ()
2098 Reducing stack 0 by rule 4 (line 31):
2099 -> $][$ = nterm d ()
2102 Now at end of input.
2103 Stack 0 Entering state 7
2104 Now at end of input.
2105 Splitting off stack 1 from 0.
2106 Reduced stack 1 by rule 2 (line 28); action deferred. Now in state 2.
2107 Stack 1 Entering state 2
2108 Now at end of input.
2109 Reduced stack 0 by rule 1 (line 27); action deferred. Now in state 2.
2110 Merging stack 0 into stack 1.
2111 Stack 1 Entering state 2
2112 Now at end of input.
2113 Removing dead stacks.
2114 Rename stack 1 -> 0.
2115 On stack 0, shifting token "end of file" ()
2116 Stack 0 now in state 5
2119 start -> <Rule 1, tokens 1 .. 3>
2126 start -> <Rule 2, tokens 1 .. 3>
2133 Cleanup: popping token "end of file" ()
2134 Cleanup: popping unresolved nterm start ()
2135 Cleanup: popping nterm d ()
2136 Cleanup: popping token 'c' ()
2137 Cleanup: popping nterm b ()
2138 Cleanup: popping token 'a' ()
2141 AT_BISON_OPTION_POPDEFS
2145 AT_TEST([%skeleton "glr.c"])
2146 AT_TEST([%skeleton "glr.cc"])
2147 AT_TEST([%skeleton "glr2.cc"])
2149 m4_popdef([AT_TEST])
2153 ## ------------------------------------------------------- ##
2156 ## https://lists.gnu.org/r/bug-bison/2013-10/msg00004.html ##
2157 ## https://lists.gnu.org/r/bug-bison/2018-05/msg00033.html ##
2158 ## ------------------------------------------------------- ##
2160 m4_pushdef([AT_TEST],
2161 [AT_SETUP([Predicates: $1])
2163 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
2164 AT_DATA_GRAMMAR([input.y],
2165 [[%define parse.assert
2168 %define parse.error verbose
2175 #include <stdbool.h>
2176 bool new_syntax = false;
2177 const char *input = YY_NULLPTR;
2178 ]AT_YYERROR_DECLARE[
2183 %? {new_syntax} 'w' id new_args { printf("new"); }
2184 | %?{!new_syntax} 'w' id old_args { printf("old"); }
2193 ]AT_YYLEX_PROTOTYPE[
2200 main (int argc, const char* argv[])
2202 assert (argc == 2); (void) argc;
2203 // First char decides whether new, or old syntax.
2205 new_syntax = argv[1][0] == 'N';
2206 input = argv[1] + 1;
2207 if (getenv ("YYDEBUG"))
2213 AT_FULL_COMPILE([input])
2214 AT_PARSER_CHECK([[input Nwin]], [0], [new])
2215 AT_PARSER_CHECK([[input Owin]], [1], [], [[syntax error, unexpected 'n', expecting 'o'
2217 AT_PARSER_CHECK([[input Owio]], [0], [old])
2218 AT_PARSER_CHECK([[input Nwio]], [1], [], [[syntax error, unexpected 'o', expecting 'n'
2221 AT_BISON_OPTION_POPDEFS
2225 AT_TEST([%skeleton "glr.c"])
2226 AT_TEST([%skeleton "glr.cc"])
2227 AT_TEST([%skeleton "glr2.cc"])
2229 m4_popdef([AT_TEST])
2232 m4_popdef([AT_YYPARSE_DEFINE])