tests/regression.at

   1 # Bison Regressions.                               -*- Autotest -*-
   2
   3 # Copyright (C) 2001-2013 Free Software Foundation, Inc.
   4
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 AT_BANNER([[Regression tests.]])
  19
  20
  21 ## ------------------ ##
  22 ## Trivial grammars.  ##
  23 ## ------------------ ##
  24
  25 AT_SETUP([Trivial grammars])
  26
  27 AT_BISON_OPTION_PUSHDEFS
  28 AT_DATA_GRAMMAR([input.y],
  29 [[%{
  30 ]AT_YYERROR_DECLARE_EXTERN[
  31 ]AT_YYLEX_DECLARE_EXTERN[
  32 #define YYSTYPE int *
  33 %}
  34
  35 %error-verbose
  36
  37 %%
  38
  39 program: 'x';
  40 ]])
  41 AT_BISON_OPTION_POPDEFS
  42
  43 AT_BISON_CHECK([-o input.c input.y])
  44 AT_COMPILE([input.o])
  45 AT_COMPILE([input.o], [-DYYDEBUG -c input.c])
  46
  47 AT_CLEANUP
  48
  49
  50
  51 ## ----------------- ##
  52 ## YYSTYPE typedef.  ##
  53 ## ----------------- ##
  54
  55 AT_SETUP([YYSTYPE typedef])
  56
  57 AT_BISON_OPTION_PUSHDEFS
  58 AT_DATA_GRAMMAR([input.y],
  59 [[%{
  60 ]AT_YYERROR_DECLARE_EXTERN[
  61 ]AT_YYLEX_DECLARE_EXTERN[
  62 typedef union { char const *val; } YYSTYPE;
  63 %}
  64
  65 %type <val> program
  66
  67 %%
  68
  69 program: { $$ = ""; };
  70 ]])
  71 AT_BISON_OPTION_POPDEFS
  72
  73 AT_BISON_CHECK([-o input.c input.y])
  74 AT_COMPILE([input.o])
  75
  76 AT_CLEANUP
  77
  78
  79
  80 ## ------------------------------------- ##
  81 ## Early token definitions with --yacc.  ##
  82 ## ------------------------------------- ##
  83
  84
  85 AT_SETUP([Early token definitions with --yacc])
  86
  87 # Found in GCJ: they expect the tokens to be defined before the user
  88 # prologue, so that they can use the token definitions in it.
  89
  90 AT_BISON_OPTION_PUSHDEFS
  91 AT_DATA_GRAMMAR([input.y],
  92 [[%{
  93 ]AT_YYERROR_DECLARE_EXTERN[
  94 ]AT_YYLEX_DECLARE_EXTERN[
  95 %}
  96
  97 %union
  98 {
  99   int val;
 100 };
 101 %{
 102 #ifndef MY_TOKEN
 103 # error "MY_TOKEN not defined."
 104 #endif
 105 %}
 106 %token MY_TOKEN
 107 %%
 108 exp: MY_TOKEN;
 109 %%
 110 ]])
 111 AT_BISON_OPTION_POPDEFS
 112
 113 AT_BISON_CHECK([-y -o input.c input.y])
 114 AT_COMPILE([input.o])
 115
 116 AT_CLEANUP
 117
 118
 119
 120 ## ---------------------------------------- ##
 121 ## Early token definitions without --yacc.  ##
 122 ## ---------------------------------------- ##
 123
 124
 125 AT_SETUP([Early token definitions without --yacc])
 126
 127 # Found in GCJ: they expect the tokens to be defined before the user
 128 # prologue, so that they can use the token definitions in it.
 129
 130 AT_BISON_OPTION_PUSHDEFS
 131 AT_DATA_GRAMMAR([input.y],
 132 [[%{
 133 #include <stdio.h>
 134 ]AT_YYERROR_DECLARE_EXTERN[
 135 ]AT_YYLEX_DECLARE_EXTERN[
 136 void print_my_token (void);
 137 %}
 138
 139 %union
 140 {
 141   int val;
 142 };
 143 %{
 144 void
 145 print_my_token (void)
 146 {
 147   enum yytokentype my_token = MY_TOKEN;
 148   printf ("%d\n", my_token);
 149 }
 150 %}
 151 %token MY_TOKEN
 152 %%
 153 exp: MY_TOKEN;
 154 %%
 155 ]])
 156 AT_BISON_OPTION_POPDEFS
 157
 158 AT_BISON_CHECK([-o input.c input.y])
 159 AT_COMPILE([input.o])
 160
 161 AT_CLEANUP
 162
 163
 164
 165 ## ---------------- ##
 166 ## Braces parsing.  ##
 167 ## ---------------- ##
 168
 169
 170 AT_SETUP([Braces parsing])
 171
 172 AT_BISON_OPTION_PUSHDEFS
 173 AT_DATA([input.y],
 174 [[/* Bison used to swallow the character after '}'. */
 175
 176 %%
 177 exp: { tests = {{{{{{{{{{}}}}}}}}}}; };
 178 %%
 179 ]])
 180 AT_BISON_OPTION_POPDEFS
 181
 182 AT_BISON_CHECK([-v -o input.c input.y])
 183
 184 AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore])
 185
 186 AT_CLEANUP
 187
 188
 189 ## ------------------ ##
 190 ## Duplicate string.  ##
 191 ## ------------------ ##
 192
 193
 194 AT_SETUP([Duplicate string])
 195
 196 AT_BISON_OPTION_PUSHDEFS
 197 AT_DATA([input.y],
 198 [[/* 'Bison -v' used to dump core when two tokens are defined with the same
 199    string, as LE and GE below. */
 200
 201 %token NUM
 202 %token LE "<="
 203 %token GE "<="
 204
 205 %%
 206 exp: '(' exp ')' | NUM ;
 207 %%
 208 ]])
 209 AT_BISON_OPTION_POPDEFS
 210
 211 AT_BISON_CHECK([-v -o input.c input.y], 0, [],
 212 [[input.y:6.8-14: warning: symbol "<=" used more than once as a literal string [-Wother]
 213 ]])
 214
 215 AT_CLEANUP
 216
 217
 218 ## ------------------- ##
 219 ## Rule Line Numbers.  ##
 220 ## ------------------- ##
 221
 222 AT_SETUP([Rule Line Numbers])
 223
 224 AT_KEYWORDS([report])
 225
 226 AT_BISON_OPTION_PUSHDEFS
 227 AT_DATA([input.y],
 228 [[%%
 229 expr:
 230 'a'
 231
 232 {
 233
 234 }
 235
 236 'b'
 237
 238 {
 239
 240 }
 241
 242 |
 243
 244
 245 {
 246
 247
 248 }
 249
 250 'c'
 251
 252 {
 253
 254 };
 255 ]])
 256 AT_BISON_OPTION_POPDEFS
 257
 258 AT_BISON_CHECK([-o input.c -v input.y])
 259
 260 # Check the contents of the report.
 261 AT_CHECK([cat input.output], [],
 262 [[Grammar
 263
 264     0 $accept: expr $end
 265
 266     1 $@1: /* empty */
 267
 268     2 expr: 'a' $@1 'b'
 269
 270     3 $@2: /* empty */
 271
 272     4 expr: $@2 'c'
 273
 274
 275 Terminals, with rules where they appear
 276
 277 $end (0) 0
 278 'a' (97) 2
 279 'b' (98) 2
 280 'c' (99) 4
 281 error (256)
 282
 283
 284 Nonterminals, with rules where they appear
 285
 286 $accept (6)
 287     on left: 0
 288 expr (7)
 289     on left: 2 4, on right: 0
 290 $@1 (8)
 291     on left: 1, on right: 2
 292 $@2 (9)
 293     on left: 3, on right: 4
 294
 295
 296 State 0
 297
 298     0 $accept: . expr $end
 299
 300     'a'  shift, and go to state 1
 301
 302     $default  reduce using rule 3 ($@2)
 303
 304     expr  go to state 2
 305     $@2   go to state 3
 306
 307
 308 State 1
 309
 310     2 expr: 'a' . $@1 'b'
 311
 312     $default  reduce using rule 1 ($@1)
 313
 314     $@1  go to state 4
 315
 316
 317 State 2
 318
 319     0 $accept: expr . $end
 320
 321     $end  shift, and go to state 5
 322
 323
 324 State 3
 325
 326     4 expr: $@2 . 'c'
 327
 328     'c'  shift, and go to state 6
 329
 330
 331 State 4
 332
 333     2 expr: 'a' $@1 . 'b'
 334
 335     'b'  shift, and go to state 7
 336
 337
 338 State 5
 339
 340     0 $accept: expr $end .
 341
 342     $default  accept
 343
 344
 345 State 6
 346
 347     4 expr: $@2 'c' .
 348
 349     $default  reduce using rule 4 (expr)
 350
 351
 352 State 7
 353
 354     2 expr: 'a' $@1 'b' .
 355
 356     $default  reduce using rule 2 (expr)
 357 ]])
 358
 359 AT_CLEANUP
 360
 361
 362
 363 ## ---------------------- ##
 364 ## Mixing %token styles.  ##
 365 ## ---------------------- ##
 366
 367
 368 AT_SETUP([Mixing %token styles])
 369
 370 # Taken from the documentation.
 371 AT_DATA([input.y],
 372 [[%token  <operator>  OR      "||"
 373 %token  <operator>  LE 134  "<="
 374 %left  OR  "<="
 375 %%
 376 exp: ;
 377 %%
 378 ]])
 379
 380 AT_BISON_CHECK([-v -o input.c input.y])
 381
 382 AT_CLEANUP
 383
 384
 385
 386 ## ---------------- ##
 387 ## Invalid inputs.  ##
 388 ## ---------------- ##
 389
 390
 391 AT_SETUP([Invalid inputs])
 392
 393 AT_DATA([input.y],
 394 [[%%
 395 ?
 396 default: 'a' }
 397 %&
 398 %a-does-not-exist
 399 %-
 400 %{
 401 ]])
 402
 403 AT_BISON_CHECK([input.y], [1], [],
 404 [[input.y:2.1: error: invalid character: '?'
 405 input.y:3.14: error: invalid character: '}'
 406 input.y:4.1: error: invalid character: '%'
 407 input.y:4.2: error: invalid character: '&'
 408 input.y:5.1-17: error: invalid directive: '%a-does-not-exist'
 409 input.y:6.1: error: invalid character: '%'
 410 input.y:6.2: error: invalid character: '-'
 411 input.y:7.1-8.0: error: missing '%}' at end of file
 412 input.y:7.1-8.0: error: syntax error, unexpected %{...%}
 413 ]])
 414
 415 AT_CLEANUP
 416
 417
 418 AT_SETUP([Invalid inputs with {}])
 419
 420 AT_DATA([input.y],
 421 [[
 422 %destructor
 423 %initial-action
 424 %lex-param
 425 %parse-param
 426 %printer
 427 %union
 428 ]])
 429
 430 AT_BISON_CHECK([input.y], [1], [],
 431 [[input.y:3.1-15: error: syntax error, unexpected %initial-action, expecting {...}
 432 ]])
 433
 434 AT_CLEANUP
 435
 436
 437
 438 ## ------------------- ##
 439 ## Token definitions.  ##
 440 ## ------------------- ##
 441
 442
 443 AT_SETUP([Token definitions])
 444
 445 AT_BISON_OPTION_PUSHDEFS
 446 # Bison managed, when fed with '%token 'f' "f"' to #define 'f'!
 447 AT_DATA_GRAMMAR([input.y],
 448 [%{
 449 #include <stdlib.h>
 450 #include <stdio.h>
 451 ]AT_YYERROR_DECLARE[
 452 ]AT_YYLEX_DECLARE[
 453 %}
 454 [%error-verbose
 455 %token MYEOF 0 "end of file"
 456 %token 'a' "a"
 457 %token B_TOKEN "b"
 458 %token C_TOKEN 'c'
 459 %token 'd' D_TOKEN
 460 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 461 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 462 %%
 463 exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
 464 %%
 465 ]AT_YYERROR_DEFINE[
 466 ]AT_YYLEX_DEFINE([{ SPECIAL }])[
 467 ]AT_MAIN_DEFINE[
 468 ]])
 469 AT_BISON_OPTION_POPDEFS
 470
 471 # Checking the warning message guarantees that the trigraph "??!" isn't
 472 # unnecessarily escaped here even though it would need to be if encoded in a
 473 # C-string literal.  Also notice that unnecessary escaping, such as "\?", from
 474 # the user specification is eliminated.
 475 AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
 476 [[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
 477 input.y:22.8-63: warning: symbol "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!" used more than once as a literal string [-Wother]
 478 ]])
 479 AT_BISON_CHECK([-fcaret -o input.c input.y], [[0]], [[]],
 480 [[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
 481  %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 482         ^^^^^^^
 483 input.y:22.8-63: warning: symbol "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!" used more than once as a literal string [-Wother]
 484  %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 485         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 486 ]])
 487 AT_COMPILE([input])
 488
 489 # Checking the error message here guarantees that yytname, which does contain
 490 # C-string literals, does have the trigraph escaped correctly.  Thus, the
 491 # symbol name reported by the parser is exactly the same as that reported by
 492 # Bison itself.
 493 AT_DATA([experr],
 494 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
 495 ]])
 496 AT_PARSER_CHECK([./input], 1, [], [experr])
 497 AT_CLEANUP
 498
 499
 500
 501 ## -------------------- ##
 502 ## Characters Escapes.  ##
 503 ## -------------------- ##
 504
 505
 506 AT_SETUP([Characters Escapes])
 507
 508 AT_BISON_OPTION_PUSHDEFS
 509 AT_DATA_GRAMMAR([input.y],
 510 [%{
 511 ]AT_YYERROR_DECLARE_EXTERN[
 512 ]AT_YYLEX_DECLARE_EXTERN[
 513 %}
 514 [%%
 515 exp:
 516   '\'' "\'"
 517 | '\"' "\""
 518 | '"'  "'" /* Pacify font-lock-mode: ". */
 519 ;
 520 ]])
 521
 522 AT_BISON_OPTION_POPDEFS
 523
 524 AT_BISON_CHECK([-o input.c input.y])
 525 AT_COMPILE([input.o])
 526 AT_CLEANUP
 527
 528
 529
 530 ## -------------- ##
 531 ## Web2c Report.  ##
 532 ## -------------- ##
 533
 534 # The generation of the reduction was once wrong in Bison, and made it
 535 # miss some reductions.  In the following test case, the reduction on
 536 # 'undef_id_tok' in state 1 was missing.  This is stripped down from
 537 # the actual web2c.y.
 538
 539 AT_SETUP([Web2c Report])
 540
 541 AT_KEYWORDS([report])
 542
 543 AT_DATA([input.y],
 544 [[%token        undef_id_tok const_id_tok
 545
 546 %start CONST_DEC_PART
 547 \f
 548 %%
 549 CONST_DEC_PART:
 550          CONST_DEC_LIST
 551         ;
 552
 553 CONST_DEC_LIST:
 554           CONST_DEC
 555         | CONST_DEC_LIST CONST_DEC
 556         ;
 557
 558 CONST_DEC:
 559           { } undef_id_tok '=' const_id_tok ';'
 560         ;
 561 %%
 562 ]])
 563
 564 AT_BISON_CHECK([-v input.y])
 565 AT_CHECK([cat input.output], 0,
 566 [[Grammar
 567
 568     0 $accept: CONST_DEC_PART $end
 569
 570     1 CONST_DEC_PART: CONST_DEC_LIST
 571
 572     2 CONST_DEC_LIST: CONST_DEC
 573     3               | CONST_DEC_LIST CONST_DEC
 574
 575     4 $@1: /* empty */
 576
 577     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
 578
 579
 580 Terminals, with rules where they appear
 581
 582 $end (0) 0
 583 ';' (59) 5
 584 '=' (61) 5
 585 error (256)
 586 undef_id_tok (258) 5
 587 const_id_tok (259) 5
 588
 589
 590 Nonterminals, with rules where they appear
 591
 592 $accept (7)
 593     on left: 0
 594 CONST_DEC_PART (8)
 595     on left: 1, on right: 0
 596 CONST_DEC_LIST (9)
 597     on left: 2 3, on right: 1 3
 598 CONST_DEC (10)
 599     on left: 5, on right: 2 3
 600 $@1 (11)
 601     on left: 4, on right: 5
 602
 603
 604 State 0
 605
 606     0 $accept: . CONST_DEC_PART $end
 607
 608     $default  reduce using rule 4 ($@1)
 609
 610     CONST_DEC_PART  go to state 1
 611     CONST_DEC_LIST  go to state 2
 612     CONST_DEC       go to state 3
 613     $@1             go to state 4
 614
 615
 616 State 1
 617
 618     0 $accept: CONST_DEC_PART . $end
 619
 620     $end  shift, and go to state 5
 621
 622
 623 State 2
 624
 625     1 CONST_DEC_PART: CONST_DEC_LIST .
 626     3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
 627
 628     undef_id_tok  reduce using rule 4 ($@1)
 629     $default      reduce using rule 1 (CONST_DEC_PART)
 630
 631     CONST_DEC  go to state 6
 632     $@1        go to state 4
 633
 634
 635 State 3
 636
 637     2 CONST_DEC_LIST: CONST_DEC .
 638
 639     $default  reduce using rule 2 (CONST_DEC_LIST)
 640
 641
 642 State 4
 643
 644     5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
 645
 646     undef_id_tok  shift, and go to state 7
 647
 648
 649 State 5
 650
 651     0 $accept: CONST_DEC_PART $end .
 652
 653     $default  accept
 654
 655
 656 State 6
 657
 658     3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
 659
 660     $default  reduce using rule 3 (CONST_DEC_LIST)
 661
 662
 663 State 7
 664
 665     5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
 666
 667     '='  shift, and go to state 8
 668
 669
 670 State 8
 671
 672     5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
 673
 674     const_id_tok  shift, and go to state 9
 675
 676
 677 State 9
 678
 679     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
 680
 681     ';'  shift, and go to state 10
 682
 683
 684 State 10
 685
 686     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
 687
 688     $default  reduce using rule 5 (CONST_DEC)
 689 ]])
 690
 691 AT_CLEANUP
 692
 693
 694 ## --------------- ##
 695 ## Web2c Actions.  ##
 696 ## --------------- ##
 697
 698 # The generation of the mapping 'state -> action' was once wrong in
 699 # extremely specific situations.  web2c.y exhibits this situation.
 700 # Below is a stripped version of the grammar.  It looks like one can
 701 # simplify it further, but just don't: it is tuned to exhibit a bug,
 702 # which disapears when applying sane grammar transformations.
 703 #
 704 # It used to be wrong on yydefact only:
 705 #
 706 # static const yytype_uint8 yydefact[] =
 707 #  {
 708 # -       2,     0,     1,     0,     0,     2,     3,     2,     5,     4,
 709 # +       2,     0,     1,     0,     0,     0,     3,     2,     5,     4,
 710 #         0,     0
 711 #  };
 712 #
 713 # but let's check all the tables.
 714
 715
 716 AT_SETUP([Web2c Actions])
 717
 718 AT_KEYWORDS([report])
 719
 720 AT_DATA([input.y],
 721 [[%%
 722 statement:  struct_stat;
 723 struct_stat:  /* empty. */ | if else;
 724 if: "if" "const" "then" statement;
 725 else: "else" statement;
 726 %%
 727 ]])
 728
 729 AT_BISON_CHECK([-v -o input.c input.y])
 730
 731 # Check only the tables.
 732 [sed -n 's/  *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
 733
 734 AT_CHECK([[cat tables.c]], 0,
 735 [[static const yytype_uint8 yytranslate[] =
 736 {
 737        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 738        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 739        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 740        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 741        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 742        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 743        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 744        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 745        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 746        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 747        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 748        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 749        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 750        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 751        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 752        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 753        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 754        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 755        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 756        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 757        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 758        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 759        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 760        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 761        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 762        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 763        5,     6
 764 };
 765 static const yytype_uint8 yyrline[] =
 766 {
 767        0,     2,     2,     3,     3,     4,     5
 768 };
 769 static const char *const yytname[] =
 770 {
 771   "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
 772   "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL
 773 };
 774 static const yytype_uint16 yytoknum[] =
 775 {
 776        0,   256,   257,   258,   259,   260,   261
 777 };
 778 static const yytype_int8 yypact[] =
 779 {
 780       -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 781       -8,    -8
 782 };
 783 static const yytype_uint8 yydefact[] =
 784 {
 785        3,     0,     0,     2,     0,     0,     1,     3,     4,     3,
 786        6,     5
 787 };
 788 static const yytype_int8 yypgoto[] =
 789 {
 790       -8,    -7,    -8,    -8,    -8
 791 };
 792 static const yytype_int8 yydefgoto[] =
 793 {
 794       -1,     2,     3,     4,     8
 795 };
 796 static const yytype_uint8 yytable[] =
 797 {
 798       10,     1,    11,     5,     6,     0,     7,     9
 799 };
 800 static const yytype_int8 yycheck[] =
 801 {
 802        7,     3,     9,     4,     0,    -1,     6,     5
 803 };
 804 static const yytype_uint8 yystos[] =
 805 {
 806        0,     3,     8,     9,    10,     4,     0,     6,    11,     5,
 807        8,     8
 808 };
 809 static const yytype_uint8 yyr1[] =
 810 {
 811        0,     7,     8,     9,     9,    10,    11
 812 };
 813 static const yytype_uint8 yyr2[] =
 814 {
 815        0,     2,     1,     0,     2,     4,     2
 816 };
 817 ]])
 818
 819 AT_CLEANUP
 820
 821
 822 ## ------------------------- ##
 823 ## yycheck Bound Violation.  ##
 824 ## ------------------------- ##
 825
 826
 827 # _AT_DATA_DANCER_Y(BISON-OPTIONS)
 828 # --------------------------------
 829 # The following grammar, taken from Andrew Suffield's GPL'd implementation
 830 # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate
 831 # yycheck's bounds where issuing a verbose error message.  Keep this test
 832 # so that possible bound checking compilers could check all the skeletons.
 833 m4_define([_AT_DATA_DANCER_Y],
 834 [AT_DATA_GRAMMAR([dancer.y],
 835 [[%code provides
 836 {
 837   ]AT_YYERROR_DECLARE[
 838   ]AT_YYLEX_DECLARE[
 839 }
 840 $1
 841 %token ARROW INVALID NUMBER STRING DATA
 842 %defines
 843 %verbose
 844 %error-verbose
 845 /* Grammar follows */
 846 %%
 847 line: header body
 848    ;
 849
 850 header: '<' from ARROW to '>' type ':'
 851    | '<' ARROW to '>' type ':'
 852    | ARROW to type ':'
 853    | type ':'
 854    | '<' '>'
 855    ;
 856
 857 from: DATA
 858    | STRING
 859    | INVALID
 860    ;
 861
 862 to: DATA
 863    | STRING
 864    | INVALID
 865    ;
 866
 867 type: DATA
 868    | STRING
 869    | INVALID
 870    ;
 871
 872 body: /* empty */
 873    | body member
 874    ;
 875
 876 member: STRING
 877    | DATA
 878    | '+' NUMBER
 879    | '-' NUMBER
 880    | NUMBER
 881    | INVALID
 882    ;
 883 %%
 884 ]AT_YYERROR_DEFINE[
 885 ]AT_YYLEX_DEFINE([":"])[
 886 ]AT_LALR1_CC_IF(
 887 [int
 888 yyparse ()
 889 {
 890   yy::parser parser;
 891 #if YYDEBUG
 892   parser.set_debug_level (YYDEBUG);
 893 #endif
 894   return parser.parse ();
 895 }
 896 ])[
 897 ]AT_MAIN_DEFINE[
 898 ]])
 899 ])# _AT_DATA_DANCER_Y
 900
 901
 902 # AT_CHECK_DANCER(BISON-OPTIONS)
 903 # ------------------------------
 904 # Generate the grammar, compile it, run it.
 905 m4_define([AT_CHECK_DANCER],
 906 [AT_SETUP([Dancer $1])
 907 AT_BISON_OPTION_PUSHDEFS([$1])
 908 _AT_DATA_DANCER_Y([$1])
 909 AT_FULL_COMPILE([dancer])
 910 AT_PARSER_CHECK([./dancer], 1, [],
 911 [syntax error, unexpected ':'
 912 ])
 913 AT_BISON_OPTION_POPDEFS
 914 AT_CLEANUP
 915 ])
 916
 917 AT_CHECK_DANCER()
 918 AT_CHECK_DANCER([%glr-parser])
 919 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
 920
 921
 922 ## ------------------------------------------ ##
 923 ## Diagnostic that expects two alternatives.  ##
 924 ## ------------------------------------------ ##
 925
 926
 927 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
 928 # --------------------------------
 929 m4_define([_AT_DATA_EXPECT2_Y],
 930 [AT_DATA_GRAMMAR([expect2.y],
 931 [%{
 932 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 933 AT_LALR1_CC_IF([[#include <cstdlib>]],
 934 [[#include <stdlib.h>
 935 #include <stdio.h>
 936 ]AT_YYERROR_DECLARE])[
 937 %}
 938 $1
 939 %defines
 940 %error-verbose
 941 %token A 1000
 942 %token B
 943
 944 %%
 945 program: /* empty */
 946  | program e ';'
 947  | program error ';';
 948
 949 e: e '+' t | t;
 950 t: A | B;
 951
 952 %%
 953 ]AT_YYERROR_DEFINE[
 954 ]AT_LALR1_CC_IF(
 955 [int
 956 yyparse ()
 957 {
 958   yy::parser parser;
 959   return parser.parse ();
 960 }
 961 ])[
 962
 963 #include <assert.h>
 964 static int
 965 yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
 966 {
 967   static int const tokens[] =
 968     {
 969       1000, '+', '+', -1
 970     };
 971   static size_t toknum;
 972   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
 973   assert (toknum < sizeof tokens / sizeof *tokens);
 974   return tokens[toknum++];
 975 }
 976 ]AT_MAIN_DEFINE[
 977 ]])
 978 ])# _AT_DATA_EXPECT2_Y
 979
 980
 981 # AT_CHECK_EXPECT2(BISON-OPTIONS)
 982 # -------------------------------
 983 # Generate the grammar, compile it, run it.
 984 m4_define([AT_CHECK_EXPECT2],
 985 [AT_SETUP([Expecting two tokens $1])
 986 AT_BISON_OPTION_PUSHDEFS([$1])
 987 _AT_DATA_EXPECT2_Y([$1])
 988 AT_FULL_COMPILE([expect2])
 989 AT_PARSER_CHECK([./expect2], 1, [],
 990 [syntax error, unexpected '+', expecting A or B
 991 ])
 992 AT_BISON_OPTION_POPDEFS
 993 AT_CLEANUP
 994 ])
 995
 996 AT_CHECK_EXPECT2()
 997 AT_CHECK_EXPECT2([%glr-parser])
 998 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
 999
1000
1001
1002 ## --------------------------------------------- ##
1003 ## Braced code in declaration in rules section.  ##
1004 ## --------------------------------------------- ##
1005
1006 AT_SETUP([Braced code in declaration in rules section])
1007
1008 # Bison once mistook braced code in a declaration in the rules section to be a
1009 # rule action.
1010 AT_BISON_OPTION_PUSHDEFS
1011 AT_DATA_GRAMMAR([input.y],
1012 [[%{
1013 #include <stdio.h>
1014 ]AT_YYERROR_DECLARE[
1015 ]AT_YYLEX_DECLARE[
1016 %}
1017
1018 %error-verbose
1019
1020 %%
1021
1022 start:
1023   {
1024     printf ("Bison would once convert this action to a midrule because of the"
1025             " subsequent braced code.\n");
1026   }
1027   ;
1028
1029 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1030 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1031
1032 %%
1033 ]AT_YYERROR_DEFINE[
1034 ]AT_YYLEX_DEFINE(["a"])[
1035
1036 int
1037 main (void)
1038 {
1039   yydebug = 1;
1040   return !yyparse ();
1041 }
1042 ]])
1043 AT_BISON_OPTION_POPDEFS
1044
1045 AT_BISON_CHECK([-t -o input.c input.y])
1046 AT_COMPILE([input])
1047 AT_PARSER_CHECK([./input], 0,
1048 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1049 ]],
1050 [[Starting parse
1051 Entering state 0
1052 Reducing stack by rule 1 (line 20):
1053 -> $$ = nterm start ()
1054 Stack now 0
1055 Entering state 1
1056 Reading a token: Next token is token 'a' (PRINTER)
1057 syntax error, unexpected 'a', expecting $end
1058 Error: popping nterm start ()
1059 Stack now 0
1060 Cleanup: discarding lookahead token 'a' (PRINTER)
1061 DESTRUCTOR
1062 Stack now 0
1063 ]])
1064
1065 AT_CLEANUP
1066
1067
1068
1069 ## --------------------------------- ##
1070 ## String alias declared after use.  ##
1071 ## --------------------------------- ##
1072
1073 AT_SETUP([String alias declared after use])
1074
1075 # Bison once incorrectly asserted that the symbol number for either a token or
1076 # its alias was the highest symbol number so far at the point of the alias
1077 # declaration.  That was true unless the declaration appeared after their first
1078 # uses and other tokens appeared in between.
1079
1080 AT_DATA([input.y],
1081 [[%%
1082 start: 'a' "A" 'b';
1083 %token 'a' "A";
1084 ]])
1085
1086 AT_BISON_CHECK([-t -o input.c input.y])
1087
1088 AT_CLEANUP
1089
1090
1091
1092 ## -------------------------------- ##
1093 ## Extra lookahead sets in report.  ##
1094 ## -------------------------------- ##
1095
1096 AT_SETUP([[Extra lookahead sets in report]])
1097
1098 # Bison prints each reduction's lookahead set only next to the associated
1099 # state's one item that (1) is associated with the same rule as the reduction
1100 # and (2) has its dot at the end of its RHS.  Previously, Bison also
1101 # erroneously printed the lookahead set next to all of the state's other items
1102 # associated with the same rule.  This bug affected only the '.output' file and
1103 # not the generated parser source code.
1104
1105 AT_DATA([[input.y]],
1106 [[%%
1107 start: a | 'a' a 'a' ;
1108 a: 'a' ;
1109 ]])
1110
1111 AT_BISON_CHECK([[--report=all input.y]])
1112 AT_CHECK([[sed -n '/^State 1$/,/^State 2$/p' input.output]], [[0]],
1113 [[State 1
1114
1115     2 start: 'a' . a 'a'
1116     3 a: . 'a'
1117     3  | 'a' .  [$end]
1118
1119     'a'  shift, and go to state 4
1120
1121     $default  reduce using rule 3 (a)
1122
1123     a  go to state 5
1124
1125
1126 State 2
1127 ]])
1128
1129 AT_CLEANUP
1130
1131
1132
1133 ## ---------------------------------------- ##
1134 ## Token number in precedence declaration.  ##
1135 ## ---------------------------------------- ##
1136
1137 AT_SETUP([[Token number in precedence declaration]])
1138
1139 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1140 # we lost this in Bison 1.50.
1141 AT_BISON_OPTION_PUSHDEFS
1142 AT_DATA_GRAMMAR([input.y],
1143 [[%{
1144   #include <stdio.h>
1145   ]AT_YYERROR_DECLARE[
1146   ]AT_YYLEX_DECLARE[
1147 %}
1148
1149 %error-verbose
1150 %right END 0
1151 %left TK1 1 TK2 2 "tok alias" 3
1152
1153 %%
1154
1155 start:
1156     TK1 sr_conflict "tok alias"
1157   | start %prec END
1158   ;
1159 sr_conflict:
1160   TK2
1161   | TK2 "tok alias"
1162   ;
1163
1164 %%
1165
1166 ]AT_YYERROR_DEFINE[
1167 ]AT_YYLEX_DEFINE([{ 1, 2, 3, 0 }])[
1168 ]AT_MAIN_DEFINE[
1169 ]])
1170 AT_BISON_OPTION_POPDEFS
1171
1172 AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1173 [[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start [-Wother]
1174 input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" [-Wother]
1175 ]])
1176 AT_COMPILE([[input]])
1177 AT_PARSER_CHECK([[./input]])
1178
1179 AT_CLEANUP
1180
1181
1182
1183 ## --------------------------- ##
1184 ## parse-gram.y: LALR = IELR.  ##
1185 ## --------------------------- ##
1186
1187 # If parse-gram.y's LALR and IELR parser tables ever begin to differ, we
1188 # need to fix parse-gram.y or start using IELR.
1189
1190 AT_SETUP([[parse-gram.y: LALR = IELR]])
1191
1192 # Avoid tests/bison's dark magic by processing a local copy of the
1193 # grammar.  Avoid differences in synclines by telling bison that the
1194 # output files have the same name.
1195 [cp $abs_top_srcdir/src/parse-gram.y input.y]
1196 AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
1197 [mv input.c lalr.c]
1198 AT_CAPTURE_FILE([lalr.c])
1199 AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1200 [mv input.c ielr.c]
1201 AT_CAPTURE_FILE([ielr.c])
1202 AT_CHECK([[diff lalr.c ielr.c]], [[0]])
1203
1204 AT_CLEANUP
1205
1206
1207
1208 ## -------------------------------------------- ##
1209 ## parse.error=verbose and YYSTACK_USE_ALLOCA.  ##
1210 ## -------------------------------------------- ##
1211
1212 AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]])
1213
1214 AT_BISON_OPTION_PUSHDEFS
1215 AT_DATA_GRAMMAR([input.y],
1216 [[%code {
1217   #include <stdio.h>
1218   ]AT_YYERROR_DECLARE[
1219   ]AT_YYLEX_DECLARE[
1220   #define YYSTACK_USE_ALLOCA 1
1221 }
1222
1223 %define parse.error verbose
1224
1225 %%
1226
1227 start: check syntax_error syntax_error ;
1228
1229 check:
1230 {
1231   if (128 < sizeof yymsgbuf)
1232     {
1233       fprintf (stderr,
1234                "The initial size of yymsgbuf in yyparse has increased\n"
1235                "since this test group was last updated.  As a result,\n"
1236                "this test group may no longer manage to induce a\n"
1237                "reallocation of the syntax error message buffer.\n"
1238                "This test group must be adjusted to produce a longer\n"
1239                "error message.\n");
1240       YYABORT;
1241     }
1242 }
1243 ;
1244
1245 // Induce a syntax error message whose total length is more than
1246 // sizeof yymsgbuf in yyparse.  Each token here is 64 bytes.
1247 syntax_error:
1248   "123456789112345678921234567893123456789412345678951234567896123A"
1249 | "123456789112345678921234567893123456789412345678951234567896123B"
1250 | error 'a' 'b' 'c'
1251 ;
1252
1253 %%
1254
1255 ]AT_YYERROR_DEFINE[
1256   /* Induce two syntax error messages (which requires full error
1257      recovery by shifting 3 tokens) in order to detect any loss of the
1258      reallocated buffer.  */
1259 ]AT_YYLEX_DEFINE(["abc"])[
1260 ]AT_MAIN_DEFINE[
1261 ]])
1262 AT_BISON_OPTION_POPDEFS
1263
1264 AT_BISON_CHECK([[-o input.c input.y]])
1265 AT_COMPILE([[input]])
1266 AT_PARSER_CHECK([[./input]], [[1]], [],
1267 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1268 syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1269 ]])
1270
1271 AT_CLEANUP
1272
1273
1274
1275 ## ------------------------------ ##
1276 ## parse.error=verbose overflow.  ##
1277 ## ------------------------------ ##
1278
1279 # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an
1280 # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly
1281 # YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had
1282 # to be clipped to YYSTACK_ALLOC_MAXIMUM).  In an old version of yacc.c,
1283 # a subsequent invocation of yysyntax_error that overflows during its
1284 # size calculation would return YYSIZE_MAXIMUM to yyparse.  Then,
1285 # yyparse would invoke yyerror using the old contents of yymsg.
1286
1287 AT_SETUP([[parse.error=verbose overflow]])
1288
1289 AT_BISON_OPTION_PUSHDEFS
1290 AT_DATA_GRAMMAR([input.y],
1291 [[%code {
1292   #include <stdio.h>
1293   ]AT_YYERROR_DECLARE[
1294   ]AT_YYLEX_DECLARE[
1295
1296   /* This prevents this test case from having to induce error messages
1297      large enough to overflow size_t.  */
1298   #define YYSIZE_T unsigned char
1299
1300   /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1301      provide a malloc prototype using our YYSIZE_T.  */
1302   #include <stdlib.h>
1303   #ifndef EXIT_SUCCESS
1304   # define EXIT_SUCCESS 0
1305   #endif
1306
1307   /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and
1308      we don't want gcc to warn everywhere this constant would be too big
1309      to make sense for our YYSIZE_T.  */
1310   #define YYMAXDEPTH 100
1311 }
1312
1313 %define parse.error verbose
1314
1315 %%
1316
1317 start: syntax_error1 check syntax_error2 ;
1318
1319 // Induce a syntax error message whose total length causes yymsg in
1320 // yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which
1321 // should be 255.  Each token here is 64 bytes.
1322 syntax_error1:
1323   "123456789112345678921234567893123456789412345678951234567896123A"
1324 | "123456789112345678921234567893123456789412345678951234567896123B"
1325 | "123456789112345678921234567893123456789412345678951234567896123C"
1326 | error 'a' 'b' 'c'
1327 ;
1328
1329 check:
1330 {
1331   if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM
1332       || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM
1333       || YYSIZE_MAXIMUM != 255)
1334     {
1335       fprintf (stderr,
1336                "The assumptions of this test group are no longer\n"
1337                "valid, so it may no longer catch the error it was\n"
1338                "designed to catch.  Specifically, the following\n"
1339                "values should all be 255:\n\n");
1340       fprintf (stderr, "  yymsg_alloc = %d\n", yymsg_alloc);
1341       fprintf (stderr, "  YYSTACK_ALLOC_MAXIMUM = %d\n",
1342                YYSTACK_ALLOC_MAXIMUM);
1343       fprintf (stderr, "  YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM);
1344       YYABORT;
1345     }
1346 }
1347 ;
1348
1349 // Now overflow.
1350 syntax_error2:
1351   "123456789112345678921234567893123456789412345678951234567896123A"
1352 | "123456789112345678921234567893123456789412345678951234567896123B"
1353 | "123456789112345678921234567893123456789412345678951234567896123C"
1354 | "123456789112345678921234567893123456789412345678951234567896123D"
1355 | "123456789112345678921234567893123456789412345678951234567896123E"
1356 ;
1357
1358 %%
1359
1360 ]AT_YYERROR_DEFINE[
1361   /* Induce two syntax error messages (which requires full error
1362      recovery by shifting 3 tokens).  */
1363 ]AT_YYLEX_DEFINE(["abc"])[
1364 int
1365 main (void)
1366 {
1367   /* Push parsers throw away the message buffer between tokens, so skip
1368      this test under maintainer-push-check.  */
1369   if (YYPUSH)
1370     return 77;
1371   return yyparse ();
1372 }
1373 ]])
1374
1375 AT_BISON_CHECK([[-o input.c input.y]])
1376
1377 # gcc warns about tautologies and fallacies involving comparisons for
1378 # unsigned char.  However, it doesn't produce these same warnings for
1379 # size_t and many other types when the warnings would seem to make just
1380 # as much sense.  We ignore the warnings.
1381 [CFLAGS="$NO_WERROR_CFLAGS"]
1382 AT_COMPILE([[input]])
1383
1384 AT_PARSER_CHECK([[./input]], [[2]], [],
1385 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1386 syntax error
1387 memory exhausted
1388 ]])
1389 AT_BISON_OPTION_POPDEFS
1390 AT_CLEANUP
1391
1392
1393
1394 ## ------------------------ ##
1395 ## LAC: Exploratory stack.  ##
1396 ## ------------------------ ##
1397
1398 AT_SETUP([[LAC: Exploratory stack]])
1399
1400 m4_pushdef([AT_LAC_CHECK], [
1401
1402 AT_BISON_OPTION_PUSHDEFS([$1])
1403
1404 AT_DATA_GRAMMAR([input.y],
1405 [[%code {
1406   #include <stdio.h>
1407   ]AT_YYERROR_DECLARE[
1408   int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[);
1409 }
1410
1411 ]$1[
1412 %define parse.error verbose
1413 %token 'c'
1414
1415 %%
1416
1417 // default reductions in inconsistent states
1418 // v   v v   v v v v   v v v v v v v
1419 S: A B A A B A A A A B A A A A A A A B C C A A A A A A A A A A A A B ;
1420 //       ^                     ^                               ^
1421 // LAC reallocs
1422
1423 A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1424 B: 'b' ;
1425 C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1426
1427 %%
1428 ]AT_YYERROR_DEFINE[
1429 int
1430 yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1431 {
1432   static char const *input = "bbbbc";]AT_PURE_IF([[
1433   *v = 0;]])[
1434   return *input++;
1435 }
1436
1437 int
1438 main (void)
1439 {
1440   yydebug = 1;
1441   return yyparse ();
1442 }
1443 ]])
1444
1445 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1446                  -Dparse.lac.memory-trace=full \
1447                  -t -o input.c input.y]], [[0]], [],
1448 [[input.y: warning: 21 shift/reduce conflicts [-Wconflicts-sr]
1449 ]])
1450 AT_COMPILE([[input]])
1451 AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]])
1452
1453 # Make sure syntax error doesn't forget that 'a' is expected.  It would
1454 # be forgotten without lookahead correction.
1455 AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]],
1456 [[syntax error, unexpected 'c', expecting 'a' or 'b'
1457 ]])
1458
1459 # Check number of default reductions in inconsistent states to be sure
1460 # syntax error is detected before unnecessary reductions are performed.
1461 AT_CHECK([[$PERL -0777 -ne 'print s/inconsistent default reduction//g;' \
1462            < stdout.txt || exit 77]], [[0]], [[14]])
1463
1464 # Check number of default reductions in consistent states to be sure
1465 # it is performed before the syntax error is detected.
1466 AT_CHECK([[$PERL -0777 -ne 'print s/\bconsistent default reduction//g;' \
1467            < stdout.txt || exit 77]], [[0]], [[2]])
1468
1469 # Check number of reallocs to be sure reallocated memory isn't somehow
1470 # lost between LAC invocations.
1471 AT_CHECK([[$PERL -0777 -ne 'print s/\(realloc//g;' < stderr.txt \
1472            || exit 77]], [[0]], [[3]])
1473
1474 AT_BISON_OPTION_POPDEFS
1475 ])
1476
1477 AT_LAC_CHECK([[%define api.push-pull pull]])
1478 AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]])
1479 AT_LAC_CHECK([[%define api.push-pull both]])
1480 AT_LAC_CHECK([[%define api.push-pull both %define api.pure]])
1481
1482 m4_popdef([AT_LAC_CHECK])
1483
1484 AT_CLEANUP
1485
1486
1487
1488 ## ------------------------ ##
1489 ## LAC: Memory exhaustion.  ##
1490 ## ------------------------ ##
1491
1492 AT_SETUP([[LAC: Memory exhaustion]])
1493
1494 m4_pushdef([AT_LAC_CHECK],
1495 [AT_BISON_OPTION_PUSHDEFS
1496 AT_DATA_GRAMMAR([input.y],
1497 [[%code {
1498   #include <stdio.h>
1499   ]AT_YYERROR_DECLARE[
1500   ]AT_YYLEX_DECLARE[
1501   #define YYMAXDEPTH 8
1502 }
1503
1504 %error-verbose
1505
1506 %%
1507
1508 S: A A A A A A A A A ;
1509 A: /*empty*/ | 'a' ;
1510
1511 %%
1512 ]AT_YYERROR_DEFINE[
1513 ]AT_YYLEX_DEFINE(["$1"])[
1514 int
1515 main (void)
1516 {
1517   yydebug = 1;
1518   return yyparse ();
1519 }
1520 ]])
1521
1522 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1523                  -t -o input.c input.y]], [[0]], [],
1524 [[input.y: warning: 8 shift/reduce conflicts [-Wconflicts-sr]
1525 ]])
1526 AT_COMPILE([[input]])
1527 AT_BISON_OPTION_POPDEFS
1528 ])
1529
1530 # Check for memory exhaustion during parsing.
1531 AT_LAC_CHECK([])
1532 AT_PARSER_CHECK([[./input]], [[2]], [],
1533 [[Starting parse
1534 Entering state 0
1535 Reading a token: Now at end of input.
1536 LAC: initial context established for $end
1537 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1538 memory exhausted
1539 Cleanup: discarding lookahead token $end ()
1540 Stack now 0
1541 ]])
1542
1543 # Induce an immediate syntax error with an undefined token, and check
1544 # for memory exhaustion while building syntax error message.
1545 AT_LAC_CHECK([z], [[0]])
1546 AT_PARSER_CHECK([[./input]], [[2]], [],
1547 [[Starting parse
1548 Entering state 0
1549 Reading a token: Next token is token $undefined ()
1550 LAC: initial context established for $undefined
1551 LAC: checking lookahead $undefined: Always Err
1552 Constructing syntax error message
1553 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1554 syntax error
1555 memory exhausted
1556 Cleanup: discarding lookahead token $undefined ()
1557 Stack now 0
1558 ]])
1559
1560 m4_popdef([AT_LAC_CHECK])
1561
1562 AT_CLEANUP
1563
1564
1565 ## ---------------------- ##
1566 ## Lex and parse params.  ##
1567 ## ---------------------- ##
1568
1569 # AT_TEST(SKELETON)
1570 # -----------------
1571 # Check that the identifier of the params is properly fetched
1572 # even when there are trailing blanks.
1573
1574 m4_pushdef([AT_TEST],
1575 [AT_SETUP([[Lex and parse params: $1]])
1576
1577 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" %parse-param { int x } %parse-param { int y }])
1578
1579 ## FIXME: Improve parsing of parse-param and use the generated
1580 ## yyerror.
1581 AT_DATA_GRAMMAR([input.y],
1582 [[%defines
1583 %locations
1584 %skeleton "$1"
1585 %union { int ival; }
1586 %parse-param { int x }
1587 // Spaces, tabs, and new lines.
1588 %parse-param { @&t@
1589          int y   @&t@
1590          @&t@
1591  @&t@
1592 }
1593
1594 %{
1595 #include <stdio.h>
1596 #include <stdlib.h>
1597
1598   ]AT_YYERROR_DECLARE[
1599   ]AT_YYLEX_DECLARE[
1600 %}
1601
1602 %%
1603 exp: 'a' { fprintf (stdout, "x: %d, y: %d\n", x, y); };
1604 %%
1605 ]AT_YYERROR_DEFINE[
1606 ]AT_YYLEX_DEFINE(["a"])[
1607
1608 ]AT_SKEL_CC_IF(
1609 [int
1610 yyparse (int x, int y)
1611 {
1612   yy::parser parser(x, y);
1613   return parser.parse ();
1614 }
1615 ])[
1616
1617 int
1618 main (void)
1619 {
1620   return !!yyparse(1, 2);
1621 }
1622 ]])
1623
1624 AT_FULL_COMPILE([input])
1625 AT_PARSER_CHECK([./input], 0, [[x: 1, y: 2
1626 ]])
1627 AT_BISON_OPTION_POPDEFS
1628
1629 AT_CLEANUP
1630 ])
1631
1632 ## FIXME: test Java, and iterate over skeletons.
1633 AT_TEST([yacc.c])
1634 AT_TEST([glr.c])
1635 AT_TEST([lalr1.cc])
1636 AT_TEST([glr.cc])
1637
1638 m4_popdef([AT_TEST])