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 ]AT_YYERROR_DECLARE_EXTERN[
 134 ]AT_YYLEX_DECLARE_EXTERN[
 135 void print_my_token (void);
 136 %}
 137
 138 %union
 139 {
 140   int val;
 141 };
 142 %{
 143 #include <stdio.h>
 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 ]AT_YYERROR_DECLARE[
 450 ]AT_YYLEX_DECLARE[
 451 %}
 452 [%error-verbose
 453 %token MYEOF 0 "end of file"
 454 %token 'a' "a"
 455 %token B_TOKEN "b"
 456 %token C_TOKEN 'c'
 457 %token 'd' D_TOKEN
 458 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 459 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 460 %%
 461 exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
 462 %%
 463 ]AT_YYERROR_DEFINE[
 464 ]AT_YYLEX_DEFINE([{ SPECIAL }])[
 465 ]AT_MAIN_DEFINE[
 466 ]])
 467 AT_BISON_OPTION_POPDEFS
 468
 469 # Checking the warning message guarantees that the trigraph "??!" isn't
 470 # unnecessarily escaped here even though it would need to be if encoded in a
 471 # C-string literal.  Also notice that unnecessary escaping, such as "\?", from
 472 # the user specification is eliminated.
 473 AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
 474 [[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
 475 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]
 476 ]])
 477 AT_BISON_CHECK([-fcaret -o input.c input.y], [[0]], [[]],
 478 [[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
 479  %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 480         ^^^^^^^
 481 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]
 482  %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 483         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 484 ]])
 485 AT_COMPILE([input])
 486
 487 # Checking the error message here guarantees that yytname, which does contain
 488 # C-string literals, does have the trigraph escaped correctly.  Thus, the
 489 # symbol name reported by the parser is exactly the same as that reported by
 490 # Bison itself.
 491 AT_DATA([experr],
 492 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
 493 ]])
 494 AT_PARSER_CHECK([./input], 1, [], [experr])
 495 AT_CLEANUP
 496
 497
 498
 499 ## -------------------- ##
 500 ## Characters Escapes.  ##
 501 ## -------------------- ##
 502
 503
 504 AT_SETUP([Characters Escapes])
 505
 506 AT_BISON_OPTION_PUSHDEFS
 507 AT_DATA_GRAMMAR([input.y],
 508 [%{
 509 ]AT_YYERROR_DECLARE_EXTERN[
 510 ]AT_YYLEX_DECLARE_EXTERN[
 511 %}
 512 [%%
 513 exp:
 514   '\'' "\'"
 515 | '\"' "\""
 516 | '"'  "'" /* Pacify font-lock-mode: ". */
 517 ;
 518 ]])
 519
 520 AT_BISON_OPTION_POPDEFS
 521
 522 AT_BISON_CHECK([-o input.c input.y])
 523 AT_COMPILE([input.o])
 524 AT_CLEANUP
 525
 526
 527
 528 ## -------------- ##
 529 ## Web2c Report.  ##
 530 ## -------------- ##
 531
 532 # The generation of the reduction was once wrong in Bison, and made it
 533 # miss some reductions.  In the following test case, the reduction on
 534 # 'undef_id_tok' in state 1 was missing.  This is stripped down from
 535 # the actual web2c.y.
 536
 537 AT_SETUP([Web2c Report])
 538
 539 AT_KEYWORDS([report])
 540
 541 AT_DATA([input.y],
 542 [[%token        undef_id_tok const_id_tok
 543
 544 %start CONST_DEC_PART
 545 \f
 546 %%
 547 CONST_DEC_PART:
 548          CONST_DEC_LIST
 549         ;
 550
 551 CONST_DEC_LIST:
 552           CONST_DEC
 553         | CONST_DEC_LIST CONST_DEC
 554         ;
 555
 556 CONST_DEC:
 557           { } undef_id_tok '=' const_id_tok ';'
 558         ;
 559 %%
 560 ]])
 561
 562 AT_BISON_CHECK([-v input.y])
 563 AT_CHECK([cat input.output], 0,
 564 [[Grammar
 565
 566     0 $accept: CONST_DEC_PART $end
 567
 568     1 CONST_DEC_PART: CONST_DEC_LIST
 569
 570     2 CONST_DEC_LIST: CONST_DEC
 571     3               | CONST_DEC_LIST CONST_DEC
 572
 573     4 $@1: /* empty */
 574
 575     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
 576
 577
 578 Terminals, with rules where they appear
 579
 580 $end (0) 0
 581 ';' (59) 5
 582 '=' (61) 5
 583 error (256)
 584 undef_id_tok (258) 5
 585 const_id_tok (259) 5
 586
 587
 588 Nonterminals, with rules where they appear
 589
 590 $accept (7)
 591     on left: 0
 592 CONST_DEC_PART (8)
 593     on left: 1, on right: 0
 594 CONST_DEC_LIST (9)
 595     on left: 2 3, on right: 1 3
 596 CONST_DEC (10)
 597     on left: 5, on right: 2 3
 598 $@1 (11)
 599     on left: 4, on right: 5
 600
 601
 602 State 0
 603
 604     0 $accept: . CONST_DEC_PART $end
 605
 606     $default  reduce using rule 4 ($@1)
 607
 608     CONST_DEC_PART  go to state 1
 609     CONST_DEC_LIST  go to state 2
 610     CONST_DEC       go to state 3
 611     $@1             go to state 4
 612
 613
 614 State 1
 615
 616     0 $accept: CONST_DEC_PART . $end
 617
 618     $end  shift, and go to state 5
 619
 620
 621 State 2
 622
 623     1 CONST_DEC_PART: CONST_DEC_LIST .
 624     3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
 625
 626     undef_id_tok  reduce using rule 4 ($@1)
 627     $default      reduce using rule 1 (CONST_DEC_PART)
 628
 629     CONST_DEC  go to state 6
 630     $@1        go to state 4
 631
 632
 633 State 3
 634
 635     2 CONST_DEC_LIST: CONST_DEC .
 636
 637     $default  reduce using rule 2 (CONST_DEC_LIST)
 638
 639
 640 State 4
 641
 642     5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
 643
 644     undef_id_tok  shift, and go to state 7
 645
 646
 647 State 5
 648
 649     0 $accept: CONST_DEC_PART $end .
 650
 651     $default  accept
 652
 653
 654 State 6
 655
 656     3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
 657
 658     $default  reduce using rule 3 (CONST_DEC_LIST)
 659
 660
 661 State 7
 662
 663     5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
 664
 665     '='  shift, and go to state 8
 666
 667
 668 State 8
 669
 670     5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
 671
 672     const_id_tok  shift, and go to state 9
 673
 674
 675 State 9
 676
 677     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
 678
 679     ';'  shift, and go to state 10
 680
 681
 682 State 10
 683
 684     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
 685
 686     $default  reduce using rule 5 (CONST_DEC)
 687 ]])
 688
 689 AT_CLEANUP
 690
 691
 692 ## --------------- ##
 693 ## Web2c Actions.  ##
 694 ## --------------- ##
 695
 696 # The generation of the mapping 'state -> action' was once wrong in
 697 # extremely specific situations.  web2c.y exhibits this situation.
 698 # Below is a stripped version of the grammar.  It looks like one can
 699 # simplify it further, but just don't: it is tuned to exhibit a bug,
 700 # which disapears when applying sane grammar transformations.
 701 #
 702 # It used to be wrong on yydefact only:
 703 #
 704 # static const yytype_uint8 yydefact[] =
 705 #  {
 706 # -       2,     0,     1,     0,     0,     2,     3,     2,     5,     4,
 707 # +       2,     0,     1,     0,     0,     0,     3,     2,     5,     4,
 708 #         0,     0
 709 #  };
 710 #
 711 # but let's check all the tables.
 712
 713
 714 AT_SETUP([Web2c Actions])
 715
 716 AT_KEYWORDS([report])
 717
 718 AT_DATA([input.y],
 719 [[%%
 720 statement:  struct_stat;
 721 struct_stat:  /* empty. */ | if else;
 722 if: "if" "const" "then" statement;
 723 else: "else" statement;
 724 %%
 725 ]])
 726
 727 AT_BISON_CHECK([-v -o input.c input.y])
 728
 729 # Check only the tables.
 730 [sed -n 's/  *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
 731
 732 AT_CHECK([[cat tables.c]], 0,
 733 [[static const yytype_uint8 yytranslate[] =
 734 {
 735        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 736        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 737        2,     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,     1,     2,     3,     4,
 761        5,     6
 762 };
 763 static const yytype_uint8 yyrline[] =
 764 {
 765        0,     2,     2,     3,     3,     4,     5
 766 };
 767 static const char *const yytname[] =
 768 {
 769   "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
 770   "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL
 771 };
 772 static const yytype_uint16 yytoknum[] =
 773 {
 774        0,   256,   257,   258,   259,   260,   261
 775 };
 776 static const yytype_int8 yypact[] =
 777 {
 778       -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 779       -8,    -8
 780 };
 781 static const yytype_uint8 yydefact[] =
 782 {
 783        3,     0,     0,     2,     0,     0,     1,     3,     4,     3,
 784        6,     5
 785 };
 786 static const yytype_int8 yypgoto[] =
 787 {
 788       -8,    -7,    -8,    -8,    -8
 789 };
 790 static const yytype_int8 yydefgoto[] =
 791 {
 792       -1,     2,     3,     4,     8
 793 };
 794 static const yytype_uint8 yytable[] =
 795 {
 796       10,     1,    11,     5,     6,     0,     7,     9
 797 };
 798 static const yytype_int8 yycheck[] =
 799 {
 800        7,     3,     9,     4,     0,    -1,     6,     5
 801 };
 802 static const yytype_uint8 yystos[] =
 803 {
 804        0,     3,     8,     9,    10,     4,     0,     6,    11,     5,
 805        8,     8
 806 };
 807 static const yytype_uint8 yyr1[] =
 808 {
 809        0,     7,     8,     9,     9,    10,    11
 810 };
 811 static const yytype_uint8 yyr2[] =
 812 {
 813        0,     2,     1,     0,     2,     4,     2
 814 };
 815 ]])
 816
 817 AT_CLEANUP
 818
 819
 820 ## ------------------------- ##
 821 ## yycheck Bound Violation.  ##
 822 ## ------------------------- ##
 823
 824
 825 # _AT_DATA_DANCER_Y(BISON-OPTIONS)
 826 # --------------------------------
 827 # The following grammar, taken from Andrew Suffield's GPL'd implementation
 828 # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate
 829 # yycheck's bounds where issuing a verbose error message.  Keep this test
 830 # so that possible bound checking compilers could check all the skeletons.
 831 m4_define([_AT_DATA_DANCER_Y],
 832 [AT_DATA_GRAMMAR([dancer.y],
 833 [[%code provides
 834 {
 835   ]AT_YYERROR_DECLARE[
 836   ]AT_YYLEX_DECLARE[
 837 }
 838 $1
 839 %token ARROW INVALID NUMBER STRING DATA
 840 %defines
 841 %verbose
 842 %error-verbose
 843 /* Grammar follows */
 844 %%
 845 line: header body
 846    ;
 847
 848 header: '<' from ARROW to '>' type ':'
 849    | '<' ARROW to '>' type ':'
 850    | ARROW to type ':'
 851    | type ':'
 852    | '<' '>'
 853    ;
 854
 855 from: DATA
 856    | STRING
 857    | INVALID
 858    ;
 859
 860 to: DATA
 861    | STRING
 862    | INVALID
 863    ;
 864
 865 type: DATA
 866    | STRING
 867    | INVALID
 868    ;
 869
 870 body: /* empty */
 871    | body member
 872    ;
 873
 874 member: STRING
 875    | DATA
 876    | '+' NUMBER
 877    | '-' NUMBER
 878    | NUMBER
 879    | INVALID
 880    ;
 881 %%
 882 ]AT_YYERROR_DEFINE[
 883 ]AT_YYLEX_DEFINE([":"])[
 884 ]AT_MAIN_DEFINE[
 885 ]])
 886 ])# _AT_DATA_DANCER_Y
 887
 888
 889 # AT_CHECK_DANCER(BISON-OPTIONS)
 890 # ------------------------------
 891 # Generate the grammar, compile it, run it.
 892 m4_define([AT_CHECK_DANCER],
 893 [AT_SETUP([Dancer $1])
 894 AT_BISON_OPTION_PUSHDEFS([$1])
 895 _AT_DATA_DANCER_Y([$1])
 896 AT_FULL_COMPILE([dancer])
 897 AT_PARSER_CHECK([./dancer], 1, [],
 898 [syntax error, unexpected ':'
 899 ])
 900 AT_BISON_OPTION_POPDEFS
 901 AT_CLEANUP
 902 ])
 903
 904 AT_CHECK_DANCER()
 905 AT_CHECK_DANCER([%glr-parser])
 906 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
 907
 908
 909 ## ------------------------------------------ ##
 910 ## Diagnostic that expects two alternatives.  ##
 911 ## ------------------------------------------ ##
 912
 913
 914 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
 915 # --------------------------------
 916 m4_define([_AT_DATA_EXPECT2_Y],
 917 [AT_DATA_GRAMMAR([expect2.y],
 918 [%{
 919 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 920 AT_LALR1_CC_IF([[#include <cstdlib>]],
 921 [[
 922 ]AT_YYERROR_DECLARE])[
 923 %}
 924 $1
 925 %defines
 926 %error-verbose
 927 %token A 1000
 928 %token B
 929
 930 %%
 931 program: /* empty */
 932  | program e ';'
 933  | program error ';';
 934
 935 e: e '+' t | t;
 936 t: A | B;
 937
 938 %%
 939 ]AT_YYERROR_DEFINE[
 940 ]AT_LALR1_CC_IF(
 941 [int
 942 yyparse ()
 943 {
 944   yy::parser parser;
 945   return parser.parse ();
 946 }
 947 ])[
 948
 949 #include <assert.h>
 950 static int
 951 yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
 952 {
 953   static int const tokens[] =
 954     {
 955       1000, '+', '+', -1
 956     };
 957   static size_t toknum;
 958   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
 959   assert (toknum < sizeof tokens / sizeof *tokens);
 960   return tokens[toknum++];
 961 }
 962 ]AT_MAIN_DEFINE[
 963 ]])
 964 ])# _AT_DATA_EXPECT2_Y
 965
 966
 967 # AT_CHECK_EXPECT2(BISON-OPTIONS)
 968 # -------------------------------
 969 # Generate the grammar, compile it, run it.
 970 m4_define([AT_CHECK_EXPECT2],
 971 [AT_SETUP([Expecting two tokens $1])
 972 AT_BISON_OPTION_PUSHDEFS([$1])
 973 _AT_DATA_EXPECT2_Y([$1])
 974 AT_FULL_COMPILE([expect2])
 975 AT_PARSER_CHECK([./expect2], 1, [],
 976 [syntax error, unexpected '+', expecting A or B
 977 ])
 978 AT_BISON_OPTION_POPDEFS
 979 AT_CLEANUP
 980 ])
 981
 982 AT_CHECK_EXPECT2()
 983 AT_CHECK_EXPECT2([%glr-parser])
 984 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
 985
 986
 987
 988 ## --------------------------------------------- ##
 989 ## Braced code in declaration in rules section.  ##
 990 ## --------------------------------------------- ##
 991
 992 AT_SETUP([Braced code in declaration in rules section])
 993
 994 # Bison once mistook braced code in a declaration in the rules section to be a
 995 # rule action.
 996 AT_BISON_OPTION_PUSHDEFS([%debug])
 997 AT_DATA_GRAMMAR([input.y],
 998 [[%{
 999 ]AT_YYERROR_DECLARE[
1000 ]AT_YYLEX_DECLARE[
1001 %}
1002 %debug
1003 %error-verbose
1004 %%
1005
1006 start:
1007   {
1008     printf ("Bison would once convert this action to a midrule because of the"
1009             " subsequent braced code.\n");
1010   }
1011   ;
1012
1013 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1014 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1015
1016 %%
1017 ]AT_YYERROR_DEFINE[
1018 ]AT_YYLEX_DEFINE(["a"])[
1019 ]AT_MAIN_DEFINE[
1020 ]])
1021 AT_BISON_OPTION_POPDEFS
1022
1023 AT_BISON_CHECK([-o input.c input.y])
1024 AT_COMPILE([input])
1025 AT_PARSER_CHECK([./input --debug], 1,
1026 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1027 ]],
1028 [[Starting parse
1029 Entering state 0
1030 Reducing stack by rule 1 (line 20):
1031 -> $$ = nterm start ()
1032 Stack now 0
1033 Entering state 1
1034 Reading a token: Next token is token 'a' (PRINTER)
1035 syntax error, unexpected 'a', expecting $end
1036 Error: popping nterm start ()
1037 Stack now 0
1038 Cleanup: discarding lookahead token 'a' (PRINTER)
1039 DESTRUCTOR
1040 Stack now 0
1041 ]])
1042
1043 AT_CLEANUP
1044
1045
1046
1047 ## --------------------------------- ##
1048 ## String alias declared after use.  ##
1049 ## --------------------------------- ##
1050
1051 AT_SETUP([String alias declared after use])
1052
1053 # Bison once incorrectly asserted that the symbol number for either a token or
1054 # its alias was the highest symbol number so far at the point of the alias
1055 # declaration.  That was true unless the declaration appeared after their first
1056 # uses and other tokens appeared in between.
1057
1058 AT_DATA([input.y],
1059 [[%%
1060 start: 'a' "A" 'b';
1061 %token 'a' "A";
1062 ]])
1063
1064 AT_BISON_CHECK([-o input.c input.y])
1065
1066 AT_CLEANUP
1067
1068
1069
1070 ## -------------------------------- ##
1071 ## Extra lookahead sets in report.  ##
1072 ## -------------------------------- ##
1073
1074 AT_SETUP([[Extra lookahead sets in report]])
1075
1076 # Bison prints each reduction's lookahead set only next to the associated
1077 # state's one item that (1) is associated with the same rule as the reduction
1078 # and (2) has its dot at the end of its RHS.  Previously, Bison also
1079 # erroneously printed the lookahead set next to all of the state's other items
1080 # associated with the same rule.  This bug affected only the '.output' file and
1081 # not the generated parser source code.
1082
1083 AT_DATA([[input.y]],
1084 [[%%
1085 start: a | 'a' a 'a' ;
1086 a: 'a' ;
1087 ]])
1088
1089 AT_BISON_CHECK([[--report=all input.y]])
1090 AT_CHECK([[sed -n '/^State 1$/,/^State 2$/p' input.output]], [[0]],
1091 [[State 1
1092
1093     2 start: 'a' . a 'a'
1094     3 a: . 'a'
1095     3  | 'a' .  [$end]
1096
1097     'a'  shift, and go to state 4
1098
1099     $default  reduce using rule 3 (a)
1100
1101     a  go to state 5
1102
1103
1104 State 2
1105 ]])
1106
1107 AT_CLEANUP
1108
1109
1110
1111 ## ---------------------------------------- ##
1112 ## Token number in precedence declaration.  ##
1113 ## ---------------------------------------- ##
1114
1115 AT_SETUP([[Token number in precedence declaration]])
1116
1117 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1118 # we lost this in Bison 1.50.
1119 AT_BISON_OPTION_PUSHDEFS
1120 AT_DATA_GRAMMAR([input.y],
1121 [[%code {
1122   ]AT_YYERROR_DECLARE[
1123   ]AT_YYLEX_DECLARE[
1124 }
1125
1126 %error-verbose
1127 %right END 0
1128 %left TK1 1 TK2 2 "tok alias" 3
1129
1130 %%
1131
1132 start:
1133     TK1 sr_conflict "tok alias"
1134   | start %prec END
1135   ;
1136 sr_conflict:
1137   TK2
1138   | TK2 "tok alias"
1139   ;
1140
1141 %%
1142
1143 ]AT_YYERROR_DEFINE[
1144 ]AT_YYLEX_DEFINE([{ 1, 2, 3, 0 }])[
1145 ]AT_MAIN_DEFINE[
1146 ]])
1147 AT_BISON_OPTION_POPDEFS
1148
1149 AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1150 [[input.y:24.5-19: warning: rule useless in parser due to conflicts: start: start [-Wother]
1151 input.y:28.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" [-Wother]
1152 ]])
1153 AT_COMPILE([[input]])
1154 AT_PARSER_CHECK([[./input]])
1155
1156 AT_CLEANUP
1157
1158
1159
1160 ## --------------------------- ##
1161 ## parse-gram.y: LALR = IELR.  ##
1162 ## --------------------------- ##
1163
1164 # If parse-gram.y's LALR and IELR parser tables ever begin to differ, we
1165 # need to fix parse-gram.y or start using IELR.
1166
1167 AT_SETUP([[parse-gram.y: LALR = IELR]])
1168
1169 # Avoid tests/bison's dark magic by processing a local copy of the
1170 # grammar.  Avoid differences in synclines by telling bison that the
1171 # output files have the same name.
1172 [cp $abs_top_srcdir/src/parse-gram.y input.y]
1173 AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
1174 [mv input.c lalr.c]
1175 AT_CAPTURE_FILE([lalr.c])
1176 AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1177 [mv input.c ielr.c]
1178 AT_CAPTURE_FILE([ielr.c])
1179 AT_CHECK([[diff lalr.c ielr.c]], [[0]])
1180
1181 AT_CLEANUP
1182
1183
1184
1185 ## -------------------------------------------- ##
1186 ## parse.error=verbose and YYSTACK_USE_ALLOCA.  ##
1187 ## -------------------------------------------- ##
1188
1189 AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]])
1190
1191 AT_BISON_OPTION_PUSHDEFS
1192 AT_DATA_GRAMMAR([input.y],
1193 [[%code {
1194   ]AT_YYERROR_DECLARE[
1195   ]AT_YYLEX_DECLARE[
1196   #define YYSTACK_USE_ALLOCA 1
1197 }
1198
1199 %define parse.error verbose
1200
1201 %%
1202
1203 start: check syntax_error syntax_error ;
1204
1205 check:
1206 {
1207   if (128 < sizeof yymsgbuf)
1208     {
1209       fprintf (stderr,
1210                "The initial size of yymsgbuf in yyparse has increased\n"
1211                "since this test group was last updated.  As a result,\n"
1212                "this test group may no longer manage to induce a\n"
1213                "reallocation of the syntax error message buffer.\n"
1214                "This test group must be adjusted to produce a longer\n"
1215                "error message.\n");
1216       YYABORT;
1217     }
1218 }
1219 ;
1220
1221 // Induce a syntax error message whose total length is more than
1222 // sizeof yymsgbuf in yyparse.  Each token here is 64 bytes.
1223 syntax_error:
1224   "123456789112345678921234567893123456789412345678951234567896123A"
1225 | "123456789112345678921234567893123456789412345678951234567896123B"
1226 | error 'a' 'b' 'c'
1227 ;
1228
1229 %%
1230
1231 ]AT_YYERROR_DEFINE[
1232   /* Induce two syntax error messages (which requires full error
1233      recovery by shifting 3 tokens) in order to detect any loss of the
1234      reallocated buffer.  */
1235 ]AT_YYLEX_DEFINE(["abc"])[
1236 ]AT_MAIN_DEFINE[
1237 ]])
1238 AT_BISON_OPTION_POPDEFS
1239
1240 AT_BISON_CHECK([[-o input.c input.y]])
1241 AT_COMPILE([[input]])
1242 AT_PARSER_CHECK([[./input]], [[1]], [],
1243 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1244 syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1245 ]])
1246
1247 AT_CLEANUP
1248
1249
1250
1251 ## ------------------------------ ##
1252 ## parse.error=verbose overflow.  ##
1253 ## ------------------------------ ##
1254
1255 # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an
1256 # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly
1257 # YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had
1258 # to be clipped to YYSTACK_ALLOC_MAXIMUM).  In an old version of yacc.c,
1259 # a subsequent invocation of yysyntax_error that overflows during its
1260 # size calculation would return YYSIZE_MAXIMUM to yyparse.  Then,
1261 # yyparse would invoke yyerror using the old contents of yymsg.
1262
1263 AT_SETUP([[parse.error=verbose overflow]])
1264
1265 AT_BISON_OPTION_PUSHDEFS
1266 AT_DATA_GRAMMAR([input.y],
1267 [[%code {
1268   ]AT_YYERROR_DECLARE[
1269   ]AT_YYLEX_DECLARE[
1270
1271   /* This prevents this test case from having to induce error messages
1272      large enough to overflow size_t.  */
1273   #define YYSIZE_T unsigned char
1274
1275   /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1276      provide a malloc prototype using our YYSIZE_T.  */
1277   #include <stdlib.h>
1278   #ifndef EXIT_SUCCESS
1279   # define EXIT_SUCCESS 0
1280   #endif
1281
1282   /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and
1283      we don't want gcc to warn everywhere this constant would be too big
1284      to make sense for our YYSIZE_T.  */
1285   #define YYMAXDEPTH 100
1286 }
1287
1288 %define parse.error verbose
1289
1290 %%
1291
1292 start: syntax_error1 check syntax_error2 ;
1293
1294 // Induce a syntax error message whose total length causes yymsg in
1295 // yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which
1296 // should be 255.  Each token here is 64 bytes.
1297 syntax_error1:
1298   "123456789112345678921234567893123456789412345678951234567896123A"
1299 | "123456789112345678921234567893123456789412345678951234567896123B"
1300 | "123456789112345678921234567893123456789412345678951234567896123C"
1301 | error 'a' 'b' 'c'
1302 ;
1303
1304 check:
1305 {
1306   if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM
1307       || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM
1308       || YYSIZE_MAXIMUM != 255)
1309     {
1310       fprintf (stderr,
1311                "The assumptions of this test group are no longer\n"
1312                "valid, so it may no longer catch the error it was\n"
1313                "designed to catch.  Specifically, the following\n"
1314                "values should all be 255:\n\n");
1315       fprintf (stderr, "  yymsg_alloc = %d\n", yymsg_alloc);
1316       fprintf (stderr, "  YYSTACK_ALLOC_MAXIMUM = %d\n",
1317                YYSTACK_ALLOC_MAXIMUM);
1318       fprintf (stderr, "  YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM);
1319       YYABORT;
1320     }
1321 }
1322 ;
1323
1324 // Now overflow.
1325 syntax_error2:
1326   "123456789112345678921234567893123456789412345678951234567896123A"
1327 | "123456789112345678921234567893123456789412345678951234567896123B"
1328 | "123456789112345678921234567893123456789412345678951234567896123C"
1329 | "123456789112345678921234567893123456789412345678951234567896123D"
1330 | "123456789112345678921234567893123456789412345678951234567896123E"
1331 ;
1332
1333 %%
1334
1335 ]AT_YYERROR_DEFINE[
1336   /* Induce two syntax error messages (which requires full error
1337      recovery by shifting 3 tokens).  */
1338 ]AT_YYLEX_DEFINE(["abc"])[
1339 int
1340 main (void)
1341 {
1342   /* Push parsers throw away the message buffer between tokens, so skip
1343      this test under maintainer-push-check.  */
1344   if (YYPUSH)
1345     return 77;
1346   return yyparse ();
1347 }
1348 ]])
1349
1350 AT_BISON_CHECK([[-o input.c input.y]])
1351
1352 # gcc warns about tautologies and fallacies involving comparisons for
1353 # unsigned char.  However, it doesn't produce these same warnings for
1354 # size_t and many other types when the warnings would seem to make just
1355 # as much sense.  We ignore the warnings.
1356 [CFLAGS="$NO_WERROR_CFLAGS"]
1357 AT_COMPILE([[input]])
1358
1359 AT_PARSER_CHECK([[./input]], [[2]], [],
1360 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1361 syntax error
1362 memory exhausted
1363 ]])
1364 AT_BISON_OPTION_POPDEFS
1365 AT_CLEANUP
1366
1367
1368
1369 ## ------------------------ ##
1370 ## LAC: Exploratory stack.  ##
1371 ## ------------------------ ##
1372
1373 AT_SETUP([[LAC: Exploratory stack]])
1374
1375 m4_pushdef([AT_LAC_CHECK], [
1376
1377 AT_BISON_OPTION_PUSHDEFS([%debug $1])
1378
1379 AT_DATA_GRAMMAR([input.y],
1380 [[%code {
1381   ]AT_YYERROR_DECLARE[
1382   int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[);
1383 }
1384 %debug
1385 ]$1[
1386 %define parse.error verbose
1387 %token 'c'
1388
1389 %%
1390
1391 // default reductions in inconsistent states
1392 // v   v v   v v v v   v v v v v v v
1393 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 ;
1394 //       ^                     ^                               ^
1395 // LAC reallocs
1396
1397 A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1398 B: 'b' ;
1399 C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1400
1401 %%
1402 ]AT_YYERROR_DEFINE[
1403 int
1404 yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1405 {
1406   static char const *input = "bbbbc";]AT_PURE_IF([[
1407   *v = 0;]])[
1408   return *input++;
1409 }
1410
1411 ]AT_MAIN_DEFINE[
1412 ]])
1413
1414 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1415                  -Dparse.lac.memory-trace=full \
1416                  -o input.c input.y]], [[0]], [],
1417 [[input.y: warning: 21 shift/reduce conflicts [-Wconflicts-sr]
1418 ]])
1419 AT_COMPILE([[input]])
1420 AT_PARSER_CHECK([[./input --debug > stdout.txt 2> stderr.txt]], [[1]])
1421
1422 # Make sure syntax error doesn't forget that 'a' is expected.  It would
1423 # be forgotten without lookahead correction.
1424 AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]],
1425 [[syntax error, unexpected 'c', expecting 'a' or 'b'
1426 ]])
1427
1428 # Check number of default reductions in inconsistent states to be sure
1429 # syntax error is detected before unnecessary reductions are performed.
1430 AT_CHECK([[$PERL -0777 -ne 'print s/inconsistent default reduction//g;' \
1431            < stdout.txt || exit 77]], [[0]], [[14]])
1432
1433 # Check number of default reductions in consistent states to be sure
1434 # it is performed before the syntax error is detected.
1435 AT_CHECK([[$PERL -0777 -ne 'print s/\bconsistent default reduction//g;' \
1436            < stdout.txt || exit 77]], [[0]], [[2]])
1437
1438 # Check number of reallocs to be sure reallocated memory isn't somehow
1439 # lost between LAC invocations.
1440 AT_CHECK([[$PERL -0777 -ne 'print s/\(realloc//g;' < stderr.txt \
1441            || exit 77]], [[0]], [[3]])
1442
1443 AT_BISON_OPTION_POPDEFS
1444 ])
1445
1446 AT_LAC_CHECK([[%define api.push-pull pull]])
1447 AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]])
1448 AT_LAC_CHECK([[%define api.push-pull both]])
1449 AT_LAC_CHECK([[%define api.push-pull both %define api.pure]])
1450
1451 m4_popdef([AT_LAC_CHECK])
1452
1453 AT_CLEANUP
1454
1455
1456
1457 ## ------------------------ ##
1458 ## LAC: Memory exhaustion.  ##
1459 ## ------------------------ ##
1460
1461 AT_SETUP([[LAC: Memory exhaustion]])
1462
1463 m4_pushdef([AT_LAC_CHECK],
1464 [AT_BISON_OPTION_PUSHDEFS([%debug])
1465 AT_DATA_GRAMMAR([input.y],
1466 [[%code {
1467   ]AT_YYERROR_DECLARE[
1468   ]AT_YYLEX_DECLARE[
1469   #define YYMAXDEPTH 8
1470 }
1471 %debug
1472 %error-verbose
1473
1474 %%
1475
1476 S: A A A A A A A A A ;
1477 A: /*empty*/ | 'a' ;
1478
1479 %%
1480 ]AT_YYERROR_DEFINE[
1481 ]AT_YYLEX_DEFINE(["$1"])[
1482 ]AT_MAIN_DEFINE[
1483 ]])
1484
1485 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1486                  -o input.c input.y]], [[0]], [],
1487 [[input.y: warning: 8 shift/reduce conflicts [-Wconflicts-sr]
1488 ]])
1489 AT_COMPILE([[input]])
1490 AT_BISON_OPTION_POPDEFS
1491 ])
1492
1493 # Check for memory exhaustion during parsing.
1494 AT_LAC_CHECK([])
1495 AT_PARSER_CHECK([[./input --debug]], [[2]], [],
1496 [[Starting parse
1497 Entering state 0
1498 Reading a token: Now at end of input.
1499 LAC: initial context established for $end
1500 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1501 memory exhausted
1502 Cleanup: discarding lookahead token $end ()
1503 Stack now 0
1504 ]])
1505
1506 # Induce an immediate syntax error with an undefined token, and check
1507 # for memory exhaustion while building syntax error message.
1508 AT_LAC_CHECK([z], [[0]])
1509 AT_PARSER_CHECK([[./input --debug]], [[2]], [],
1510 [[Starting parse
1511 Entering state 0
1512 Reading a token: Next token is token $undefined ()
1513 LAC: initial context established for $undefined
1514 LAC: checking lookahead $undefined: Always Err
1515 Constructing syntax error message
1516 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1517 syntax error
1518 memory exhausted
1519 Cleanup: discarding lookahead token $undefined ()
1520 Stack now 0
1521 ]])
1522
1523 m4_popdef([AT_LAC_CHECK])
1524
1525 AT_CLEANUP
1526
1527
1528 ## ---------------------- ##
1529 ## Lex and parse params.  ##
1530 ## ---------------------- ##
1531
1532 # AT_TEST(SKELETON)
1533 # -----------------
1534 # Check that the identifier of the params is properly fetched
1535 # even when there are trailing blanks.
1536
1537 m4_pushdef([AT_TEST],
1538 [AT_SETUP([[Lex and parse params: $1]])
1539
1540 ## FIXME: Improve parsing of parse-param.
1541 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" %parse-param { int x } %parse-param { int y }])
1542
1543 AT_DATA_GRAMMAR([input.y],
1544 [[%defines
1545 %locations
1546 %skeleton "$1"
1547 %union { int ival; }
1548 %parse-param { int x }
1549 // Spaces, tabs, and new lines.
1550 %parse-param { @&t@
1551          int y   @&t@
1552          @&t@
1553  @&t@
1554 }
1555
1556 %{
1557   ]AT_YYERROR_DECLARE[
1558   ]AT_YYLEX_DECLARE[
1559 %}
1560
1561 %%
1562 exp: 'a' { fprintf (stdout, "x: %d, y: %d\n", x, y); };
1563 %%
1564 ]AT_YYERROR_DEFINE[
1565 ]AT_YYLEX_DEFINE(["a"])[
1566
1567 ]AT_SKEL_CC_IF(
1568 [int
1569 yyparse (int x, int y)
1570 {
1571   yy::parser parser(x, y);
1572   return parser.parse ();
1573 }
1574 ])[
1575
1576 int
1577 main (void)
1578 {
1579   return !!yyparse(1, 2);
1580 }
1581 ]])
1582
1583 AT_FULL_COMPILE([input])
1584 AT_PARSER_CHECK([./input], 0, [[x: 1, y: 2
1585 ]])
1586 AT_BISON_OPTION_POPDEFS
1587
1588 AT_CLEANUP
1589 ])
1590
1591 ## FIXME: test Java, and iterate over skeletons.
1592 AT_TEST([yacc.c])
1593 AT_TEST([glr.c])
1594 AT_TEST([lalr1.cc])
1595 AT_TEST([glr.cc])
1596
1597 m4_popdef([AT_TEST])
1598
1599
1600 ## ----------------------- ##
1601 ## stdio.h is not needed.  ##
1602 ## ----------------------- ##
1603
1604 # At some point, by accident, yy_location_print_ was using fprintf and
1605 # FILE which are from stdio.h, which we do not require.
1606 AT_SETUP([[stdio.h is not needed]])
1607
1608 AT_BISON_OPTION_PUSHDEFS
1609
1610 AT_DATA_GRAMMAR([input.y],
1611 [[%locations
1612 %code
1613 {
1614   static int yylex (void) { return 0; }
1615   static void yyerror (const char* msg) { (void) msg; }
1616 }
1617 %%
1618 exp: {}
1619 %%
1620 ]AT_MAIN_DEFINE[
1621 ]])
1622
1623 AT_FULL_COMPILE([input])
1624
1625 AT_BISON_OPTION_POPDEFS
1626
1627 AT_CLEANUP