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