[bison.git] / tests / glr-regression.at

# Checking GLR Parsing: Regression Tests           -*- Autotest -*-
# Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.

AT_BANNER([[GLR Regression Tests]])

## --------------------------- ##
## Badly Collapsed GLR States. ##
## --------------------------- ##

AT_SETUP([Badly Collapsed GLR States])

AT_DATA_GRAMMAR([glr-regr1.y],
[[/* Regression Test: Improper state compression */
/* Reported by Scott McPeak */

%{
#include <stdio.h>

#define YYSTYPE int
static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
int yylex (void);
void yyerror (char const *msg);
%}


%glr-parser


/* -------- productions ------ */
%%

StartSymbol: E  { $$=0; }                   %merge <exprMerge>
           ;

E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); }  %merge <exprMerge>
 | 'B'     { $$=2; printf("E -> 'B'\n"); }      %merge <exprMerge>
 ;


/* ---------- C code ----------- */
%%

static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1)
{
  (void) x0;
  (void) x1;
  printf ("<OR>\n");
  return 0;
}

int
main (void)
{
  return yyparse ();
}

void
yyerror (char const *msg)
{
  fprintf (stderr, "%s\n", msg);
}


int
yylex (void)
{
  for (;;)
    {
      int ch = getchar ();
      if (ch == EOF)
	return 0;
      else if (ch == 'B' || ch == 'P')
	return ch;
    }
}
]])

AT_CHECK([[bison -o glr-regr1.c glr-regr1.y]], 0, [],
[glr-regr1.y: conflicts: 1 shift/reduce
])
AT_COMPILE([glr-regr1])
AT_CHECK([[echo BPBPB | ./glr-regr1]], 0,
[[E -> 'B'
E -> 'B'
E -> E 'P' E
E -> 'B'
E -> E 'P' E
E -> 'B'
E -> E 'P' E
E -> E 'P' E
<OR>
]], [])

AT_CLEANUP

## ------------------------------------------------------------ ##
## Improper handling of embedded actions and $-N in GLR parsers ##
## ------------------------------------------------------------ ##

AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers])

AT_DATA_GRAMMAR([glr-regr2a.y],
[[/* Regression Test: Improper handling of embedded actions and $-N  */
/* Reported by S. Eken */

%{
  #define YYSTYPE char const *

  #include <ctype.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  int yylex (void);
  void yyerror (char const *);
%}

%glr-parser

%%

command:
    's' var 't'
       { printf ("Variable: '%s'\n", $2); }
    'v' 'x' 'q'
  | 's' var_list 't' 'e'
       { printf ("Varlist: '%s'\n", $2); }
  | 's' var 't' var_printer 'x'
  ;

var:
  'V'
     { $$ = $1; }
  ;

var_list:
  var
    { $$ = $1; }
  | var ',' var_list
    {
      char *s = (char *) malloc (strlen ($1) + 1 + strlen ($3) + 1);
      strcpy (s, $1);
      strcat (s, ",");
      strcat (s, $3);
      $$ = s;
    }
  ;

var_printer: 'v'
   { printf ("Variable: '%s'\n", $-1); }

%%

FILE *input = NULL;

int
yylex (void)
{
  char buf[50];
  char *s;
  switch (fscanf (input, " %1[a-z,]", buf)) {
  case 1:
    return buf[0];
  case EOF:
    return 0;
  default:
    break;
  }
  if (fscanf (input, "%49s", buf) != 1)
    return 0;
  if (sizeof buf - 1 <= strlen (buf))
    abort ();
  s = (char *) malloc (strlen (buf) + 1);
  strcpy (s, buf);
  yylval = s;
  return 'V';
}

void
yyerror (char const *s)
{ printf ("%s\n", s);
}

int
main (int argc, char **argv)
{
  input = stdin;
  if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
  return yyparse ();
}
]])

AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [],
[glr-regr2a.y: conflicts: 2 shift/reduce
])
AT_COMPILE([glr-regr2a])

AT_CHECK([[echo s VARIABLE_1 t v x q | ./glr-regr2a]], 0,
[[Variable: 'VARIABLE_1'
]], [])
AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e | ./glr-regr2a]], 0,
[[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
]])
AT_CHECK([[echo s VARIABLE_3 t v x | ./glr-regr2a]], 0,
[[Variable: 'VARIABLE_3'
]], [])


AT_CLEANUP

## ------------------------------------------------------------ ##
## Improper merging of GLR delayed action sets                  ##
## ------------------------------------------------------------ ##

AT_SETUP([Improper merging of GLR delayed action sets])

AT_DATA_GRAMMAR([glr-regr3.y],
[[/* Regression Test: Improper merging of GLR delayed action sets.  */
/* Reported by M. Rosien */

%{
#include <stdio.h>
#include <stdarg.h>

static int MergeRule (int x0, int x1);
static void yyerror(char const * s);
int yylex (void);

#define RULE(x) (1 << (x))

%}

%glr-parser

%token BAD_CHAR
%token P1 P2 T1 T2 T3 T4 O1 O2

%%

S : P1 T4 O2 NT6 P2  { printf ("Result: %x\n", $4); }
;

NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); }  %merge<MergeRule>
;

NT2 : NT1             { $$ = RULE(3); } %merge<MergeRule>
    | P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
;

NT3 : T3              { $$ = RULE(5); } %merge<MergeRule>
    | P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
;

NT4 : NT3              { $$ = RULE(7); } %merge<MergeRule>
    | NT2              { $$ = RULE(8); } %merge<MergeRule>
    | P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
;

NT5 : NT4              { $$ = RULE(10); } %merge<MergeRule>
;

NT6 : P1 NT1 O1 T3 P2  { $$ = RULE(11) | $2; } %merge<MergeRule>
    | NT5              { $$ = RULE(12) | $1; } %merge<MergeRule>
;

%%

static int MergeRule (int x0, int x1) {
  return x0 | x1;
}

static void yyerror(char const * s) {
  fprintf(stderr,"error: %s\n",s);
}

FILE *input = NULL;

int P[] = { P1, P2 };
int O[] = { O1, O2 };
int T[] = { T1, T2, T3, T4 };

int yylex (void)
{
  char inp[3];
  if (fscanf (input, "%2s", inp) == EOF)
    return 0;
  switch (inp[0])
    {
    case 'p': return P[inp[1] - '1'];
    case 't': return T[inp[1] - '1'];
    case 'o': return O[inp[1] - '1'];
    }
  return BAD_CHAR;
}

int main(int argc, char* argv[]) {
  input = stdin;
  if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
  return yyparse ();
}
]])

AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [],
[glr-regr3.y: conflicts: 1 shift/reduce, 1 reduce/reduce
])
AT_COMPILE([glr-regr3])

AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 | ./glr-regr3]], 0,
[[Result: 1c04
]], [])

AT_CLEANUP


## ---------------------------------------------------------------------- ##
## Duplicate representation of merged trees                               ##
## Thanks to Joel E. Denny for this test; see                             ##
## <http://lists.gnu.org/archive/html/help-bison/2005-07/msg00013.html>.  ##
## ---------------------------------------------------------------------- ##

AT_SETUP([Duplicate representation of merged trees])

AT_DATA_GRAMMAR([glr-regr4.y],
[[
%union { char *ptr; }
%type <ptr> S A A1 A2 B
%glr-parser

%{
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  static char *merge (YYSTYPE, YYSTYPE);
  static char *make_value (char const *, char const *);
  static void yyerror (char const *);
  static int yylex (void);
%}

%%

tree: S { printf ("%s\n", $1); } ;

S:
  A   %merge<merge> { $$ = make_value ("S", $1); }
  | B %merge<merge> { $$ = make_value ("S", $1); }
  ;

A:
  A1   %merge<merge> { $$ = make_value ("A", $1); }
  | A2 %merge<merge> { $$ = make_value ("A", $1); }
  ;

A1: 'a' { $$ = make_value ("A1", "'a'"); } ;
A2: 'a' { $$ = make_value ("A2", "'a'"); } ;
B:  'a' { $$ = make_value ("B", "'a'");  } ;

%%

static int
yylex (void)
{
  static char const *input = "a";
  return *input++;
}

int
main (void)
{
  return yyparse ();
}

static char *
make_value (char const *parent, char const *child)
{
  char const format[] = "%s <- %s";
  char *value =
    (char *) malloc (strlen (parent) + strlen (child) + sizeof format);
  sprintf (value, format, parent, child);
  return value;
}

static char *
merge (YYSTYPE s1, YYSTYPE s2)
{
  char const format[] = "merge{ %s and %s }";
  char *value =
    (char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format);
  sprintf (value, format, s1.ptr, s2.ptr);
  return value;
}

static void
yyerror (char const *msg)
{
  fprintf (stderr, "%s\n", msg);
}
]])

AT_CHECK([[bison -o glr-regr4.c glr-regr4.y]], 0, [],
[glr-regr4.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr4])

AT_CHECK([[./glr-regr4]], 0,
[[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
]], [])

AT_CLEANUP


## ------------------------------------------------------------------------- ##
## User destructor for unresolved GLR semantic value                         ##
## Thanks to Joel E. Denny for this test; see                                ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00016.html>.  ##
## ------------------------------------------------------------------------- ##

AT_SETUP([User destructor for unresolved GLR semantic value])

AT_DATA_GRAMMAR([glr-regr5.y],
[[
%{
  #include <stdio.h>
  #include <stdlib.h>
  static void yyerror (char const *);
  static int yylex (void);
  enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
%}

%glr-parser
%union { int value; }
%type <value> start

%destructor {
  if ($$ != MAGIC_VALUE)
    {
      fprintf (stderr, "Bad destructor call.\n");
      exit (EXIT_FAILURE);
    }
} start

%%

start:
   'a' { $$ = MAGIC_VALUE; }
   | 'a' { $$ = MAGIC_VALUE; }
   ;

%%

static int
yylex (void)
{
  static char const *input = "a";
  return *input++;
}

static void
yyerror (char const *msg)
{
  fprintf (stderr, "%s\n", msg);
}

int
main (void)
{
  return yyparse () != 1;
}
]])

AT_CHECK([[bison -o glr-regr5.c glr-regr5.y]], 0, [],
[glr-regr5.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr5])

AT_CHECK([[./glr-regr5]], 0, [],
[syntax is ambiguous
])

AT_CLEANUP


## ------------------------------------------------------------------------- ##
## User destructor after an error during a split parse                       ##
## Thanks to Joel E. Denny for this test; see                                ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00029.html>.  ##
## ------------------------------------------------------------------------- ##

AT_SETUP([User destructor after an error during a split parse])

AT_DATA_GRAMMAR([glr-regr6.y],
[[
%{
  #include <stdio.h>
  #include <stdlib.h>
  static void yyerror (char const *);
  static int yylex (void);
%}

%glr-parser
%union { int value; }
%type <value> 'a'

%destructor {
  printf ("Destructor called.\n");
} 'a'

%%

start: 'a' | 'a' ;

%%

static int
yylex (void)
{
  static char const *input = "a";
  return *input++;
}

static void
yyerror (char const *msg)
{
  fprintf (stderr, "%s\n", msg);
}

int
main (void)
{
  return yyparse () != 1;
}
]])

AT_CHECK([[bison -o glr-regr6.c glr-regr6.y]], 0, [],
[glr-regr6.y: conflicts: 1 reduce/reduce
])
AT_COMPILE([glr-regr6])

AT_CHECK([[./glr-regr6]], 0,
[Destructor called.
],
[syntax is ambiguous
])

AT_CLEANUP


## ------------------------------------------------------------------------- ##
## Duplicated user destructor for lookahead                                  ##
## Thanks to Joel E. Denny for this test; see                                ##
## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00035.html>.  ##
## ------------------------------------------------------------------------- ##

AT_SETUP([Duplicated user destructor for lookahead])

AT_DATA_GRAMMAR([glr-regr7.y],
[[
%{
  #include <stdio.h>
  #include <stdlib.h>
  static void yyerror (char const *);
  static int yylex (void);
  #define YYSTACKEXPANDABLE 0
%}

%glr-parser
%union { int *count; }
%type <count> 'a'

%destructor {
  if ((*$$)++)
    fprintf (stderr, "Destructor called on same value twice.\n");
} 'a'

%%

start:
    stack1 start
  | stack2 start
  | /* empty */
  ;
stack1: 'a' ;
stack2: 'a' ;

%%

static int
yylex (void)
{
  yylval.count = (int *) malloc (sizeof (int));
  if (!yylval.count)
    {
      fprintf (stderr, "Test inconclusive.\n");
      exit (EXIT_FAILURE);
    }
  *yylval.count = 0;
  return 'a';
}

static void
yyerror (char const *msg)
{
  fprintf (stderr, "%s\n", msg);
}

int
main (void)
{
  return yyparse ();
}
]])

AT_CHECK([[bison -o glr-regr7.c glr-regr7.y]], 0, [],
[glr-regr7.y: conflicts: 2 reduce/reduce
])
AT_COMPILE([glr-regr7])

AT_CHECK([[./glr-regr7]], 2, [],
[memory exhausted
])

AT_XFAIL_IF(:)

AT_CLEANUP
Commit	Line	Data
ede3d3bc	1	# Checking GLR Parsing: Regression Tests -- Autotest --
d6d67dbd	2	# Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
ede3d3bc PH	3
	4	# This program is free software; you can redistribute it and/or modify
	5	# it under the terms of the GNU General Public License as published by
	6	# the Free Software Foundation; either version 2, or (at your option)
	7	# any later version.
	8
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
0fb669f9 PE	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
0fb669f9 PE	17	# 02110-1301, USA.
ede3d3bc PH	18
	19	AT_BANNER([[GLR Regression Tests]])
	20
	21	## --------------------------- ##
	22	## Badly Collapsed GLR States. ##
	23	## --------------------------- ##
	24
	25	AT_SETUP([Badly Collapsed GLR States])
	26
	27	AT_DATA_GRAMMAR([glr-regr1.y],
	28	[[/* Regression Test: Improper state compression */
	29	/* Reported by Scott McPeak */
	30
	31	%{
	32	#include <stdio.h>
	33
	34	#define YYSTYPE int
	35	static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
	36	int yylex (void);
ac8c5689	37	void yyerror (char const *msg);
ede3d3bc PH	38	%}
	39
	40
	41	%glr-parser
	42
	43
	44	/* -------- productions ------ */
	45	%%
	46
	47	StartSymbol: E { $$=0; } %merge <exprMerge>
	48	;
	49
	50	E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); } %merge <exprMerge>
	51	\| 'B' { $$=2; printf("E -> 'B'\n"); } %merge <exprMerge>
	52	;
	53
	54
	55
	56	/* ---------- C code ----------- */
	57	%%
	58
	59	static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1)
	60	{
	61	(void) x0;
	62	(void) x1;
	63	printf ("<OR>\n");
	64	return 0;
	65	}
	66
	67	int
	68	main (void)
	69	{
	70	return yyparse ();
	71	}
	72
ac8c5689	73	void
ede3d3bc PH	74	yyerror (char const *msg)
	75	{
	76	fprintf (stderr, "%s\n", msg);
ede3d3bc PH	77	}
	78
	79
	80	int
	81	yylex (void)
	82	{
	83	for (;;)
	84	{
	85	int ch = getchar ();
	86	if (ch == EOF)
	87	return 0;
	88	else if (ch == 'B' \|\| ch == 'P')
	89	return ch;
	90	}
	91	}
	92	]])
	93
	94	AT_CHECK([[bison -o glr-regr1.c glr-regr1.y]], 0, [],
	95	[glr-regr1.y: conflicts: 1 shift/reduce
	96	])
	97	AT_COMPILE([glr-regr1])
	98	AT_CHECK([[echo BPBPB \| ./glr-regr1]], 0,
	99	[[E -> 'B'
	100	E -> 'B'
	101	E -> E 'P' E
	102	E -> 'B'
	103	E -> E 'P' E
	104	E -> 'B'
	105	E -> E 'P' E
	106	E -> E 'P' E
	107	<OR>
	108	]], [])
	109
	110	AT_CLEANUP
	111
	112	## ------------------------------------------------------------ ##
	113	## Improper handling of embedded actions and $-N in GLR parsers ##
	114	## ------------------------------------------------------------ ##
	115
d6d67dbd	116	AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers])
ede3d3bc PH	117
	118	AT_DATA_GRAMMAR([glr-regr2a.y],
	119	[[/* Regression Test: Improper handling of embedded actions and $-N */
	120	/* Reported by S. Eken */
	121
	122	%{
c70fdfcd	123	#define YYSTYPE char const *
ede3d3bc PH	124
	125	#include <ctype.h>
	126	#include <stdio.h>
f508a6a0	127	#include <stdlib.h>
ede3d3bc PH	128	#include <string.h>
	129	int yylex (void);
	130	void yyerror (char const *);
	131	%}
	132
	133	%glr-parser
	134
	135	%%
	136
	137	command:
	138	's' var 't'
d6d67dbd	139	{ printf ("Variable: '%s'\n", $2); }
ede3d3bc PH	140	'v' 'x' 'q'
	141	\| 's' var_list 't' 'e'
	142	{ printf ("Varlist: '%s'\n", $2); }
	143	\| 's' var 't' var_printer 'x'
	144	;
	145
	146	var:
	147	'V'
	148	{ $$ = $1; }
	149	;
	150
	151	var_list:
	152	var
	153	{ $$ = $1; }
	154	\| var ',' var_list
	155	{
c70fdfcd PE	156	char s = (char ) malloc (strlen ($1) + 1 + strlen ($3) + 1);
	157	strcpy (s, $1);
	158	strcat (s, ",");
	159	strcat (s, $3);
	160	$$ = s;
d6d67dbd	161	}
ede3d3bc PH	162	;
	163
	164	var_printer: 'v'
	165	{ printf ("Variable: '%s'\n", $-1); }
	166
	167	%%
	168
a9739e7c	169	FILE *input = NULL;
ede3d3bc PH	170
	171	int
	172	yylex (void)
d6d67dbd	173	{
ede3d3bc	174	char buf[50];
c70fdfcd	175	char *s;
a9739e7c	176	switch (fscanf (input, " %1[a-z,]", buf)) {
ede3d3bc PH	177	case 1:
	178	return buf[0];
	179	case EOF:
	180	return 0;
	181	default:
	182	break;
	183	}
a9739e7c	184	if (fscanf (input, "%49s", buf) != 1)
ac8c5689	185	return 0;
f508a6a0 PE	186	if (sizeof buf - 1 <= strlen (buf))
f508a6a0 PE	187	abort ();
c70fdfcd PE	188	s = (char *) malloc (strlen (buf) + 1);
	189	strcpy (s, buf);
	190	yylval = s;
ede3d3bc PH	191	return 'V';
	192	}
	193
	194	void
	195	yyerror (char const *s)
	196	{ printf ("%s\n", s);
	197	}
	198
	199	int
	200	main (int argc, char **argv)
d6d67dbd	201	{
a9739e7c PE	202	input = stdin;
a9739e7c PE	203	if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
ede3d3bc PH	204	return yyparse ();
	205	}
	206	]])
	207
	208	AT_CHECK([[bison -o glr-regr2a.c glr-regr2a.y]], 0, [],
	209	[glr-regr2a.y: conflicts: 2 shift/reduce
	210	])
	211	AT_COMPILE([glr-regr2a])
	212
	213	AT_CHECK([[echo s VARIABLE_1 t v x q \| ./glr-regr2a]], 0,
	214	[[Variable: 'VARIABLE_1'
	215	]], [])
	216	AT_CHECK([[echo s VARIABLE_1 , ANOTHER_VARIABLE_2 t e \| ./glr-regr2a]], 0,
	217	[[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
	218	]])
	219	AT_CHECK([[echo s VARIABLE_3 t v x \| ./glr-regr2a]], 0,
	220	[[Variable: 'VARIABLE_3'
	221	]], [])
	222
	223
5e6f62f2 PH	224	AT_CLEANUP
	225
	226	## ------------------------------------------------------------ ##
	227	## Improper merging of GLR delayed action sets ##
	228	## ------------------------------------------------------------ ##
	229
	230	AT_SETUP([Improper merging of GLR delayed action sets])
	231
	232	AT_DATA_GRAMMAR([glr-regr3.y],
	233	[[/* Regression Test: Improper merging of GLR delayed action sets. */
	234	/* Reported by M. Rosien */
	235
	236	%{
	237	#include <stdio.h>
	238	#include <stdarg.h>
	239
	240	static int MergeRule (int x0, int x1);
	241	static void yyerror(char const * s);
1beb0b24	242	int yylex (void);
5e6f62f2 PH	243
	244	#define RULE(x) (1 << (x))
	245
	246	%}
	247
	248	%glr-parser
	249
	250	%token BAD_CHAR
	251	%token P1 P2 T1 T2 T3 T4 O1 O2
	252
	253	%%
	254
	255	S : P1 T4 O2 NT6 P2 { printf ("Result: %x\n", $4); }
	256	;
	257
	258	NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); } %merge<MergeRule>
	259	;
	260
	261	NT2 : NT1 { $$ = RULE(3); } %merge<MergeRule>
	262	\| P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
	263	;
	264
	265	NT3 : T3 { $$ = RULE(5); } %merge<MergeRule>
	266	\| P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
	267	;
	268
	269	NT4 : NT3 { $$ = RULE(7); } %merge<MergeRule>
	270	\| NT2 { $$ = RULE(8); } %merge<MergeRule>
	271	\| P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
	272	;
	273
	274	NT5 : NT4 { $$ = RULE(10); } %merge<MergeRule>
	275	;
	276
	277	NT6 : P1 NT1 O1 T3 P2 { $$ = RULE(11) \| $2; } %merge<MergeRule>
	278	\| NT5 { $$ = RULE(12) \| $1; } %merge<MergeRule>
	279	;
	280
	281	%%
	282
	283	static int MergeRule (int x0, int x1) {
	284	return x0 \| x1;
	285	}
	286
	287	static void yyerror(char const * s) {
	288	fprintf(stderr,"error: %s\n",s);
	289	}
	290
a9739e7c	291	FILE *input = NULL;
5e6f62f2 PH	292
	293	int P[] = { P1, P2 };
	294	int O[] = { O1, O2 };
	295	int T[] = { T1, T2, T3, T4 };
	296
	297	int yylex (void)
	298	{
	299	char inp[3];
a9739e7c	300	if (fscanf (input, "%2s", inp) == EOF)
5e6f62f2	301	return 0;
1beb0b24	302	switch (inp[0])
5e6f62f2 PH	303	{
	304	case 'p': return P[inp[1] - '1'];
	305	case 't': return T[inp[1] - '1'];
	306	case 'o': return O[inp[1] - '1'];
	307	}
	308	return BAD_CHAR;
	309	}
	310
	311	int main(int argc, char* argv[]) {
a9739e7c PE	312	input = stdin;
a9739e7c PE	313	if (argc == 2 && !(input = fopen (argv[1], "r"))) return 3;
5e6f62f2 PH	314	return yyparse ();
	315	}
	316	]])
	317
	318	AT_CHECK([[bison -o glr-regr3.c glr-regr3.y]], 0, [],
	319	[glr-regr3.y: conflicts: 1 shift/reduce, 1 reduce/reduce
	320	])
	321	AT_COMPILE([glr-regr3])
	322
	323	AT_CHECK([[echo p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2 \| ./glr-regr3]], 0,
	324	[[Result: 1c04
	325	]], [])
	326
ede3d3bc	327	AT_CLEANUP
f9315de5 PE	328
	329
	330	## ---------------------------------------------------------------------- ##
	331	## Duplicate representation of merged trees ##
	332	## Thanks to Joel E. Denny for this test; see ##
	333	## <http://lists.gnu.org/archive/html/help-bison/2005-07/msg00013.html>. ##
	334	## ---------------------------------------------------------------------- ##
	335
	336	AT_SETUP([Duplicate representation of merged trees])
	337
	338	AT_DATA_GRAMMAR([glr-regr4.y],
1bd0deda PE	339	[[
1bd0deda PE	340	%union { char *ptr; }
f9315de5 PE	341	%type <ptr> S A A1 A2 B
	342	%glr-parser
	343
	344	%{
	345	#include <stdio.h>
	346	#include <stdlib.h>
	347	#include <string.h>
	348	static char *merge (YYSTYPE, YYSTYPE);
1bd0deda	349	static char make_value (char const , char const *);
f9315de5 PE	350	static void yyerror (char const *);
	351	static int yylex (void);
	352	%}
	353
	354	%%
	355
	356	tree: S { printf ("%s\n", $1); } ;
	357
	358	S:
	359	A %merge<merge> { $$ = make_value ("S", $1); }
	360	\| B %merge<merge> { $$ = make_value ("S", $1); }
	361	;
	362
	363	A:
	364	A1 %merge<merge> { $$ = make_value ("A", $1); }
	365	\| A2 %merge<merge> { $$ = make_value ("A", $1); }
	366	;
	367
	368	A1: 'a' { $$ = make_value ("A1", "'a'"); } ;
	369	A2: 'a' { $$ = make_value ("A2", "'a'"); } ;
	370	B: 'a' { $$ = make_value ("B", "'a'"); } ;
	371
	372	%%
	373
	374	static int
	375	yylex (void)
	376	{
	377	static char const *input = "a";
	378	return *input++;
	379	}
	380
	381	int
	382	main (void)
	383	{
	384	return yyparse ();
	385	}
	386
	387	static char *
1bd0deda	388	make_value (char const parent, char const child)
f9315de5 PE	389	{
f9315de5 PE	390	char const format[] = "%s <- %s";
7812f299 PE	391	char *value =
7812f299 PE	392	(char *) malloc (strlen (parent) + strlen (child) + sizeof format);
f9315de5 PE	393	sprintf (value, format, parent, child);
	394	return value;
	395	}
	396
	397	static char *
	398	merge (YYSTYPE s1, YYSTYPE s2)
	399	{
	400	char const format[] = "merge{ %s and %s }";
7812f299 PE	401	char *value =
7812f299 PE	402	(char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format);
f9315de5 PE	403	sprintf (value, format, s1.ptr, s2.ptr);
	404	return value;
	405	}
	406
	407	static void
	408	yyerror (char const *msg)
	409	{
42a6501d	410	fprintf (stderr, "%s\n", msg);
f9315de5 PE	411	}
	412	]])
	413
	414	AT_CHECK([[bison -o glr-regr4.c glr-regr4.y]], 0, [],
	415	[glr-regr4.y: conflicts: 1 reduce/reduce
	416	])
	417	AT_COMPILE([glr-regr4])
	418
	419	AT_CHECK([[./glr-regr4]], 0,
	420	[[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
	421	]], [])
	422
	423	AT_CLEANUP
adc90f13 PE	424
adc90f13 PE	425
42a6501d PE	426	## ------------------------------------------------------------------------- ##
	427	## User destructor for unresolved GLR semantic value ##
	428	## Thanks to Joel E. Denny for this test; see ##
	429	## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00016.html>. ##
	430	## ------------------------------------------------------------------------- ##
adc90f13 PE	431
	432	AT_SETUP([User destructor for unresolved GLR semantic value])
	433
	434	AT_DATA_GRAMMAR([glr-regr5.y],
1bd0deda PE	435	[[
1bd0deda PE	436	%{
adc90f13 PE	437	#include <stdio.h>
	438	#include <stdlib.h>
	439	static void yyerror (char const *);
	440	static int yylex (void);
	441	enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
	442	%}
	443
	444	%glr-parser
	445	%union { int value; }
	446	%type <value> start
	447
	448	%destructor {
	449	if ($$ != MAGIC_VALUE)
	450	{
	451	fprintf (stderr, "Bad destructor call.\n");
	452	exit (EXIT_FAILURE);
	453	}
	454	} start
	455
	456	%%
	457
	458	start:
	459	'a' { $$ = MAGIC_VALUE; }
	460	\| 'a' { $$ = MAGIC_VALUE; }
	461	;
	462
	463	%%
	464
	465	static int
	466	yylex (void)
	467	{
	468	static char const *input = "a";
	469	return *input++;
	470	}
	471
	472	static void
	473	yyerror (char const *msg)
	474	{
42a6501d	475	fprintf (stderr, "%s\n", msg);
adc90f13 PE	476	}
	477
	478	int
	479	main (void)
	480	{
	481	return yyparse () != 1;
	482	}
	483	]])
	484
	485	AT_CHECK([[bison -o glr-regr5.c glr-regr5.y]], 0, [],
	486	[glr-regr5.y: conflicts: 1 reduce/reduce
	487	])
	488	AT_COMPILE([glr-regr5])
	489
42a6501d PE	490	AT_CHECK([[./glr-regr5]], 0, [],
	491	[syntax is ambiguous
	492	])
	493
	494	AT_CLEANUP
	495
	496
	497	## ------------------------------------------------------------------------- ##
	498	## User destructor after an error during a split parse ##
	499	## Thanks to Joel E. Denny for this test; see ##
	500	## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00029.html>. ##
	501	## ------------------------------------------------------------------------- ##
	502
	503	AT_SETUP([User destructor after an error during a split parse])
	504
	505	AT_DATA_GRAMMAR([glr-regr6.y],
1bd0deda PE	506	[[
1bd0deda PE	507	%{
42a6501d PE	508	#include <stdio.h>
	509	#include <stdlib.h>
	510	static void yyerror (char const *);
	511	static int yylex (void);
	512	%}
	513
	514	%glr-parser
	515	%union { int value; }
	516	%type <value> 'a'
	517
	518	%destructor {
	519	printf ("Destructor called.\n");
	520	} 'a'
	521
	522	%%
	523
	524	start: 'a' \| 'a' ;
	525
	526	%%
	527
	528	static int
	529	yylex (void)
	530	{
	531	static char const *input = "a";
	532	return *input++;
	533	}
	534
	535	static void
	536	yyerror (char const *msg)
	537	{
	538	fprintf (stderr, "%s\n", msg);
	539	}
	540
	541	int
	542	main (void)
	543	{
	544	return yyparse () != 1;
	545	}
	546	]])
	547
	548	AT_CHECK([[bison -o glr-regr6.c glr-regr6.y]], 0, [],
	549	[glr-regr6.y: conflicts: 1 reduce/reduce
	550	])
	551	AT_COMPILE([glr-regr6])
	552
	553	AT_CHECK([[./glr-regr6]], 0,
	554	[Destructor called.
	555	],
adc90f13 PE	556	[syntax is ambiguous
	557	])
	558
	559	AT_CLEANUP
1bd0deda PE	560
	561
	562	## ------------------------------------------------------------------------- ##
	563	## Duplicated user destructor for lookahead ##
	564	## Thanks to Joel E. Denny for this test; see ##
	565	## <http://lists.gnu.org/archive/html/bison-patches/2005-08/msg00035.html>. ##
	566	## ------------------------------------------------------------------------- ##
	567
	568	AT_SETUP([Duplicated user destructor for lookahead])
	569
	570	AT_DATA_GRAMMAR([glr-regr7.y],
	571	[[
	572	%{
	573	#include <stdio.h>
	574	#include <stdlib.h>
	575	static void yyerror (char const *);
	576	static int yylex (void);
	577	#define YYSTACKEXPANDABLE 0
	578	%}
	579
	580	%glr-parser
	581	%union { int *count; }
	582	%type <count> 'a'
	583
	584	%destructor {
	585	if ((*$$)++)
	586	fprintf (stderr, "Destructor called on same value twice.\n");
	587	} 'a'
	588
	589	%%
	590
	591	start:
	592	stack1 start
	593	\| stack2 start
	594	\| /* empty */
	595	;
	596	stack1: 'a' ;
	597	stack2: 'a' ;
	598
	599	%%
	600
	601	static int
	602	yylex (void)
	603	{
a9739e7c	604	yylval.count = (int *) malloc (sizeof (int));
1bd0deda PE	605	if (!yylval.count)
	606	{
	607	fprintf (stderr, "Test inconclusive.\n");
	608	exit (EXIT_FAILURE);
	609	}
	610	*yylval.count = 0;
	611	return 'a';
	612	}
	613
	614	static void
	615	yyerror (char const *msg)
	616	{
	617	fprintf (stderr, "%s\n", msg);
	618	}
	619
	620	int
	621	main (void)
	622	{
	623	return yyparse ();
	624	}
	625	]])
	626
	627	AT_CHECK([[bison -o glr-regr7.c glr-regr7.y]], 0, [],
	628	[glr-regr7.y: conflicts: 2 reduce/reduce
	629	])
	630	AT_COMPILE([glr-regr7])
	631
a9739e7c	632	AT_CHECK([[./glr-regr7]], 2, [],
1bd0deda PE	633	[memory exhausted
	634	])
	635
a9739e7c PE	636	AT_XFAIL_IF(:)
a9739e7c PE	637
1bd0deda	638	AT_CLEANUP