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 18AT_BANNER([[Regression tests.]]) 19 20 21## ------------------ ## 22## Trivial grammars. ## 23## ------------------ ## 24 25AT_SETUP([Trivial grammars]) 26 27AT_BISON_OPTION_PUSHDEFS 28AT_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 39program: 'x'; 40]]) 41AT_BISON_OPTION_POPDEFS 42 43AT_BISON_CHECK([-o input.c input.y]) 44AT_COMPILE([input.o]) 45AT_COMPILE([input.o], [-DYYDEBUG -c input.c]) 46 47AT_CLEANUP 48 49 50 51## ----------------- ## 52## YYSTYPE typedef. ## 53## ----------------- ## 54 55AT_SETUP([YYSTYPE typedef]) 56 57AT_BISON_OPTION_PUSHDEFS 58AT_DATA_GRAMMAR([input.y], 59[[%{ 60]AT_YYERROR_DECLARE_EXTERN[ 61]AT_YYLEX_DECLARE_EXTERN[ 62typedef union { char const *val; } YYSTYPE; 63%} 64 65%type <val> program 66 67%% 68 69program: { $$ = ""; }; 70]]) 71AT_BISON_OPTION_POPDEFS 72 73AT_BISON_CHECK([-o input.c input.y]) 74AT_COMPILE([input.o]) 75 76AT_CLEANUP 77 78 79 80## ------------------------------------- ## 81## Early token definitions with --yacc. ## 82## ------------------------------------- ## 83 84 85AT_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 90AT_BISON_OPTION_PUSHDEFS 91AT_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%% 108exp: MY_TOKEN; 109%% 110]]) 111AT_BISON_OPTION_POPDEFS 112 113AT_BISON_CHECK([-y -o input.c input.y]) 114AT_COMPILE([input.o]) 115 116AT_CLEANUP 117 118 119 120## ---------------------------------------- ## 121## Early token definitions without --yacc. ## 122## ---------------------------------------- ## 123 124 125AT_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 130AT_BISON_OPTION_PUSHDEFS 131AT_DATA_GRAMMAR([input.y], 132[[%{ 133#include <stdio.h> 134]AT_YYERROR_DECLARE_EXTERN[ 135]AT_YYLEX_DECLARE_EXTERN[ 136void print_my_token (void); 137%} 138 139%union 140{ 141 int val; 142}; 143%{ 144void 145print_my_token (void) 146{ 147 enum yytokentype my_token = MY_TOKEN; 148 printf ("%d\n", my_token); 149} 150%} 151%token MY_TOKEN 152%% 153exp: MY_TOKEN; 154%% 155]]) 156AT_BISON_OPTION_POPDEFS 157 158AT_BISON_CHECK([-o input.c input.y]) 159AT_COMPILE([input.o]) 160 161AT_CLEANUP 162 163 164 165## ---------------- ## 166## Braces parsing. ## 167## ---------------- ## 168 169 170AT_SETUP([Braces parsing]) 171 172AT_BISON_OPTION_PUSHDEFS 173AT_DATA([input.y], 174[[/* Bison used to swallow the character after '}'. */ 175 176%% 177exp: { tests = {{{{{{{{{{}}}}}}}}}}; }; 178%% 179]]) 180AT_BISON_OPTION_POPDEFS 181 182AT_BISON_CHECK([-v -o input.c input.y]) 183 184AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore]) 185 186AT_CLEANUP 187 188 189## ------------------ ## 190## Duplicate string. ## 191## ------------------ ## 192 193 194AT_SETUP([Duplicate string]) 195 196AT_BISON_OPTION_PUSHDEFS 197AT_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%% 206exp: '(' exp ')' | NUM ; 207%% 208]]) 209AT_BISON_OPTION_POPDEFS 210 211AT_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 215AT_CLEANUP 216 217 218## ------------------- ## 219## Rule Line Numbers. ## 220## ------------------- ## 221 222AT_SETUP([Rule Line Numbers]) 223 224AT_KEYWORDS([report]) 225 226AT_BISON_OPTION_PUSHDEFS 227AT_DATA([input.y], 228[[%% 229expr: 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]]) 256AT_BISON_OPTION_POPDEFS 257 258AT_BISON_CHECK([-o input.c -v input.y]) 259 260# Check the contents of the report. 261AT_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 275Terminals, with rules where they appear 276 277$end (0) 0 278'a' (97) 2 279'b' (98) 2 280'c' (99) 4 281error (256) 282 283 284Nonterminals, with rules where they appear 285 286$accept (6) 287 on left: 0 288expr (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 296State 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 308State 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 317State 2 318 319 0 $accept: expr . $end 320 321 $end shift, and go to state 5 322 323 324State 3 325 326 4 expr: $@2 . 'c' 327 328 'c' shift, and go to state 6 329 330 331State 4 332 333 2 expr: 'a' $@1 . 'b' 334 335 'b' shift, and go to state 7 336 337 338State 5 339 340 0 $accept: expr $end . 341 342 $default accept 343 344 345State 6 346 347 4 expr: $@2 'c' . 348 349 $default reduce using rule 4 (expr) 350 351 352State 7 353 354 2 expr: 'a' $@1 'b' . 355 356 $default reduce using rule 2 (expr) 357]]) 358 359AT_CLEANUP 360 361 362 363## ---------------------- ## 364## Mixing %token styles. ## 365## ---------------------- ## 366 367 368AT_SETUP([Mixing %token styles]) 369 370# Taken from the documentation. 371AT_DATA([input.y], 372[[%token <operator> OR "||" 373%token <operator> LE 134 "<=" 374%left OR "<=" 375%% 376exp: ; 377%% 378]]) 379 380AT_BISON_CHECK([-v -o input.c input.y]) 381 382AT_CLEANUP 383 384 385 386## ---------------- ## 387## Invalid inputs. ## 388## ---------------- ## 389 390 391AT_SETUP([Invalid inputs]) 392 393AT_DATA([input.y], 394[[%% 395? 396default: 'a' } 397%& 398%a-does-not-exist 399%- 400%{ 401]]) 402 403AT_BISON_CHECK([input.y], [1], [], 404[[input.y:2.1: error: invalid character: '?' 405input.y:3.14: error: invalid character: '}' 406input.y:4.1: error: invalid character: '%' 407input.y:4.2: error: invalid character: '&' 408input.y:5.1-17: error: invalid directive: '%a-does-not-exist' 409input.y:6.1: error: invalid character: '%' 410input.y:6.2: error: invalid character: '-' 411input.y:7.1-8.0: error: missing '%}' at end of file 412input.y:7.1-8.0: error: syntax error, unexpected %{...%} 413]]) 414 415AT_CLEANUP 416 417 418AT_SETUP([Invalid inputs with {}]) 419 420AT_DATA([input.y], 421[[ 422%destructor 423%initial-action 424%lex-param 425%parse-param 426%printer 427%union 428]]) 429 430AT_BISON_CHECK([input.y], [1], [], 431[[input.y:3.1-15: error: syntax error, unexpected %initial-action, expecting {...} 432]]) 433 434AT_CLEANUP 435 436 437 438## ------------------- ## 439## Token definitions. ## 440## ------------------- ## 441 442 443AT_SETUP([Token definitions]) 444 445AT_BISON_OPTION_PUSHDEFS 446# Bison managed, when fed with '%token 'f' "f"' to #define 'f'! 447AT_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%% 463exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"; 464%% 465]AT_YYERROR_DEFINE[ 466]AT_YYLEX_DEFINE([{ SPECIAL }])[ 467 468int 469main (void) 470{ 471 return yyparse (); 472} 473]]) 474AT_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. 480AT_BISON_CHECK([-o input.c input.y], [[0]], [[]], 481[[input.y:22.8-14: warning: symbol SPECIAL redeclared 482input.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]]) 484AT_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 ^^^^^^^ 488input.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]]) 492AT_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. 498AT_DATA([experr], 499[[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a 500]]) 501AT_PARSER_CHECK([./input], 1, [], [experr]) 502AT_CLEANUP 503 504 505 506## -------------------- ## 507## Characters Escapes. ## 508## -------------------- ## 509 510 511AT_SETUP([Characters Escapes]) 512 513AT_BISON_OPTION_PUSHDEFS 514AT_DATA_GRAMMAR([input.y], 515[%{ 516]AT_YYERROR_DECLARE_EXTERN[ 517]AT_YYLEX_DECLARE_EXTERN[ 518%} 519[%% 520exp: 521 '\'' "\'" 522| '\"' "\"" 523| '"' "'" /* Pacify font-lock-mode: ". */ 524; 525]]) 526 527AT_BISON_OPTION_POPDEFS 528 529AT_BISON_CHECK([-o input.c input.y]) 530AT_COMPILE([input.o]) 531AT_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 544AT_SETUP([Web2c Report]) 545 546AT_KEYWORDS([report]) 547 548AT_DATA([input.y], 549[[%token undef_id_tok const_id_tok 550 551%start CONST_DEC_PART 552 553%% 554CONST_DEC_PART: 555 CONST_DEC_LIST 556 ; 557 558CONST_DEC_LIST: 559 CONST_DEC 560 | CONST_DEC_LIST CONST_DEC 561 ; 562 563CONST_DEC: 564 { } undef_id_tok '=' const_id_tok ';' 565 ; 566%% 567]]) 568 569AT_BISON_CHECK([-v input.y]) 570AT_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 585Terminals, with rules where they appear 586 587$end (0) 0 588';' (59) 5 589'=' (61) 5 590error (256) 591undef_id_tok (258) 5 592const_id_tok (259) 5 593 594 595Nonterminals, with rules where they appear 596 597$accept (7) 598 on left: 0 599CONST_DEC_PART (8) 600 on left: 1, on right: 0 601CONST_DEC_LIST (9) 602 on left: 2 3, on right: 1 3 603CONST_DEC (10) 604 on left: 5, on right: 2 3 605$@1 (11) 606 on left: 4, on right: 5 607 608 609State 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 621State 1 622 623 0 $accept: CONST_DEC_PART . $end 624 625 $end shift, and go to state 5 626 627 628State 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 640State 3 641 642 2 CONST_DEC_LIST: CONST_DEC . 643 644 $default reduce using rule 2 (CONST_DEC_LIST) 645 646 647State 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 654State 5 655 656 0 $accept: CONST_DEC_PART $end . 657 658 $default accept 659 660 661State 6 662 663 3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC . 664 665 $default reduce using rule 3 (CONST_DEC_LIST) 666 667 668State 7 669 670 5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';' 671 672 '=' shift, and go to state 8 673 674 675State 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 682State 9 683 684 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';' 685 686 ';' shift, and go to state 10 687 688 689State 10 690 691 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' . 692 693 $default reduce using rule 5 (CONST_DEC) 694]]) 695 696AT_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 721AT_SETUP([Web2c Actions]) 722 723AT_KEYWORDS([report]) 724 725AT_DATA([input.y], 726[[%% 727statement: struct_stat; 728struct_stat: /* empty. */ | if else; 729if: "if" "const" "then" statement; 730else: "else" statement; 731%% 732]]) 733 734AT_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 739AT_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}; 770static const yytype_uint8 yyprhs[] = 771{ 772 0, 0, 3, 5, 6, 9, 14 773}; 774static const yytype_int8 yyrhs[] = 775{ 776 8, 0, -1, 9, -1, -1, 10, 11, -1, 3, 777 4, 5, 8, -1, 6, 8, -1 778}; 779static const yytype_uint8 yyrline[] = 780{ 781 0, 2, 2, 3, 3, 4, 5 782}; 783static const char *const yytname[] = 784{ 785 "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"", 786 "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL 787}; 788static const yytype_uint16 yytoknum[] = 789{ 790 0, 256, 257, 258, 259, 260, 261 791}; 792static const yytype_uint8 yyr1[] = 793{ 794 0, 7, 8, 9, 9, 10, 11 795}; 796static const yytype_uint8 yyr2[] = 797{ 798 0, 2, 1, 0, 2, 4, 2 799}; 800static const yytype_uint8 yydefact[] = 801{ 802 3, 0, 0, 2, 0, 0, 1, 3, 4, 3, 803 6, 5 804}; 805static const yytype_int8 yydefgoto[] = 806{ 807 -1, 2, 3, 4, 8 808}; 809static const yytype_int8 yypact[] = 810{ 811 -2, -1, 4, -8, 0, 2, -8, -2, -8, -2, 812 -8, -8 813}; 814static const yytype_int8 yypgoto[] = 815{ 816 -8, -7, -8, -8, -8 817}; 818static const yytype_uint8 yytable[] = 819{ 820 10, 1, 11, 5, 6, 0, 7, 9 821}; 822static const yytype_int8 yycheck[] = 823{ 824 7, 3, 9, 4, 0, -1, 6, 5 825}; 826static const yytype_uint8 yystos[] = 827{ 828 0, 3, 8, 9, 10, 4, 0, 6, 11, 5, 829 8, 8 830}; 831]]) 832 833AT_CLEANUP 834 835 836## ------------------------- ## 837## yycheck Bound Violation. ## 838## ------------------------- ## 839 840 841# _AT_DATA_DANCER_Y(BISON-OPTIONS) 842# -------------------------------- 843# The following grammar, taken from Andrew Suffield's GPL'd implementation 844# of DGMTP, the Dancer Generic Message Transport Protocol, used to violate 845# yycheck's bounds where issuing a verbose error message. Keep this test 846# so that possible bound checking compilers could check all the skeletons. 847m4_define([_AT_DATA_DANCER_Y], 848[AT_DATA_GRAMMAR([dancer.y], 849[[%code provides 850{ 851 ]AT_YYERROR_DECLARE[ 852 ]AT_YYLEX_DECLARE[ 853} 854$1 855%token ARROW INVALID NUMBER STRING DATA 856%defines 857%verbose 858%error-verbose 859/* Grammar follows */ 860%% 861line: header body 862 ; 863 864header: '<' from ARROW to '>' type ':' 865 | '<' ARROW to '>' type ':' 866 | ARROW to type ':' 867 | type ':' 868 | '<' '>' 869 ; 870 871from: DATA 872 | STRING 873 | INVALID 874 ; 875 876to: DATA 877 | STRING 878 | INVALID 879 ; 880 881type: DATA 882 | STRING 883 | INVALID 884 ; 885 886body: /* empty */ 887 | body member 888 ; 889 890member: STRING 891 | DATA 892 | '+' NUMBER 893 | '-' NUMBER 894 | NUMBER 895 | INVALID 896 ; 897%% 898]AT_YYERROR_DEFINE[ 899]AT_YYLEX_DEFINE([":"])[ 900]AT_LALR1_CC_IF( 901[int 902yyparse () 903{ 904 yy::parser parser; 905#if YYDEBUG 906 parser.set_debug_level (YYDEBUG); 907#endif 908 return parser.parse (); 909} 910])[ 911 912int 913main (void) 914{ 915 return yyparse (); 916} 917]]) 918])# _AT_DATA_DANCER_Y 919 920 921# AT_CHECK_DANCER(BISON-OPTIONS) 922# ------------------------------ 923# Generate the grammar, compile it, run it. 924m4_define([AT_CHECK_DANCER], 925[AT_SETUP([Dancer $1]) 926AT_BISON_OPTION_PUSHDEFS([$1]) 927_AT_DATA_DANCER_Y([$1]) 928AT_FULL_COMPILE([dancer]) 929AT_PARSER_CHECK([./dancer], 1, [], 930[syntax error, unexpected ':' 931]) 932AT_BISON_OPTION_POPDEFS 933AT_CLEANUP 934]) 935 936AT_CHECK_DANCER() 937AT_CHECK_DANCER([%glr-parser]) 938AT_CHECK_DANCER([%skeleton "lalr1.cc"]) 939 940 941## ------------------------------------------ ## 942## Diagnostic that expects two alternatives. ## 943## ------------------------------------------ ## 944 945 946# _AT_DATA_EXPECT2_Y(BISON-OPTIONS) 947# -------------------------------- 948m4_define([_AT_DATA_EXPECT2_Y], 949[AT_DATA_GRAMMAR([expect2.y], 950[[%{ 951static int yylex (]AT_LALR1_CC_IF([int *], [void])); 952AT_LALR1_CC_IF([], 953[[#include <stdio.h> 954#include <stdlib.h> 955]AT_YYERROR_DECLARE])[ 956%} 957$1 958%defines 959%error-verbose 960%token A 1000 961%token B 962 963%% 964program: /* empty */ 965 | program e ';' 966 | program error ';'; 967 968e: e '+' t | t; 969t: A | B; 970 971%% 972]AT_YYERROR_DEFINE[ 973]AT_LALR1_CC_IF( 974[int 975yyparse () 976{ 977 yy::parser parser; 978 return parser.parse (); 979} 980])[ 981 982#include <assert.h> 983static int 984yylex (]AT_LALR1_CC_IF([int *lval], [void])[) 985{ 986 static int const tokens[] = 987 { 988 1000, '+', '+', -1 989 }; 990 static size_t toknum; 991 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[ 992 assert (toknum < sizeof tokens / sizeof *tokens); 993 return tokens[toknum++]; 994} 995 996int 997main (void) 998{ 999 return yyparse (); 1000} 1001]]) 1002])# _AT_DATA_EXPECT2_Y 1003 1004 1005# AT_CHECK_EXPECT2(BISON-OPTIONS) 1006# ------------------------------- 1007# Generate the grammar, compile it, run it. 1008m4_define([AT_CHECK_EXPECT2], 1009[AT_SETUP([Expecting two tokens $1]) 1010AT_BISON_OPTION_PUSHDEFS([$1]) 1011_AT_DATA_EXPECT2_Y([$1]) 1012AT_FULL_COMPILE([expect2]) 1013AT_PARSER_CHECK([./expect2], 1, [], 1014[syntax error, unexpected '+', expecting A or B 1015]) 1016AT_BISON_OPTION_POPDEFS 1017AT_CLEANUP 1018]) 1019 1020AT_CHECK_EXPECT2() 1021AT_CHECK_EXPECT2([%glr-parser]) 1022AT_CHECK_EXPECT2([%skeleton "lalr1.cc"]) 1023 1024 1025 1026## --------------------------------------------- ## 1027## Braced code in declaration in rules section. ## 1028## --------------------------------------------- ## 1029 1030AT_SETUP([Braced code in declaration in rules section]) 1031 1032# Bison once mistook braced code in a declaration in the rules section to be a 1033# rule action. 1034AT_BISON_OPTION_PUSHDEFS 1035AT_DATA_GRAMMAR([input.y], 1036[[%{ 1037#include <stdio.h> 1038]AT_YYERROR_DECLARE[ 1039]AT_YYLEX_DECLARE[ 1040%} 1041 1042%error-verbose 1043 1044%% 1045 1046start: 1047 { 1048 printf ("Bison would once convert this action to a midrule because of the" 1049 " subsequent braced code.\n"); 1050 } 1051 ; 1052 1053%destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a'; 1054%printer { fprintf (yyoutput, "PRINTER"); } 'a'; 1055 1056%% 1057]AT_YYERROR_DEFINE[ 1058]AT_YYLEX_DEFINE(["a"])[ 1059 1060int 1061main (void) 1062{ 1063 yydebug = 1; 1064 return !yyparse (); 1065} 1066]]) 1067AT_BISON_OPTION_POPDEFS 1068 1069AT_BISON_CHECK([-t -o input.c input.y]) 1070AT_COMPILE([input]) 1071AT_PARSER_CHECK([./input], 0, 1072[[Bison would once convert this action to a midrule because of the subsequent braced code. 1073]], 1074[[Starting parse 1075Entering state 0 1076Reducing stack by rule 1 (line 20): 1077-> $$ = nterm start () 1078Stack now 0 1079Entering state 1 1080Reading a token: Next token is token 'a' (PRINTER) 1081syntax error, unexpected 'a', expecting $end 1082Error: popping nterm start () 1083Stack now 0 1084Cleanup: discarding lookahead token 'a' (PRINTER) 1085DESTRUCTOR 1086Stack now 0 1087]]) 1088 1089AT_CLEANUP 1090 1091 1092 1093## --------------------------------- ## 1094## String alias declared after use. ## 1095## --------------------------------- ## 1096 1097AT_SETUP([String alias declared after use]) 1098 1099# Bison once incorrectly asserted that the symbol number for either a token or 1100# its alias was the highest symbol number so far at the point of the alias 1101# declaration. That was true unless the declaration appeared after their first 1102# uses and other tokens appeared in between. 1103 1104AT_DATA([input.y], 1105[[%% 1106start: 'a' "A" 'b'; 1107%token 'a' "A"; 1108]]) 1109 1110AT_BISON_CHECK([-t -o input.c input.y]) 1111 1112AT_CLEANUP 1113 1114 1115 1116## -------------------------------- ## 1117## Extra lookahead sets in report. ## 1118## -------------------------------- ## 1119 1120AT_SETUP([[Extra lookahead sets in report]]) 1121 1122# Bison prints each reduction's lookahead set only next to the associated 1123# state's one item that (1) is associated with the same rule as the reduction 1124# and (2) has its dot at the end of its RHS. Previously, Bison also 1125# erroneously printed the lookahead set next to all of the state's other items 1126# associated with the same rule. This bug affected only the '.output' file and 1127# not the generated parser source code. 1128 1129AT_DATA([[input.y]], 1130[[%% 1131start: a | 'a' a 'a' ; 1132a: 'a' ; 1133]]) 1134 1135AT_BISON_CHECK([[--report=all input.y]]) 1136AT_CHECK([[sed -n '/^State 1$/,/^State 2$/p' input.output]], [[0]], 1137[[State 1 1138 1139 2 start: 'a' . a 'a' 1140 3 a: . 'a' 1141 3 | 'a' . [$end] 1142 1143 'a' shift, and go to state 4 1144 1145 $default reduce using rule 3 (a) 1146 1147 a go to state 5 1148 1149 1150State 2 1151]]) 1152 1153AT_CLEANUP 1154 1155 1156 1157## ---------------------------------------- ## 1158## Token number in precedence declaration. ## 1159## ---------------------------------------- ## 1160 1161AT_SETUP([[Token number in precedence declaration]]) 1162 1163# POSIX says token numbers can be declared in %left, %right, and %nonassoc, but 1164# we lost this in Bison 1.50. 1165AT_BISON_OPTION_PUSHDEFS 1166AT_DATA_GRAMMAR([input.y], 1167[[%{ 1168 #include <stdio.h> 1169 ]AT_YYERROR_DECLARE[ 1170 ]AT_YYLEX_DECLARE[ 1171%} 1172 1173%error-verbose 1174%right END 0 1175%left TK1 1 TK2 2 "tok alias" 3 1176 1177%% 1178 1179start: 1180 TK1 sr_conflict "tok alias" 1181 | start %prec END 1182 ; 1183sr_conflict: 1184 TK2 1185 | TK2 "tok alias" 1186 ; 1187 1188%% 1189 1190]AT_YYERROR_DEFINE[ 1191]AT_YYLEX_DEFINE([{ 1, 2, 3, 0 }])[ 1192 1193int 1194main (void) 1195{ 1196 return yyparse (); 1197} 1198]]) 1199AT_BISON_OPTION_POPDEFS 1200 1201AT_BISON_CHECK([[-o input.c input.y]], [[0]],, 1202[[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start 1203input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" 1204]]) 1205AT_COMPILE([[input]]) 1206AT_PARSER_CHECK([[./input]]) 1207 1208AT_CLEANUP 1209 1210 1211 1212## --------------------------- ## 1213## parse-gram.y: LALR = IELR. ## 1214## --------------------------- ## 1215 1216# If parse-gram.y's LALR and IELR parser tables ever begin to differ, we 1217# need to fix parse-gram.y or start using IELR. 1218 1219AT_SETUP([[parse-gram.y: LALR = IELR]]) 1220 1221# Avoid differences in synclines by telling bison that the output files 1222# have the same name. 1223[cp $abs_top_srcdir/src/parse-gram.y input.y] 1224AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]]) 1225[mv input.c lalr.c] 1226AT_CAPTURE_FILE([lalr.c]) 1227AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]]) 1228[mv input.c ielr.c] 1229AT_CAPTURE_FILE([ielr.c]) 1230AT_CHECK([[diff lalr.c ielr.c]], [[0]]) 1231 1232AT_CLEANUP 1233 1234 1235 1236## --------------------------------------- ## 1237## %error-verbose and YYSTACK_USE_ALLOCA. ## 1238## --------------------------------------- ## 1239 1240AT_SETUP([[%error-verbose and YYSTACK_USE_ALLOCA]]) 1241 1242AT_BISON_OPTION_PUSHDEFS 1243AT_DATA_GRAMMAR([input.y], 1244[[%code { 1245 #include <stdio.h> 1246 ]AT_YYERROR_DECLARE[ 1247 ]AT_YYLEX_DECLARE[ 1248 #define YYSTACK_USE_ALLOCA 1 1249} 1250 1251%error-verbose 1252 1253%% 1254 1255start: check syntax_error syntax_error ; 1256 1257check: 1258{ 1259 if (128 < sizeof yymsgbuf) 1260 { 1261 fprintf (stderr, 1262 "The initial size of yymsgbuf in yyparse has increased\n" 1263 "since this test group was last updated. As a result,\n" 1264 "this test group may no longer manage to induce a\n" 1265 "reallocation of the syntax error message buffer.\n" 1266 "This test group must be adjusted to produce a longer\n" 1267 "error message.\n"); 1268 YYABORT; 1269 } 1270} 1271; 1272 1273// Induce a syntax error message whose total length is more than 1274// sizeof yymsgbuf in yyparse. Each token here is 64 bytes. 1275syntax_error: 1276 "123456789112345678921234567893123456789412345678951234567896123A" 1277| "123456789112345678921234567893123456789412345678951234567896123B" 1278| error 'a' 'b' 'c' 1279; 1280 1281%% 1282 1283]AT_YYERROR_DEFINE[ 1284/* Induce two syntax error messages (which requires full error 1285 recovery by shifting 3 tokens) in order to detect any loss of the 1286 reallocated buffer. */ 1287]AT_YYLEX_DEFINE(["abc"])[ 1288int 1289main (void) 1290{ 1291 return yyparse (); 1292} 1293]]) 1294AT_BISON_OPTION_POPDEFS 1295 1296AT_BISON_CHECK([[-o input.c input.y]]) 1297AT_COMPILE([[input]]) 1298AT_PARSER_CHECK([[./input]], [[1]], [], 1299[[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B 1300syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B 1301]]) 1302 1303AT_CLEANUP 1304 1305 1306 1307## ------------------------- ## 1308## %error-verbose overflow. ## 1309## ------------------------- ## 1310 1311# Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an 1312# invocation of yysyntax_error has caused yymsg_alloc to grow to exactly 1313# YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had 1314# to be clipped to YYSTACK_ALLOC_MAXIMUM). In an old version of yacc.c, 1315# a subsequent invocation of yysyntax_error that overflows during its 1316# size calculation would return YYSIZE_MAXIMUM to yyparse. Then, 1317# yyparse would invoke yyerror using the old contents of yymsg. 1318 1319AT_SETUP([[%error-verbose overflow]]) 1320AT_BISON_OPTION_PUSHDEFS 1321AT_DATA_GRAMMAR([input.y], 1322[[%code { 1323 #include <stdio.h> 1324 ]AT_YYERROR_DECLARE[ 1325 ]AT_YYLEX_DECLARE[ 1326 1327 /* This prevents this test case from having to induce error messages 1328 large enough to overflow size_t. */ 1329 #define YYSIZE_T unsigned char 1330 1331 /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to 1332 provide a malloc prototype using our YYSIZE_T. */ 1333 #include <stdlib.h> 1334 #ifndef EXIT_SUCCESS 1335 # define EXIT_SUCCESS 0 1336 #endif 1337 1338 /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and 1339 we don't want gcc to warn everywhere this constant would be too big 1340 to make sense for our YYSIZE_T. */ 1341 #define YYMAXDEPTH 100 1342} 1343 1344%error-verbose 1345 1346%% 1347 1348start: syntax_error1 check syntax_error2 ; 1349 1350// Induce a syntax error message whose total length causes yymsg in 1351// yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which 1352// should be 255. Each token here is 64 bytes. 1353syntax_error1: 1354 "123456789112345678921234567893123456789412345678951234567896123A" 1355| "123456789112345678921234567893123456789412345678951234567896123B" 1356| "123456789112345678921234567893123456789412345678951234567896123C" 1357| error 'a' 'b' 'c' 1358; 1359 1360check: 1361{ 1362 if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM 1363 || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM 1364 || YYSIZE_MAXIMUM != 255) 1365 { 1366 fprintf (stderr, 1367 "The assumptions of this test group are no longer\n" 1368 "valid, so it may no longer catch the error it was\n" 1369 "designed to catch. Specifically, the following\n" 1370 "values should all be 255:\n\n"); 1371 fprintf (stderr, " yymsg_alloc = %d\n", yymsg_alloc); 1372 fprintf (stderr, " YYSTACK_ALLOC_MAXIMUM = %d\n", 1373 YYSTACK_ALLOC_MAXIMUM); 1374 fprintf (stderr, " YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM); 1375 YYABORT; 1376 } 1377} 1378; 1379 1380// Now overflow. 1381syntax_error2: 1382 "123456789112345678921234567893123456789412345678951234567896123A" 1383| "123456789112345678921234567893123456789412345678951234567896123B" 1384| "123456789112345678921234567893123456789412345678951234567896123C" 1385| "123456789112345678921234567893123456789412345678951234567896123D" 1386| "123456789112345678921234567893123456789412345678951234567896123E" 1387; 1388 1389%% 1390 1391]AT_YYERROR_DEFINE[ 1392/* Induce two syntax error messages (which requires full error 1393 recovery by shifting 3 tokens). */ 1394]AT_YYLEX_DEFINE(["abc"])[ 1395int 1396main (void) 1397{ 1398 /* Push parsers throw away the message buffer between tokens, so skip 1399 this test under maintainer-push-check. */ 1400 if (YYPUSH) 1401 return 77; 1402 return yyparse (); 1403} 1404]]) 1405 1406AT_BISON_CHECK([[-o input.c input.y]]) 1407 1408# gcc warns about tautologies and fallacies involving comparisons for 1409# unsigned char. However, it doesn't produce these same warnings for 1410# size_t and many other types when the warnings would seem to make just 1411# as much sense. We ignore the warnings. 1412[CFLAGS="$NO_WERROR_CFLAGS"] 1413AT_COMPILE([[input]]) 1414 1415AT_PARSER_CHECK([[./input]], [[2]], [], 1416[[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C 1417syntax error 1418memory exhausted 1419]]) 1420AT_BISON_OPTION_POPDEFS 1421AT_CLEANUP 1422 1423 1424 1425## ------------------------ ## 1426## LAC: Exploratory stack. ## 1427## ------------------------ ## 1428 1429AT_SETUP([[LAC: Exploratory stack]]) 1430 1431m4_pushdef([AT_LAC_CHECK], [ 1432 1433AT_BISON_OPTION_PUSHDEFS([$1]) 1434 1435AT_DATA_GRAMMAR([input.y], 1436[[%code { 1437 #include <stdio.h> 1438 ]AT_YYERROR_DECLARE[ 1439 int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[); 1440} 1441 1442]$1[ 1443%error-verbose 1444%token 'c' 1445 1446%% 1447 1448// default reductions in inconsistent states 1449// v v v v v v v v v v v v v v 1450S: A B A A B A A A A B A A A A A A A B C C A A A A A A A A A A A A B ; 1451// ^ ^ ^ 1452// LAC reallocs 1453 1454A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ; 1455B: 'b' ; 1456C: /*empty*/ { printf ("consistent default reduction\n"); } ; 1457 1458%% 1459]AT_YYERROR_DEFINE[ 1460int 1461yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[) 1462{ 1463 static char const *input = "bbbbc";]AT_PURE_IF([[ 1464 *v = 0;]])[ 1465 return *input++; 1466} 1467 1468int 1469main (void) 1470{ 1471 yydebug = 1; 1472 return yyparse (); 1473} 1474]]) 1475 1476AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \ 1477 -Dparse.lac.memory-trace=full \ 1478 -t -o input.c input.y]], [[0]], [], 1479[[input.y: conflicts: 21 shift/reduce 1480]]) 1481AT_COMPILE([[input]]) 1482AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]]) 1483 1484# Make sure syntax error doesn't forget that 'a' is expected. It would 1485# be forgotten without lookahead correction. 1486AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]], 1487[[syntax error, unexpected 'c', expecting 'a' or 'b' 1488]]) 1489 1490# Check number of default reductions in inconsistent states to be sure 1491# syntax error is detected before unnecessary reductions are performed. 1492AT_CHECK([[$PERL -0777 -ne 'print s/inconsistent default reduction//g;' \ 1493 < stdout.txt || exit 77]], [[0]], [[14]]) 1494 1495# Check number of default reductions in consistent states to be sure 1496# it is performed before the syntax error is detected. 1497AT_CHECK([[$PERL -0777 -ne 'print s/\bconsistent default reduction//g;' \ 1498 < stdout.txt || exit 77]], [[0]], [[2]]) 1499 1500# Check number of reallocs to be sure reallocated memory isn't somehow 1501# lost between LAC invocations. 1502AT_CHECK([[$PERL -0777 -ne 'print s/\(realloc//g;' < stderr.txt \ 1503 || exit 77]], [[0]], [[3]]) 1504 1505AT_BISON_OPTION_POPDEFS 1506]) 1507 1508AT_LAC_CHECK([[%define api.push-pull pull]]) 1509AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]]) 1510AT_LAC_CHECK([[%define api.push-pull both]]) 1511AT_LAC_CHECK([[%define api.push-pull both %define api.pure]]) 1512 1513m4_popdef([AT_LAC_CHECK]) 1514 1515AT_CLEANUP 1516 1517 1518 1519## ------------------------ ## 1520## LAC: Memory exhaustion. ## 1521## ------------------------ ## 1522 1523AT_SETUP([[LAC: Memory exhaustion]]) 1524 1525m4_pushdef([AT_LAC_CHECK], 1526[AT_BISON_OPTION_PUSHDEFS 1527AT_DATA_GRAMMAR([input.y], 1528[[%code { 1529 #include <stdio.h> 1530 ]AT_YYERROR_DECLARE[ 1531 ]AT_YYLEX_DECLARE[ 1532 #define YYMAXDEPTH 8 1533} 1534 1535%error-verbose 1536 1537%% 1538 1539S: A A A A A A A A A ; 1540A: /*empty*/ | 'a' ; 1541 1542%% 1543]AT_YYERROR_DEFINE[ 1544]AT_YYLEX_DEFINE(["$1"])[ 1545int 1546main (void) 1547{ 1548 yydebug = 1; 1549 return yyparse (); 1550} 1551]]) 1552 1553AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \ 1554 -t -o input.c input.y]], [[0]], [], 1555[[input.y: conflicts: 8 shift/reduce 1556]]) 1557AT_COMPILE([[input]]) 1558AT_BISON_OPTION_POPDEFS 1559]) 1560 1561# Check for memory exhaustion during parsing. 1562AT_LAC_CHECK([]) 1563AT_PARSER_CHECK([[./input]], [[2]], [], 1564[[Starting parse 1565Entering state 0 1566Reading a token: Now at end of input. 1567LAC: initial context established for $end 1568LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded) 1569memory exhausted 1570Cleanup: discarding lookahead token $end () 1571Stack now 0 1572]]) 1573 1574# Induce an immediate syntax error with an undefined token, and check 1575# for memory exhaustion while building syntax error message. 1576AT_LAC_CHECK([z], [[0]]) 1577AT_PARSER_CHECK([[./input]], [[2]], [], 1578[[Starting parse 1579Entering state 0 1580Reading a token: Next token is token $undefined () 1581LAC: initial context established for $undefined 1582LAC: checking lookahead $undefined: Always Err 1583Constructing syntax error message 1584LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded) 1585syntax error 1586memory exhausted 1587Cleanup: discarding lookahead token $undefined () 1588Stack now 0 1589]]) 1590 1591m4_popdef([AT_LAC_CHECK]) 1592 1593AT_CLEANUP 1594 1595 1596## ---------------------- ## 1597## Lex and parse params. ## 1598## ---------------------- ## 1599 1600# AT_TEST(SKELETON) 1601# ----------------- 1602# Check that the identifier of the params is properly fetched 1603# even when there are trailing blanks. 1604 1605m4_pushdef([AT_TEST], 1606[AT_SETUP([[Lex and parse params: $1]]) 1607 1608AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" %parse-param { int x } %parse-param { int y }]) 1609 1610## FIXME: Improve parsing of parse-param and use the generated 1611## yyerror. 1612AT_DATA_GRAMMAR([input.y], 1613[[%defines 1614%locations 1615%skeleton "$1" 1616%union { int ival; } 1617%parse-param { int x } 1618// Spaces, tabs, and new lines. 1619%parse-param { @&t@ 1620 int y @&t@ 1621 @&t@ 1622 @&t@ 1623} 1624 1625%{ 1626#include <stdio.h> 1627#include <stdlib.h> 1628 1629 ]AT_YYERROR_DECLARE[ 1630 ]AT_YYLEX_DECLARE[ 1631%} 1632 1633%% 1634exp: 'a' { fprintf (stdout, "x: %d, y: %d\n", x, y); }; 1635%% 1636]AT_YYERROR_DEFINE[ 1637]AT_YYLEX_DEFINE(["a"])[ 1638 1639]AT_SKEL_CC_IF( 1640[int 1641yyparse (int x, int y) 1642{ 1643 yy::parser parser(x, y); 1644 return parser.parse (); 1645} 1646])[ 1647 1648int 1649main (void) 1650{ 1651 return !!yyparse(1, 2); 1652} 1653]]) 1654 1655AT_FULL_COMPILE([input]) 1656AT_PARSER_CHECK([./input], 0, [[x: 1, y: 2 1657]]) 1658AT_BISON_OPTION_POPDEFS 1659 1660AT_CLEANUP 1661]) 1662 1663## FIXME: test Java, and iterate over skeletons. 1664AT_TEST([yacc.c]) 1665AT_TEST([glr.c]) 1666AT_TEST([lalr1.cc]) 1667AT_TEST([glr.cc]) 1668 1669m4_popdef([AT_TEST]) 1670