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