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