1 # Executing Actions. -*- 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([[User Actions.]]) 19 20 ## ------------------ ## 21 ## Mid-rule actions. ## 22 ## ------------------ ## 23 24 AT_SETUP([Mid-rule actions]) 25 26 # Bison once forgot the mid-rule actions. It was because the action 27 # was attached to the host rule (the one with the mid-rule action), 28 # instead of being attached to the empty rule dedicated to this 29 # action. 30 31 AT_BISON_OPTION_PUSHDEFS 32 AT_DATA_GRAMMAR([[input.y]], 33 [[%error-verbose 34 %debug 35 %{ 36 ]AT_YYERROR_DECLARE[ 37 ]AT_YYLEX_DECLARE[ 38 %} 39 %% 40 exp: { putchar ('0'); } 41 '1' { putchar ('1'); } 42 '2' { putchar ('2'); } 43 '3' { putchar ('3'); } 44 '4' { putchar ('4'); } 45 '5' { putchar ('5'); } 46 '6' { putchar ('6'); } 47 '7' { putchar ('7'); } 48 '8' { putchar ('8'); } 49 '9' { putchar ('9'); } 50 { putchar ('\n'); } 51 ; 52 %% 53 ]AT_YYERROR_DEFINE[ 54 ]AT_YYLEX_DEFINE(["123456789"])[ 55 int 56 main (void) 57 { 58 return yyparse (); 59 } 60 ]]) 61 AT_BISON_OPTION_POPDEFS 62 63 AT_BISON_CHECK([-d -v -o input.c input.y]) 64 AT_COMPILE([input]) 65 AT_PARSER_CHECK([./input], 0, 66 [[0123456789 67 ]]) 68 69 AT_CLEANUP 70 71 72 ## ------------------ ## 73 ## Initial location. ## 74 ## ------------------ ## 75 76 # AT_TEST(SKELETON-NAME, DIRECTIVES, [MORE-DIRECTIVES], [LOCATION = 1.1]) 77 # ----------------------------------------------------------------------- 78 # Check that the initial location is correct. 79 m4_pushdef([AT_TEST], 80 [AT_SETUP([Initial location: $1 $2]) 81 82 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" $2]) 83 AT_DATA_GRAMMAR([[input.y]], 84 [[%defines /* FIXME: Required by lalr1.cc in Bison 2.6. */ 85 %locations 86 %debug 87 %skeleton "$1" 88 ]$2[ 89 ]$3[ 90 %code 91 { 92 # include <stdio.h> 93 # include <stdlib.h> /* getenv */ 94 ]AT_YYERROR_DECLARE[ 95 ]AT_YYLEX_DECLARE[ 96 } 97 %% 98 exp: { ]AT_SKEL_CC_IF([[std::cerr << @$ << std::endl]], 99 [[YY_LOCATION_PRINT(stderr, @$); fputc ('\n', stderr)]])[; } 100 %% 101 ]AT_YYERROR_DEFINE[ 102 103 ]AT_YYLEX_PROTOTYPE[ 104 {]AT_PURE_IF([ 105 YYUSE(lvalp); 106 YYUSE(llocp);], [AT_SKEL_CC_IF([ 107 YYUSE(lvalp); 108 YYUSE(llocp);])])[ 109 return 'x'; 110 } 111 112 int 113 main (void) 114 {]AT_SKEL_CC_IF([[ 115 yy::parser p; 116 p.set_debug_level (!!getenv("YYDEBUG")); 117 return p.parse ();]], [[ 118 yydebug = !!getenv("YYDEBUG"); 119 return !!yyparse (]AT_PARAM_IF([0])[);]])[ 120 } 121 ]]) 122 123 AT_FULL_COMPILE([input]) 124 AT_PARSER_CHECK([./input], 1, [], 125 [m4_default([$4], [1.1]) 126 m4_default([$4], [1.1])[: syntax error 127 ]]) 128 AT_BISON_OPTION_POPDEFS 129 AT_CLEANUP 130 ]) 131 132 ## FIXME: test Java, and iterate over skeletons. 133 AT_TEST([yacc.c]) 134 AT_TEST([yacc.c], [%define api.pure full]) 135 AT_TEST([yacc.c], [%define api.pure %parse-param { int x }]) 136 AT_TEST([yacc.c], [%define api.push-pull both]) 137 AT_TEST([yacc.c], [%define api.push-pull both %define api.pure full]) 138 AT_TEST([glr.c]) 139 AT_TEST([glr.c], [%define api.pure]) 140 AT_TEST([lalr1.cc]) 141 AT_TEST([glr.cc]) 142 143 ## A very different test, based on PostgreSQL's implementation of the 144 ## locations. See 145 ## http://lists.gnu.org/archive/html/bug-bison/2012-11/msg00023.html 146 ## 147 ## Weirdly enough, to trigger the warning with GCC 4.7, we must not 148 ## use fprintf, so run the test twice: once to check the warning 149 ## (absence thereof), and another time to check the value. 150 AT_TEST([yacc.c], [%define api.pure full], 151 [[%{ 152 # define YYLTYPE int 153 # define YY_LOCATION_PRINT(Stream, Loc) \ 154 (void) (Loc) 155 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 156 (Current) = ((Rhs)[N ? 1 : 0]) 157 %} 158 ]], 159 [@&t@]) 160 161 AT_TEST([yacc.c], [%define api.pure full], 162 [[%{ 163 # define YYLTYPE int 164 # define YY_LOCATION_PRINT(Stream, Loc) \ 165 fprintf ((Stream), "%d", (Loc)) 166 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 167 (Current) = ((Rhs)[N ? 1 : 0]) 168 %} 169 ]], 170 [0]) 171 172 173 m4_popdef([AT_TEST]) 174 175 176 177 ## ---------------- ## 178 ## Location Print. ## 179 ## ---------------- ## 180 181 # AT_TEST(SKELETON-NAME, DIRECTIVES, [MORE-DIRECTIVES], [LOCATION = 1.1]) 182 # ----------------------------------------------------------------------- 183 # Check that the initial location is correct. 184 m4_pushdef([AT_TEST], 185 [AT_SETUP([Location print: $1 $2]) 186 187 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" $2]) 188 AT_DATA_GRAMMAR([[input.y]], 189 [[%defines /* FIXME: Required by lalr1.cc in Bison 2.6. */ 190 %locations 191 %debug 192 %skeleton "$1" 193 ]$2[ 194 ]$3[ 195 %code 196 { 197 # include <stdio.h> 198 # include <stdlib.h> /* getenv */ 199 ]AT_YYERROR_DECLARE[ 200 ]AT_YYLEX_DECLARE[ 201 } 202 %% 203 exp:; 204 %% 205 ]AT_YYERROR_DEFINE[ 206 ]AT_YYLEX_DEFINE[ 207 208 int 209 main (void) 210 { 211 #define TEST(L1, C1, L2, C2) \ 212 ]AT_LOC_FIRST_LINE[ = L1; \ 213 ]AT_LOC_FIRST_COLUMN[ = C1; \ 214 ]AT_LOC_LAST_LINE[ = L2; \ 215 ]AT_LOC_LAST_COLUMN[ = C2; \ 216 ]YY_LOCATION_PRINT(stdout, AT_LOC)[;\ 217 putchar ('\n'); 218 219 TEST(1, 1, 1, 1); 220 TEST(2, 1, 2, 10); 221 TEST(3, 1, 4, 1); 222 TEST(5, 1, 6, 10); 223 224 TEST(7, 2, 0, 2); 225 TEST(8, 0, 8, 0); 226 return 0; 227 } 228 ]]) 229 230 AT_FULL_COMPILE([input]) 231 AT_PARSER_CHECK([./input], 0, 232 [[1.1 233 2.1-9 234 3.1-4.0 235 5.1-6.9 236 7.2 237 8.0 238 ]]) 239 AT_BISON_OPTION_POPDEFS 240 AT_CLEANUP 241 ]) 242 243 ## FIXME: test Java, and iterate over skeletons. 244 AT_TEST([yacc.c]) 245 AT_TEST([glr.c]) 246 #AT_TEST([lalr1.cc]) 247 #AT_TEST([glr.cc]) 248 249 m4_popdef([AT_TEST]) 250 251 252 253 ## ---------------- ## 254 ## Exotic Dollars. ## 255 ## ---------------- ## 256 257 AT_SETUP([Exotic Dollars]) 258 259 AT_BISON_OPTION_PUSHDEFS 260 AT_DATA_GRAMMAR([[input.y]], 261 [[%error-verbose 262 %debug 263 %{ 264 ]AT_YYERROR_DECLARE[ 265 ]AT_YYLEX_DECLARE[ 266 # define USE(Var) 267 %} 268 269 %union 270 { 271 int val; 272 }; 273 274 %type <val> a_1 a_2 a_5 275 sum_of_the_five_previous_values 276 277 %% 278 exp: a_1 a_2 { $<val>$ = 3; } { $<val>$ = $<val>3 + 1; } a_5 279 sum_of_the_five_previous_values 280 { 281 USE (($1, $2, $<foo>3, $<foo>4, $5)); 282 printf ("%d\n", $6); 283 } 284 ; 285 a_1: { $$ = 1; }; 286 a_2: { $$ = 2; }; 287 a_5: { $$ = 5; }; 288 289 sum_of_the_five_previous_values: 290 { 291 $$ = $<val>0 + $<val>-1 + $<val>-2 + $<val>-3 + $<val>-4; 292 } 293 ; 294 295 %% 296 ]AT_YYERROR_DEFINE[ 297 ]AT_YYLEX_DEFINE[ 298 int 299 main (void) 300 { 301 return yyparse (); 302 } 303 ]]) 304 305 AT_BISON_CHECK([-d -v -o input.c input.y], 0) 306 AT_COMPILE([input]) 307 AT_PARSER_CHECK([./input], 0, 308 [[15 309 ]]) 310 311 # Make sure that fields after $n or $-n are parsed correctly. At one 312 # point while implementing dashes in symbol names, we were dropping 313 # fields after $-n. 314 AT_DATA_GRAMMAR([[input.y]], 315 [[ 316 %{ 317 #include <stdio.h> 318 ]AT_YYERROR_DECLARE[ 319 ]AT_YYLEX_DECLARE[ 320 typedef struct { int val; } stype; 321 # define YYSTYPE stype 322 %} 323 324 %% 325 start: one two { $$.val = $1.val + $2.val; } sum ; 326 one: { $$.val = 1; } ; 327 two: { $$.val = 2; } ; 328 sum: { printf ("%d\n", $0.val + $-1.val + $-2.val); } ; 329 330 %% 331 ]AT_YYERROR_DEFINE[ 332 ]AT_YYLEX_DEFINE[ 333 int 334 main (void) 335 { 336 return yyparse (); 337 } 338 ]]) 339 340 AT_FULL_COMPILE([input]) 341 AT_PARSER_CHECK([[./input]], [[0]], 342 [[6 343 ]]) 344 345 AT_BISON_OPTION_POPDEFS 346 AT_CLEANUP 347 348 349 350 ## -------------------------- ## 351 ## Printers and Destructors. ## 352 ## -------------------------- ## 353 354 # _AT_CHECK_PRINTER_AND_DESTRUCTOR($1, $2, $3, $4, 355 # BISON-DIRECTIVE, UNION-FLAG) 356 # ------------------------------------------------------------- 357 m4_define([_AT_CHECK_PRINTER_AND_DESTRUCTOR], 358 [# Make sure complex $n work. 359 m4_if([$1$2$3$4], $[1]$[2]$[3]$[4], [], 360 [m4_fatal([$0: Invalid arguments: $@])])dnl 361 362 # Be sure to pass all the %directives to this macro to have correct 363 # helping macros. So don't put any directly in the Bison file. 364 AT_BISON_OPTION_PUSHDEFS([$5]) 365 AT_DATA_GRAMMAR([[input.y]], 366 [[%code requires { 367 #include <stdio.h> 368 #include <stdlib.h> 369 #include <string.h> 370 #include <assert.h> 371 372 #define YYINITDEPTH 10 373 #define YYMAXDEPTH 10 374 #define RANGE(Location) ]AT_LALR1_CC_IF([(Location).begin.line, (Location).end.line], 375 [(Location).first_line, (Location).last_line])[ 376 377 /* Display the symbol type Symbol. */ 378 #define V(Symbol, Value, Location, Sep) \ 379 fprintf (stderr, #Symbol " (%d@%d-%d)" Sep, Value, RANGE(Location)) 380 } 381 382 $5 383 ]m4_ifval([$6], [%union 384 { 385 int ival; 386 }]) 387 AT_LALR1_CC_IF([%define global_tokens_and_yystype]) 388 m4_ifval([$6], [[%code provides {]], [[%code {]]) 389 AT_LALR1_CC_IF([typedef yy::location YYLTYPE;])[ 390 ]AT_YYLEX_DECLARE[ 391 ]AT_LALR1_CC_IF([], [AT_YYERROR_DECLARE]) 392 [} 393 394 ]m4_ifval([$6], [%type <ival> '(' 'x' 'y' ')' ';' thing line input END])[ 395 396 /* FIXME: This %printer isn't actually tested. */ 397 %printer 398 { 399 ]AT_LALR1_CC_IF([debug_stream () << $$;], 400 [fprintf (yyoutput, "%d", $$)])[; 401 } 402 input line thing 'x' 'y' 403 404 %destructor 405 { fprintf (stderr, "Freeing nterm input (%d@%d-%d)\n", $$, RANGE (@$)); } 406 input 407 408 %destructor 409 { fprintf (stderr, "Freeing nterm line (%d@%d-%d)\n", $$, RANGE (@$)); } 410 line 411 412 %destructor 413 { fprintf (stderr, "Freeing nterm thing (%d@%d-%d)\n", $$, RANGE (@$)); } 414 thing 415 416 %destructor 417 { fprintf (stderr, "Freeing token 'x' (%d@%d-%d)\n", $$, RANGE (@$)); } 418 'x' 419 420 %destructor 421 { fprintf (stderr, "Freeing token 'y' (%d@%d-%d)\n", $$, RANGE (@$)); } 422 'y' 423 424 %token END 0 425 %destructor 426 { fprintf (stderr, "Freeing token END (%d@%d-%d)\n", $$, RANGE (@$)); } 427 END 428 429 %% 430 /* 431 This grammar is made to exercise error recovery. 432 "Lines" starting with `(' support error recovery, with 433 ')' as synchronizing token. Lines starting with 'x' can never 434 be recovered from if in error. 435 */ 436 437 input: 438 /* Nothing. */ 439 { 440 $$ = 0; 441 V(input, $$, @$, ": /* Nothing */\n"); 442 } 443 | line input /* Right recursive to load the stack so that popping at 444 END can be exercised. */ 445 { 446 $$ = 2; 447 V(input, $$, @$, ": "); 448 V(line, $1, @1, " "); 449 V(input, $2, @2, "\n"); 450 } 451 ; 452 453 line: 454 thing thing thing ';' 455 { 456 $$ = $1; 457 V(line, $$, @$, ": "); 458 V(thing, $1, @1, " "); 459 V(thing, $2, @2, " "); 460 V(thing, $3, @3, " "); 461 V(;, $4, @4, "\n"); 462 } 463 | '(' thing thing ')' 464 { 465 $$ = $1; 466 V(line, $$, @$, ": "); 467 V('(', $1, @1, " "); 468 V(thing, $2, @2, " "); 469 V(thing, $3, @3, " "); 470 V(')', $4, @4, "\n"); 471 } 472 | '(' thing ')' 473 { 474 $$ = $1; 475 V(line, $$, @$, ": "); 476 V('(', $1, @1, " "); 477 V(thing, $2, @2, " "); 478 V(')', $3, @3, "\n"); 479 } 480 | '(' error ')' 481 { 482 $$ = -1; 483 V(line, $$, @$, ": "); 484 V('(', $1, @1, " "); 485 fprintf (stderr, "error (@%d-%d) ", RANGE (@2)); 486 V(')', $3, @3, "\n"); 487 } 488 ; 489 490 thing: 491 'x' 492 { 493 $$ = $1; 494 V(thing, $$, @$, ": "); 495 V('x', $1, @1, "\n"); 496 } 497 ; 498 %% 499 /* Alias to ARGV[1]. */ 500 const char *source = YY_NULL; 501 502 ]AT_YYERROR_DEFINE[ 503 504 static 505 ]AT_YYLEX_PROTOTYPE[ 506 { 507 static unsigned int counter = 0; 508 509 int c = ]AT_VAL[]m4_ifval([$6], [.ival])[ = counter++; 510 /* As in BASIC, line numbers go from 10 to 10. */ 511 ]AT_LOC_FIRST_LINE[ = ]AT_LOC_FIRST_COLUMN[ = 10 * c; 512 ]AT_LOC_LAST_LINE[ = ]AT_LOC_LAST_COLUMN[ = ]AT_LOC_FIRST_LINE[ + 9; 513 assert (0 <= c && c <= strlen (source)); 514 if (source[c]) 515 fprintf (stderr, "sending: '%c'", source[c]); 516 else 517 fprintf (stderr, "sending: END"); 518 fprintf (stderr, " (%d@%d-%d)\n", c, RANGE (]AT_LOC[)); 519 return source[c]; 520 } 521 ]AT_LALR1_CC_IF( 522 [static bool yydebug; 523 int 524 yyparse () 525 { 526 yy::parser parser; 527 parser.set_debug_level (yydebug); 528 return parser.parse (); 529 } 530 ])[ 531 532 int 533 main (int argc, const char *argv[]) 534 { 535 int status; 536 yydebug = !!getenv ("YYDEBUG"); 537 assert (argc == 2); 538 source = argv[1]; 539 status = yyparse (); 540 switch (status) 541 { 542 case 0: fprintf (stderr, "Successful parse.\n"); break; 543 case 1: fprintf (stderr, "Parsing FAILED.\n"); break; 544 default: fprintf (stderr, "Parsing FAILED (status %d).\n", status); break; 545 } 546 return status; 547 } 548 ]]) 549 550 AT_FULL_COMPILE([input]) 551 552 553 # Check the location of "empty" 554 # ----------------------------- 555 # I.e., epsilon-reductions, as in "(x)" which ends by reducing 556 # an empty "line" nterm. 557 # FIXME: This location is not satisfying. Depend on the lookahead? 558 AT_PARSER_CHECK([./input '(x)'], 0, [], 559 [[sending: '(' (0@0-9) 560 sending: 'x' (1@10-19) 561 thing (1@10-19): 'x' (1@10-19) 562 sending: ')' (2@20-29) 563 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29) 564 sending: END (3@30-39) 565 input (0@29-29): /* Nothing */ 566 input (2@0-29): line (0@0-29) input (0@29-29) 567 Freeing token END (3@30-39) 568 Freeing nterm input (2@0-29) 569 Successful parse. 570 ]]) 571 572 573 # Check locations in error recovery 574 # --------------------------------- 575 # '(y)' is an error, but can be recovered from. But what's the location 576 # of the error itself ('y'), and of the resulting reduction ('(error)'). 577 AT_PARSER_CHECK([./input '(y)'], 0, [], 578 [[sending: '(' (0@0-9) 579 sending: 'y' (1@10-19) 580 10.10-19.18: syntax error, unexpected 'y', expecting 'x' 581 Freeing token 'y' (1@10-19) 582 sending: ')' (2@20-29) 583 line (-1@0-29): '(' (0@0-9) error (@10-19) ')' (2@20-29) 584 sending: END (3@30-39) 585 input (0@29-29): /* Nothing */ 586 input (2@0-29): line (-1@0-29) input (0@29-29) 587 Freeing token END (3@30-39) 588 Freeing nterm input (2@0-29) 589 Successful parse. 590 ]]) 591 592 593 # Syntax errors caught by the parser 594 # ---------------------------------- 595 # Exercise the discarding of stack top and input until `error' 596 # can be reduced. 597 # 598 # '(', 'x', 'x', 'x', 'x', 'x', ')', 599 # 600 # Load the stack and provoke an error that cannot be caught by the 601 # grammar, to check that the stack is cleared. And make sure the 602 # lookahead is freed. 603 # 604 # '(', 'x', ')', 605 # '(', 'x', ')', 606 # 'y' 607 AT_PARSER_CHECK([./input '(xxxxx)(x)(x)y'], 1, [], 608 [[sending: '(' (0@0-9) 609 sending: 'x' (1@10-19) 610 thing (1@10-19): 'x' (1@10-19) 611 sending: 'x' (2@20-29) 612 thing (2@20-29): 'x' (2@20-29) 613 sending: 'x' (3@30-39) 614 30.30-39.38: syntax error, unexpected 'x', expecting ')' 615 Freeing nterm thing (2@20-29) 616 Freeing nterm thing (1@10-19) 617 Freeing token 'x' (3@30-39) 618 sending: 'x' (4@40-49) 619 Freeing token 'x' (4@40-49) 620 sending: 'x' (5@50-59) 621 Freeing token 'x' (5@50-59) 622 sending: ')' (6@60-69) 623 line (-1@0-69): '(' (0@0-9) error (@10-59) ')' (6@60-69) 624 sending: '(' (7@70-79) 625 sending: 'x' (8@80-89) 626 thing (8@80-89): 'x' (8@80-89) 627 sending: ')' (9@90-99) 628 line (7@70-99): '(' (7@70-79) thing (8@80-89) ')' (9@90-99) 629 sending: '(' (10@100-109) 630 sending: 'x' (11@110-119) 631 thing (11@110-119): 'x' (11@110-119) 632 sending: ')' (12@120-129) 633 line (10@100-129): '(' (10@100-109) thing (11@110-119) ')' (12@120-129) 634 sending: 'y' (13@130-139) 635 input (0@129-129): /* Nothing */ 636 input (2@100-129): line (10@100-129) input (0@129-129) 637 input (2@70-129): line (7@70-99) input (2@100-129) 638 input (2@0-129): line (-1@0-69) input (2@70-129) 639 130.130-139.138: syntax error, unexpected 'y', expecting END 640 Freeing nterm input (2@0-129) 641 Freeing token 'y' (13@130-139) 642 Parsing FAILED. 643 ]]) 644 645 646 # Syntax error caught by the parser where lookahead = END 647 # -------------------------------------------------------- 648 # Load the stack and provoke an error that cannot be caught by the 649 # grammar, to check that the stack is cleared. And make sure the 650 # lookahead is freed. 651 # 652 # '(', 'x', ')', 653 # '(', 'x', ')', 654 # 'x' 655 AT_PARSER_CHECK([./input '(x)(x)x'], 1, [], 656 [[sending: '(' (0@0-9) 657 sending: 'x' (1@10-19) 658 thing (1@10-19): 'x' (1@10-19) 659 sending: ')' (2@20-29) 660 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29) 661 sending: '(' (3@30-39) 662 sending: 'x' (4@40-49) 663 thing (4@40-49): 'x' (4@40-49) 664 sending: ')' (5@50-59) 665 line (3@30-59): '(' (3@30-39) thing (4@40-49) ')' (5@50-59) 666 sending: 'x' (6@60-69) 667 thing (6@60-69): 'x' (6@60-69) 668 sending: END (7@70-79) 669 70.70-79.78: syntax error, unexpected END, expecting 'x' 670 Freeing nterm thing (6@60-69) 671 Freeing nterm line (3@30-59) 672 Freeing nterm line (0@0-29) 673 Freeing token END (7@70-79) 674 Parsing FAILED. 675 ]]) 676 677 678 # Check destruction upon stack overflow 679 # ------------------------------------- 680 # Upon stack overflow, all symbols on the stack should be destroyed. 681 # Only check for yacc.c. 682 AT_YACC_IF([ 683 AT_PARSER_CHECK([./input '(x)(x)(x)(x)(x)(x)(x)'], 2, [], 684 [[sending: '(' (0@0-9) 685 sending: 'x' (1@10-19) 686 thing (1@10-19): 'x' (1@10-19) 687 sending: ')' (2@20-29) 688 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29) 689 sending: '(' (3@30-39) 690 sending: 'x' (4@40-49) 691 thing (4@40-49): 'x' (4@40-49) 692 sending: ')' (5@50-59) 693 line (3@30-59): '(' (3@30-39) thing (4@40-49) ')' (5@50-59) 694 sending: '(' (6@60-69) 695 sending: 'x' (7@70-79) 696 thing (7@70-79): 'x' (7@70-79) 697 sending: ')' (8@80-89) 698 line (6@60-89): '(' (6@60-69) thing (7@70-79) ')' (8@80-89) 699 sending: '(' (9@90-99) 700 sending: 'x' (10@100-109) 701 thing (10@100-109): 'x' (10@100-109) 702 sending: ')' (11@110-119) 703 line (9@90-119): '(' (9@90-99) thing (10@100-109) ')' (11@110-119) 704 sending: '(' (12@120-129) 705 sending: 'x' (13@130-139) 706 thing (13@130-139): 'x' (13@130-139) 707 sending: ')' (14@140-149) 708 line (12@120-149): '(' (12@120-129) thing (13@130-139) ')' (14@140-149) 709 sending: '(' (15@150-159) 710 sending: 'x' (16@160-169) 711 thing (16@160-169): 'x' (16@160-169) 712 sending: ')' (17@170-179) 713 line (15@150-179): '(' (15@150-159) thing (16@160-169) ')' (17@170-179) 714 sending: '(' (18@180-189) 715 sending: 'x' (19@190-199) 716 thing (19@190-199): 'x' (19@190-199) 717 sending: ')' (20@200-209) 718 200.200-209.208: memory exhausted 719 Freeing nterm thing (19@190-199) 720 Freeing nterm line (15@150-179) 721 Freeing nterm line (12@120-149) 722 Freeing nterm line (9@90-119) 723 Freeing nterm line (6@60-89) 724 Freeing nterm line (3@30-59) 725 Freeing nterm line (0@0-29) 726 Parsing FAILED (status 2). 727 ]]) 728 ]) 729 730 AT_BISON_OPTION_POPDEFS 731 ])# _AT_CHECK_PRINTER_AND_DESTRUCTOR 732 733 734 # AT_CHECK_PRINTER_AND_DESTRUCTOR([BISON-OPTIONS], [UNION-FLAG], [SKIP_FLAG]) 735 # --------------------------------------------------------------------------- 736 m4_define([AT_CHECK_PRINTER_AND_DESTRUCTOR], 737 [AT_SETUP([Printers and Destructors$2]m4_ifval([$1], [[: $1]])) 738 739 $3 740 _AT_CHECK_PRINTER_AND_DESTRUCTOR($[1], $[2], $[3], $[4], 741 [%error-verbose 742 %debug 743 %verbose 744 %locations 745 $1], [$2]) 746 747 AT_CLEANUP 748 ]) 749 750 751 AT_CHECK_PRINTER_AND_DESTRUCTOR([]) 752 AT_CHECK_PRINTER_AND_DESTRUCTOR([], [ with union]) 753 754 AT_CHECK_PRINTER_AND_DESTRUCTOR([%defines %skeleton "lalr1.cc"]) 755 AT_CHECK_PRINTER_AND_DESTRUCTOR([%defines %skeleton "lalr1.cc"], [ with union]) 756 757 AT_CHECK_PRINTER_AND_DESTRUCTOR([%glr-parser]) 758 AT_CHECK_PRINTER_AND_DESTRUCTOR([%glr-parser], [ with union]) 759 760 761 762 ## ----------------------------------------- ## 763 ## Default tagless %printer and %destructor. ## 764 ## ----------------------------------------- ## 765 766 # Check that the right %printer and %destructor are called, that they're not 767 # called for $end, and that $$ and @$ work correctly. 768 769 AT_SETUP([Default tagless %printer and %destructor]) 770 AT_BISON_OPTION_PUSHDEFS([%locations]) 771 AT_DATA_GRAMMAR([[input.y]], 772 [[%error-verbose 773 %debug 774 %locations 775 776 %{ 777 # include <stdio.h> 778 # include <stdlib.h> 779 ]AT_YYLEX_DECLARE[ 780 ]AT_YYERROR_DECLARE[ 781 # define USE(SYM) 782 %} 783 784 %printer { 785 fprintf (yyoutput, "<*> printer should not be called.\n"); 786 } <*> 787 788 %printer { 789 fprintf (yyoutput, "<> printer for '%c' @ %d", $$, @$.first_column); 790 } <> 791 %destructor { 792 fprintf (stdout, "<> destructor for '%c' @ %d.\n", $$, @$.first_column); 793 } <> 794 795 %printer { 796 fprintf (yyoutput, "'b'/'c' printer for '%c' @ %d", $$, @$.first_column); 797 } 'b' 'c' 798 %destructor { 799 fprintf (stdout, "'b'/'c' destructor for '%c' @ %d.\n", $$, @$.first_column); 800 } 'b' 'c' 801 802 %destructor { 803 fprintf (yyoutput, "<*> destructor should not be called.\n"); 804 } <*> 805 806 %% 807 808 start: 'a' 'b' 'c' 'd' 'e' { $$ = 'S'; USE(($1, $2, $3, $4, $5)); } ; 809 810 %% 811 ]AT_YYERROR_DEFINE[ 812 ]AT_YYLEX_DEFINE(["abcd"], [[yylval = res]])[ 813 814 int 815 main (void) 816 { 817 yydebug = 1; 818 return yyparse (); 819 } 820 ]]) 821 822 AT_BISON_CHECK([-o input.c input.y]) 823 AT_COMPILE([input]) 824 AT_PARSER_CHECK([./input], 1, 825 [[<> destructor for 'd' @ 4. 826 'b'/'c' destructor for 'c' @ 3. 827 'b'/'c' destructor for 'b' @ 2. 828 <> destructor for 'a' @ 1. 829 ]], 830 [[Starting parse 831 Entering state 0 832 Reading a token: Next token is token 'a' (1.1: <> printer for 'a' @ 1) 833 Shifting token 'a' (1.1: <> printer for 'a' @ 1) 834 Entering state 1 835 Reading a token: Next token is token 'b' (1.2: 'b'/'c' printer for 'b' @ 2) 836 Shifting token 'b' (1.2: 'b'/'c' printer for 'b' @ 2) 837 Entering state 3 838 Reading a token: Next token is token 'c' (1.3: 'b'/'c' printer for 'c' @ 3) 839 Shifting token 'c' (1.3: 'b'/'c' printer for 'c' @ 3) 840 Entering state 5 841 Reading a token: Next token is token 'd' (1.4: <> printer for 'd' @ 4) 842 Shifting token 'd' (1.4: <> printer for 'd' @ 4) 843 Entering state 6 844 Reading a token: Now at end of input. 845 1.5: syntax error, unexpected $end, expecting 'e' 846 Error: popping token 'd' (1.4: <> printer for 'd' @ 4) 847 Stack now 0 1 3 5 848 Error: popping token 'c' (1.3: 'b'/'c' printer for 'c' @ 3) 849 Stack now 0 1 3 850 Error: popping token 'b' (1.2: 'b'/'c' printer for 'b' @ 2) 851 Stack now 0 1 852 Error: popping token 'a' (1.1: <> printer for 'a' @ 1) 853 Stack now 0 854 Cleanup: discarding lookahead token $end (1.5: ) 855 Stack now 0 856 ]]) 857 858 AT_BISON_OPTION_POPDEFS 859 AT_CLEANUP 860 861 862 863 ## ------------------------------------------------------ ## 864 ## Default tagged and per-type %printer and %destructor. ## 865 ## ------------------------------------------------------ ## 866 867 AT_SETUP([Default tagged and per-type %printer and %destructor]) 868 AT_BISON_OPTION_PUSHDEFS 869 AT_DATA_GRAMMAR([[input.y]], 870 [[%error-verbose 871 %debug 872 873 %{ 874 # include <stdio.h> 875 # include <stdlib.h> 876 ]AT_YYERROR_DECLARE[ 877 ]AT_YYLEX_DECLARE[ 878 # define USE(SYM) 879 %} 880 881 %printer { 882 fprintf (yyoutput, "<> printer should not be called.\n"); 883 } <> 884 885 %union { int field0; int field1; int field2; } 886 %type <field0> start 'a' 'g' 887 %type <field1> 'e' 888 %type <field2> 'f' 889 %printer { 890 fprintf (yyoutput, "<*>/<field2>/e printer"); 891 } <*> 'e' <field2> 892 %destructor { 893 fprintf (stdout, "<*>/<field2>/e destructor.\n"); 894 } <*> 'e' <field2> 895 896 %type <field1> 'b' 897 %printer { fprintf (yyoutput, "<field1> printer"); } <field1> 898 %destructor { fprintf (stdout, "<field1> destructor.\n"); } <field1> 899 900 %type <field0> 'c' 901 %printer { fprintf (yyoutput, "'c' printer"); } 'c' 902 %destructor { fprintf (stdout, "'c' destructor.\n"); } 'c' 903 904 %type <field1> 'd' 905 %printer { fprintf (yyoutput, "'d' printer"); } 'd' 906 %destructor { fprintf (stdout, "'d' destructor.\n"); } 'd' 907 908 %destructor { 909 fprintf (yyoutput, "<> destructor should not be called.\n"); 910 } <> 911 912 %% 913 914 start: 915 'a' 'b' 'c' 'd' 'e' 'f' 'g' 916 { 917 USE(($1, $2, $3, $4, $5, $6, $7)); 918 $$ = 'S'; 919 } 920 ; 921 922 %% 923 ]AT_YYERROR_DEFINE[ 924 ]AT_YYLEX_DEFINE(["abcdef"])[ 925 926 int 927 main (void) 928 { 929 yydebug = 1; 930 return yyparse (); 931 } 932 ]]) 933 934 AT_BISON_CHECK([-o input.c input.y]) 935 AT_COMPILE([input]) 936 AT_PARSER_CHECK([./input], 1, 937 [[<*>/<field2>/e destructor. 938 <*>/<field2>/e destructor. 939 'd' destructor. 940 'c' destructor. 941 <field1> destructor. 942 <*>/<field2>/e destructor. 943 ]], 944 [[Starting parse 945 Entering state 0 946 Reading a token: Next token is token 'a' (<*>/<field2>/e printer) 947 Shifting token 'a' (<*>/<field2>/e printer) 948 Entering state 1 949 Reading a token: Next token is token 'b' (<field1> printer) 950 Shifting token 'b' (<field1> printer) 951 Entering state 3 952 Reading a token: Next token is token 'c' ('c' printer) 953 Shifting token 'c' ('c' printer) 954 Entering state 5 955 Reading a token: Next token is token 'd' ('d' printer) 956 Shifting token 'd' ('d' printer) 957 Entering state 6 958 Reading a token: Next token is token 'e' (<*>/<field2>/e printer) 959 Shifting token 'e' (<*>/<field2>/e printer) 960 Entering state 7 961 Reading a token: Next token is token 'f' (<*>/<field2>/e printer) 962 Shifting token 'f' (<*>/<field2>/e printer) 963 Entering state 8 964 Reading a token: Now at end of input. 965 syntax error, unexpected $end, expecting 'g' 966 Error: popping token 'f' (<*>/<field2>/e printer) 967 Stack now 0 1 3 5 6 7 968 Error: popping token 'e' (<*>/<field2>/e printer) 969 Stack now 0 1 3 5 6 970 Error: popping token 'd' ('d' printer) 971 Stack now 0 1 3 5 972 Error: popping token 'c' ('c' printer) 973 Stack now 0 1 3 974 Error: popping token 'b' (<field1> printer) 975 Stack now 0 1 976 Error: popping token 'a' (<*>/<field2>/e printer) 977 Stack now 0 978 Cleanup: discarding lookahead token $end () 979 Stack now 0 980 ]]) 981 982 AT_BISON_OPTION_POPDEFS 983 AT_CLEANUP 984 985 986 987 ## ------------------------------------------------------------- ## 988 ## Default %printer and %destructor for user-defined end token. ## 989 ## ------------------------------------------------------------- ## 990 991 AT_SETUP([Default %printer and %destructor for user-defined end token]) 992 993 # _AT_CHECK_DEFAULT_PRINTER_AND_DESTRUCTOR_FOR_END_TOKEN(TYPED) 994 # ------------------------------------------------------------- 995 m4_define([_AT_CHECK_DEFAULT_PRINTER_AND_DESTRUCTOR_FOR_END_TOKEN], 996 [m4_if($1, 0, 997 [m4_pushdef([kind], []) m4_pushdef([not_kind], [*])], 998 [m4_pushdef([kind], [*]) m4_pushdef([not_kind], [])]) 999 1000 AT_BISON_OPTION_PUSHDEFS([%locations]) 1001 AT_DATA_GRAMMAR([[input]]$1[[.y]], 1002 [[%error-verbose 1003 %debug 1004 %locations 1005 1006 %{ 1007 # include <stdio.h> 1008 # include <stdlib.h> 1009 ]AT_YYERROR_DECLARE[ 1010 ]AT_YYLEX_DECLARE[ 1011 # define USE(SYM) 1012 %} 1013 1014 %destructor { 1015 fprintf (yyoutput, "<]]not_kind[[> destructor should not be called.\n"); 1016 } <]]not_kind[[> 1017 1018 %token END 0 1019 %printer { 1020 fprintf (yyoutput, "<]]kind[[> for '%c' @ %d", $$, @$.first_column); 1021 } <]]kind[[> 1022 %destructor { 1023 fprintf (stdout, "<]]kind[[> for '%c' @ %d.\n", $$, @$.first_column); 1024 } <]]kind[[> 1025 1026 %printer { 1027 fprintf (yyoutput, "<]]not_kind[[> printer should not be called.\n"); 1028 } <]]not_kind[[> 1029 1030 ]]m4_if($1, 0, [[[ 1031 ]]], 1032 [[[%union { char tag; } 1033 %type <tag> start END]]])[[ 1034 1035 %% 1036 1037 start: { $$ = 'S'; } ; 1038 1039 %% 1040 1041 static int 1042 yylex (void) 1043 { 1044 static int called; 1045 if (called++) 1046 abort (); 1047 yylval]]m4_if($1, 0,, [[[.tag]]])[[ = 'E'; 1048 yylloc.first_line = yylloc.last_line = 1; 1049 yylloc.first_column = yylloc.last_column = 1; 1050 return 0; 1051 } 1052 ]AT_YYERROR_DEFINE[ 1053 1054 int 1055 main (void) 1056 { 1057 yydebug = 1; 1058 return yyparse (); 1059 } 1060 ]]) 1061 AT_BISON_OPTION_POPDEFS 1062 1063 AT_BISON_CHECK([-o input$1.c input$1.y]) 1064 AT_COMPILE([input$1]) 1065 AT_PARSER_CHECK([./input$1], 0, 1066 [[<]]kind[[> for 'E' @ 1. 1067 <]]kind[[> for 'S' @ 1. 1068 ]], 1069 [[Starting parse 1070 Entering state 0 1071 Reducing stack by rule 1 (line 42): 1072 -> $$ = nterm start (1.1: <]]kind[[> for 'S' @ 1) 1073 Stack now 0 1074 Entering state 1 1075 Reading a token: Now at end of input. 1076 Shifting token END (1.1: <]]kind[[> for 'E' @ 1) 1077 Entering state 2 1078 Stack now 0 1 2 1079 Cleanup: popping token END (1.1: <]]kind[[> for 'E' @ 1) 1080 Cleanup: popping nterm start (1.1: <]]kind[[> for 'S' @ 1) 1081 ]]) 1082 1083 m4_popdef([kind]) 1084 m4_popdef([not_kind]) 1085 ]) 1086 1087 _AT_CHECK_DEFAULT_PRINTER_AND_DESTRUCTOR_FOR_END_TOKEN(0) 1088 _AT_CHECK_DEFAULT_PRINTER_AND_DESTRUCTOR_FOR_END_TOKEN(1) 1089 1090 AT_CLEANUP 1091 1092 1093 1094 ## ------------------------------------------------------------------ ## 1095 ## Default %printer and %destructor are not for error or $undefined. ## 1096 ## ------------------------------------------------------------------ ## 1097 1098 AT_SETUP([Default %printer and %destructor are not for error or $undefined]) 1099 1100 # If Bison were to apply the default %printer and %destructor to the error 1101 # token or to $undefined: 1102 # - For the error token: 1103 # - It would generate warnings for unused $n. 1104 # - It would invoke the %printer and %destructor on the error token's 1105 # semantic value, which would be initialized from the lookahead, which 1106 # would be destroyed separately. 1107 # - For $undefined, who knows what the semantic value would be. 1108 AT_BISON_OPTION_PUSHDEFS 1109 AT_DATA_GRAMMAR([[input.y]], 1110 [[%debug 1111 1112 %{ 1113 # include <stdio.h> 1114 # include <stdlib.h> 1115 ]AT_YYERROR_DECLARE[ 1116 ]AT_YYLEX_DECLARE[ 1117 # define USE(SYM) 1118 %} 1119 1120 %printer { 1121 fprintf (yyoutput, "'%c'", $$); 1122 } <> <*> 1123 %destructor { 1124 fprintf (stderr, "DESTROY '%c'\n", $$); 1125 } <> <*> 1126 1127 %% 1128 1129 start: 1130 { $$ = 'S'; } 1131 /* In order to reveal the problems that this bug caused during parsing, add 1132 * $2 to USE. */ 1133 | 'a' error 'b' 'c' { USE(($1, $3, $4)); $$ = 'S'; } 1134 ; 1135 1136 %% 1137 ]AT_YYERROR_DEFINE[ 1138 ]AT_YYLEX_DEFINE(["abd"], [yylval = res])[ 1139 int 1140 main (void) 1141 { 1142 yydebug = 1; 1143 return yyparse (); 1144 } 1145 ]]) 1146 AT_BISON_OPTION_POPDEFS 1147 1148 AT_BISON_CHECK([-o input.c input.y]) 1149 AT_COMPILE([input]) 1150 AT_PARSER_CHECK([./input], [1], [], 1151 [[Starting parse 1152 Entering state 0 1153 Reading a token: Next token is token 'a' ('a') 1154 Shifting token 'a' ('a') 1155 Entering state 1 1156 Reading a token: Next token is token 'b' ('b') 1157 syntax error 1158 Shifting token error () 1159 Entering state 3 1160 Next token is token 'b' ('b') 1161 Shifting token 'b' ('b') 1162 Entering state 5 1163 Reading a token: Next token is token $undefined () 1164 Error: popping token 'b' ('b') 1165 DESTROY 'b' 1166 Stack now 0 1 3 1167 Error: popping token error () 1168 Stack now 0 1 1169 Shifting token error () 1170 Entering state 3 1171 Next token is token $undefined () 1172 Error: discarding token $undefined () 1173 Error: popping token error () 1174 Stack now 0 1 1175 Shifting token error () 1176 Entering state 3 1177 Reading a token: Now at end of input. 1178 Cleanup: discarding lookahead token $end () 1179 Stack now 0 1 3 1180 Cleanup: popping token error () 1181 Cleanup: popping token 'a' ('a') 1182 DESTROY 'a' 1183 ]]) 1184 1185 AT_CLEANUP 1186 1187 1188 1189 ## ------------------------------------------------------ ## 1190 ## Default %printer and %destructor are not for $accept. ## 1191 ## ------------------------------------------------------ ## 1192 1193 AT_SETUP([Default %printer and %destructor are not for $accept]) 1194 1195 # If YYSTYPE is a union and Bison were to apply the default %printer and 1196 # %destructor to $accept: 1197 # - The %printer and %destructor code generated for $accept would always be 1198 # dead code because $accept is currently never shifted onto the stack. 1199 # - $$ for $accept would always be of type YYSTYPE because it's not possible 1200 # to declare `%type <field> $accept'. (Also true for $undefined.) 1201 # - Thus, the compiler might complain that the user code assumes the wrong 1202 # type for $$ since the code might assume the type associated with a 1203 # specific union field, which is especially reasonable in C++ since that 1204 # type may be a base type. This test case checks for this problem. (Also 1205 # true for $undefined and the error token, so there are three warnings for 1206 # %printer and three for %destructor.) 1207 1208 AT_BISON_OPTION_PUSHDEFS 1209 AT_DATA_GRAMMAR([[input.y]], 1210 [[%debug /* So that %printer is actually compiled. */ 1211 1212 %{ 1213 # include <stdio.h> 1214 # include <stdlib.h> 1215 ]AT_YYERROR_DECLARE[ 1216 ]AT_YYLEX_DECLARE[ 1217 # define USE(SYM) 1218 %} 1219 1220 %printer { 1221 char chr = $$; 1222 fprintf (yyoutput, "'%c'", chr); 1223 } <> <*> 1224 %destructor { 1225 char chr = $$; 1226 fprintf (stderr, "DESTROY '%c'\n", chr); 1227 } <> <*> 1228 1229 %union { char chr; } 1230 %type <chr> start 1231 1232 %% 1233 1234 start: { USE($$); } ; 1235 1236 %% 1237 ]AT_YYERROR_DEFINE[ 1238 ]AT_YYLEX_DEFINE[ 1239 int 1240 main (void) 1241 { 1242 return yyparse (); 1243 } 1244 ]]) 1245 AT_BISON_OPTION_POPDEFS 1246 1247 AT_BISON_CHECK([-o input.c input.y]) 1248 AT_COMPILE([input]) 1249 1250 AT_CLEANUP 1251 1252 1253 1254 ## ------------------------------------------------------ ## 1255 ## Default %printer and %destructor for mid-rule values. ## 1256 ## ------------------------------------------------------ ## 1257 1258 AT_SETUP([Default %printer and %destructor for mid-rule values]) 1259 1260 AT_BISON_OPTION_PUSHDEFS 1261 AT_DATA_GRAMMAR([[input.y]], 1262 [[%debug /* So that %printer is actually compiled. */ 1263 1264 %{ 1265 # include <stdio.h> 1266 # include <stdlib.h> 1267 ]AT_YYERROR_DECLARE[ 1268 ]AT_YYLEX_DECLARE[ 1269 # define USE(SYM) 1270 # define YYLTYPE int 1271 # define YYLLOC_DEFAULT(Current, Rhs, N) (void)(Rhs) 1272 # define YY_LOCATION_PRINT(File, Loc) 1273 %} 1274 1275 %printer { fprintf (yyoutput, "%d", @$); } <> 1276 %destructor { fprintf (stderr, "DESTROY %d\n", @$); } <> 1277 %printer { fprintf (yyoutput, "<*> printer should not be called"); } <*> 1278 %destructor { fprintf (yyoutput, "<*> destructor should not be called"); } <*> 1279 1280 %% 1281 1282 start: 1283 { @$ = 1; } // Not set or used. 1284 { USE ($$); @$ = 2; } // Both set and used. 1285 { USE ($$); @$ = 3; } // Only set. 1286 { @$ = 4; } // Only used. 1287 'c' 1288 { USE (($$, $2, $4, $5)); @$ = 0; } 1289 ; 1290 1291 %% 1292 ]AT_YYERROR_DEFINE[ 1293 ]AT_YYLEX_DEFINE[ 1294 int 1295 main (void) 1296 { 1297 yydebug = 1; 1298 return yyparse (); 1299 } 1300 ]]) 1301 AT_BISON_OPTION_POPDEFS 1302 1303 AT_BISON_CHECK([-o input.c input.y], 0,, 1304 [[input.y:33.3-23: warning: unset value: $$ 1305 input.y:32.3-23: warning: unused value: $3 1306 ]]) 1307 1308 AT_BISON_CHECK([-fcaret -o input.c input.y], 0,, 1309 [[input.y:33.3-23: warning: unset value: $$ 1310 { @$ = 4; } // Only used. 1311 ^^^^^^^^^^^^^^^^^^^^^ 1312 input.y:32.3-23: warning: unused value: $3 1313 { USE ($$); @$ = 3; } // Only set. 1314 ^^^^^^^^^^^^^^^^^^^^^ 1315 ]]) 1316 1317 AT_COMPILE([input]) 1318 AT_PARSER_CHECK([./input], 1,, 1319 [[Starting parse 1320 Entering state 0 1321 Reducing stack by rule 1 (line 30): 1322 -> $$ = nterm $@1 (: ) 1323 Stack now 0 1324 Entering state 2 1325 Reducing stack by rule 2 (line 31): 1326 -> $$ = nterm @2 (: 2) 1327 Stack now 0 2 1328 Entering state 4 1329 Reducing stack by rule 3 (line 32): 1330 -> $$ = nterm @3 (: 3) 1331 Stack now 0 2 4 1332 Entering state 5 1333 Reducing stack by rule 4 (line 33): 1334 -> $$ = nterm @4 (: 4) 1335 Stack now 0 2 4 5 1336 Entering state 6 1337 Reading a token: Now at end of input. 1338 syntax error 1339 Error: popping nterm @4 (: 4) 1340 DESTROY 4 1341 Stack now 0 2 4 5 1342 Error: popping nterm @3 (: 3) 1343 DESTROY 3 1344 Stack now 0 2 4 1345 Error: popping nterm @2 (: 2) 1346 DESTROY 2 1347 Stack now 0 2 1348 Error: popping nterm $@1 (: ) 1349 Stack now 0 1350 Cleanup: discarding lookahead token $end (: ) 1351 Stack now 0 1352 ]]) 1353 1354 AT_CLEANUP 1355 1356 1357 ## ----------------------- ## 1358 ## @$ implies %locations. ## 1359 ## ----------------------- ## 1360 1361 # Bison once forgot to check for @$ in actions other than semantic actions. 1362 1363 # AT_CHECK_ACTION_LOCATIONS(ACTION-DIRECTIVE) 1364 # ------------------------------------------- 1365 m4_define([AT_CHECK_ACTION_LOCATIONS], 1366 [AT_SETUP([[@$ in ]$1[ implies %locations]]) 1367 AT_BISON_OPTION_PUSHDEFS 1368 AT_DATA_GRAMMAR([[input.y]], 1369 [[%code { 1370 #include <stdio.h> 1371 ]AT_YYERROR_DECLARE[ 1372 ]AT_YYLEX_DECLARE[ 1373 } 1374 1375 %debug 1376 1377 ]$1[ { 1378 fprintf (stderr, "%d\n", @$.first_line); 1379 } ]m4_if($1, [%initial-action], [], [[start]])[ 1380 1381 %% 1382 1383 start: ; 1384 1385 %% 1386 1387 static int 1388 yylex (void) 1389 { 1390 return 0; 1391 } 1392 1393 ]AT_YYERROR_DEFINE[ 1394 int 1395 main (void) 1396 { 1397 return yyparse (); 1398 } 1399 ]]) 1400 1401 AT_BISON_CHECK([[-o input.c input.y]]) 1402 AT_COMPILE([[input]]) 1403 AT_BISON_OPTION_POPDEFS 1404 AT_CLEANUP]) 1405 1406 AT_CHECK_ACTION_LOCATIONS([[%initial-action]]) 1407 AT_CHECK_ACTION_LOCATIONS([[%destructor]]) 1408 AT_CHECK_ACTION_LOCATIONS([[%printer]]) 1409 1410 1411 ## ------------------------- ## 1412 ## Qualified $$ in actions. ## 1413 ## ------------------------- ## 1414 1415 # Check that we can used qualified $$ (v.g., $<type>$) not only in 1416 # rule actions, but also where $$ is valid: %printer and %destructor. 1417 # 1418 # FIXME: Not actually checking %destructor, but it's the same code as 1419 # %printer... 1420 # 1421 # To do that, use a semantic value that has two fields (sem_type), 1422 # declare symbols to have only one of these types (INT, float), and 1423 # use $<type>$ to get the other one. Including for symbols that are 1424 # not typed (UNTYPED). 1425 1426 m4_pushdef([AT_TEST], 1427 [AT_SETUP([[Qualified $$ in actions: $1]]) 1428 1429 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1"]) 1430 1431 AT_DATA_GRAMMAR([[input.y]], 1432 [[%skeleton "$1" 1433 %defines // FIXME: Mandated by lalr1.cc in Bison 2.6. 1434 %locations // FIXME: Mandated by lalr1.cc in Bison 2.6. 1435 %debug 1436 %code requires 1437 { 1438 typedef struct sem_type 1439 { 1440 int ival; 1441 float fval; 1442 } sem_type; 1443 1444 # define YYSTYPE sem_type 1445 1446 ]AT_SKEL_CC_IF([[ 1447 # include <iostream> 1448 static void 1449 report (std::ostream& yyo, int ival, float fval) 1450 { 1451 yyo << "ival: " << ival << ", fval: " << fval; 1452 } 1453 ]], [[ 1454 # include <stdio.h> 1455 static void 1456 report (FILE* yyo, int ival, float fval) 1457 { 1458 fprintf (yyo, "ival: %d, fval: %1.1f", ival, fval); 1459 } 1460 ]])[ 1461 } 1462 1463 %code 1464 { 1465 ]AT_YYERROR_DECLARE[ 1466 ]AT_YYLEX_DECLARE[ 1467 } 1468 1469 %token UNTYPED 1470 %token <ival> INT 1471 %type <fval> float 1472 %printer { report (yyo, $$, $<fval>$); } <ival>; 1473 %printer { report (yyo, $<ival>$, $$ ); } <fval>; 1474 %printer { report (yyo, $<ival>$, $<fval>$); } <>; 1475 1476 %initial-action 1477 { 1478 $<ival>$ = 42; 1479 $<fval>$ = 4.2; 1480 } 1481 1482 %% 1483 float: UNTYPED INT 1484 { 1485 $$ = $<fval>1 + $<fval>2; 1486 $<ival>$ = $<ival>1 + $][2; 1487 }; 1488 %% 1489 ]AT_YYERROR_DEFINE[ 1490 ]AT_YYLEX_DEFINE(AT_SKEL_CC_IF([[{yy::parser::token::UNTYPED, 1491 yy::parser::token::INT, 1492 EOF}]], 1493 [[{UNTYPED, INT, EOF}]]), 1494 [AT_VAL.ival = toknum * 10; AT_VAL.fval = toknum / 10.0;])[ 1495 int 1496 main (void) 1497 {]AT_SKEL_CC_IF([[ 1498 yy::parser p; 1499 p.set_debug_level(1); 1500 return p.parse ();]], [[ 1501 yydebug = 1; 1502 return yyparse ();]])[ 1503 } 1504 ]]) 1505 1506 AT_FULL_COMPILE([[input]]) 1507 AT_PARSER_CHECK([./input], 0, [], [stderr]) 1508 # Don't be too picky on the traces, GLR is not exactly the same. Keep 1509 # only the lines from the printer. 1510 # 1511 # Don't care about locations. FIXME: remove their removal when Bison 1512 # supports C++ without locations. 1513 AT_CHECK([[sed -ne 's/([-0-9.]*: /(/;/ival:/p' stderr]], 0, 1514 [[Reading a token: Next token is token UNTYPED (ival: 10, fval: 0.1) 1515 Shifting token UNTYPED (ival: 10, fval: 0.1) 1516 Reading a token: Next token is token INT (ival: 20, fval: 0.2) 1517 Shifting token INT (ival: 20, fval: 0.2) 1518 $][1 = token UNTYPED (ival: 10, fval: 0.1) 1519 $][2 = token INT (ival: 20, fval: 0.2) 1520 -> $$ = nterm float (ival: 30, fval: 0.3) 1521 Cleanup: popping nterm float (ival: 30, fval: 0.3) 1522 ]]) 1523 1524 AT_BISON_OPTION_POPDEFS 1525 1526 AT_CLEANUP 1527 ]) 1528 1529 AT_TEST([yacc.c]) 1530 AT_TEST([glr.c]) 1531 AT_TEST([lalr1.cc]) 1532 AT_TEST([glr.cc]) 1533 1534 m4_popdef([AT_TEST]) 1535 1536 ## ----------------------------------------------- ## 1537 ## Fix user actions without a trailing semicolon. ## 1538 ## ----------------------------------------------- ## 1539 1540 AT_SETUP([[Fix user actions without a trailing semicolon]]) 1541 1542 # This feature is undocumented, but we accidentally broke it in 2.3a, 1543 # and there was a complaint at: 1544 # <http://lists.gnu.org/archive/html/bug-bison/2008-11/msg00001.html>. 1545 AT_BISON_OPTION_PUSHDEFS 1546 AT_DATA([input.y], 1547 [[%% 1548 start: test2 test1 test0 testc; 1549 1550 test2 1551 : 'a' { semi; /* TEST:N:2 */ } 1552 | 'b' { if (0) {no_semi} /* TEST:N:2 */ } 1553 | 'c' { if (0) {semi;} /* TEST:N:2 */ } 1554 | 'd' { semi; no_semi /* TEST:Y:2 */ } 1555 | 'e' { semi(); no_semi() /* TEST:Y:2 */ } 1556 | 'f' { semi[]; no_semi[] /* TEST:Y:2 */ } 1557 | 'g' { semi++; no_semi++ /* TEST:Y:2 */ } 1558 | 'h' { {no_semi} no_semi /* TEST:Y:2 */ } 1559 | 'i' { {semi;} no_semi /* TEST:Y:2 */ } 1560 ; 1561 test1 1562 : 'a' { semi; // TEST:N:1 ; 1563 } | 'b' { if (0) {no_semi} // TEST:N:1 ; 1564 } | 'c' { if (0) {semi;} // TEST:N:1 ; 1565 } | 'd' { semi; no_semi // TEST:Y:1 ; 1566 } | 'e' { semi(); no_semi() // TEST:Y:1 ; 1567 } | 'f' { semi[]; no_semi[] // TEST:Y:1 ; 1568 } | 'g' { semi++; no_semi++ // TEST:Y:1 ; 1569 } | 'h' { {no_semi} no_semi // TEST:Y:1 ; 1570 } | 'i' { {semi;} no_semi // TEST:Y:1 ; 1571 } ; 1572 test0 1573 : 'a' { semi; // TEST:N:1 {} 1574 } | 'b' { if (0) {no_semi} // TEST:N:1 {} 1575 } | 'c' { if (0) {semi;} // TEST:N:1 {} 1576 } | 'd' { semi; no_semi // TEST:Y:1 {} 1577 } | 'e' { semi(); no_semi() // TEST:Y:1 {} 1578 } | 'f' { semi[]; no_semi[] // TEST:Y:1 {} 1579 } | 'g' { semi++; no_semi++ // TEST:Y:1 {} 1580 } | 'h' { {no_semi} no_semi // TEST:Y:1 {} 1581 } | 'i' { {semi;} no_semi // TEST:Y:1 {} 1582 } ; 1583 1584 testc 1585 : 'a' { 1586 #define TEST_MACRO_N \ 1587 []"broken\" $ @ $$ @$ [];\ 1588 string;"} 1589 | 'b' { 1590 no_semi 1591 #define TEST_MACRO_N \ 1592 []"broken\" $ @ $$ @$ [];\ 1593 string;"} 1594 ]]) 1595 AT_BISON_OPTION_POPDEFS 1596 1597 AT_BISON_CHECK([[-o input.c input.y]], [0], [], 1598 [[input.y:8.48: warning: a ';' might be needed at the end of action code 1599 input.y:8.48: future versions of Bison will not add the ';' 1600 input.y:9.48: warning: a ';' might be needed at the end of action code 1601 input.y:9.48: future versions of Bison will not add the ';' 1602 input.y:10.48: warning: a ';' might be needed at the end of action code 1603 input.y:10.48: future versions of Bison will not add the ';' 1604 input.y:11.48: warning: a ';' might be needed at the end of action code 1605 input.y:11.48: future versions of Bison will not add the ';' 1606 input.y:12.48: warning: a ';' might be needed at the end of action code 1607 input.y:12.48: future versions of Bison will not add the ';' 1608 input.y:13.48: warning: a ';' might be needed at the end of action code 1609 input.y:13.48: future versions of Bison will not add the ';' 1610 input.y:20.1: warning: a ';' might be needed at the end of action code 1611 input.y:20.1: future versions of Bison will not add the ';' 1612 input.y:21.1: warning: a ';' might be needed at the end of action code 1613 input.y:21.1: future versions of Bison will not add the ';' 1614 input.y:22.1: warning: a ';' might be needed at the end of action code 1615 input.y:22.1: future versions of Bison will not add the ';' 1616 input.y:23.1: warning: a ';' might be needed at the end of action code 1617 input.y:23.1: future versions of Bison will not add the ';' 1618 input.y:24.1: warning: a ';' might be needed at the end of action code 1619 input.y:24.1: future versions of Bison will not add the ';' 1620 input.y:25.1: warning: a ';' might be needed at the end of action code 1621 input.y:25.1: future versions of Bison will not add the ';' 1622 input.y:31.1: warning: a ';' might be needed at the end of action code 1623 input.y:31.1: future versions of Bison will not add the ';' 1624 input.y:32.1: warning: a ';' might be needed at the end of action code 1625 input.y:32.1: future versions of Bison will not add the ';' 1626 input.y:33.1: warning: a ';' might be needed at the end of action code 1627 input.y:33.1: future versions of Bison will not add the ';' 1628 input.y:34.1: warning: a ';' might be needed at the end of action code 1629 input.y:34.1: future versions of Bison will not add the ';' 1630 input.y:35.1: warning: a ';' might be needed at the end of action code 1631 input.y:35.1: future versions of Bison will not add the ';' 1632 input.y:36.1: warning: a ';' might be needed at the end of action code 1633 input.y:36.1: future versions of Bison will not add the ';' 1634 ]]) 1635 1636 AT_MATCHES_CHECK([input.c], [[/\* TEST:N:2 \*/ \}$]], [[3]]) 1637 AT_MATCHES_CHECK([input.c], [[/\* TEST:Y:2 \*/ ;\}$]], [[6]]) 1638 AT_MATCHES_CHECK([input.c], [[// TEST:N:1 [;{}]*\n\}$]], [[6]]) 1639 AT_MATCHES_CHECK([input.c], [[// TEST:Y:1 [;{}]*\n;\}$]], [[12]]) 1640 AT_MATCHES_CHECK([input.c], [[#define TEST_MACRO_N \\\n\[\]"broken\\" \$ \@ \$\$ \@\$ \[\];\\\nstring;"\}]], [[2]]) 1641 1642 AT_CLEANUP 1643 1644 1645 ## -------------------------------------------------- ## 1646 ## Destroying lookahead assigned by semantic action. ## 1647 ## -------------------------------------------------- ## 1648 1649 AT_SETUP([[Destroying lookahead assigned by semantic action]]) 1650 1651 AT_BISON_OPTION_PUSHDEFS 1652 AT_DATA_GRAMMAR([input.y], 1653 [[ 1654 %code { 1655 #include <assert.h> 1656 #include <stdio.h> 1657 ]AT_YYERROR_DECLARE[ 1658 ]AT_YYLEX_DECLARE[ 1659 #define USE(Var) 1660 } 1661 1662 %destructor { fprintf (stderr, "'a' destructor\n"); } 'a' 1663 %destructor { fprintf (stderr, "'b' destructor\n"); } 'b' 1664 1665 %% 1666 1667 // In a previous version of Bison, yychar assigned by the semantic 1668 // action below was not translated into yytoken before the lookahead was 1669 // discarded and thus before its destructor (selected according to 1670 // yytoken) was called in order to return from yyparse. This would 1671 // happen even if YYACCEPT was performed in a later semantic action as 1672 // long as only consistent states with default reductions were visited 1673 // in between. However, we leave YYACCEPT in the same semantic action 1674 // for this test in order to show that skeletons cannot simply translate 1675 // immediately after every semantic action because a semantic action 1676 // that has set yychar might not always return normally. Instead, 1677 // skeletons must translate before every use of yytoken. 1678 start: 'a' accept { USE($1); } ; 1679 accept: /*empty*/ { 1680 assert (yychar == YYEMPTY); 1681 yychar = 'b'; 1682 YYACCEPT; 1683 } ; 1684 1685 %% 1686 ]AT_YYERROR_DEFINE[ 1687 ]AT_YYLEX_DEFINE(["a"])[ 1688 int 1689 main (void) 1690 { 1691 return yyparse (); 1692 } 1693 ]]) 1694 AT_BISON_OPTION_POPDEFS 1695 AT_BISON_CHECK([[-o input.c input.y]]) 1696 AT_COMPILE([[input]]) 1697 AT_PARSER_CHECK([[./input]], [[0]], [], 1698 [['b' destructor 1699 'a' destructor 1700 ]]) 1701 1702 AT_CLEANUP 1703 1704 ## ---------- ## 1705 ## YYBACKUP. ## 1706 ## ---------- ## 1707 1708 AT_SETUP([[YYBACKUP]]) 1709 1710 AT_BISON_OPTION_PUSHDEFS([%pure-parser]) 1711 1712 AT_DATA_GRAMMAR([input.y], 1713 [[ 1714 %error-verbose 1715 %debug 1716 %pure-parser 1717 %code { 1718 # include <stdio.h> 1719 # include <stdlib.h> 1720 # include <assert.h> 1721 1722 ]AT_YYERROR_DECLARE[ 1723 ]AT_YYLEX_DECLARE[ 1724 } 1725 %% 1726 input: 1727 exp exp {} 1728 ; 1729 1730 exp: 1731 'a' { printf ("a: %d\n", $1); } 1732 | 'b' { YYBACKUP('a', 123); } 1733 | 'c' 'd' { YYBACKUP('a', 456); } 1734 ; 1735 1736 %% 1737 ]AT_YYERROR_DEFINE[ 1738 ]AT_YYLEX_DEFINE(["bcd"], [*lvalp = (toknum + 1) * 10])[ 1739 1740 int 1741 main (void) 1742 { 1743 yydebug = !!getenv("YYDEBUG"); 1744 return yyparse (); 1745 } 1746 ]]) 1747 AT_BISON_OPTION_POPDEFS 1748 1749 AT_BISON_CHECK([[-o input.c input.y]]) 1750 AT_COMPILE([[input]]) 1751 AT_PARSER_CHECK([[./input]], [[0]], 1752 [[a: 123 1753 a: 456 1754 ]]) 1755 1756 AT_CLEANUP 1757
