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: invalid character: '?'
 405 input.y:3.14: invalid character: '}'
 406 input.y:4.1: invalid character: '%'
 407 input.y:4.2: invalid character: '&'
 408 input.y:5.1-17: invalid directive: '%a-does-not-exist'
 409 input.y:6.1: invalid character: '%'
 410 input.y:6.2: invalid character: '-'
 411 input.y:7.1-8.0: missing '%}' at end of file
 412 input.y:7.1-8.0: 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: 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
 467 int
 468 yylex (void)
 469 {
 470   static int called;
 471   if (called++)
 472     abort ();
 473   return SPECIAL;
 474 }
 475
 476 int
 477 main (void)
 478 {
 479   return yyparse ();
 480 }
 481 ]])
 482 AT_BISON_OPTION_POPDEFS
 483
 484 # Checking the warning message guarantees that the trigraph "??!" isn't
 485 # unnecessarily escaped here even though it would need to be if encoded in a
 486 # C-string literal.  Also notice that unnecessary escaping, such as "\?", from
 487 # the user specification is eliminated.
 488 AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
 489 [[input.y:22.8-14: warning: symbol SPECIAL redeclared
 490 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
 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 yyrline[] =
 771 {
 772        0,     2,     2,     3,     3,     4,     5
 773 };
 774 static const char *const yytname[] =
 775 {
 776   "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
 777   "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL
 778 };
 779 static const yytype_uint16 yytoknum[] =
 780 {
 781        0,   256,   257,   258,   259,   260,   261
 782 };
 783 static const yytype_int8 yypact[] =
 784 {
 785       -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 786       -8,    -8
 787 };
 788 static const yytype_uint8 yydefact[] =
 789 {
 790        3,     0,     0,     2,     0,     0,     1,     3,     4,     3,
 791        6,     5
 792 };
 793 static const yytype_int8 yypgoto[] =
 794 {
 795       -8,    -7,    -8,    -8,    -8
 796 };
 797 static const yytype_int8 yydefgoto[] =
 798 {
 799       -1,     2,     3,     4,     8
 800 };
 801 static const yytype_uint8 yytable[] =
 802 {
 803       10,     1,    11,     5,     6,     0,     7,     9
 804 };
 805 static const yytype_int8 yycheck[] =
 806 {
 807        7,     3,     9,     4,     0,    -1,     6,     5
 808 };
 809 static const yytype_uint8 yystos[] =
 810 {
 811        0,     3,     8,     9,    10,     4,     0,     6,    11,     5,
 812        8,     8
 813 };
 814 static const yytype_uint8 yyr1[] =
 815 {
 816        0,     7,     8,     9,     9,    10,    11
 817 };
 818 static const yytype_uint8 yyr2[] =
 819 {
 820        0,     2,     1,     0,     2,     4,     2
 821 };
 822 ]])
 823
 824 AT_CLEANUP
 825
 826
 827 ## ------------------------- ##
 828 ## yycheck Bound Violation.  ##
 829 ## ------------------------- ##
 830
 831
 832 # _AT_DATA_DANCER_Y(BISON-OPTIONS)
 833 # --------------------------------
 834 # The following grammar, taken from Andrew Suffield's GPL'd implementation
 835 # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate
 836 # yycheck's bounds where issuing a verbose error message.  Keep this test
 837 # so that possible bound checking compilers could check all the skeletons.
 838 m4_define([_AT_DATA_DANCER_Y],
 839 [AT_DATA_GRAMMAR([dancer.y],
 840 [%{
 841 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 842 AT_LALR1_CC_IF([#include <cstdlib>],
 843 [#include <stdlib.h>
 844 #include <stdio.h>
 845 ]AT_YYERROR_DECLARE[])
 846 %}
 847 $1
 848 %token ARROW INVALID NUMBER STRING DATA
 849 %defines
 850 %verbose
 851 %error-verbose
 852 /* Grammar follows */
 853 %%
 854 line: header body
 855    ;
 856
 857 header: '<' from ARROW to '>' type ':'
 858    | '<' ARROW to '>' type ':'
 859    | ARROW to type ':'
 860    | type ':'
 861    | '<' '>'
 862    ;
 863
 864 from: DATA
 865    | STRING
 866    | INVALID
 867    ;
 868
 869 to: DATA
 870    | STRING
 871    | INVALID
 872    ;
 873
 874 type: DATA
 875    | STRING
 876    | INVALID
 877    ;
 878
 879 body: /* empty */
 880    | body member
 881    ;
 882
 883 member: STRING
 884    | DATA
 885    | '+' NUMBER
 886    | '-' NUMBER
 887    | NUMBER
 888    | INVALID
 889    ;
 890 %%
 891 AT_YYERROR_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 #include <assert.h>
 905 static int
 906 yylex (AT_LALR1_CC_IF([int *lval], [void]))
 907 [{
 908   static int const tokens[] =
 909     {
 910       ':', -1
 911     };
 912   static size_t toknum;
 913   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
 914   assert (toknum < sizeof tokens / sizeof *tokens);
 915   return tokens[toknum++];
 916 }]
 917
 918 int
 919 main (void)
 920 {
 921   return yyparse ();
 922 }
 923 ])
 924 ])# _AT_DATA_DANCER_Y
 925
 926
 927 # AT_CHECK_DANCER(BISON-OPTIONS)
 928 # ------------------------------
 929 # Generate the grammar, compile it, run it.
 930 m4_define([AT_CHECK_DANCER],
 931 [AT_SETUP([Dancer $1])
 932 AT_BISON_OPTION_PUSHDEFS([$1])
 933 _AT_DATA_DANCER_Y([$1])
 934 AT_BISON_CHECK([-o dancer.c dancer.y])
 935 AT_FULL_COMPILE([dancer])
 936 AT_PARSER_CHECK([./dancer], 1, [],
 937 [syntax error, unexpected ':'
 938 ])
 939 AT_BISON_OPTION_POPDEFS
 940 AT_CLEANUP
 941 ])
 942
 943 AT_CHECK_DANCER()
 944 AT_CHECK_DANCER([%glr-parser])
 945 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
 946
 947
 948 ## ------------------------------------------ ##
 949 ## Diagnostic that expects two alternatives.  ##
 950 ## ------------------------------------------ ##
 951
 952
 953 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
 954 # --------------------------------
 955 m4_define([_AT_DATA_EXPECT2_Y],
 956 [AT_DATA_GRAMMAR([expect2.y],
 957 [%{
 958 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 959 AT_LALR1_CC_IF([[#include <cstdlib>]],
 960 [[#include <stdlib.h>
 961 #include <stdio.h>
 962 ]AT_YYERROR_DECLARE])[
 963 %}
 964 $1
 965 %defines
 966 %error-verbose
 967 %token A 1000
 968 %token B
 969
 970 %%
 971 program: /* empty */
 972  | program e ';'
 973  | program error ';';
 974
 975 e: e '+' t | t;
 976 t: A | B;
 977
 978 %%
 979 ]AT_YYERROR_DEFINE[
 980 ]AT_LALR1_CC_IF(
 981 [int
 982 yyparse ()
 983 {
 984   yy::parser parser;
 985   return parser.parse ();
 986 }
 987 ])[
 988
 989 #include <assert.h>
 990 static int
 991 yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
 992 {
 993   static int const tokens[] =
 994     {
 995       1000, '+', '+', -1
 996     };
 997   static size_t toknum;
 998   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
 999   assert (toknum < sizeof tokens / sizeof *tokens);
1000   return tokens[toknum++];
1001 }
1002
1003 int
1004 main (void)
1005 {
1006   return yyparse ();
1007 }
1008 ]])
1009 ])# _AT_DATA_EXPECT2_Y
1010
1011
1012 # AT_CHECK_EXPECT2(BISON-OPTIONS)
1013 # -------------------------------
1014 # Generate the grammar, compile it, run it.
1015 m4_define([AT_CHECK_EXPECT2],
1016 [AT_SETUP([Expecting two tokens $1])
1017 AT_BISON_OPTION_PUSHDEFS([$1])
1018 _AT_DATA_EXPECT2_Y([$1])
1019 AT_BISON_CHECK([-o expect2.c expect2.y])
1020 AT_FULL_COMPILE([expect2])
1021 AT_PARSER_CHECK([./expect2], 1, [],
1022 [syntax error, unexpected '+', expecting A or B
1023 ])
1024 AT_BISON_OPTION_POPDEFS
1025 AT_CLEANUP
1026 ])
1027
1028 AT_CHECK_EXPECT2()
1029 AT_CHECK_EXPECT2([%glr-parser])
1030 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
1031
1032
1033
1034 ## --------------------------------------------- ##
1035 ## Braced code in declaration in rules section.  ##
1036 ## --------------------------------------------- ##
1037
1038 AT_SETUP([Braced code in declaration in rules section])
1039
1040 # Bison once mistook braced code in a declaration in the rules section to be a
1041 # rule action.
1042 AT_BISON_OPTION_PUSHDEFS
1043 AT_DATA_GRAMMAR([input.y],
1044 [[%{
1045 #include <stdio.h>
1046 ]AT_YYERROR_DECLARE[
1047 ]AT_YYLEX_DECLARE[
1048 %}
1049
1050 %error-verbose
1051
1052 %%
1053
1054 start:
1055   {
1056     printf ("Bison would once convert this action to a midrule because of the"
1057             " subsequent braced code.\n");
1058   }
1059   ;
1060
1061 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1062 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1063
1064 %%
1065
1066 ]AT_YYERROR_DEFINE[
1067 static int
1068 yylex (void)
1069 {
1070   return 'a';
1071 }
1072
1073 int
1074 main (void)
1075 {
1076   yydebug = 1;
1077   return !yyparse ();
1078 }
1079 ]])
1080 AT_BISON_OPTION_POPDEFS
1081
1082 AT_BISON_CHECK([-t -o input.c input.y])
1083 AT_COMPILE([input])
1084 AT_PARSER_CHECK([./input], 0,
1085 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1086 ]],
1087 [[Starting parse
1088 Entering state 0
1089 Reducing stack by rule 1 (line 20):
1090 -> $$ = nterm start ()
1091 Stack now 0
1092 Entering state 1
1093 Reading a token: Next token is token 'a' (PRINTER)
1094 syntax error, unexpected 'a', expecting $end
1095 Error: popping nterm start ()
1096 Stack now 0
1097 Cleanup: discarding lookahead token 'a' (PRINTER)
1098 DESTRUCTOR
1099 Stack now 0
1100 ]])
1101
1102 AT_CLEANUP
1103
1104
1105
1106 ## --------------------------------- ##
1107 ## String alias declared after use.  ##
1108 ## --------------------------------- ##
1109
1110 AT_SETUP([String alias declared after use])
1111
1112 # Bison once incorrectly asserted that the symbol number for either a token or
1113 # its alias was the highest symbol number so far at the point of the alias
1114 # declaration.  That was true unless the declaration appeared after their first
1115 # uses and other tokens appeared in between.
1116
1117 AT_DATA([input.y],
1118 [[%%
1119 start: 'a' "A" 'b';
1120 %token 'a' "A";
1121 ]])
1122
1123 AT_BISON_CHECK([-t -o input.c input.y])
1124
1125 AT_CLEANUP
1126
1127
1128
1129 ## -------------------------------- ##
1130 ## Extra lookahead sets in report.  ##
1131 ## -------------------------------- ##
1132
1133 AT_SETUP([[Extra lookahead sets in report]])
1134
1135 # Bison prints each reduction's lookahead set only next to the associated
1136 # state's one item that (1) is associated with the same rule as the reduction
1137 # and (2) has its dot at the end of its RHS.  Previously, Bison also
1138 # erroneously printed the lookahead set next to all of the state's other items
1139 # associated with the same rule.  This bug affected only the '.output' file and
1140 # not the generated parser source code.
1141
1142 AT_DATA([[input.y]],
1143 [[%%
1144 start: a | 'a' a 'a' ;
1145 a: 'a' ;
1146 ]])
1147
1148 AT_BISON_CHECK([[--report=all input.y]])
1149 AT_CHECK([[sed -n '/^state 1$/,/^state 2$/p' input.output]], [[0]],
1150 [[state 1
1151
1152     2 start: 'a' . a 'a'
1153     3 a: . 'a'
1154     3  | 'a' .  [$end]
1155
1156     'a'  shift, and go to state 4
1157
1158     $default  reduce using rule 3 (a)
1159
1160     a  go to state 5
1161
1162
1163 state 2
1164 ]])
1165
1166 AT_CLEANUP
1167
1168
1169
1170 ## ---------------------------------------- ##
1171 ## Token number in precedence declaration.  ##
1172 ## ---------------------------------------- ##
1173
1174 AT_SETUP([[Token number in precedence declaration]])
1175
1176 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1177 # we lost this in Bison 1.50.
1178 AT_BISON_OPTION_PUSHDEFS
1179 AT_DATA_GRAMMAR([input.y],
1180 [[%{
1181   #include <stdio.h>
1182   ]AT_YYERROR_DECLARE[
1183   ]AT_YYLEX_DECLARE[
1184 %}
1185
1186 %error-verbose
1187 %right END 0
1188 %left TK1 1 TK2 2 "tok alias" 3
1189
1190 %%
1191
1192 start:
1193     TK1 sr_conflict "tok alias"
1194   | start %prec END
1195   ;
1196 sr_conflict:
1197   TK2
1198   | TK2 "tok alias"
1199   ;
1200
1201 %%
1202
1203 ]AT_YYERROR_DEFINE[
1204 int
1205 yylex (void)
1206 {
1207   static int const input[] = { 1, 2, 3, 0 };
1208   static int const *inputp = input;
1209   return *inputp++;
1210 }
1211
1212 int
1213 main (void)
1214 {
1215   return yyparse ();
1216 }
1217 ]])
1218 AT_BISON_OPTION_POPDEFS
1219
1220 AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1221 [[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start
1222 input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias"
1223 ]])
1224 AT_COMPILE([[input]])
1225 AT_PARSER_CHECK([[./input]])
1226
1227 AT_CLEANUP
1228
1229
1230
1231 ## --------------------------- ##
1232 ## parse-gram.y: LALR = IELR.  ##
1233 ## --------------------------- ##
1234
1235 # If parse-gram.y's LALR and IELR parser tables ever begin to differ, we
1236 # need to fix parse-gram.y or start using IELR.
1237
1238 AT_SETUP([[parse-gram.y: LALR = IELR]])
1239
1240 # Avoid tests/bison's dark magic by processing a local copy of the
1241 # grammar.  Avoid differences in synclines by telling bison that the
1242 # output files have the same name.
1243 [cp $abs_top_srcdir/src/parse-gram.y input.y]
1244 AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
1245 [mv input.c lalr.c]
1246 AT_CAPTURE_FILE([lalr.c])
1247 AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1248 [mv input.c ielr.c]
1249 AT_CAPTURE_FILE([ielr.c])
1250 AT_CHECK([[diff lalr.c ielr.c]], [[0]])
1251
1252 AT_CLEANUP
1253
1254
1255
1256 ## -------------------------------------------- ##
1257 ## parse.error=verbose and YYSTACK_USE_ALLOCA.  ##
1258 ## -------------------------------------------- ##
1259
1260 AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]])
1261
1262 AT_BISON_OPTION_PUSHDEFS
1263 AT_DATA_GRAMMAR([input.y],
1264 [[%code {
1265   #include <stdio.h>
1266   ]AT_YYERROR_DECLARE[
1267   ]AT_YYLEX_DECLARE[
1268   #define YYSTACK_USE_ALLOCA 1
1269 }
1270
1271 %define parse.error verbose
1272
1273 %%
1274
1275 start: check syntax_error syntax_error ;
1276
1277 check:
1278 {
1279   if (128 < sizeof yymsgbuf)
1280     {
1281       fprintf (stderr,
1282                "The initial size of yymsgbuf in yyparse has increased\n"
1283                "since this test group was last updated.  As a result,\n"
1284                "this test group may no longer manage to induce a\n"
1285                "reallocation of the syntax error message buffer.\n"
1286                "This test group must be adjusted to produce a longer\n"
1287                "error message.\n");
1288       YYABORT;
1289     }
1290 }
1291 ;
1292
1293 // Induce a syntax error message whose total length is more than
1294 // sizeof yymsgbuf in yyparse.  Each token here is 64 bytes.
1295 syntax_error:
1296   "123456789112345678921234567893123456789412345678951234567896123A"
1297 | "123456789112345678921234567893123456789412345678951234567896123B"
1298 | error 'a' 'b' 'c'
1299 ;
1300
1301 %%
1302
1303 ]AT_YYERROR_DEFINE[
1304   /* Induce two syntax error messages (which requires full error
1305      recovery by shifting 3 tokens) in order to detect any loss of the
1306      reallocated buffer.  */
1307 ]AT_YYLEX_DEFINE([abc])[
1308 int
1309 main (void)
1310 {
1311   return yyparse ();
1312 }
1313 ]])
1314 AT_BISON_OPTION_POPDEFS
1315
1316 AT_BISON_CHECK([[-o input.c input.y]])
1317 AT_COMPILE([[input]])
1318 AT_PARSER_CHECK([[./input]], [[1]], [],
1319 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1320 syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1321 ]])
1322
1323 AT_CLEANUP
1324
1325
1326
1327 ## ------------------------------ ##
1328 ## parse.error=verbose overflow.  ##
1329 ## ------------------------------ ##
1330
1331 # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an
1332 # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly
1333 # YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had
1334 # to be clipped to YYSTACK_ALLOC_MAXIMUM).  In an old version of yacc.c,
1335 # a subsequent invocation of yysyntax_error that overflows during its
1336 # size calculation would return YYSIZE_MAXIMUM to yyparse.  Then,
1337 # yyparse would invoke yyerror using the old contents of yymsg.
1338
1339 AT_SETUP([[parse.error=verbose overflow]])
1340
1341 AT_BISON_OPTION_PUSHDEFS
1342 AT_DATA_GRAMMAR([input.y],
1343 [[%code {
1344   #include <stdio.h>
1345   ]AT_YYERROR_DECLARE[
1346   ]AT_YYLEX_DECLARE[
1347
1348   /* This prevents this test case from having to induce error messages
1349      large enough to overflow size_t.  */
1350   #define YYSIZE_T unsigned char
1351
1352   /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1353      provide a malloc prototype using our YYSIZE_T.  */
1354   #include <stdlib.h>
1355   #ifndef EXIT_SUCCESS
1356   # define EXIT_SUCCESS 0
1357   #endif
1358
1359   /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and
1360      we don't want gcc to warn everywhere this constant would be too big
1361      to make sense for our YYSIZE_T.  */
1362   #define YYMAXDEPTH 100
1363 }
1364
1365 %define parse.error verbose
1366
1367 %%
1368
1369 start: syntax_error1 check syntax_error2 ;
1370
1371 // Induce a syntax error message whose total length causes yymsg in
1372 // yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which
1373 // should be 255.  Each token here is 64 bytes.
1374 syntax_error1:
1375   "123456789112345678921234567893123456789412345678951234567896123A"
1376 | "123456789112345678921234567893123456789412345678951234567896123B"
1377 | "123456789112345678921234567893123456789412345678951234567896123C"
1378 | error 'a' 'b' 'c'
1379 ;
1380
1381 check:
1382 {
1383   if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM
1384       || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM
1385       || YYSIZE_MAXIMUM != 255)
1386     {
1387       fprintf (stderr,
1388                "The assumptions of this test group are no longer\n"
1389                "valid, so it may no longer catch the error it was\n"
1390                "designed to catch.  Specifically, the following\n"
1391                "values should all be 255:\n\n");
1392       fprintf (stderr, "  yymsg_alloc = %d\n", yymsg_alloc);
1393       fprintf (stderr, "  YYSTACK_ALLOC_MAXIMUM = %d\n",
1394                YYSTACK_ALLOC_MAXIMUM);
1395       fprintf (stderr, "  YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM);
1396       YYABORT;
1397     }
1398 }
1399 ;
1400
1401 // Now overflow.
1402 syntax_error2:
1403   "123456789112345678921234567893123456789412345678951234567896123A"
1404 | "123456789112345678921234567893123456789412345678951234567896123B"
1405 | "123456789112345678921234567893123456789412345678951234567896123C"
1406 | "123456789112345678921234567893123456789412345678951234567896123D"
1407 | "123456789112345678921234567893123456789412345678951234567896123E"
1408 ;
1409
1410 %%
1411
1412 ]AT_YYERROR_DEFINE[
1413   /* Induce two syntax error messages (which requires full error
1414      recovery by shifting 3 tokens).  */
1415 ]AT_YYLEX_DEFINE([abc])[
1416 int
1417 main (void)
1418 {
1419   /* Push parsers throw away the message buffer between tokens, so skip
1420      this test under maintainer-push-check.  */
1421   if (YYPUSH)
1422     return 77;
1423   return yyparse ();
1424 }
1425 ]])
1426
1427 AT_BISON_CHECK([[-o input.c input.y]])
1428
1429 # gcc warns about tautologies and fallacies involving comparisons for
1430 # unsigned char.  However, it doesn't produce these same warnings for
1431 # size_t and many other types when the warnings would seem to make just
1432 # as much sense.  We ignore the warnings.
1433 [CFLAGS="$NO_WERROR_CFLAGS"]
1434 AT_COMPILE([[input]])
1435
1436 AT_PARSER_CHECK([[./input]], [[2]], [],
1437 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1438 syntax error
1439 memory exhausted
1440 ]])
1441 AT_BISON_OPTION_POPDEFS
1442 AT_CLEANUP
1443
1444
1445
1446 ## ------------------------ ##
1447 ## LAC: Exploratory stack.  ##
1448 ## ------------------------ ##
1449
1450 AT_SETUP([[LAC: Exploratory stack]])
1451
1452 m4_pushdef([AT_LAC_CHECK], [
1453
1454 AT_BISON_OPTION_PUSHDEFS([$1])
1455
1456 AT_DATA_GRAMMAR([input.y],
1457 [[%code {
1458   #include <stdio.h>
1459   ]AT_YYERROR_DECLARE[
1460   int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[);
1461 }
1462
1463 ]$1[
1464 %define parse.error verbose
1465 %token 'c'
1466
1467 %%
1468
1469 // default reductions in inconsistent states
1470 // v   v v   v v v v   v v v v v v v
1471 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 ;
1472 //       ^                     ^                               ^
1473 // LAC reallocs
1474
1475 A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1476 B: 'b' ;
1477 C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1478
1479 %%
1480 ]AT_YYERROR_DEFINE[
1481 int
1482 yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1483 {
1484   static char const *input = "bbbbc";]AT_PURE_IF([[
1485   *v = 0;]])[
1486   return *input++;
1487 }
1488
1489 int
1490 main (void)
1491 {
1492   yydebug = 1;
1493   return yyparse ();
1494 }
1495 ]])
1496
1497 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1498                  -Dparse.lac.memory-trace=full \
1499                  -t -o input.c input.y]], [[0]], [],
1500 [[input.y: conflicts: 21 shift/reduce
1501 ]])
1502 AT_COMPILE([[input]])
1503 AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]])
1504
1505 # Make sure syntax error doesn't forget that 'a' is expected.  It would
1506 # be forgotten without lookahead correction.
1507 AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]],
1508 [[syntax error, unexpected 'c', expecting 'a' or 'b'
1509 ]])
1510
1511 # Check number of default reductions in inconsistent states to be sure
1512 # syntax error is detected before unnecessary reductions are performed.
1513 AT_CHECK([[perl -0777 -ne 'print s/inconsistent default reduction//g;' \
1514            < stdout.txt || exit 77]], [[0]], [[14]])
1515
1516 # Check number of default reductions in consistent states to be sure
1517 # it is performed before the syntax error is detected.
1518 AT_CHECK([[perl -0777 -ne 'print s/\bconsistent default reduction//g;' \
1519            < stdout.txt || exit 77]], [[0]], [[2]])
1520
1521 # Check number of reallocs to be sure reallocated memory isn't somehow
1522 # lost between LAC invocations.
1523 AT_CHECK([[perl -0777 -ne 'print s/\(realloc//g;' < stderr.txt \
1524            || exit 77]], [[0]], [[3]])
1525
1526 AT_BISON_OPTION_POPDEFS
1527 ])
1528
1529 AT_LAC_CHECK([[%define api.push-pull pull]])
1530 AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]])
1531 AT_LAC_CHECK([[%define api.push-pull both]])
1532 AT_LAC_CHECK([[%define api.push-pull both %define api.pure]])
1533
1534 m4_popdef([AT_LAC_CHECK])
1535
1536 AT_CLEANUP
1537
1538
1539
1540 ## ------------------------ ##
1541 ## LAC: Memory exhaustion.  ##
1542 ## ------------------------ ##
1543
1544 AT_SETUP([[LAC: Memory exhaustion]])
1545
1546 m4_pushdef([AT_LAC_CHECK],
1547 [AT_BISON_OPTION_PUSHDEFS
1548 AT_DATA_GRAMMAR([input.y],
1549 [[%code {
1550   #include <stdio.h>
1551   ]AT_YYERROR_DECLARE[
1552   ]AT_YYLEX_DECLARE[
1553   #define YYMAXDEPTH 8
1554 }
1555
1556 %error-verbose
1557
1558 %%
1559
1560 S: A A A A A A A A A ;
1561 A: /*empty*/ | 'a' ;
1562
1563 %%
1564 ]AT_YYERROR_DEFINE[
1565 ]AT_YYLEX_DEFINE([$1])[
1566 int
1567 main (void)
1568 {
1569   yydebug = 1;
1570   return yyparse ();
1571 }
1572 ]])
1573
1574 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1575                  -t -o input.c input.y]], [[0]], [],
1576 [[input.y: conflicts: 8 shift/reduce
1577 ]])
1578 AT_COMPILE([[input]])
1579 AT_BISON_OPTION_POPDEFS
1580 ])
1581
1582 # Check for memory exhaustion during parsing.
1583 AT_LAC_CHECK([])
1584 AT_PARSER_CHECK([[./input]], [[2]], [],
1585 [[Starting parse
1586 Entering state 0
1587 Reading a token: Now at end of input.
1588 LAC: initial context established for $end
1589 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1590 memory exhausted
1591 Cleanup: discarding lookahead token $end ()
1592 Stack now 0
1593 ]])
1594
1595 # Induce an immediate syntax error with an undefined token, and check
1596 # for memory exhaustion while building syntax error message.
1597 AT_LAC_CHECK([z], [[0]])
1598 AT_PARSER_CHECK([[./input]], [[2]], [],
1599 [[Starting parse
1600 Entering state 0
1601 Reading a token: Next token is token $undefined ()
1602 LAC: initial context established for $undefined
1603 LAC: checking lookahead $undefined: Always Err
1604 Constructing syntax error message
1605 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1606 syntax error
1607 memory exhausted
1608 Cleanup: discarding lookahead token $undefined ()
1609 Stack now 0
1610 ]])
1611
1612 m4_popdef([AT_LAC_CHECK])
1613
1614 AT_CLEANUP