tests/regression.at

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