tests/regression.at

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