tests/glr-regression.at

   1 # Checking GLR Parsing: Regression Tests           -*- Autotest -*-
   2
   3 # Copyright (C) 2002-2003, 2005-2007, 2009-2015, 2018-2021 Free Software
   4 # Foundation, Inc.
   5
   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.
  10 #
  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.
  15 #
  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/>.
  18
  19 AT_BANNER([[GLR Regression Tests]])
  20
  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"
  23 # in ps.
  24
  25 # AT_YYPARSE_DEFINE
  26 # -----------------
  27 # Wrap the C++ parser in a C-like function interface.
  28 m4_pushdef([AT_YYPARSE_DEFINE],
  29 [AT_CXX_IF([[
  30 static int
  31 yyparse ()
  32 {
  33   ]AT_NAMESPACE[::]AT_PARSER_CLASS[ p;]AT_DEBUG_IF([[
  34   int debug = !!getenv ("YYDEBUG");
  35   p.set_debug_level (debug);]])[
  36   return p.parse ();
  37 }
  38 ]])])
  39
  40
  41 # AT_PRINT_LOOKAHEAD_DECLARE
  42 # --------------------------
  43 m4_define([AT_PRINT_LOOKAHEAD_DECLARE],
  44 [AT_GLR2_CC_IF(
  45 [[  static void
  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)
  50 ]],
  51 [[  static void
  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)
  56 ]])])
  57
  58 # AT_PRINT_LOOKAHEAD_DEFINE
  59 # -------------------------
  60 m4_define([AT_PRINT_LOOKAHEAD_DEFINE],
  61 [AT_GLR2_CC_IF(
  62 [[static void
  63 print_lookahead (int yytoken, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
  64                  char const *reduction)
  65 ]],
  66 [[static void
  67 print_lookahead (int yychr, ]AT_YYSTYPE[ *yylvalp, ]AT_YYLTYPE[ *yyllocp,
  68                  char const *reduction)
  69 ]])[
  70 {
  71 ]AT_GLR2_CC_IF([[
  72   // We use -2 and 0 to avoid this warning:
  73   //
  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   //       |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  81   //   117 |     : '?';
  82   //       |     ~~~~~
  83   int yychr
  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'
  88     : '?';
  89 ]])[
  90   printf ("%s:\n  yychar=", reduction);
  91   if (yychr == ]AT_TOKEN([YYEMPTY])[)
  92     printf ("YYEMPTY");
  93   else if (yychr == ]AT_TOKEN([YYEOF])[)
  94     printf ("YYEOF");
  95   else
  96     {
  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[);
 103     }
 104   printf ("\n");
 105 }
 106 ]])
 107
 108
 109 ## ---------------------------- ##
 110 ## Badly Collapsed GLR States.  ##
 111 ## ---------------------------- ##
 112
 113 m4_pushdef([AT_TEST],
 114 [AT_SETUP([Badly Collapsed GLR States: $1])
 115
 116 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 117 AT_KEYWORDS([%merge])
 118
 119 AT_DATA_GRAMMAR([glr-regr1.y],
 120 [[/* Regression Test: Improper state compression */
 121 /* Reported by Scott McPeak */
 122
 123 %define api.value.type {int}
 124
 125 %code {
 126 #include <assert.h>
 127
 128 static ]AT_YYSTYPE[ exprMerge (]AT_YYSTYPE[ x0, ]AT_YYSTYPE[ x1);
 129 ]AT_YYERROR_DECLARE[
 130 ]AT_YYLEX_DECLARE[
 131 }
 132
 133 %define parse.assert
 134 %define parse.trace
 135 %glr-parser
 136 %expect 1
 137 ]$1[
 138
 139 /* -------- productions ------ */
 140 %%
 141
 142 StartSymbol: E  { $$=0; }                   %merge <exprMerge>
 143            ;
 144
 145 E: E 'P' E { $$=1; printf("E -> E 'P' E\n"); }  %merge <exprMerge>
 146  | 'B'     { $$=2; printf("E -> 'B'\n"); }      %merge <exprMerge>
 147  ;
 148
 149
 150
 151 /* ---------- C code ----------- */
 152 %%
 153
 154 static ]AT_YYSTYPE[ exprMerge (]AT_YYSTYPE[ x0, ]AT_YYSTYPE[ x1)
 155 {
 156   (void) x0;
 157   (void) x1;
 158   printf ("<OR>\n");
 159   return 0;
 160 }
 161
 162 ]AT_YYERROR_DEFINE[
 163 ]AT_YYPARSE_DEFINE[
 164
 165 const char *input = YY_NULLPTR;
 166
 167 ]AT_YYLEX_PROTOTYPE[
 168 {
 169   ]AT_USE_LEX_ARGS[
 170   return *input++;
 171 }
 172
 173 int
 174 main (int argc, const char* argv[])
 175 {
 176   assert (argc == 2); (void) argc;
 177   input = argv[1];
 178   if (getenv ("YYDEBUG"))
 179     yydebug = 1;
 180   return yyparse ();
 181 }
 182 ]])
 183
 184 AT_FULL_COMPILE([glr-regr1])
 185 AT_PARSER_CHECK([[glr-regr1 BPBPB]], 0,
 186 [[E -> 'B'
 187 E -> 'B'
 188 E -> E 'P' E
 189 E -> 'B'
 190 E -> E 'P' E
 191 E -> 'B'
 192 E -> E 'P' E
 193 E -> E 'P' E
 194 <OR>
 195 ]])
 196
 197 AT_BISON_OPTION_POPDEFS
 198 AT_CLEANUP
 199 ])
 200
 201 AT_TEST([%skeleton "glr.c"])
 202 AT_TEST([%skeleton "glr.cc"])
 203 AT_TEST([%skeleton "glr2.cc"])
 204
 205 m4_popdef([AT_TEST])
 206
 207
 208
 209 ## -------------------------------------------------------------- ##
 210 ## Improper handling of embedded actions and $-N in GLR parsers.  ##
 211 ## -------------------------------------------------------------- ##
 212
 213 m4_pushdef([AT_TEST],
 214 [AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers: $1])
 215
 216 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 217
 218 AT_DATA_GRAMMAR([glr-regr2a.y],
 219 [[/* Regression Test: Improper handling of embedded actions and $-N  */
 220 /* Reported by S. Eken */
 221
 222 %define api.value.type {char *}
 223 %code {
 224   #include <ctype.h>
 225   #include <stdio.h>
 226   #include <stdlib.h>
 227   #include <string.h>
 228   #include <assert.h>
 229   ]AT_YYERROR_DECLARE[
 230   ]AT_YYLEX_DECLARE[
 231 }
 232
 233 %define parse.assert
 234 %define parse.trace
 235 %glr-parser
 236 %expect 2
 237 ]$1[
 238
 239 %%
 240
 241 command:
 242     's' var 't'
 243        { printf ("Variable: '%s'\n", $][2); }
 244     'v' 'x' 'q'
 245        { free ($][2); }
 246   | 's' var_list 't' 'e'
 247        { printf ("Varlist: '%s'\n", $][2); free ($][2); }
 248   | 's' var 't' var_printer 'x'
 249        { free ($][2); }
 250   ;
 251
 252 var:
 253   'V'
 254      { $$ = $][1; }
 255   ;
 256
 257 var_list:
 258   var
 259     { $$ = $][1; }
 260   | var ',' var_list
 261     {
 262       char *s = YY_CAST (char *, realloc ($][1, strlen ($][1) + 1 + strlen ($][3) + 1));
 263       strcat (s, ",");
 264       strcat (s, $][3);
 265       free ($][3);
 266       $$ = s;
 267     }
 268   ;
 269
 270 var_printer: 'v'
 271    { printf ("Variable: '%s'\n", $-1); }
 272
 273 %%
 274 ]AT_YYERROR_DEFINE[
 275 FILE *input;
 276
 277 ]AT_YYLEX_PROTOTYPE[
 278 {
 279   char buf[50];
 280   ]AT_USE_LEX_ARGS[
 281   assert (!feof (stdin));
 282   switch (fscanf (input, " %1[a-z,]", buf))
 283   {
 284   case 1:
 285     return buf[0];
 286   case EOF:
 287     return 0;
 288   default:
 289     if (fscanf (input, "%49s", buf) != 1)
 290       return 0;
 291     else
 292       {
 293         char *s;
 294         assert (strlen (buf) < sizeof buf - 1);
 295         s = YY_CAST (char *, malloc (strlen (buf) + 1));
 296         strcpy (s, buf);
 297         ]AT_VAL[ = s;
 298         return 'V';
 299       }
 300     break;
 301   }
 302 }
 303
 304 ]AT_YYPARSE_DEFINE[
 305
 306 int
 307 main (int argc, char **argv)
 308 {
 309   int res;
 310   input = stdin;
 311   if (argc == 2 && !(input = fopen (argv[1], "r")))
 312     return 3;
 313   if (getenv ("YYDEBUG"))
 314     yydebug = 1;
 315   res = yyparse ();
 316   if (argc == 2 && fclose (input))
 317     return 4;
 318   return res;
 319 }
 320 ]])
 321
 322 AT_FULL_COMPILE([glr-regr2a],,,,[-rall])
 323
 324 AT_DATA([input1.txt],
 325 [[s VARIABLE_1 t v x q
 326 ]])
 327 AT_PARSER_CHECK([[glr-regr2a input1.txt]], 0,
 328 [[Variable: 'VARIABLE_1'
 329 ]])
 330
 331 AT_DATA([input2.txt],
 332 [[s VARIABLE_1 , ANOTHER_VARIABLE_2 t e
 333 ]])
 334 AT_PARSER_CHECK([[glr-regr2a input2.txt]],
 335 0,
 336 [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
 337 ]])
 338
 339 AT_DATA([input3.txt],
 340 [[s VARIABLE_3 t v x
 341 ]])
 342 AT_PARSER_CHECK([[glr-regr2a input3.txt]], 0,
 343 [[Variable: 'VARIABLE_3'
 344 ]])
 345
 346 AT_BISON_OPTION_POPDEFS
 347 AT_CLEANUP
 348 ])
 349
 350 AT_TEST([%skeleton "glr.c"])
 351 AT_TEST([%skeleton "glr.cc"])
 352 AT_TEST([%skeleton "glr2.cc"])
 353
 354 m4_popdef([AT_TEST])
 355
 356
 357 ## --------------------------------------------- ##
 358 ## Improper merging of GLR delayed action sets.  ##
 359 ## --------------------------------------------- ##
 360
 361 m4_pushdef([AT_TEST],
 362 [AT_SETUP([Improper merging of GLR delayed action sets: $1])
 363 AT_KEYWORDS([%merge])
 364
 365 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 366
 367 AT_DATA_GRAMMAR([glr-regr3.y],
 368 [[/* Regression Test: Improper merging of GLR delayed action sets.  */
 369 /* Reported by M. Rosien */
 370
 371 %code {
 372 #include <stdarg.h>
 373 #include <assert.h>
 374
 375 static int MergeRule (int x0, int x1);
 376 ]AT_YYERROR_DECLARE[
 377 ]AT_YYLEX_DECLARE[
 378
 379 #define RULE(x) (1 << (x))
 380
 381 }
 382
 383 %define parse.assert
 384 %define parse.trace
 385 %glr-parser
 386 %expect 1
 387 %expect-rr 2
 388 ]$1[
 389
 390 %token BAD_CHAR
 391 %token P1 P2 T1 T2 T3 T4 O1 O2
 392
 393 %%
 394
 395 S : P1 T4 O2 NT6 P2  { printf ("Result: %x\n", $][4); }
 396 ;
 397
 398 NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); }  %merge<MergeRule>
 399 ;
 400
 401 NT2 : NT1             { $$ = RULE(3); } %merge<MergeRule>
 402     | P1 NT1 O1 T3 P2 { $$ = RULE(4); } %merge<MergeRule>
 403 ;
 404
 405 NT3 : T3              { $$ = RULE(5); } %merge<MergeRule>
 406     | P1 NT1 O1 T3 P2 { $$ = RULE(6); } %merge<MergeRule>
 407 ;
 408
 409 NT4 : NT3              { $$ = RULE(7); } %merge<MergeRule>
 410     | NT2              { $$ = RULE(8); } %merge<MergeRule>
 411     | P1 NT2 O1 NT3 P2 { $$ = RULE(9); } %merge<MergeRule>
 412 ;
 413
 414 NT5 : NT4              { $$ = RULE(10); } %merge<MergeRule>
 415 ;
 416
 417 NT6 : P1 NT1 O1 T3 P2  { $$ = RULE(11) | $][2; } %merge<MergeRule>
 418     | NT5              { $$ = RULE(12) | $][1; } %merge<MergeRule>
 419 ;
 420
 421 %%
 422
 423 static int
 424 MergeRule (int x0, int x1)
 425 {
 426   return x0 | x1;
 427 }
 428 ]AT_YYERROR_DEFINE[
 429
 430 FILE *input = YY_NULLPTR;
 431
 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])[ };
 435
 436 ]AT_YYLEX_PROTOTYPE[
 437 {
 438   char inp[3];
 439   ]AT_USE_LEX_ARGS[
 440   assert (!feof (stdin));
 441   if (fscanf (input, "%2s", inp) == EOF)
 442     return 0;
 443   switch (inp[0])
 444     {
 445     case 'p': return P[inp[1] - '1'];
 446     case 't': return T[inp[1] - '1'];
 447     case 'o': return O[inp[1] - '1'];
 448     }
 449   return ]AT_TOKEN([BAD_CHAR])[;
 450 }
 451
 452 ]AT_YYPARSE_DEFINE[
 453
 454 int
 455 main (int argc, char* argv[])
 456 {
 457   int res;
 458   input = stdin;
 459   if (argc == 2 && !(input = fopen (argv[1], "r")))
 460     return 3;
 461   if (getenv ("YYDEBUG"))
 462     yydebug = 1;
 463   res = yyparse ();
 464   if (argc == 2 && fclose (input))
 465     return 4;
 466   return res;
 467 }
 468 ]])
 469
 470 AT_FULL_COMPILE([glr-regr3],,,,[-rall])
 471
 472 AT_DATA([input.txt],
 473 [[p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2
 474 ]])
 475 AT_PARSER_CHECK([[glr-regr3 input.txt]],
 476 0,
 477 [[Result: 1c04
 478 ]])
 479
 480 AT_BISON_OPTION_POPDEFS
 481 AT_CLEANUP
 482 ])
 483
 484 AT_TEST([%skeleton "glr.c"])
 485 AT_TEST([%skeleton "glr.cc"])
 486 AT_TEST([%skeleton "glr2.cc"])
 487
 488 m4_popdef([AT_TEST])
 489
 490
 491 ## ------------------------------------------------------------ ##
 492 ## Duplicate representation of merged trees.  See               ##
 493 ## <https://lists.gnu.org/r/help-bison/2005-07/msg00013.html>.  ##
 494 ## ------------------------------------------------------------ ##
 495
 496 m4_pushdef([AT_TEST],
 497 [AT_SETUP([Duplicate representation of merged trees: $1])
 498 AT_KEYWORDS([%merge])
 499
 500 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 501
 502 AT_DATA_GRAMMAR([glr-regr4.y],
 503 [[
 504 %define parse.assert
 505 %define parse.trace
 506 %type <]AT_VALUE_UNION_IF([char*], [ptr])[> S A A1 A2 B
 507 %glr-parser
 508 %expect-rr 2
 509 ]$1[
 510
 511 %code {
 512   #include <string.h>
 513   static char *merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
 514   static char *make_value (char const *, char const *);
 515   ]AT_YYERROR_DECLARE[
 516   ]AT_YYLEX_DECLARE[
 517   static char *ptrs[100];
 518   static char **ptrs_next = ptrs;
 519 }
 520
 521 %%
 522
 523 tree: S { printf ("%s\n", $][1); } ;
 524
 525 S : A %merge<merge> { $$ = make_value ("S", $][1); }
 526   | B %merge<merge> { $$ = make_value ("S", $][1); }
 527   ;
 528
 529 A : A1 %merge<merge> { $$ = make_value ("A", $][1); }
 530   | A2 %merge<merge> { $$ = make_value ("A", $][1); }
 531   ;
 532
 533 A1: 'a' { $$ = make_value ("A1", "'a'"); } ;
 534 A2: 'a' { $$ = make_value ("A2", "'a'"); } ;
 535 B:  'a' { $$ = make_value ("B", "'a'");  } ;
 536
 537 %%
 538 ]AT_YYERROR_DEFINE[
 539 ]AT_YYPARSE_DEFINE[
 540 ]AT_YYLEX_DEFINE(["a"])[
 541
 542 int
 543 main (void)
 544 {
 545   int status = -1;
 546   if (getenv ("YYDEBUG"))
 547     yydebug = 1;
 548   status = yyparse ();
 549   while (ptrs_next != ptrs)
 550     free (*--ptrs_next);
 551   return status;
 552 }
 553
 554 static char *
 555 make_value (char const *parent, char const *child)
 556 {
 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);
 561   return value;
 562 }
 563
 564 static char *
 565 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
 566 {
 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);]])[
 574   return res;
 575 }
 576 ]])
 577
 578 AT_FULL_COMPILE([glr-regr4],,,,[-rall])
 579
 580 AT_PARSER_CHECK([[glr-regr4]], 0,
 581 [[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
 582 ]], [])
 583
 584 AT_BISON_OPTION_POPDEFS
 585 AT_CLEANUP
 586 ])
 587
 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"])
 591
 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"])
 595
 596 m4_popdef([AT_TEST])
 597
 598
 599 ## --------------------------------------------------------------- ##
 600 ## User destructor for unresolved GLR semantic value.  See         ##
 601 ## <https://lists.gnu.org/r/bison-patches/2005-08/msg00016.html>.  ##
 602 ## --------------------------------------------------------------- ##
 603
 604 m4_pushdef([AT_TEST],
 605 [AT_SETUP([User destructor for unresolved GLR semantic value: $1])
 606
 607 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 608 AT_DATA_GRAMMAR([glr-regr5.y],
 609 [[
 610 %code {
 611   ]AT_YYERROR_DECLARE[
 612   ]AT_YYLEX_DECLARE[
 613   enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */
 614 }
 615
 616 %define parse.assert
 617 %define parse.trace
 618 %glr-parser
 619 %expect 0
 620 %expect-rr 1
 621 ]$1[
 622
 623 %union { int value; }
 624 %type <value> start
 625
 626 %destructor {
 627   if ($$ != MAGIC_VALUE)
 628     {
 629       fprintf (stderr, "Bad destructor call.\n");
 630       exit (EXIT_FAILURE);
 631     }
 632 } start
 633
 634 %%
 635
 636 start:
 637    'a' { $$ = MAGIC_VALUE; }
 638    | 'a' { $$ = MAGIC_VALUE; }
 639    ;
 640
 641 %%
 642 ]AT_YYERROR_DEFINE[
 643 ]AT_YYLEX_DEFINE(["a"])[
 644 ]AT_MAIN_DEFINE[
 645 ]])
 646
 647 AT_FULL_COMPILE([glr-regr5],,,, [-rall])
 648
 649 AT_PARSER_CHECK([[glr-regr5]], 1, [],
 650 [Ambiguity detected.
 651 Option 1,
 652   start -> <Rule 1, tokens 1 .. 1>
 653     'a' <tokens 1 .. 1>
 654
 655 Option 2,
 656   start -> <Rule 2, tokens 1 .. 1>
 657     'a' <tokens 1 .. 1>
 658
 659 syntax is ambiguous
 660 ])
 661
 662 AT_BISON_OPTION_POPDEFS
 663 AT_CLEANUP
 664 ])
 665
 666 AT_TEST([%skeleton "glr.c"])
 667 AT_TEST([%skeleton "glr.cc"])
 668 AT_TEST([%skeleton "glr2.cc"])
 669
 670 m4_popdef([AT_TEST])
 671
 672
 673
 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 ## --------------------------------------------------------------- ##
 678
 679 m4_pushdef([AT_TEST],
 680 [AT_SETUP([User destructor after an error during a split parse: $1])
 681
 682 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 683 AT_DATA_GRAMMAR([glr-regr6.y],
 684 [[
 685 %code {
 686   ]AT_YYERROR_DECLARE[
 687   ]AT_YYLEX_DECLARE[
 688 }
 689
 690 %define parse.assert
 691 %define parse.trace
 692 %glr-parser
 693 %expect-rr 1
 694 ]$1[
 695
 696 %union { int value; }
 697 %type <value> 'a'
 698
 699 %destructor {
 700   printf ("Destructor called.\n");
 701 } 'a'
 702
 703 %%
 704
 705 start: 'a' | 'a' ;
 706
 707 %%
 708 ]AT_YYERROR_DEFINE[
 709 ]AT_YYLEX_DEFINE(["a"])[
 710 ]AT_MAIN_DEFINE[
 711 ]])
 712
 713 AT_FULL_COMPILE([glr-regr6],,,, [-rall])
 714
 715 AT_PARSER_CHECK([[glr-regr6]], 1,
 716 [Destructor called.
 717 ],
 718 [Ambiguity detected.
 719 Option 1,
 720   start -> <Rule 1, tokens 1 .. 1>
 721     'a' <tokens 1 .. 1>
 722
 723 Option 2,
 724   start -> <Rule 2, tokens 1 .. 1>
 725     'a' <tokens 1 .. 1>
 726
 727 syntax is ambiguous
 728 ])
 729
 730 AT_BISON_OPTION_POPDEFS
 731 AT_CLEANUP
 732 ])
 733
 734 AT_TEST([%skeleton "glr.c"])
 735 AT_TEST([%skeleton "glr.cc"])
 736 AT_TEST([%skeleton "glr2.cc"])
 737
 738 m4_popdef([AT_TEST])
 739
 740
 741
 742 ## --------------------------------------------------------------- ##
 743 ## Duplicated user destructor for lookahead.  See                  ##
 744 ## <https://lists.gnu.org/r/bison-patches/2005-08/msg00035.html>.  ##
 745 ## --------------------------------------------------------------- ##
 746
 747 m4_pushdef([AT_TEST],
 748 [AT_SETUP([Duplicated user destructor for lookahead: $1])
 749
 750 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 751
 752 AT_DATA_GRAMMAR([glr-regr7.y],
 753 [[
 754 %code requires {
 755   typedef struct count_node {
 756     int count;
 757     struct count_node *prev;
 758   } count_node;
 759 }
 760
 761 %code {
 762   ]AT_YYERROR_DECLARE[
 763   ]AT_YYLEX_DECLARE[
 764   #define YYSTACKEXPANDABLE 0
 765   static count_node *tail;
 766 }
 767
 768 %define parse.assert
 769 %define parse.trace
 770 %glr-parser
 771 %expect-rr 2
 772 ]$1[
 773
 774 %union { count_node *node; }
 775 %type <node> 'a'
 776
 777 %destructor {
 778   if ($$->count++)
 779     fprintf (stderr, "Destructor called on same value twice.\n");
 780 } 'a'
 781
 782 %%
 783
 784 start:
 785     stack1 start
 786   | stack2 start
 787   | %empty
 788   ;
 789 stack1: 'a' ;
 790 stack2: 'a' ;
 791
 792 %%
 793
 794 ]AT_YYLEX_PROTOTYPE[
 795 {
 796   ]AT_USE_LEX_ARGS[
 797   ]AT_VAL[.node = YY_CAST (count_node*, malloc (sizeof *]AT_VAL[.node));
 798   if (!]AT_VAL[.node)
 799     {
 800       fprintf (stderr, "Test inconclusive.\n");
 801       exit (EXIT_FAILURE);
 802     }
 803   ]AT_VAL[.node->count = 0;
 804   ]AT_VAL[.node->prev = tail;
 805   tail = ]AT_VAL[.node;
 806   return 'a';
 807 }
 808
 809 ]AT_YYERROR_DEFINE[
 810 ]AT_YYPARSE_DEFINE[
 811
 812 int
 813 main (void)
 814 {
 815   int status;
 816   if (getenv ("YYDEBUG"))
 817     yydebug = 1;
 818   status = yyparse ();
 819   while (tail)
 820     {
 821       count_node *prev = tail->prev;
 822       free (tail);
 823       tail = prev;
 824     }
 825   return status;
 826 }
 827 ]])
 828
 829 AT_FULL_COMPILE([glr-regr7],,,, [-rall])
 830
 831 AT_PARSER_CHECK([[glr-regr7]], 2, [],
 832 [memory exhausted
 833 ])
 834
 835 AT_BISON_OPTION_POPDEFS
 836 AT_CLEANUP
 837 ])
 838
 839 AT_TEST([%skeleton "glr.c"])
 840 AT_TEST([%skeleton "glr.cc"])
 841 AT_TEST([%skeleton "glr2.cc"])
 842
 843 m4_popdef([AT_TEST])
 844
 845
 846
 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 ## ------------------------------------------------------------------------- ##
 853
 854 m4_pushdef([AT_TEST],
 855 [AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR: $1])
 856
 857 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
 858
 859 AT_DATA_GRAMMAR([glr-regr8.y],
 860 [[
 861 %code {
 862   ]AT_YYERROR_DECLARE[
 863   ]AT_YYLEX_DECLARE[
 864 }
 865
 866 %define parse.assert
 867 %define parse.trace
 868 %glr-parser
 869 %expect-rr 1
 870 ]$1[
 871
 872 %token T_CONSTANT
 873 %token T_PORT
 874 %token T_SIGNAL
 875
 876 %%
 877
 878
 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[); }
 884         ;
 885
 886 InterfaceDeclaration    : OptConstantWord       %dprec 1
 887         | OptSignalWord %dprec 2
 888         ;
 889
 890 OptConstantWord : %empty
 891         | T_CONSTANT
 892         ;
 893
 894 OptSignalWord   : %empty
 895                 { printf("empty: %d/%d\n", @$.]AT_FIRST_COLUMN[, @$.]AT_LAST_COLUMN[); }
 896         | T_SIGNAL
 897         ;
 898
 899 %%
 900
 901 ]AT_YYERROR_DEFINE[
 902 static int lexIndex;
 903
 904 ]AT_YYLEX_PROTOTYPE[
 905 {
 906   ]AT_USE_LEX_ARGS[
 907   lexIndex += 1;
 908   switch (lexIndex)
 909     {
 910     default:
 911       abort ();
 912     case 1:
 913       ]AT_LOC_FIRST_COLUMN[ = 1;
 914       ]AT_LOC_LAST_COLUMN[ = 9;
 915       return ]AT_TOKEN([T_PORT])[;
 916     case 2:
 917       ]AT_LOC_FIRST_COLUMN[ = 13;
 918       ]AT_LOC_LAST_COLUMN[ = 17;
 919       return ]AT_TOKEN([T])[_PORT;
 920     case 3:
 921       return 0;
 922     }
 923 }
 924
 925 ]AT_MAIN_DEFINE[
 926 ]])
 927
 928 AT_FULL_COMPILE([glr-regr8],,,, [-rall])
 929
 930 AT_PARSER_CHECK([[glr-regr8]], 0,
 931 [empty: 9/9
 932 1/9 - 9/9 - 13/17
 933 ],
 934 [])
 935
 936 AT_BISON_OPTION_POPDEFS
 937 AT_CLEANUP
 938 ])
 939
 940 AT_TEST([%skeleton "glr.c"])
 941 AT_TEST([%skeleton "glr.cc"])
 942 AT_TEST([%skeleton "glr2.cc"])
 943
 944 m4_popdef([AT_TEST])
 945
 946
 947
 948 ## --------------------------------------------------------------- ##
 949 ## No users destructors if stack 0 deleted.  See                   ##
 950 ## <https://lists.gnu.org/r/bison-patches/2005-09/msg00109.html>.  ##
 951 ## --------------------------------------------------------------- ##
 952
 953 m4_pushdef([AT_TEST],
 954 [AT_SETUP([No users destructors if stack 0 deleted: $1])
 955
 956 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
 957 AT_DATA_GRAMMAR([glr-regr9.y],
 958 [[
 959 %code {
 960   ]AT_YYERROR_DECLARE[
 961   ]AT_YYLEX_DECLARE[
 962 # define YYSTACKEXPANDABLE 0
 963   static int tokens = 0;
 964   static int destructors = 0;
 965 # define USE(Var)
 966 }
 967
 968 %define parse.assert
 969 %define parse.trace
 970 %glr-parser
 971 %expect-rr 2
 972 ]$1[
 973
 974 %union { int dummy; }
 975 %type <dummy> 'a'
 976
 977 %destructor {
 978   destructors += 1;
 979 } 'a'
 980
 981 %%
 982
 983 start:
 984     ambig0 'a'   { destructors += 2; USE ($][2); }
 985   | ambig1 start { destructors += 1; }
 986   | ambig2 start { destructors += 1; }
 987   ;
 988
 989 ambig0: 'a' ;
 990 ambig1: 'a' ;
 991 ambig2: 'a' ;
 992
 993 %%
 994
 995 ]AT_YYLEX_PROTOTYPE[
 996 {
 997   ]AT_USE_LEX_ARGS[
 998   tokens += 1;
 999   return 'a';
1000 }
1001
1002 ]AT_YYERROR_DEFINE[
1003 ]AT_YYPARSE_DEFINE[
1004
1005 int
1006 main (void)
1007 {
1008   int status;
1009   if (getenv ("YYDEBUG"))
1010     yydebug = 1;
1011   status = yyparse ();
1012   if (tokens != destructors)
1013     {
1014       fprintf (stderr, "Tokens = %d, Destructors = %d\n", tokens, destructors);
1015       return 10;
1016     }
1017   return status;
1018 }
1019 ]])
1020
1021 AT_FULL_COMPILE([glr-regr9],,,, [-rall])
1022
1023 # Exit 2: memory exhausted.
1024 AT_PARSER_CHECK([[glr-regr9]], 2, [],
1025 [memory exhausted
1026 ])
1027
1028 AT_BISON_OPTION_POPDEFS
1029 AT_CLEANUP
1030 ])
1031
1032 AT_TEST([%skeleton "glr.c"])
1033 AT_TEST([%skeleton "glr.cc"])
1034 AT_TEST([%skeleton "glr2.cc"])
1035
1036 m4_popdef([AT_TEST])
1037
1038
1039
1040 ## ------------------------------------------------------ ##
1041 ## Corrupted semantic options if user action cuts parse.  ##
1042 ## ------------------------------------------------------ ##
1043
1044 m4_pushdef([AT_TEST],
1045 [AT_SETUP([Corrupted semantic options if user action cuts parse: $1])
1046
1047 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1048 AT_DATA_GRAMMAR([glr-regr10.y],
1049 [[
1050 %code {
1051   ]AT_YYERROR_DECLARE[
1052   ]AT_YYLEX_DECLARE[
1053   #define GARBAGE_SIZE 50
1054   static char garbage[GARBAGE_SIZE];
1055 }
1056
1057 %define parse.assert
1058 %define parse.trace
1059 %glr-parser
1060 %expect-rr 1
1061 ]$1[
1062
1063 %union { char *ptr; }
1064 %type <ptr> start
1065
1066 %%
1067
1068 start:
1069     %dprec 2 { $$ = garbage; YYACCEPT; }
1070   | %dprec 1 { $$ = garbage; YYACCEPT; }
1071   ;
1072
1073 %%
1074 ]AT_YYERROR_DEFINE[
1075 ]AT_YYPARSE_DEFINE[
1076 ]AT_YYLEX_DEFINE[
1077
1078 int
1079 main (void)
1080 {
1081   int i;
1082   for (i = 0; i < GARBAGE_SIZE; i+=1)
1083     garbage[i] = 108;
1084   if (getenv ("YYDEBUG"))
1085     yydebug = 1;
1086   return yyparse ();
1087 }
1088 ]])
1089
1090 AT_FULL_COMPILE([glr-regr10],,,, [-rall])
1091
1092 AT_PARSER_CHECK([[glr-regr10]], 0, [], [])
1093
1094 AT_BISON_OPTION_POPDEFS
1095 AT_CLEANUP
1096 ])
1097
1098 AT_TEST([%skeleton "glr.c"])
1099 AT_TEST([%skeleton "glr.cc"])
1100 AT_TEST([%skeleton "glr2.cc"])
1101
1102 m4_popdef([AT_TEST])
1103
1104
1105
1106 ## --------------------------------------------------- ##
1107 ## Undesirable destructors if user action cuts parse.  ##
1108 ## --------------------------------------------------- ##
1109
1110 m4_pushdef([AT_TEST],
1111 [AT_SETUP([Undesirable destructors if user action cuts parse: $1])
1112
1113 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1114 AT_DATA_GRAMMAR([glr-regr11.y],
1115 [[
1116 %code {
1117   ]AT_YYERROR_DECLARE[
1118   ]AT_YYLEX_DECLARE[
1119   static int destructors = 0;
1120 # define USE(val)
1121 }
1122
1123 %define parse.assert
1124 %define parse.trace
1125 %glr-parser
1126 %expect-rr 1
1127 ]$1[
1128
1129 %union { int dummy; }
1130 %type <int> 'a'
1131 %destructor { destructors += 1; } 'a'
1132
1133 %%
1134
1135 start:
1136     'a' %dprec 2 { USE ($][1); destructors += 1; YYACCEPT; }
1137   | 'a' %dprec 1 { USE ($][1); destructors += 1; YYACCEPT; }
1138   ;
1139
1140 %%
1141
1142 ]AT_YYERROR_DEFINE[
1143 ]AT_YYPARSE_DEFINE[
1144 ]AT_YYLEX_DEFINE(["a"])[
1145
1146 int
1147 main (void)
1148 {
1149   int status;
1150   if (getenv ("YYDEBUG"))
1151     yydebug = 1;
1152   status = yyparse ();
1153   if (destructors != 1)
1154     {
1155       fprintf (stderr, "Destructor calls: %d\n", destructors);
1156       return 1;
1157     }
1158   return status;
1159 }
1160 ]])
1161
1162 AT_FULL_COMPILE([glr-regr11],,,, [-rall])
1163
1164 AT_PARSER_CHECK([[glr-regr11]], 0, [], [])
1165
1166 AT_BISON_OPTION_POPDEFS
1167 AT_CLEANUP
1168 ])
1169
1170 AT_TEST([%skeleton "glr.c"])
1171 AT_TEST([%skeleton "glr.cc"])
1172 AT_TEST([%skeleton "glr2.cc"])
1173
1174 m4_popdef([AT_TEST])
1175
1176
1177
1178 ## -------------------------------------------------- ##
1179 ## Leaked semantic values if user action cuts parse.  ##
1180 ## -------------------------------------------------- ##
1181
1182 m4_pushdef([AT_TEST],
1183 [AT_SETUP([Leaked semantic values if user action cuts parse: $1])
1184 AT_KEYWORDS([%merge])
1185
1186 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1187 AT_DATA_GRAMMAR([glr-regr12.y],
1188 [[
1189 %define parse.assert
1190 %define parse.trace
1191 %glr-parser
1192 %expect 1
1193 %expect-rr 1
1194 ]$1[
1195
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
1202
1203 %code {
1204 # include <assert.h>
1205   static int merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
1206   ]AT_YYERROR_DECLARE[
1207   ]AT_YYLEX_DECLARE[
1208   static int parent_rhs_before_value = 0;
1209   static int merged_value = 0;
1210   static int parent_rhs_after_value = 0;
1211 # define USE(val)
1212 }
1213
1214 %%
1215
1216 start:
1217   alt1 %dprec 1
1218   | alt2 %dprec 2
1219   ;
1220
1221 alt1:
1222   PARENT_RHS_AFTER {
1223     USE ($][1);
1224     parent_rhs_after_value = 0;
1225   }
1226   ;
1227
1228 alt2:
1229   parent_rhs_before merged PARENT_RHS_AFTER {
1230     USE (($][1, $][2, $][3));
1231     parent_rhs_before_value = 0;
1232     merged_value = 0;
1233     parent_rhs_after_value = 0;
1234   }
1235   ;
1236
1237 parent_rhs_before:
1238   {
1239     USE ($$);
1240     parent_rhs_before_value = 1;
1241   }
1242   ;
1243
1244 merged:
1245   %merge<merge> {
1246     USE ($$);
1247     merged_value = 1;
1248   }
1249   | cut %merge<merge> {
1250     USE ($$);
1251     merged_value = 1;
1252   }
1253   ;
1254
1255 cut: { YYACCEPT; } ;
1256
1257 %%
1258
1259 static int
1260 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
1261 {
1262   /* Not invoked. */
1263   return s1.dummy + s2.dummy;
1264 }
1265
1266 ]AT_YYERROR_DEFINE[
1267 ]AT_YYPARSE_DEFINE[
1268 ]AT_YYLEX_DEFINE([{ ]AT_TOKEN([PARENT_RHS_AFTER])[, 0 }],
1269  [if (res == ]AT_TOKEN([PARENT_RHS_AFTER])[)
1270     parent_rhs_after_value = 1;])[
1271
1272 int
1273 main (void)
1274 {
1275   int status;
1276   if (getenv ("YYDEBUG"))
1277     yydebug = 1;
1278   status = yyparse ();
1279   if (parent_rhs_before_value)
1280     {
1281       fprintf (stderr, "'parent_rhs_before' destructor not called.\n");
1282       status = 1;
1283     }
1284   if (merged_value)
1285     {
1286       fprintf (stderr, "'merged' destructor not called.\n");
1287       status = 1;
1288     }
1289   if (parent_rhs_after_value)
1290     {
1291       fprintf (stderr, "'PARENT_RHS_AFTER' destructor not called.\n");
1292       status = 1;
1293     }
1294   return status;
1295 }
1296 ]])
1297
1298 AT_FULL_COMPILE([glr-regr12],,,, [-rall])
1299
1300 AT_PARSER_CHECK([[glr-regr12]], 0, [], [])
1301
1302 AT_BISON_OPTION_POPDEFS
1303 AT_CLEANUP
1304 ])
1305
1306 AT_TEST([%skeleton "glr.c"])
1307 AT_TEST([%skeleton "glr.cc"])
1308 AT_TEST([%skeleton "glr2.cc"])
1309
1310 m4_popdef([AT_TEST])
1311
1312
1313
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 ## --------------------------------------------------------------- ##
1319
1320 m4_pushdef([AT_TEST],
1321 [AT_SETUP([Incorrect lookahead during deterministic GLR: $1])
1322
1323 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1324 AT_DATA_GRAMMAR([glr-regr13.y],
1325 [[
1326 /* Tests:
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.  */
1332
1333 %code {
1334   #include <assert.h>
1335   ]AT_YYERROR_DECLARE[
1336   ]AT_YYLEX_DECLARE[
1337   ]AT_PRINT_LOOKAHEAD_DECLARE[
1338   #define USE(value)
1339 }
1340
1341 %define parse.assert
1342 %define parse.trace
1343 %locations
1344 %glr-parser
1345 ]$1[
1346
1347 %union { char value; }
1348 %type <value> 'a' 'b'
1349
1350 %%
1351
1352 start:
1353   defstate_init defstate_shift 'b' change_lookahead 'a'
1354     {
1355       USE ($][3);
1356       PRINT_LOOKAHEAD ("start <- defstate_init defstate_shift 'b'");
1357     }
1358 ;
1359
1360 defstate_init:
1361   %empty
1362     {
1363       PRINT_LOOKAHEAD ("defstate_init <- empty string");
1364     }
1365 ;
1366
1367 defstate_shift:
1368   nondefstate defstate_look 'a'
1369     {
1370       USE ($][3);
1371       PRINT_LOOKAHEAD ("defstate_shift <- nondefstate defstate_look 'a'");
1372     }
1373 ;
1374
1375 defstate_look:
1376   %empty
1377     {
1378       PRINT_LOOKAHEAD ("defstate_look <- empty string");
1379     }
1380 ;
1381
1382 nondefstate:
1383   %empty
1384     {
1385       PRINT_LOOKAHEAD ("nondefstate <- empty string");
1386     }
1387 | 'b'
1388     {
1389       USE ($][1);
1390       PRINT_LOOKAHEAD ("nondefstate <- 'b'");
1391     }
1392 ;
1393
1394 change_lookahead:
1395   %empty
1396     {
1397       ]AT_GLR2_CC_IF([[yytoken = yy::parser::yytranslate_ ('a')]], [[yychar = 'a']])[;
1398     }
1399 ;
1400
1401 %%
1402
1403 ]AT_YYERROR_DEFINE[
1404 ]AT_YYPARSE_DEFINE[
1405 ]AT_PRINT_LOOKAHEAD_DEFINE[
1406 ]AT_YYLEX_DEFINE(["ab"],
1407                  []AT_VAL[.value = YY_CAST (char, res + 'A' - 'a')])[
1408
1409 int
1410 main (void)
1411 {
1412 ]AT_CXX_IF([], [[
1413   yychar = '#'; /* Not a token in the grammar.  */
1414   yylval.value = '!';
1415 ]])[
1416   if (getenv ("YYDEBUG"))
1417     yydebug = 1;
1418   return yyparse ();
1419 }
1420 ]])
1421
1422 AT_FULL_COMPILE([glr-regr13],,,, [-rall])
1423
1424 AT_PARSER_CHECK([[glr-regr13]], 0,
1425 [defstate_init <- empty string:
1426   yychar=YYEMPTY
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':
1432   yychar=YYEMPTY
1433 start <- defstate_init defstate_shift 'b':
1434   yychar=YYEMPTY
1435 ], [])
1436
1437 AT_BISON_OPTION_POPDEFS
1438 AT_CLEANUP
1439 ])
1440
1441 AT_TEST([%skeleton "glr.c"])
1442 AT_TEST([%skeleton "glr.cc"])
1443 AT_TEST([%skeleton "glr2.cc"])
1444
1445 m4_popdef([AT_TEST])
1446
1447
1448
1449 ## ------------------------------------------------- ##
1450 ## Incorrect lookahead during nondeterministic GLR.  ##
1451 ## ------------------------------------------------- ##
1452
1453 m4_pushdef([AT_TEST],
1454 [AT_SETUP([Incorrect lookahead during nondeterministic GLR: $1])
1455 AT_KEYWORDS([%merge])
1456
1457 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1458
1459 AT_DATA_GRAMMAR([glr-regr14.y],
1460 [[
1461 /* Tests:
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
1476        entered.
1477      - If only defaulted states are entered, there are no conflicts, so
1478        nondeterministic operation does not start.  */
1479
1480 %define parse.assert
1481 %define parse.trace
1482 %type <value> 'a' 'b' 'c' 'd' stack_explosion
1483 %glr-parser
1484 %expect 0
1485 %expect-rr 5
1486 ]$1[
1487 %locations
1488
1489 %union { char value; }
1490
1491 %code {
1492   #include <assert.h>
1493   ]AT_YYERROR_DECLARE[
1494   ]AT_YYLEX_DECLARE[
1495   ]AT_PRINT_LOOKAHEAD_DECLARE[
1496   static char merge (]AT_YYSTYPE[, ]AT_YYSTYPE[);
1497   #define USE(value)
1498 }
1499
1500 %%
1501
1502 start:
1503   merge 'c' stack_explosion
1504     {
1505       USE ($][2); USE ($][3);
1506       PRINT_LOOKAHEAD ("start <- merge 'c' stack_explosion");
1507     }
1508 ;
1509
1510 /* When merging the 2 deferred actions, the lookahead needs are different.  */
1511 merge:
1512   nonconflict1 'a' 'b' nonconflict2 %dprec 1
1513     {
1514       USE ($][2); USE ($][3);
1515       PRINT_LOOKAHEAD ("merge <- nonconflict1 'a' 'b' nonconflict2");
1516     }
1517 | conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2
1518     {
1519       USE ($][3); USE ($][5);
1520       PRINT_LOOKAHEAD ("merge <- conflict defstate_look 'a' nonconflict2 'b'"
1521                        " defstate_shift");
1522     }
1523 ;
1524
1525 nonconflict1:
1526   %empty
1527     {
1528       PRINT_LOOKAHEAD ("nonconflict1 <- empty string");
1529     }
1530 ;
1531
1532 nonconflict2:
1533   %empty
1534     {
1535       PRINT_LOOKAHEAD ("nonconflict2 <- empty string");
1536     }
1537 | 'a'
1538     {
1539       USE ($][1);
1540       PRINT_LOOKAHEAD ("nonconflict2 <- 'a'");
1541     }
1542 ;
1543
1544 conflict:
1545   %empty
1546   {
1547     PRINT_LOOKAHEAD ("conflict <- empty string");
1548   }
1549 ;
1550
1551 defstate_look:
1552   %empty
1553   {
1554     PRINT_LOOKAHEAD ("defstate_look <- empty string");
1555   }
1556 ;
1557
1558 /* yychar != YYEMPTY but lookahead need is yyfalse.  */
1559 defstate_shift:
1560   %empty
1561   {
1562     PRINT_LOOKAHEAD ("defstate_shift <- empty string");
1563   }
1564 ;
1565
1566 stack_explosion:
1567   %empty { $$ = '\0'; }
1568 | alt1 stack_explosion %merge<merge> { $$ = $][2; }
1569 | alt2 stack_explosion %merge<merge> { $$ = $][2; }
1570 | alt3 stack_explosion %merge<merge> { $$ = $][2; }
1571 ;
1572
1573 alt1:
1574   'd' no_look
1575     {
1576       USE ($][1);
1577       if (]AT_GLR2_CC_IF(
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.");
1581     }
1582 ;
1583
1584 alt2:
1585   'd' no_look
1586     {
1587       USE ($][1);
1588       if (]AT_GLR2_CC_IF(
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.");
1592     }
1593 ;
1594
1595 alt3:
1596   'd' no_look
1597     {
1598       USE ($][1);
1599         if (]AT_GLR2_CC_IF(
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.");
1603     }
1604 ;
1605
1606 no_look:
1607   %empty
1608     {
1609       if (]AT_GLR2_CC_IF(
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.");
1613     }
1614 ;
1615
1616 %%
1617
1618 ]AT_YYERROR_DEFINE[
1619 ]AT_YYPARSE_DEFINE[
1620 ]AT_PRINT_LOOKAHEAD_DEFINE[
1621
1622 ]AT_YYLEX_PROTOTYPE[
1623 {
1624   ]AT_USE_LEX_ARGS[
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++];
1632 }
1633
1634 static char
1635 merge (]AT_YYSTYPE[ s1, ]AT_YYSTYPE[ s2)
1636 {
1637   return YY_CAST (char, s1.value + s2.value);
1638 }
1639
1640 int
1641 main (void)
1642 {
1643 ]AT_CXX_IF([], [[
1644   yychar = '#'; /* Not a token in the grammar.  */
1645   yylval.value = '!';
1646 ]])[
1647   if (getenv ("YYDEBUG"))
1648     yydebug = 1;
1649   return yyparse ();
1650 }
1651 ]])
1652
1653 AT_FULL_COMPILE([glr-regr14],,,, [-rall])
1654
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:
1663   yychar=YYEMPTY
1664 merge <- conflict defstate_look 'a' nonconflict2 'b' defstate_shift:
1665   yychar=YYEMPTY
1666 start <- merge 'c' stack_explosion:
1667   yychar=YYEOF
1668 ], [])
1669
1670 AT_BISON_OPTION_POPDEFS
1671 AT_CLEANUP
1672 ])
1673
1674 AT_TEST([%skeleton "glr.c"])
1675 AT_TEST([%skeleton "glr.cc"])
1676 AT_TEST([%skeleton "glr2.cc"])
1677
1678 m4_popdef([AT_TEST])
1679
1680
1681
1682 ## ------------------------------------------------- ##
1683 ## Leaked semantic values when reporting ambiguity.  ##
1684 ## ------------------------------------------------- ##
1685
1686 m4_pushdef([AT_TEST],
1687 [AT_SETUP([Leaked semantic values when reporting ambiguity: $1])
1688
1689 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1690
1691 AT_DATA_GRAMMAR([glr-regr15.y],
1692 [[
1693 %define parse.assert
1694 %define parse.trace
1695 %glr-parser
1696 %expect 0
1697 %expect-rr 2
1698 ]$1[
1699
1700 %destructor { parent_rhs_before_value = 0; } parent_rhs_before
1701
1702 %code {
1703   ]AT_YYERROR_DECLARE[
1704   ]AT_YYLEX_DECLARE[
1705   static int parent_rhs_before_value = 0;
1706 # define USE(val)
1707 }
1708
1709 %%
1710
1711 start:
1712   alt1 %dprec 1
1713   | alt2 %dprec 2
1714   ;
1715
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.  */
1721 alt1: ;
1722
1723 alt2:
1724   parent_rhs_before ambiguity {
1725     USE ($][1);
1726     parent_rhs_before_value = 0;
1727   }
1728   ;
1729
1730 parent_rhs_before:
1731   {
1732     USE ($$);
1733     parent_rhs_before_value = 1;
1734   }
1735   ;
1736
1737 ambiguity: ambiguity1 | ambiguity2 ;
1738 ambiguity1: ;
1739 ambiguity2: ;
1740
1741 %%
1742 ]AT_YYERROR_DEFINE[
1743 ]AT_YYPARSE_DEFINE[
1744 ]AT_YYLEX_DEFINE[
1745
1746 int
1747 main (void)
1748 {
1749   int status;
1750   if (getenv ("YYDEBUG"))
1751     yydebug = 1;
1752   status = yyparse () != 1;
1753   if (parent_rhs_before_value)
1754     {
1755       fprintf (stderr, "'parent_rhs_before' destructor not called.\n");
1756       status = 1;
1757     }
1758   return status;
1759 }
1760 ]])
1761
1762 AT_FULL_COMPILE([glr-regr15],,,, [-rall])
1763
1764 AT_PARSER_CHECK([[glr-regr15]], 0, [],
1765 [Ambiguity detected.
1766 Option 1,
1767   ambiguity -> <Rule 6, empty>
1768     ambiguity1 -> <Rule 8, empty>
1769
1770 Option 2,
1771   ambiguity -> <Rule 7, empty>
1772     ambiguity2 -> <Rule 9, empty>
1773
1774 syntax is ambiguous
1775 ])
1776
1777 AT_BISON_OPTION_POPDEFS
1778 AT_CLEANUP
1779 ])
1780
1781 AT_TEST([%skeleton "glr.c"])
1782 AT_TEST([%skeleton "glr.cc"])
1783 AT_TEST([%skeleton "glr2.cc"])
1784
1785 m4_popdef([AT_TEST])
1786
1787
1788
1789 ## ------------------------------------------------------------ ##
1790 ## Leaked lookahead after nondeterministic parse syntax error.  ##
1791 ## ------------------------------------------------------------ ##
1792
1793 m4_pushdef([AT_TEST],
1794 [AT_SETUP([Leaked lookahead after nondeterministic parse syntax error: $1])
1795
1796 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1797 AT_DATA_GRAMMAR([glr-regr16.y],
1798 [[
1799 %define parse.assert
1800 %define parse.trace
1801 %glr-parser
1802 %expect 0
1803 %expect-rr 1
1804 ]$1[
1805
1806 %destructor { lookahead_value = 0; } 'b'
1807
1808 %code {
1809 # include <assert.h>
1810   ]AT_YYERROR_DECLARE[
1811   ]AT_YYLEX_DECLARE[
1812   static int lookahead_value = 0;
1813 # define USE(val)
1814 }
1815
1816 %%
1817
1818 start: alt1 'a' | alt2 'a' ;
1819 alt1: ;
1820 alt2: ;
1821
1822 %%
1823
1824 ]AT_YYERROR_DEFINE[
1825 ]AT_YYPARSE_DEFINE[
1826 ]AT_YYLEX_DEFINE(["ab"],
1827   [if (res == 'b')
1828     lookahead_value = 1])[
1829
1830 int
1831 main (void)
1832 {
1833   int status;
1834   if (getenv ("YYDEBUG"))
1835     yydebug = 1;
1836   status = yyparse () != 1;
1837   if (lookahead_value)
1838     {
1839       fprintf (stderr, "Lookahead destructor not called.\n");
1840       status = 1;
1841     }
1842   return status;
1843 }
1844 ]])
1845
1846 AT_FULL_COMPILE([glr-regr16],,,, [-rall])
1847
1848 AT_PARSER_CHECK([[glr-regr16]], 0, [],
1849 [syntax error
1850 ])
1851
1852 AT_BISON_OPTION_POPDEFS
1853 AT_CLEANUP
1854 ])
1855
1856 AT_TEST([%skeleton "glr.c"])
1857 AT_TEST([%skeleton "glr.cc"])
1858 AT_TEST([%skeleton "glr2.cc"])
1859
1860 m4_popdef([AT_TEST])
1861
1862
1863
1864 ## ------------------------------------------------- ##
1865 ## Uninitialized location when reporting ambiguity.  ##
1866 ## ------------------------------------------------- ##
1867
1868 m4_pushdef([AT_TEST],
1869 [AT_SETUP([Uninitialized location when reporting ambiguity: $1])
1870
1871 AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations $1])
1872
1873 AT_DATA_GRAMMAR([glr-regr17.y],
1874 [[
1875 %define parse.assert
1876 %define parse.trace
1877 %glr-parser
1878 %expect 0
1879 %expect-rr 3
1880 ]$1[
1881 %locations
1882 %define parse.error verbose
1883
1884 %union { int dummy; }
1885
1886 %code {
1887   ]AT_YYERROR_DECLARE[
1888   ]AT_YYLEX_DECLARE[
1889 }
1890
1891 %%
1892
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 ;
1897
1898 /* Tests multiple levels of yyresolveLocations recursion.  */
1899 ambig1: sub_ambig1 | sub_ambig2 ;
1900 ambig2: sub_ambig1 | sub_ambig2 ;
1901
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' ;
1907 empty1: ;
1908 empty2: ;
1909
1910 %%
1911 # include <assert.h>
1912
1913 ]AT_YYERROR_DEFINE[
1914
1915 ]AT_YYLEX_PROTOTYPE[
1916 {
1917   static char const input[] = "ab";
1918   static int toknum = 0;
1919   ]AT_USE_LEX_ARGS[
1920   assert (toknum < YY_CAST (int, sizeof input));
1921   lvalp->dummy = 0;
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++];
1926 }
1927
1928 ]AT_MAIN_DEFINE[
1929 ]])
1930
1931 AT_FULL_COMPILE([glr-regr17],,,, [-rall])
1932
1933 AT_PARSER_CHECK([[glr-regr17]], 1, [],
1934 [Ambiguity detected.
1935 Option 1,
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>
1940         'a' <tokens 1 .. 1>
1941         'b' <tokens 2 .. 2>
1942     empty1 -> <Rule 9, empty>
1943
1944 Option 2,
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>
1949         'a' <tokens 1 .. 1>
1950         'b' <tokens 2 .. 2>
1951     empty2 -> <Rule 10, empty>
1952
1953 1.1-2.2: syntax is ambiguous
1954 ])
1955
1956 AT_BISON_OPTION_POPDEFS
1957 AT_CLEANUP
1958 ])
1959
1960 AT_TEST([%skeleton "glr.c" %define api.pure])
1961 AT_TEST([%skeleton "glr.cc"])
1962 AT_TEST([%skeleton "glr2.cc"])
1963
1964 m4_popdef([AT_TEST])
1965
1966
1967
1968 ## ------------------------------------------------------------- ##
1969 ## Missed %merge type warnings when LHS type is declared later.  ##
1970 ## ------------------------------------------------------------- ##
1971
1972 m4_pushdef([AT_TEST],
1973 [AT_SETUP([Missed %merge type warnings when LHS type is declared later: $1])
1974 AT_KEYWORDS([%merge])
1975
1976 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
1977 AT_DATA_GRAMMAR([glr-regr18.y],
1978 [[%define parse.assert
1979 %define parse.trace
1980 %glr-parser
1981 ]$1[
1982
1983 %code {
1984   ]AT_YYERROR_DECLARE[
1985   ]AT_YYLEX_DECLARE[
1986 }
1987
1988 %union {
1989   int type1;
1990   int type2;
1991   int type3;
1992 }
1993 ]AT_CXX_IF([[
1994 // In C++ we need one more line for the line numbers to match.
1995 ]])[
1996 %%
1997
1998 sym1: sym2 %merge<merge> { $$ = $][1; } ;
1999 sym2: sym3 %merge<merge> { $$ = $][1; } ;
2000 sym3: %merge<merge> { $$ = 0; } ;
2001
2002 %type <type1> sym1;
2003 %type <type2> sym2;
2004 %type <type3> sym3;
2005
2006 %%
2007 ]AT_YYERROR_DEFINE[
2008 ]AT_YYLEX_DEFINE[
2009 ]AT_MAIN_DEFINE[
2010 ]])
2011
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; } ;
2015       |                  ^~~~~~~
2016 glr-regr18.y:29.18-24: note: previous declaration
2017    29 | sym1: sym2 %merge<merge> { $$ = $][1; } ;
2018       |                  ^~~~~~~
2019 glr-regr18.y:31.13-19: error: result type clash on merge function 'merge': <type3> != <type1>
2020    31 | sym3: %merge<merge> { $$ = 0; } ;
2021       |             ^~~~~~~
2022 glr-regr18.y:29.18-24: note: previous declaration
2023    29 | sym1: sym2 %merge<merge> { $$ = $][1; } ;
2024       |                  ^~~~~~~
2025 ]])
2026
2027 AT_BISON_OPTION_POPDEFS
2028 AT_CLEANUP
2029 ])
2030
2031 AT_TEST([%skeleton "glr.c"])
2032 AT_TEST([%skeleton "glr.cc"])
2033 AT_TEST([%skeleton "glr2.cc"])
2034
2035 m4_popdef([AT_TEST])
2036
2037
2038
2039 ## ------------------- ##
2040 ## Ambiguity reports.  ##
2041 ## ------------------- ##
2042
2043 m4_pushdef([AT_TEST],
2044 [AT_SETUP([Ambiguity reports: $1])
2045
2046 AT_BISON_OPTION_PUSHDEFS([%glr-parser %debug $1])
2047 AT_DATA_GRAMMAR([input.y],
2048 [[%code {
2049   ]AT_YYERROR_DECLARE[
2050   ]AT_YYLEX_DECLARE[
2051 }
2052
2053 %define parse.assert
2054 %define parse.trace
2055 %debug
2056 %glr-parser
2057 %expect 0
2058 %expect-rr 1
2059 ]$1[
2060 ]AT_CXX_IF([[
2061 // In C++ we need two more lines for the line numbers in the trace to match.
2062 ]])[
2063 %%
2064
2065 start:
2066   'a' b 'c' d
2067 | 'a' b 'c' d
2068 ;
2069 b: 'b';
2070 d: %empty;
2071 %%
2072 ]AT_YYERROR_DEFINE[
2073 ]AT_YYLEX_DEFINE(["abc"])[
2074 ]AT_MAIN_DEFINE[
2075 ]])
2076
2077 AT_FULL_COMPILE([input])
2078
2079 AT_PARSER_CHECK([[input --debug]], 1, [],
2080 [Starting parse
2081 Entering state 0
2082 Reading a token
2083 Next token is token 'a' ()
2084 Shifting token 'a' ()
2085 Entering state 1
2086 Reading a token
2087 Next token is token 'b' ()
2088 Shifting token 'b' ()
2089 Entering state 3
2090 Reducing stack 0 by rule 3 (line 30):
2091    $][1 = token 'b' ()
2092 -> $][$ = nterm b ()
2093 Entering state 4
2094 Reading a token
2095 Next token is token 'c' ()
2096 Shifting token 'c' ()
2097 Entering state 6
2098 Reducing stack 0 by rule 4 (line 31):
2099 -> $][$ = nterm d ()
2100 Entering state 7
2101 Reading a token
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
2117 Ambiguity detected.
2118 Option 1,
2119   start -> <Rule 1, tokens 1 .. 3>
2120     'a' <tokens 1 .. 1>
2121     b <tokens 2 .. 2>
2122     'c' <tokens 3 .. 3>
2123     d <empty>
2124
2125 Option 2,
2126   start -> <Rule 2, tokens 1 .. 3>
2127     'a' <tokens 1 .. 1>
2128     b <tokens 2 .. 2>
2129     'c' <tokens 3 .. 3>
2130     d <empty>
2131
2132 syntax is ambiguous
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' ()
2139 ])
2140
2141 AT_BISON_OPTION_POPDEFS
2142 AT_CLEANUP
2143 ])
2144
2145 AT_TEST([%skeleton "glr.c"])
2146 AT_TEST([%skeleton "glr.cc"])
2147 AT_TEST([%skeleton "glr2.cc"])
2148
2149 m4_popdef([AT_TEST])
2150
2151
2152
2153 ## ------------------------------------------------------- ##
2154 ## Predicates.                                             ##
2155 ##                                                         ##
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 ## ------------------------------------------------------- ##
2159
2160 m4_pushdef([AT_TEST],
2161 [AT_SETUP([Predicates: $1])
2162
2163 AT_BISON_OPTION_PUSHDEFS([%glr-parser $1])
2164 AT_DATA_GRAMMAR([input.y],
2165 [[%define parse.assert
2166 %define parse.trace
2167 %glr-parser
2168 %define parse.error verbose
2169 %expect-rr 1
2170 ]$1[
2171
2172 %code
2173 {
2174   #include <assert.h>
2175   #include <stdbool.h>
2176   bool new_syntax = false;
2177   const char *input = YY_NULLPTR;
2178   ]AT_YYERROR_DECLARE[
2179   ]AT_YYLEX_DECLARE[
2180 }
2181 %%
2182 widget:
2183   %? {new_syntax} 'w' id new_args  { printf("new"); }
2184 | %?{!new_syntax} 'w' id old_args  { printf("old"); }
2185 ;
2186 id: 'i';
2187 new_args: 'n';
2188 old_args: 'o';
2189 %%
2190 ]AT_YYERROR_DEFINE[
2191 ]AT_YYPARSE_DEFINE[
2192
2193 ]AT_YYLEX_PROTOTYPE[
2194 {
2195   ]AT_USE_LEX_ARGS[
2196   return *input++;
2197 }
2198
2199 int
2200 main (int argc, const char* argv[])
2201 {
2202   assert (argc == 2); (void) argc;
2203   // First char decides whether new, or old syntax.
2204   // Then the input.
2205   new_syntax = argv[1][0] == 'N';
2206   input = argv[1] + 1;
2207   if (getenv ("YYDEBUG"))
2208     yydebug = 1;
2209   return yyparse ();
2210 }
2211 ]])
2212
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'
2216 ]])
2217 AT_PARSER_CHECK([[input Owio]], [0], [old])
2218 AT_PARSER_CHECK([[input Nwio]], [1], [], [[syntax error, unexpected 'o', expecting 'n'
2219 ]])
2220
2221 AT_BISON_OPTION_POPDEFS
2222 AT_CLEANUP
2223 ])
2224
2225 AT_TEST([%skeleton "glr.c"])
2226 AT_TEST([%skeleton "glr.cc"])
2227 AT_TEST([%skeleton "glr2.cc"])
2228
2229 m4_popdef([AT_TEST])
2230
2231
2232 m4_popdef([AT_YYPARSE_DEFINE])