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