tests/regression.at

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