X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/d659304d0a57e470f5f73ac49eb6d11bc14dd5bf..abd189e8dc6ca848f038da12e4110d6192374b82:/tests/glr-regression.at?ds=sidebyside

diff --git a/tests/glr-regression.at b/tests/glr-regression.at
index b1e91180..9e68a0f7 100644
--- a/tests/glr-regression.at
+++ b/tests/glr-regression.at
@@ -1,20 +1,20 @@
 # 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.
+# Copyright (C) 2002-2003, 2005-2007, 2009-2011 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]])
 
@@ -30,6 +30,7 @@ AT_DATA_GRAMMAR([glr-regr1.y],
 
 %{
 #include <stdio.h>
+#include <stdlib.h>
 
 #define YYSTYPE int
 static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
@@ -82,7 +83,10 @@ yylex (void)
 {
   for (;;)
     {
-      int ch = getchar ();
+      int ch;
+      if (feof (stdin))
+	abort ();
+      ch = getchar ();
       if (ch == EOF)
 	return 0;
       else if (ch == 'B' || ch == 'P')
@@ -91,11 +95,11 @@ yylex (void)
 }
 ]])
 
-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([[echo BPBPB | ./glr-regr1]], 0,
 [[E -> 'B'
 E -> 'B'
 E -> E 'P' E
@@ -168,13 +172,15 @@ var_printer: 'v'
 
 %%
 
-FILE *input = NULL;
+FILE *input;
 
 int
 yylex (void)
 {
   char buf[50];
   char *s;
+  if (feof (stdin))
+    abort ();
   switch (fscanf (input, " %1[a-z,]", buf)) {
   case 1:
     return buf[0];
@@ -207,18 +213,19 @@ main (int argc, char **argv)
 }
 ]])
 
-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_PARSER_CHECK([[echo s VARIABLE_1 t v x q | ./glr-regr2a]], 0,
 [[Variable: 'VARIABLE_1'
 ]], [])
-AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], 0,
+AT_PARSER_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]],
+0,
 [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
 ]])
-AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
+AT_PARSER_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
 [[Variable: 'VARIABLE_3'
 ]], [])
 
@@ -237,10 +244,11 @@ AT_DATA_GRAMMAR([glr-regr3.y],
 
 %{
 #include <stdio.h>
+#include <stdlib.h>
 #include <stdarg.h>
 
 static int MergeRule (int x0, int x1);
-static void yyerror(char const * s);
+static void yyerror (char const * s);
 int yylex (void);
 
 #define RULE(x) (1 << (x))
@@ -299,6 +307,8 @@ int T[] = { T1, T2, T3, T4 };
 int yylex (void)
 {
   char inp[3];
+  if (feof (stdin))
+    abort ();
   if (fscanf (input, "%2s", inp) == EOF)
     return 0;
   switch (inp[0])
@@ -317,23 +327,23 @@ int main(int argc, char* argv[]) {
 }
 ]])
 
-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_PARSER_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                               ##
-## Thanks to Joel E. Denny for this test; see                             ##
-## <http://lists.gnu.org/archive/html/help-bison/2005-07/msg00013.html>.  ##
-## ---------------------------------------------------------------------- ##
+## ------------------------------------------------------------------------- ##
+## 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])
 
@@ -351,6 +361,8 @@ AT_DATA_GRAMMAR([glr-regr4.y],
   static char *make_value (char const *, char const *);
   static void yyerror (char const *);
   static int yylex (void);
+  static char *ptrs[100];
+  static char **ptrs_next = ptrs;
 %}
 
 %%
@@ -376,21 +388,27 @@ B:  'a' { $$ = make_value ("B", "'a'");  } ;
 static int
 yylex (void)
 {
-  static char const *input = "a";
-  return *input++;
+  static char const input[] = "a";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  return input[toknum++];
 }
 
 int
 main (void)
 {
-  return yyparse ();
+  int status = yyparse ();
+  while (ptrs_next != ptrs)
+    free (*--ptrs_next);
+  return status;
 }
 
 static char *
 make_value (char const *parent, char const *child)
 {
   char const format[] = "%s <- %s";
-  char *value =
+  char *value = *ptrs_next++ =
     (char *) malloc (strlen (parent) + strlen (child) + sizeof format);
   sprintf (value, format, parent, child);
   return value;
@@ -400,7 +418,7 @@ static char *
 merge (YYSTYPE s1, YYSTYPE s2)
 {
   char const format[] = "merge{ %s and %s }";
-  char *value =
+  char *value = *ptrs_next++ =
     (char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format);
   sprintf (value, format, s1.ptr, s2.ptr);
   return value;
@@ -413,23 +431,22 @@ yyerror (char const *msg)
 }
 ]])
 
-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_CLEANUP
 
 
-## ------------------------------------------------------------------------- ##
-## User destructor for unresolved GLR semantic value                         ##
-## Thanks to Joel E. Denny for this test; see                                ##
-## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00016.html>.  ##
-## ------------------------------------------------------------------------- ##
+## -------------------------------------------------------------------------- ##
+## 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])
 
@@ -467,8 +484,11 @@ start:
 static int
 yylex (void)
 {
-  static char const *input = "a";
-  return *input++;
+  static char const input[] = "a";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  return input[toknum++];
 }
 
 static void
@@ -484,23 +504,22 @@ main (void)
 }
 ]])
 
-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_CLEANUP
 
 
-## ------------------------------------------------------------------------- ##
-## User destructor after an error during a split parse                       ##
-## Thanks to Joel E. Denny for this test; see                                ##
-## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00029.html>.  ##
-## ------------------------------------------------------------------------- ##
+## -------------------------------------------------------------------------- ##
+## 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])
 
@@ -530,8 +549,11 @@ start: 'a' | 'a' ;
 static int
 yylex (void)
 {
-  static char const *input = "a";
-  return *input++;
+  static char const input[] = "a";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  return input[toknum++];
 }
 
 static void
@@ -547,12 +569,12 @@ main (void)
 }
 ]])
 
-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
@@ -562,8 +584,7 @@ AT_CLEANUP
 
 
 ## ------------------------------------------------------------------------- ##
-## Duplicated user destructor for lookahead                                  ##
-## Thanks to Joel E. Denny for this test; see                                ##
+## Duplicated user destructor for lookahead.  See			     ##
 ## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00035.html>.  ##
 ## ------------------------------------------------------------------------- ##
 
@@ -577,14 +598,19 @@ AT_DATA_GRAMMAR([glr-regr7.y],
   static void yyerror (char const *);
   static int yylex (void);
   #define YYSTACKEXPANDABLE 0
+  typedef struct count_node {
+    int count;
+    struct count_node *prev;
+  } count_node;
+  static count_node *tail;
 %}
 
 %glr-parser
-%union { int *count; }
-%type <count> 'a'
+%union { count_node *node; }
+%type <node> 'a'
 
 %destructor {
-  if ((*$$)++)
+  if ($$->count++)
     fprintf (stderr, "Destructor called on same value twice.\n");
 } 'a'
 
@@ -603,13 +629,15 @@ stack2: 'a' ;
 static int
 yylex (void)
 {
-  yylval.count = (int *) malloc (sizeof (int));
-  if (!yylval.count)
+  yylval.node = (count_node*) malloc (sizeof *yylval.node);
+  if (!yylval.node)
     {
       fprintf (stderr, "Test inconclusive.\n");
       exit (EXIT_FAILURE);
     }
-  *yylval.count = 0;
+  yylval.node->count = 0;
+  yylval.node->prev = tail;
+  tail = yylval.node;
   return 'a';
 }
 
@@ -622,16 +650,23 @@ yyerror (char const *msg)
 int
 main (void)
 {
-  return yyparse ();
+  int status = yyparse ();
+  while (tail)
+    {
+      count_node *prev = tail->prev;
+      free (tail);
+      tail = prev;
+    }
+  return status;
 }
 ]])
 
-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
 ])
 
@@ -654,7 +689,7 @@ AT_DATA_GRAMMAR([glr-regr8.y],
   #include <stdlib.h>
   static void yyerror (char const *);
   static int yylex (void);
-  static void yyerror(const char *msg);
+  static void yyerror (char const *msg);
 %}
 
 %token T_CONSTANT
@@ -688,9 +723,10 @@ OptSignalWord	: /* empty */
 
 %%
 
-void yyerror(const char *msg)
+void
+yyerror (char const *msg)
 {
-  fprintf (stderr, "error\n");
+  fprintf (stderr, "%s\n", msg);
 }
 
 static int lexIndex;
@@ -700,6 +736,8 @@ int yylex (void)
   lexIndex += 1;
   switch (lexIndex)
     {
+    default:
+      abort ();
     case 1:
       yylloc.first_column = 1;
       yylloc.last_column = 9;
@@ -708,7 +746,7 @@ int yylex (void)
       yylloc.first_column = 13;
       yylloc.last_column = 17;
       return T_PORT;
-    default:
+    case 3:
       return 0;
     }
 }
@@ -721,12 +759,12 @@ main (void)
 }
 ]])
 
-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
 ],
@@ -736,8 +774,7 @@ AT_CLEANUP
 
 
 ## ------------------------------------------------------------------------- ##
-## No users destructors if stack 0 deleted                                   ##
-## Thanks to Joel E. Denny for this test; see                                ##
+## No users destructors if stack 0 deleted.  See			     ##
 ## <http://lists.gnu.org/archive/html/bison-patches/2005-09/msg00109.html>.  ##
 ## ------------------------------------------------------------------------- ##
 
@@ -805,12 +842,12 @@ main (void)
 }
 ]])
 
-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
 ])
 
@@ -821,11 +858,12 @@ AT_CLEANUP
 ## Corrupted semantic options if user action cuts parse.	             ##
 ## ------------------------------------------------------------------------- ##
 
-AT_SETUP([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 <stdlib.h>
 # include <stdio.h>
   static void yyerror (char const *);
   static int yylex (void);
@@ -855,25 +893,28 @@ yyerror (char const *msg)
 static int
 yylex (void)
 {
+  static int called;
+  if (called++)
+    abort ();
   return 0;
 }
 
 int
 main (void)
 {
-  int index;
-  for (index = 0; index < GARBAGE_SIZE; index+=1)
-    garbage[index] = 132;
+  int i;
+  for (i = 0; i < GARBAGE_SIZE; i+=1)
+    garbage[i] = 108;
   return yyparse ();
 }
 ]])
 
-AT_CHECK([[bison -t -o glr-regr10.c glr-regr10.y]], 0, [],
+AT_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
 
@@ -882,7 +923,7 @@ AT_CLEANUP
 ## Undesirable destructors if user action cuts parse.			     ##
 ## ------------------------------------------------------------------------- ##
 
-AT_SETUP([Undesirable destructors if user action cuts parse.])
+AT_SETUP([Undesirable destructors if user action cuts parse])
 
 AT_DATA_GRAMMAR([glr-regr11.y],
 [[
@@ -917,8 +958,11 @@ yyerror (char const *msg)
 static int
 yylex (void)
 {
-  static char const *input = "a";
-  return *input++;
+  static char const input[] = "a";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  return input[toknum++];
 }
 
 int
@@ -934,52 +978,94 @@ main (void)
 }
 ]])
 
-AT_CHECK([[bison -t -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
 
 
 ## ------------------------------------------------------------------------- ##
-## Leaked merged semantic value if user action cuts parse.		     ##
+## Leaked semantic values if user action cuts parse.			     ##
 ## ------------------------------------------------------------------------- ##
 
-AT_SETUP([Leaked merged semantic value if user action cuts parse.])
+AT_SETUP([Leaked semantic values if user action cuts parse])
 
 AT_DATA_GRAMMAR([glr-regr12.y],
 [[
 %glr-parser
 %union { int dummy; }
-%type <dummy> start
-%destructor { has_value = 0; } start
+%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 has_value = 0;
+  static int parent_rhs_before_value = 0;
+  static int merged_value = 0;
+  static int parent_rhs_after_value = 0;
 # define USE(val)
 %}
 
 %%
 
 start:
-    %merge<merge> { has_value = 1; USE ($$); }
-  | %merge<merge> { USE ($$); YYACCEPT; }
+  alt1 %dprec 1
+  | alt2 %dprec 2
+  ;
+
+alt1:
+  PARENT_RHS_AFTER {
+    USE ($1);
+    parent_rhs_after_value = 0;
+  }
+  ;
+
+alt2:
+  parent_rhs_before merged PARENT_RHS_AFTER {
+    USE (($1, $2, $3));
+    parent_rhs_before_value = 0;
+    merged_value = 0;
+    parent_rhs_after_value = 0;
+  }
+  ;
+
+parent_rhs_before:
+  {
+    USE ($$);
+    parent_rhs_before_value = 1;
+  }
   ;
 
+merged:
+  %merge<merge> {
+    USE ($$);
+    merged_value = 1;
+  }
+  | cut %merge<merge> {
+    USE ($$);
+    merged_value = 1;
+  }
+  ;
+
+cut: { YYACCEPT; } ;
+
 %%
 
 static int
 merge (YYSTYPE s1, YYSTYPE s2)
 {
   /* Not invoked. */
-  return 0;
+  char dummy = s1.dummy + s2.dummy;
+  return dummy;
 }
 
 static void
@@ -991,27 +1077,714 @@ yyerror (char const *msg)
 static int
 yylex (void)
 {
-  return 0;
+  static int const input[] = { PARENT_RHS_AFTER, 0 };
+  static size_t toknum;
+  if (! (toknum < sizeof input / sizeof *input))
+    abort ();
+  if (input[toknum] == PARENT_RHS_AFTER)
+    parent_rhs_after_value = 1;
+  return input[toknum++];
 }
 
 int
 main (void)
 {
   int exit_status = yyparse ();
-  if (has_value)
+  if (parent_rhs_before_value)
     {
-      fprintf (stderr, "Destructor not called.\n");
-      return 1;
+      fprintf (stderr, "`parent_rhs_before' destructor not called.\n");
+      exit_status = 1;
+    }
+  if (merged_value)
+    {
+      fprintf (stderr, "`merged' destructor not called.\n");
+      exit_status = 1;
+    }
+  if (parent_rhs_after_value)
+    {
+      fprintf (stderr, "`PARENT_RHS_AFTER' destructor not called.\n");
+      exit_status = 1;
     }
   return exit_status;
 }
 ]])
 
-AT_CHECK([[bison -t -o glr-regr12.c glr-regr12.y]], 0, [],
-[glr-regr12.y: conflicts: 1 reduce/reduce
+AT_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
+
+
+## ------------------------------------------------------------------------- ##
+## 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_lookahead (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_lookahead ("start <- defstate_init defstate_shift 'b'");
+  }
+  ;
+defstate_init:
+  {
+    print_lookahead ("defstate_init <- empty string");
+  }
+  ;
+defstate_shift:
+  nondefstate defstate_look 'a' {
+    USE ($3);
+    print_lookahead ("defstate_shift <- nondefstate defstate_look 'a'");
+  }
+  ;
+defstate_look:
+  {
+    print_lookahead ("defstate_look <- empty string");
+  }
+  ;
+nondefstate:
+  {
+    print_lookahead ("nondefstate <- empty string");
+  }
+  | 'b' {
+    USE ($1);
+    print_lookahead ("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 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++];
+}
+
+static void
+print_lookahead (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_BISON_CHECK([[-o glr-regr13.c glr-regr13.y]], 0, [], [])
+AT_COMPILE([glr-regr13])
+
+AT_PARSER_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 <stdlib.h>
+  #include <stdio.h>
+  static void yyerror (char const *);
+  static int yylex (void);
+  static void print_lookahead (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_lookahead ("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_lookahead ("merge <- nonconflict1 'a' 'b' nonconflict2");
+  }
+  | conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2 {
+    USE ($3); USE ($5);
+    print_lookahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'"
+		      " defstate_shift");
+  }
+  ;
+
+nonconflict1:
+  {
+    print_lookahead ("nonconflict1 <- empty string");
+  }
+  ;
+nonconflict2:
+  {
+    print_lookahead ("nonconflict2 <- empty string");
+  }
+  | 'a' {
+    USE ($1);
+    print_lookahead ("nonconflict2 <- 'a'");
+  }
+  ;
+conflict:
+  {
+    print_lookahead ("conflict <- empty string");
+  }
+  ;
+defstate_look:
+  {
+    print_lookahead ("defstate_look <- empty string");
+  }
+  ;
+
+/* yychar != YYEMPTY but lookahead need is yyfalse.  */
+defstate_shift:
+  {
+    print_lookahead ("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 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++];
+}
+
+static void
+print_lookahead (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_BISON_CHECK([[-o glr-regr14.c glr-regr14.y]], 0, [],
+[glr-regr14.y: conflicts: 3 reduce/reduce
+])
+AT_COMPILE([glr-regr14])
+
+AT_PARSER_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
+
+
+## ------------------------------------------------------------------------- ##
+## Leaked semantic values when reporting ambiguity.			     ##
+## ------------------------------------------------------------------------- ##
+
+AT_SETUP([Leaked semantic values when reporting ambiguity])
+
+AT_DATA_GRAMMAR([glr-regr15.y],
+[[
+%glr-parser
+%destructor { parent_rhs_before_value = 0; } parent_rhs_before
+
+%{
+# include <stdlib.h>
+  static void yyerror (char const *);
+  static int yylex (void);
+  static int parent_rhs_before_value = 0;
+# define USE(val)
+%}
+
+%%
+
+start:
+  alt1 %dprec 1
+  | alt2 %dprec 2
+  ;
+
+/* This stack must be merged into the other stacks *last* (added at the
+   beginning of the semantic options list) so that yyparse will choose to clean
+   it up rather than the tree for which some semantic actions have been
+   performed.  Thus, if yyreportAmbiguity longjmp's to yyparse, the values from
+   those other trees are not cleaned up.  */
+alt1: ;
+
+alt2:
+  parent_rhs_before ambiguity {
+    USE ($1);
+    parent_rhs_before_value = 0;
+  }
+  ;
+
+parent_rhs_before:
+  {
+    USE ($$);
+    parent_rhs_before_value = 1;
+  }
+  ;
+
+ambiguity: ambiguity1 | ambiguity2 ;
+ambiguity1: ;
+ambiguity2: ;
+
+%%
+
+static void
+yyerror (char const *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+}
+
+static int
+yylex (void)
+{
+  static int called;
+  if (called++)
+    abort ();
+  return 0;
+}
+
+int
+main (void)
+{
+  int exit_status = yyparse () != 1;
+  if (parent_rhs_before_value)
+    {
+      fprintf (stderr, "`parent_rhs_before' destructor not called.\n");
+      exit_status = 1;
+    }
+  return exit_status;
+}
+]])
+
+AT_BISON_CHECK([[-o glr-regr15.c glr-regr15.y]], 0, [],
+[glr-regr15.y: conflicts: 2 reduce/reduce
+])
+AT_COMPILE([glr-regr15])
+
+AT_PARSER_CHECK([[./glr-regr15]], 0, [],
+[syntax is ambiguous
+])
+
+AT_CLEANUP
+
+
+## ------------------------------------------------------------------------- ##
+## Leaked lookahead after nondeterministic parse syntax error.		     ##
+## ------------------------------------------------------------------------- ##
+
+AT_SETUP([Leaked lookahead after nondeterministic parse syntax error])
+AT_DATA_GRAMMAR([glr-regr16.y],
+[[
+%glr-parser
+%destructor { lookahead_value = 0; } 'b'
+
+%{
+# include <stdlib.h>
+  static void yyerror (char const *);
+  static int yylex (void);
+  static int lookahead_value = 0;
+# define USE(val)
+%}
+
+%%
+
+start: alt1 'a' | alt2 'a' ;
+alt1: ;
+alt2: ;
+
+%%
+
+static void
+yyerror (char const *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+}
+
+static int
+yylex (void)
+{
+  static char const input[] = "ab";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  if (input[toknum] == 'b')
+    lookahead_value = 1;
+  return input[toknum++];
+}
+
+int
+main (void)
+{
+  int exit_status = yyparse () != 1;
+  if (lookahead_value)
+    {
+      fprintf (stderr, "Lookahead destructor not called.\n");
+      exit_status = 1;
+    }
+  return exit_status;
+}
+]])
+
+AT_BISON_CHECK([[-o glr-regr16.c glr-regr16.y]], 0, [],
+[glr-regr16.y: conflicts: 1 reduce/reduce
+])
+AT_COMPILE([glr-regr16])
+
+AT_PARSER_CHECK([[./glr-regr16]], 0, [],
+[syntax error
+])
+
+AT_CLEANUP
+
+
+## ------------------------------------------------------------------------- ##
+## Uninitialized location when reporting ambiguity.			     ##
+## ------------------------------------------------------------------------- ##
+
+AT_SETUP([Uninitialized location when reporting ambiguity])
+AT_DATA_GRAMMAR([glr-regr17.y],
+[[
+%glr-parser
+%locations
+%define api.pure
+%error-verbose
+
+%union { int dummy; }
+
+%{
+  static void yyerror (YYLTYPE *, char const *);
+  static int yylex (YYSTYPE *, YYLTYPE *);
+%}
+
+%initial-action {
+  @$.first_line = 1;
+  @$.first_column = 1;
+  @$.last_line = 1;
+  @$.last_column = 1;
+}
+
+%%
+
+/* Tests the case of an empty RHS that has inherited the location of the
+   previous nonterminal, which is unresolved.  That location is reported as the
+   last position of the ambiguity.  */
+start: ambig1 empty1 | ambig2 empty2 ;
+
+/* Tests multiple levels of yyresolveLocations recursion.  */
+ambig1: sub_ambig1 | sub_ambig2 ;
+ambig2: sub_ambig1 | sub_ambig2 ;
+
+/* Tests the case of a non-empty RHS as well as the case of an empty RHS that
+   has inherited the initial location.  The empty RHS's location is reported as
+   the first position in the ambiguity.  */
+sub_ambig1: empty1 'a' 'b' ;
+sub_ambig2: empty2 'a' 'b' ;
+empty1: ;
+empty2: ;
+
+%%
+
+static void
+yyerror (YYLTYPE *locp, char const *msg)
+{
+  fprintf (stderr, "Error at %d.%d-%d.%d: %s.\n", locp->first_line,
+	   locp->first_column, locp->last_line, locp->last_column, msg);
+}
+
+static int
+yylex (YYSTYPE *lvalp, YYLTYPE *llocp)
+{
+  static char const input[] = "ab";
+  static size_t toknum;
+  if (! (toknum < sizeof input))
+    abort ();
+  lvalp->dummy = 0;
+  llocp->first_line = llocp->last_line = 2;
+  llocp->first_column = toknum + 1;
+  llocp->last_column = llocp->first_column + 1;
+  return input[toknum++];
+}
+
+int
+main (void)
+{
+  return yyparse () != 1;
+}
+]])
+
+AT_BISON_CHECK([[-o glr-regr17.c glr-regr17.y]], 0, [],
+[glr-regr17.y: conflicts: 3 reduce/reduce
+])
+AT_COMPILE([glr-regr17])
+
+AT_PARSER_CHECK([[./glr-regr17]], 0, [],
+[Error at 1.1-2.3: syntax is ambiguous.
+])
+
+AT_CLEANUP
+
+
+## -------------------------------------------------------------##
+## Missed %merge type warnings when LHS type is declared later. ##
+## -------------------------------------------------------------##
+
+AT_SETUP([Missed %merge type warnings when LHS type is declared later])
+AT_DATA_GRAMMAR([glr-regr18.y],
+[[%glr-parser
+
+%{
+  #include <stdlib.h>
+  static void yyerror (char const *);
+  static int yylex ();
+%}
+
+%union {
+  int type1;
+  int type2;
+  int type3;
+}
+
+%%
+
+sym1: sym2 %merge<merge> { $$ = $1; } ;
+sym2: sym3 %merge<merge> { $$ = $1; } ;
+sym3: %merge<merge> { $$ = 0; } ;
+
+%type <type1> sym1;
+%type <type2> sym2;
+%type <type3> sym3;
+
+%%
+
+static void
+yyerror (char const *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+}
+
+static int
+yylex ()
+{
+  static int called;
+  if (called++)
+    abort ();
+  return 0;
+}
+
+int
+main (void)
+{
+  return yyparse ();
+}
+]])
+
+AT_BISON_CHECK([[-o glr-regr18.c glr-regr18.y]], 1, [],
+[glr-regr18.y:26.18-24: result type clash on merge function `merge': <type2> != <type1>
+glr-regr18.y:25.18-24: previous declaration
+glr-regr18.y:27.13-19: result type clash on merge function `merge': <type3> != <type2>
+glr-regr18.y:26.18-24: previous declaration
+])
 
 AT_CLEANUP