tests/regression.at

   1 # Bison Regressions.                               -*- Autotest -*-
   2
   3 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software
   4 # Foundation, Inc.
   5
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 AT_BANNER([[Regression tests.]])
  20
  21
  22 ## ------------------ ##
  23 ## Trivial grammars.  ##
  24 ## ------------------ ##
  25
  26 AT_SETUP([Trivial grammars])
  27
  28 AT_DATA_GRAMMAR([input.y],
  29 [[%{
  30 void yyerror (char const *);
  31 int yylex (void);
  32 #define YYSTYPE int *
  33 %}
  34
  35 %error-verbose
  36
  37 %%
  38
  39 program: 'x';
  40 ]])
  41
  42 AT_BISON_CHECK([-o input.c input.y])
  43 AT_COMPILE([input.o], [-c input.c])
  44 AT_COMPILE([input.o], [-DYYDEBUG -c input.c])
  45
  46 AT_CLEANUP
  47
  48
  49
  50 ## ----------------- ##
  51 ## YYSTYPE typedef.  ##
  52 ## ----------------- ##
  53
  54 AT_SETUP([YYSTYPE typedef])
  55
  56 AT_DATA_GRAMMAR([input.y],
  57 [[%{
  58 void yyerror (char const *);
  59 int yylex (void);
  60 typedef union { char const *val; } YYSTYPE;
  61 %}
  62
  63 %type <val> program
  64
  65 %%
  66
  67 program: { $$ = ""; };
  68 ]])
  69
  70 AT_BISON_CHECK([-o input.c input.y])
  71 AT_COMPILE([input.o], [-c input.c])
  72
  73 AT_CLEANUP
  74
  75
  76
  77 ## ------------------------------------- ##
  78 ## Early token definitions with --yacc.  ##
  79 ## ------------------------------------- ##
  80
  81
  82 AT_SETUP([Early token definitions with --yacc])
  83
  84 # Found in GCJ: they expect the tokens to be defined before the user
  85 # prologue, so that they can use the token definitions in it.
  86
  87 AT_DATA_GRAMMAR([input.y],
  88 [[%{
  89 void yyerror (const char *s);
  90 int yylex (void);
  91 %}
  92
  93 %union
  94 {
  95   int val;
  96 };
  97 %{
  98 #ifndef MY_TOKEN
  99 # error "MY_TOKEN not defined."
 100 #endif
 101 %}
 102 %token MY_TOKEN
 103 %%
 104 exp: MY_TOKEN;
 105 %%
 106 ]])
 107
 108 AT_BISON_CHECK([-y -o input.c input.y])
 109 AT_COMPILE([input.o], [-c input.c])
 110
 111 AT_CLEANUP
 112
 113
 114
 115 ## ---------------------------------------- ##
 116 ## Early token definitions without --yacc.  ##
 117 ## ---------------------------------------- ##
 118
 119
 120 AT_SETUP([Early token definitions without --yacc])
 121
 122 # Found in GCJ: they expect the tokens to be defined before the user
 123 # prologue, so that they can use the token definitions in it.
 124
 125 AT_DATA_GRAMMAR([input.y],
 126 [[%{
 127 #include <stdio.h>
 128 void yyerror (const char *s);
 129 int yylex (void);
 130 void print_my_token (void);
 131 %}
 132
 133 %union
 134 {
 135   int val;
 136 };
 137 %{
 138 void
 139 print_my_token (void)
 140 {
 141   enum yytokentype my_token = MY_TOKEN;
 142   printf ("%d\n", my_token);
 143 }
 144 %}
 145 %token MY_TOKEN
 146 %%
 147 exp: MY_TOKEN;
 148 %%
 149 ]])
 150
 151 AT_BISON_CHECK([-o input.c input.y])
 152 AT_COMPILE([input.o], [-c input.c])
 153
 154 AT_CLEANUP
 155
 156
 157
 158 ## ---------------- ##
 159 ## Braces parsing.  ##
 160 ## ---------------- ##
 161
 162
 163 AT_SETUP([Braces parsing])
 164
 165 AT_DATA([input.y],
 166 [[/* Bison used to swallow the character after `}'. */
 167
 168 %%
 169 exp: { tests = {{{{{{{{{{}}}}}}}}}}; };
 170 %%
 171 ]])
 172
 173 AT_BISON_CHECK([-v -o input.c input.y])
 174
 175 AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore])
 176
 177 AT_CLEANUP
 178
 179
 180 ## ------------------ ##
 181 ## Duplicate string.  ##
 182 ## ------------------ ##
 183
 184
 185 AT_SETUP([Duplicate string])
 186
 187 AT_DATA([input.y],
 188 [[/* `Bison -v' used to dump core when two tokens are defined with the same
 189    string, as LE and GE below. */
 190
 191 %token NUM
 192 %token LE "<="
 193 %token GE "<="
 194
 195 %%
 196 exp: '(' exp ')' | NUM ;
 197 %%
 198 ]])
 199
 200 AT_BISON_CHECK([-v -o input.c input.y], 0, [],
 201 [[input.y:6.8-14: warning: symbol `"<="' used more than once as a literal string
 202 ]])
 203
 204 AT_CLEANUP
 205
 206
 207 ## ------------------- ##
 208 ## Rule Line Numbers.  ##
 209 ## ------------------- ##
 210
 211 AT_SETUP([Rule Line Numbers])
 212
 213 AT_KEYWORDS([report])
 214
 215 AT_DATA([input.y],
 216 [[%%
 217 expr:
 218 'a'
 219
 220 {
 221
 222 }
 223
 224 'b'
 225
 226 {
 227
 228 }
 229
 230 |
 231
 232
 233 {
 234
 235
 236 }
 237
 238 'c'
 239
 240 {
 241
 242 };
 243 ]])
 244
 245 AT_BISON_CHECK([-o input.c -v input.y])
 246
 247 # Check the contents of the report.
 248 AT_CHECK([cat input.output], [],
 249 [[Grammar
 250
 251     0 $accept: expr $end
 252
 253     1 $@1: /* empty */
 254
 255     2 expr: 'a' $@1 'b'
 256
 257     3 $@2: /* empty */
 258
 259     4 expr: $@2 'c'
 260
 261
 262 Terminals, with rules where they appear
 263
 264 $end (0) 0
 265 'a' (97) 2
 266 'b' (98) 2
 267 'c' (99) 4
 268 error (256)
 269
 270
 271 Nonterminals, with rules where they appear
 272
 273 $accept (6)
 274     on left: 0
 275 expr (7)
 276     on left: 2 4, on right: 0
 277 $@1 (8)
 278     on left: 1, on right: 2
 279 $@2 (9)
 280     on left: 3, on right: 4
 281
 282
 283 state 0
 284
 285     0 $accept: . expr $end
 286
 287     'a'  shift, and go to state 1
 288
 289     $default  reduce using rule 3 ($@2)
 290
 291     expr  go to state 2
 292     $@2   go to state 3
 293
 294
 295 state 1
 296
 297     2 expr: 'a' . $@1 'b'
 298
 299     $default  reduce using rule 1 ($@1)
 300
 301     $@1  go to state 4
 302
 303
 304 state 2
 305
 306     0 $accept: expr . $end
 307
 308     $end  shift, and go to state 5
 309
 310
 311 state 3
 312
 313     4 expr: $@2 . 'c'
 314
 315     'c'  shift, and go to state 6
 316
 317
 318 state 4
 319
 320     2 expr: 'a' $@1 . 'b'
 321
 322     'b'  shift, and go to state 7
 323
 324
 325 state 5
 326
 327     0 $accept: expr $end .
 328
 329     $default  accept
 330
 331
 332 state 6
 333
 334     4 expr: $@2 'c' .
 335
 336     $default  reduce using rule 4 (expr)
 337
 338
 339 state 7
 340
 341     2 expr: 'a' $@1 'b' .
 342
 343     $default  reduce using rule 2 (expr)
 344 ]])
 345
 346 AT_CLEANUP
 347
 348
 349
 350 ## ---------------------- ##
 351 ## Mixing %token styles.  ##
 352 ## ---------------------- ##
 353
 354
 355 AT_SETUP([Mixing %token styles])
 356
 357 # Taken from the documentation.
 358 AT_DATA([input.y],
 359 [[%token  <operator>  OR      "||"
 360 %token  <operator>  LE 134  "<="
 361 %left  OR  "<="
 362 %%
 363 exp: ;
 364 %%
 365 ]])
 366
 367 AT_BISON_CHECK([-v -o input.c input.y])
 368
 369 AT_CLEANUP
 370
 371
 372
 373 ## ---------------- ##
 374 ## Invalid inputs.  ##
 375 ## ---------------- ##
 376
 377
 378 AT_SETUP([Invalid inputs])
 379
 380 AT_DATA([input.y],
 381 [[%%
 382 ?
 383 default: 'a' }
 384 %&
 385 %a-does-not-exist
 386 %-
 387 %{
 388 ]])
 389
 390 AT_BISON_CHECK([input.y], [1], [],
 391 [[input.y:2.1: invalid character: `?'
 392 input.y:3.14: invalid character: `}'
 393 input.y:4.1: invalid character: `%'
 394 input.y:4.2: invalid character: `&'
 395 input.y:5.1-17: invalid directive: `%a-does-not-exist'
 396 input.y:6.1: invalid character: `%'
 397 input.y:6.2: invalid character: `-'
 398 input.y:7.1-8.0: missing `%}' at end of file
 399 input.y:7.1-8.0: syntax error, unexpected %{...%}
 400 ]])
 401
 402 AT_CLEANUP
 403
 404
 405 AT_SETUP([Invalid inputs with {}])
 406
 407 AT_DATA([input.y],
 408 [[
 409 %destructor
 410 %initial-action
 411 %lex-param
 412 %parse-param
 413 %printer
 414 %union
 415 ]])
 416
 417 AT_BISON_CHECK([input.y], [1], [],
 418 [[input.y:3.1-15: syntax error, unexpected %initial-action, expecting {...}
 419 ]])
 420
 421 AT_CLEANUP
 422
 423
 424
 425 ## ------------------- ##
 426 ## Token definitions.  ##
 427 ## ------------------- ##
 428
 429
 430 AT_SETUP([Token definitions])
 431
 432 # Bison managed, when fed with `%token 'f' "f"' to #define 'f'!
 433 AT_DATA_GRAMMAR([input.y],
 434 [%{
 435 #include <stdlib.h>
 436 #include <stdio.h>
 437 void yyerror (const char *s);
 438 int yylex (void);
 439 %}
 440 [%error-verbose
 441 %token MYEOF 0 "end of file"
 442 %token 'a' "a"
 443 %token B_TOKEN "b"
 444 %token C_TOKEN 'c'
 445 %token 'd' D_TOKEN
 446 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 447 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
 448 %%
 449 exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
 450 %%
 451 void
 452 yyerror (char const *s)
 453 {
 454   fprintf (stderr, "%s\n", s);
 455 }
 456
 457 int
 458 yylex (void)
 459 {
 460   static int called;
 461   if (called++)
 462     abort ();
 463   return SPECIAL;
 464 }
 465
 466 int
 467 main (void)
 468 {
 469   return yyparse ();
 470 }
 471 ]])
 472
 473 # Checking the warning message guarantees that the trigraph "??!" isn't
 474 # unnecessarily escaped here even though it would need to be if encoded in a
 475 # C-string literal.  Also notice that unnecessary escaping, such as "\?", from
 476 # the user specification is eliminated.
 477 AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
 478 [[input.y:22.8-14: warning: symbol SPECIAL redeclared
 479 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
 480 ]])
 481 AT_COMPILE([input])
 482
 483 # Checking the error message here guarantees that yytname, which does contain
 484 # C-string literals, does have the trigraph escaped correctly.  Thus, the
 485 # symbol name reported by the parser is exactly the same as that reported by
 486 # Bison itself.
 487 AT_DATA([experr],
 488 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
 489 ]])
 490 AT_PARSER_CHECK([./input], 1, [], [experr])
 491 AT_CLEANUP
 492
 493
 494
 495 ## -------------------- ##
 496 ## Characters Escapes.  ##
 497 ## -------------------- ##
 498
 499
 500 AT_SETUP([Characters Escapes])
 501
 502 AT_DATA_GRAMMAR([input.y],
 503 [%{
 504 void yyerror (const char *s);
 505 int yylex (void);
 506 %}
 507 [%%
 508 exp:
 509   '\'' "\'"
 510 | '\"' "\""
 511 | '"'  "'"
 512 ;
 513 ]])
 514 # Pacify font-lock-mode: "
 515
 516 AT_BISON_CHECK([-o input.c input.y])
 517 AT_COMPILE([input.o], [-c input.c])
 518 AT_CLEANUP
 519
 520
 521
 522 ## -------------- ##
 523 ## Web2c Report.  ##
 524 ## -------------- ##
 525
 526 # The generation of the reduction was once wrong in Bison, and made it
 527 # miss some reductions.  In the following test case, the reduction on
 528 # `undef_id_tok' in state 1 was missing.  This is stripped down from
 529 # the actual web2c.y.
 530
 531 AT_SETUP([Web2c Report])
 532
 533 AT_KEYWORDS([report])
 534
 535 AT_DATA([input.y],
 536 [[%token        undef_id_tok const_id_tok
 537
 538 %start CONST_DEC_PART
 539 \f
 540 %%
 541 CONST_DEC_PART:
 542          CONST_DEC_LIST
 543         ;
 544
 545 CONST_DEC_LIST:
 546           CONST_DEC
 547         | CONST_DEC_LIST CONST_DEC
 548         ;
 549
 550 CONST_DEC:
 551           { } undef_id_tok '=' const_id_tok ';'
 552         ;
 553 %%
 554 ]])
 555
 556 AT_BISON_CHECK([-v input.y])
 557 AT_CHECK([cat input.output], 0,
 558 [[Grammar
 559
 560     0 $accept: CONST_DEC_PART $end
 561
 562     1 CONST_DEC_PART: CONST_DEC_LIST
 563
 564     2 CONST_DEC_LIST: CONST_DEC
 565     3               | CONST_DEC_LIST CONST_DEC
 566
 567     4 $@1: /* empty */
 568
 569     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
 570
 571
 572 Terminals, with rules where they appear
 573
 574 $end (0) 0
 575 ';' (59) 5
 576 '=' (61) 5
 577 error (256)
 578 undef_id_tok (258) 5
 579 const_id_tok (259) 5
 580
 581
 582 Nonterminals, with rules where they appear
 583
 584 $accept (7)
 585     on left: 0
 586 CONST_DEC_PART (8)
 587     on left: 1, on right: 0
 588 CONST_DEC_LIST (9)
 589     on left: 2 3, on right: 1 3
 590 CONST_DEC (10)
 591     on left: 5, on right: 2 3
 592 $@1 (11)
 593     on left: 4, on right: 5
 594
 595
 596 state 0
 597
 598     0 $accept: . CONST_DEC_PART $end
 599
 600     $default  reduce using rule 4 ($@1)
 601
 602     CONST_DEC_PART  go to state 1
 603     CONST_DEC_LIST  go to state 2
 604     CONST_DEC       go to state 3
 605     $@1             go to state 4
 606
 607
 608 state 1
 609
 610     0 $accept: CONST_DEC_PART . $end
 611
 612     $end  shift, and go to state 5
 613
 614
 615 state 2
 616
 617     1 CONST_DEC_PART: CONST_DEC_LIST .
 618     3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
 619
 620     undef_id_tok  reduce using rule 4 ($@1)
 621     $default      reduce using rule 1 (CONST_DEC_PART)
 622
 623     CONST_DEC  go to state 6
 624     $@1        go to state 4
 625
 626
 627 state 3
 628
 629     2 CONST_DEC_LIST: CONST_DEC .
 630
 631     $default  reduce using rule 2 (CONST_DEC_LIST)
 632
 633
 634 state 4
 635
 636     5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
 637
 638     undef_id_tok  shift, and go to state 7
 639
 640
 641 state 5
 642
 643     0 $accept: CONST_DEC_PART $end .
 644
 645     $default  accept
 646
 647
 648 state 6
 649
 650     3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
 651
 652     $default  reduce using rule 3 (CONST_DEC_LIST)
 653
 654
 655 state 7
 656
 657     5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
 658
 659     '='  shift, and go to state 8
 660
 661
 662 state 8
 663
 664     5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
 665
 666     const_id_tok  shift, and go to state 9
 667
 668
 669 state 9
 670
 671     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
 672
 673     ';'  shift, and go to state 10
 674
 675
 676 state 10
 677
 678     5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
 679
 680     $default  reduce using rule 5 (CONST_DEC)
 681 ]])
 682
 683 AT_CLEANUP
 684
 685
 686 ## --------------- ##
 687 ## Web2c Actions.  ##
 688 ## --------------- ##
 689
 690 # The generation of the mapping `state -> action' was once wrong in
 691 # extremely specific situations.  web2c.y exhibits this situation.
 692 # Below is a stripped version of the grammar.  It looks like one can
 693 # simplify it further, but just don't: it is tuned to exhibit a bug,
 694 # which disapears when applying sane grammar transformations.
 695 #
 696 # It used to be wrong on yydefact only:
 697 #
 698 # static const yytype_uint8 yydefact[] =
 699 #  {
 700 # -       2,     0,     1,     0,     0,     2,     3,     2,     5,     4,
 701 # +       2,     0,     1,     0,     0,     0,     3,     2,     5,     4,
 702 #         0,     0
 703 #  };
 704 #
 705 # but let's check all the tables.
 706
 707
 708 AT_SETUP([Web2c Actions])
 709
 710 AT_KEYWORDS([report])
 711
 712 AT_DATA([input.y],
 713 [[%%
 714 statement:  struct_stat;
 715 struct_stat:  /* empty. */ | if else;
 716 if: "if" "const" "then" statement;
 717 else: "else" statement;
 718 %%
 719 ]])
 720
 721 AT_BISON_CHECK([-v -o input.c input.y])
 722
 723 # Check only the tables.
 724 [sed -n 's/  *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
 725
 726 AT_CHECK([[cat tables.c]], 0,
 727 [[static const yytype_uint8 yytranslate[] =
 728 {
 729        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 730        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 731        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 732        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 733        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 734        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 735        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 736        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 737        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 738        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 739        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 740        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 741        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 742        2,     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,     1,     2,     3,     4,
 755        5,     6
 756 };
 757 static const yytype_uint8 yyrline[] =
 758 {
 759        0,     2,     2,     3,     3,     4,     5
 760 };
 761 static const char *const yytname[] =
 762 {
 763   "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
 764   "\"else\"", "$accept", "statement", "struct_stat", "if", "else", 0
 765 };
 766 static const yytype_uint16 yytoknum[] =
 767 {
 768        0,   256,   257,   258,   259,   260,   261
 769 };
 770 static const yytype_int8 yypact[] =
 771 {
 772       -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
 773       -8,    -8
 774 };
 775 static const yytype_uint8 yydefact[] =
 776 {
 777        3,     0,     0,     2,     0,     0,     1,     3,     4,     3,
 778        6,     5
 779 };
 780 static const yytype_int8 yypgoto[] =
 781 {
 782       -8,    -7,    -8,    -8,    -8
 783 };
 784 static const yytype_int8 yydefgoto[] =
 785 {
 786       -1,     2,     3,     4,     8
 787 };
 788 static const yytype_uint8 yytable[] =
 789 {
 790       10,     1,    11,     5,     6,     0,     7,     9
 791 };
 792 static const yytype_int8 yycheck[] =
 793 {
 794        7,     3,     9,     4,     0,    -1,     6,     5
 795 };
 796 static const yytype_uint8 yystos[] =
 797 {
 798        0,     3,     8,     9,    10,     4,     0,     6,    11,     5,
 799        8,     8
 800 };
 801 static const yytype_uint8 yyr1[] =
 802 {
 803        0,     7,     8,     9,     9,    10,    11
 804 };
 805 static const yytype_uint8 yyr2[] =
 806 {
 807        0,     2,     1,     0,     2,     4,     2
 808 };
 809 ]])
 810
 811 AT_CLEANUP
 812
 813
 814 ## ------------------------- ##
 815 ## yycheck Bound Violation.  ##
 816 ## ------------------------- ##
 817
 818
 819 # _AT_DATA_DANCER_Y(BISON-OPTIONS)
 820 # --------------------------------
 821 # The following grammar, taken from Andrew Suffield's GPL'd implementation
 822 # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate
 823 # yycheck's bounds where issuing a verbose error message.  Keep this test
 824 # so that possible bound checking compilers could check all the skeletons.
 825 m4_define([_AT_DATA_DANCER_Y],
 826 [AT_DATA_GRAMMAR([dancer.y],
 827 [%{
 828 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 829 AT_LALR1_CC_IF([],
 830 [#include <stdlib.h>
 831 #include <stdio.h>
 832 static void yyerror (const char *);])
 833 %}
 834 $1
 835 %token ARROW INVALID NUMBER STRING DATA
 836 %defines
 837 %verbose
 838 %error-verbose
 839 /* Grammar follows */
 840 %%
 841 line: header body
 842    ;
 843
 844 header: '<' from ARROW to '>' type ':'
 845    | '<' ARROW to '>' type ':'
 846    | ARROW to type ':'
 847    | type ':'
 848    | '<' '>'
 849    ;
 850
 851 from: DATA
 852    | STRING
 853    | INVALID
 854    ;
 855
 856 to: DATA
 857    | STRING
 858    | INVALID
 859    ;
 860
 861 type: DATA
 862    | STRING
 863    | INVALID
 864    ;
 865
 866 body: /* empty */
 867    | body member
 868    ;
 869
 870 member: STRING
 871    | DATA
 872    | '+' NUMBER
 873    | '-' NUMBER
 874    | NUMBER
 875    | INVALID
 876    ;
 877 %%
 878 AT_LALR1_CC_IF(
 879 [/* A C++ error reporting function. */
 880 void
 881 yy::parser::error (const std::string& m)
 882 {
 883   std::cerr << m << std::endl;
 884 }
 885
 886 int
 887 yyparse ()
 888 {
 889   yy::parser parser;
 890 #if YYDEBUG
 891   parser.set_debug_level (YYDEBUG);
 892 #endif
 893   return parser.parse ();
 894 }
 895 ],
 896 [static void
 897 yyerror (const char *s)
 898 {
 899   fprintf (stderr, "%s\n", s);
 900 }])
 901
 902 static int
 903 yylex (AT_LALR1_CC_IF([int *lval], [void]))
 904 [{
 905   static int const tokens[] =
 906     {
 907       ':', -1
 908     };
 909   static size_t toknum;
 910   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
 911   if (! (toknum < sizeof tokens / sizeof *tokens))
 912     abort ();
 913   return tokens[toknum++];
 914 }]
 915
 916 int
 917 main (void)
 918 {
 919   return yyparse ();
 920 }
 921 ])
 922 ])# _AT_DATA_DANCER_Y
 923
 924
 925 # AT_CHECK_DANCER(BISON-OPTIONS)
 926 # ------------------------------
 927 # Generate the grammar, compile it, run it.
 928 m4_define([AT_CHECK_DANCER],
 929 [AT_SETUP([Dancer $1])
 930 AT_BISON_OPTION_PUSHDEFS([$1])
 931 _AT_DATA_DANCER_Y([$1])
 932 AT_BISON_CHECK([-o dancer.c dancer.y])
 933 AT_FULL_COMPILE([dancer])
 934 AT_PARSER_CHECK([./dancer], 1, [],
 935 [syntax error, unexpected ':'
 936 ])
 937 AT_BISON_OPTION_POPDEFS
 938 AT_CLEANUP
 939 ])
 940
 941 AT_CHECK_DANCER()
 942 AT_CHECK_DANCER([%glr-parser])
 943 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
 944
 945
 946 ## ------------------------------------------ ##
 947 ## Diagnostic that expects two alternatives.  ##
 948 ## ------------------------------------------ ##
 949
 950
 951 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
 952 # --------------------------------
 953 m4_define([_AT_DATA_EXPECT2_Y],
 954 [AT_DATA_GRAMMAR([expect2.y],
 955 [%{
 956 static int yylex (AT_LALR1_CC_IF([int *], [void]));
 957 AT_LALR1_CC_IF([],
 958 [#include <stdio.h>
 959 #include <stdlib.h>
 960 static void yyerror (const char *);])
 961 %}
 962 $1
 963 %defines
 964 %error-verbose
 965 %token A 1000
 966 %token B
 967
 968 %%
 969 program: /* empty */
 970  | program e ';'
 971  | program error ';';
 972
 973 e: e '+' t | t;
 974 t: A | B;
 975
 976 %%
 977 AT_LALR1_CC_IF(
 978 [/* A C++ error reporting function. */
 979 void
 980 yy::parser::error (const std::string& m)
 981 {
 982   std::cerr << m << std::endl;
 983 }
 984
 985 int
 986 yyparse ()
 987 {
 988   yy::parser parser;
 989   return parser.parse ();
 990 }
 991 ],
 992 [static void
 993 yyerror (const char *s)
 994 {
 995   fprintf (stderr, "%s\n", s);
 996 }])
 997
 998 static int
 999 yylex (AT_LALR1_CC_IF([int *lval], [void]))
1000 [{
1001   static int const tokens[] =
1002     {
1003       1000, '+', '+', -1
1004     };
1005   static size_t toknum;
1006   ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC.  */])[
1007   if (! (toknum < sizeof tokens / sizeof *tokens))
1008     abort ();
1009   return tokens[toknum++];
1010 }]
1011
1012 int
1013 main (void)
1014 {
1015   return yyparse ();
1016 }
1017 ])
1018 ])# _AT_DATA_EXPECT2_Y
1019
1020
1021 # AT_CHECK_EXPECT2(BISON-OPTIONS)
1022 # ------------------------------
1023 # Generate the grammar, compile it, run it.
1024 m4_define([AT_CHECK_EXPECT2],
1025 [AT_SETUP([Expecting two tokens $1])
1026 AT_BISON_OPTION_PUSHDEFS([$1])
1027 _AT_DATA_EXPECT2_Y([$1])
1028 AT_BISON_CHECK([-o expect2.c expect2.y])
1029 AT_FULL_COMPILE([expect2])
1030 AT_PARSER_CHECK([./expect2], 1, [],
1031 [syntax error, unexpected '+', expecting A or B
1032 ])
1033 AT_BISON_OPTION_POPDEFS
1034 AT_CLEANUP
1035 ])
1036
1037 AT_CHECK_EXPECT2()
1038 AT_CHECK_EXPECT2([%glr-parser])
1039 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
1040
1041
1042
1043 ## --------------------------------------------- ##
1044 ## Braced code in declaration in rules section.  ##
1045 ## --------------------------------------------- ##
1046
1047 AT_SETUP([Braced code in declaration in rules section])
1048
1049 # Bison once mistook braced code in a declaration in the rules section to be a
1050 # rule action.
1051
1052 AT_DATA_GRAMMAR([input.y],
1053 [[%{
1054 #include <stdio.h>
1055 static void yyerror (char const *msg);
1056 static int yylex (void);
1057 %}
1058
1059 %error-verbose
1060
1061 %%
1062
1063 start:
1064   {
1065     printf ("Bison would once convert this action to a midrule because of the"
1066             " subsequent braced code.\n");
1067   }
1068   ;
1069
1070 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1071 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1072
1073 %%
1074
1075 static void
1076 yyerror (char const *msg)
1077 {
1078   fprintf (stderr, "%s\n", msg);
1079 }
1080
1081 static int
1082 yylex (void)
1083 {
1084   return 'a';
1085 }
1086
1087 int
1088 main (void)
1089 {
1090   yydebug = 1;
1091   return !yyparse ();
1092 }
1093 ]])
1094
1095 AT_BISON_CHECK([-t -o input.c input.y])
1096 AT_COMPILE([input])
1097 AT_PARSER_CHECK([./input], 0,
1098 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1099 ]],
1100 [[Starting parse
1101 Entering state 0
1102 Reducing stack by rule 1 (line 20):
1103 -> $$ = nterm start ()
1104 Stack now 0
1105 Entering state 1
1106 Reading a token: Next token is token 'a' (PRINTER)
1107 syntax error, unexpected 'a', expecting $end
1108 Error: popping nterm start ()
1109 Stack now 0
1110 Cleanup: discarding lookahead token 'a' (PRINTER)
1111 DESTRUCTOR
1112 Stack now 0
1113 ]])
1114
1115 AT_CLEANUP
1116
1117
1118
1119 ## --------------------------------- ##
1120 ## String alias declared after use.  ##
1121 ## --------------------------------- ##
1122
1123 AT_SETUP([String alias declared after use])
1124
1125 # Bison once incorrectly asserted that the symbol number for either a token or
1126 # its alias was the highest symbol number so far at the point of the alias
1127 # declaration.  That was true unless the declaration appeared after their first
1128 # uses and other tokens appeared in between.
1129
1130 AT_DATA([input.y],
1131 [[%%
1132 start: 'a' "A" 'b';
1133 %token 'a' "A";
1134 ]])
1135
1136 AT_BISON_CHECK([-t -o input.c input.y])
1137
1138 AT_CLEANUP
1139
1140
1141
1142 ## -------------------------------- ##
1143 ## Extra lookahead sets in report.  ##
1144 ## -------------------------------- ##
1145
1146 AT_SETUP([[Extra lookahead sets in report]])
1147
1148 # Bison prints each reduction's lookahead set only next to the associated
1149 # state's one item that (1) is associated with the same rule as the reduction
1150 # and (2) has its dot at the end of its RHS.  Previously, Bison also
1151 # erroneously printed the lookahead set next to all of the state's other items
1152 # associated with the same rule.  This bug affected only the `.output' file and
1153 # not the generated parser source code.
1154
1155 AT_DATA([[input.y]],
1156 [[%%
1157 start: a | 'a' a 'a' ;
1158 a: 'a' ;
1159 ]])
1160
1161 AT_BISON_CHECK([[--report=all input.y]])
1162 AT_CHECK([[sed -n '/^state 1$/,/^state 2$/p' input.output]], [[0]],
1163 [[state 1
1164
1165     2 start: 'a' . a 'a'
1166     3 a: . 'a'
1167     3  | 'a' .  [$end]
1168
1169     'a'  shift, and go to state 4
1170
1171     $default  reduce using rule 3 (a)
1172
1173     a  go to state 5
1174
1175
1176 state 2
1177 ]])
1178
1179 AT_CLEANUP
1180
1181
1182
1183 ## ---------------------------------------- ##
1184 ## Token number in precedence declaration.  ##
1185 ## ---------------------------------------- ##
1186
1187 AT_SETUP([[Token number in precedence declaration]])
1188
1189 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1190 # we lost this in Bison 1.50.
1191
1192 AT_DATA_GRAMMAR([input.y],
1193 [[%{
1194   #include <stdio.h>
1195   void yyerror (char const *);
1196   int yylex (void);
1197 %}
1198
1199 %error-verbose
1200 %left TK1 1 TK2 2 "tok alias" 3
1201
1202 %%
1203
1204 start: TK1 sr_conflict "tok alias" ;
1205
1206 sr_conflict:
1207   TK2
1208   | TK2 "tok alias"
1209   ;
1210
1211 %%
1212
1213 void
1214 yyerror (char const *msg)
1215 {
1216   fprintf (stderr, "%s\n", msg);
1217 }
1218
1219 int
1220 yylex (void)
1221 {
1222   static int const input[] = { 1, 2, 3, 0 };
1223   static int const *inputp = input;
1224   return *inputp++;
1225 }
1226
1227 int
1228 main (void)
1229 {
1230   return yyparse ();
1231 }
1232 ]])
1233
1234 AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1235 [[input.y:24.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias"
1236 ]])
1237 AT_COMPILE([[input]])
1238 AT_PARSER_CHECK([[./input]])
1239
1240 AT_CLEANUP