tests/input.at

   1 # Checking the Bison scanner.                    -*- Autotest -*-
   2
   3 # Copyright (C) 2002-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([[Input Processing.]])
  19
  20 # Mostly test that we are robust to mistakes.
  21
  22
  23 ## ------------ ##
  24 ## Invalid $n.  ##
  25 ## ------------ ##
  26
  27 AT_SETUP([Invalid $n and @n])
  28
  29 AT_DATA([input.y],
  30 [[%%
  31 exp: { $$ = $1 ; };
  32 exp: { @$ = @1 ; };
  33 ]])
  34
  35 AT_BISON_CHECK([input.y], [1], [],
  36 [[input.y:2.13-14: integer out of range: '$1'
  37 input.y:3.13-14: integer out of range: '@1'
  38 ]])
  39
  40 AT_CLEANUP
  41
  42
  43 ## -------------- ##
  44 ## Type Clashes.  ##
  45 ## -------------- ##
  46
  47 AT_SETUP([Type Clashes])
  48
  49 AT_DATA([input.y],
  50 [[%union { int bar; }
  51 %token foo
  52 %type <bar> exp
  53 %%
  54 exp: foo { $$; } foo { $2; } foo
  55    | foo
  56    | /* Empty. */
  57    ;
  58 ]])
  59
  60 AT_BISON_CHECK([input.y], [1], [],
  61 [[input.y:5.12-13: $$ for the midrule at $2 of 'exp' has no declared type
  62 input.y:5.24-25: $2 of 'exp' has no declared type
  63 input.y:5.6-32: warning: type clash on default action: <bar> != <>
  64 input.y:6.6-8: warning: type clash on default action: <bar> != <>
  65 input.y:7.5: warning: empty rule for typed nonterminal, and no action
  66 ]])
  67
  68 AT_CLEANUP
  69
  70
  71 # _AT_UNUSED_VALUES_DECLARATIONS()
  72 # --------------------------------
  73 # Generate the token, type, and destructor
  74 # declarations for the unused values tests.
  75
  76 m4_define([_AT_UNUSED_VALUES_DECLARATIONS],
  77 [[[%token <integer> INT;
  78 %type <integer> a b c d e f g h i j k l;
  79 %destructor { destroy ($$); } INT a b c d e f g h i j k l;]]])
  80
  81
  82 # AT_CHECK_UNUSED_VALUES(DECLARATIONS_AFTER, CHECK_MIDRULE_VALUES)
  83 # ------------------------------------------------------------------
  84 # Generate a grammar to test unused values,
  85 # compile it, run it.  If DECLARATIONS_AFTER
  86 # is set, then the token, type, and destructor
  87 # declarations are generated after the rules
  88 # rather than before.  If CHECK_MIDRULE_VALUES
  89 # is set, then --warnings=midrule-values is
  90 # set.
  91
  92 m4_define([AT_CHECK_UNUSED_VALUES],
  93 [AT_DATA([input.y],
  94 m4_ifval($1, [
  95
  96
  97 ], [_AT_UNUSED_VALUES_DECLARATIONS
  98 ])[[%%
  99 start:
 100   'a' a { $]2[; } | 'b' b { $]2[; } | 'c' c { $]2[; } | 'd' d { $]2[; }
 101 | 'e' e { $]2[; } | 'f' f { $]2[; } | 'g' g { $]2[; } | 'h' h { $]2[; }
 102 | 'i' i { $]2[; } | 'j' j { $]2[; } | 'k' k { $]2[; } | 'l' l { $]2[; }
 103 ;
 104
 105 a: INT | INT { } INT { } INT { };
 106 b: INT | /* empty */;
 107 c: INT | INT { $]1[; } INT { $<integer>2; } INT { $<integer>4; };
 108 d: INT | INT { } INT { $]1[; } INT { $<integer>2; };
 109 e: INT | INT { } INT {  } INT { $]1[; };
 110 f: INT | INT { } INT {  } INT { $]$[ = $]1[ + $]3[ + $]5[; };
 111 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 112 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 113 i: INT | INT INT { } { $]$[ = $]1[ + $]2[; };
 114 j: INT | INT INT { $<integer>$ = 1; } { $]$[ = $]1[ + $]2[; };
 115 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 116 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; };]]m4_ifval($1, [
 117 _AT_UNUSED_VALUES_DECLARATIONS])
 118 )
 119
 120 AT_BISON_CHECK(m4_ifval($2, [ --warnings=midrule-values ])[ input.y], [0], [],
 121 [[input.y:11.10-32: warning: unset value: $]$[
 122 input.y:11.10-32: warning: unused value: $]1[
 123 input.y:11.10-32: warning: unused value: $]3[
 124 input.y:11.10-32: warning: unused value: $]5[
 125 input.y:12.9: warning: empty rule for typed nonterminal, and no action
 126 ]]m4_ifval($2, [[[input.y:13.14-20: warning: unset value: $$
 127 input.y:13.26-41: warning: unset value: $$
 128 ]]])[[input.y:13.10-62: warning: unset value: $]$[
 129 input.y:13.10-62: warning: unused value: $]3[
 130 input.y:13.10-62: warning: unused value: $]5[
 131 ]]m4_ifval($2, [[[input.y:14.14-16: warning: unset value: $$
 132 ]]])[[input.y:14.10-49: warning: unset value: $]$[
 133 input.y:14.10-49: warning: unused value: $]3[
 134 input.y:14.10-49: warning: unused value: $]5[
 135 input.y:15.10-37: warning: unset value: $]$[
 136 input.y:15.10-37: warning: unused value: $]3[
 137 input.y:15.10-37: warning: unused value: $]5[
 138 input.y:17.10-58: warning: unset value: $]$[
 139 input.y:17.10-58: warning: unused value: $]1[
 140 ]]m4_ifval($2, [[[input.y:17.10-58: warning: unused value: $]2[
 141 ]]])[[input.y:17.10-58: warning: unused value: $]3[
 142 ]]m4_ifval($2, [[[input.y:17.10-58: warning: unused value: $]4[
 143 ]]])[[input.y:17.10-58: warning: unused value: $]5[
 144 input.y:18.10-72: warning: unset value: $]$[
 145 input.y:18.10-72: warning: unused value: $]1[
 146 input.y:18.10-72: warning: unused value: $]3[
 147 ]]m4_ifval($2, [[[input.y:18.10-72: warning: unused value: $]4[
 148 ]]])[[input.y:18.10-72: warning: unused value: $]5[
 149 ]]m4_ifval($2, [[[input.y:20.10-55: warning: unused value: $]3[
 150 ]]])[[input.y:21.10-68: warning: unset value: $]$[
 151 input.y:21.10-68: warning: unused value: $]1[
 152 input.y:21.10-68: warning: unused value: $]2[
 153 ]]m4_ifval($2, [[[input.y:21.10-68: warning: unused value: $]4[
 154 ]]]))])
 155
 156
 157 ## --------------- ##
 158 ## Unused values.  ##
 159 ## --------------- ##
 160
 161 AT_SETUP([Unused values])
 162 AT_CHECK_UNUSED_VALUES
 163 AT_CHECK_UNUSED_VALUES(, [1])
 164 AT_CLEANUP
 165
 166
 167 ## ------------------------------------------ ##
 168 ## Unused values before symbol declarations.  ##
 169 ## ------------------------------------------ ##
 170
 171 AT_SETUP([Unused values before symbol declarations])
 172 AT_CHECK_UNUSED_VALUES([1])
 173 AT_CHECK_UNUSED_VALUES([1], [1])
 174 AT_CLEANUP
 175
 176
 177 ## --------------------------------------------- ##
 178 ## Default %printer and %destructor redeclared.  ##
 179 ## --------------------------------------------- ##
 180
 181 AT_SETUP([Default %printer and %destructor redeclared])
 182
 183 AT_DATA([[input.y]],
 184 [[%destructor { destroy ($$); } <*> <*>
 185 %printer { print ($$); } <*> <*>
 186
 187 %destructor { destroy ($$); } <*>
 188 %printer { print ($$); } <*>
 189
 190 %destructor { destroy ($$); } <> <>
 191 %printer { print ($$); } <> <>
 192
 193 %destructor { destroy ($$); } <>
 194 %printer { print ($$); } <>
 195
 196 %%
 197
 198 start: ;
 199
 200 %destructor { destroy ($$); } <*>;
 201 %printer { print ($$); } <*>;
 202
 203 %destructor { destroy ($$); } <>;
 204 %printer { print ($$); } <>;
 205 ]])
 206
 207 AT_BISON_CHECK([input.y], [1], [],
 208 [[input.y:1.13-29: redeclaration for default tagged %destructor
 209 input.y:1.13-29: previous declaration
 210 input.y:2.10-24: redeclaration for default tagged %printer
 211 input.y:2.10-24: previous declaration
 212 input.y:4.13-29: redeclaration for default tagged %destructor
 213 input.y:1.13-29: previous declaration
 214 input.y:5.10-24: redeclaration for default tagged %printer
 215 input.y:2.10-24: previous declaration
 216 input.y:7.13-29: redeclaration for default tagless %destructor
 217 input.y:7.13-29: previous declaration
 218 input.y:8.10-24: redeclaration for default tagless %printer
 219 input.y:8.10-24: previous declaration
 220 input.y:10.13-29: redeclaration for default tagless %destructor
 221 input.y:7.13-29: previous declaration
 222 input.y:11.10-24: redeclaration for default tagless %printer
 223 input.y:8.10-24: previous declaration
 224 input.y:17.13-29: redeclaration for default tagged %destructor
 225 input.y:4.13-29: previous declaration
 226 input.y:18.10-24: redeclaration for default tagged %printer
 227 input.y:5.10-24: previous declaration
 228 input.y:20.13-29: redeclaration for default tagless %destructor
 229 input.y:10.13-29: previous declaration
 230 input.y:21.10-24: redeclaration for default tagless %printer
 231 input.y:11.10-24: previous declaration
 232 ]])
 233
 234 AT_CLEANUP
 235
 236
 237 ## ---------------------------------------------- ##
 238 ## Per-type %printer and %destructor redeclared.  ##
 239 ## ---------------------------------------------- ##
 240
 241 AT_SETUP([Per-type %printer and %destructor redeclared])
 242
 243 AT_DATA([[input.y]],
 244 [[%destructor { destroy ($$); } <field1> <field2>
 245 %printer { print ($$); } <field1> <field2>
 246
 247 %destructor { destroy ($$); } <field1> <field1>
 248 %printer { print ($$); } <field2> <field2>
 249
 250 %%
 251
 252 start: ;
 253
 254 %destructor { destroy ($$); } <field2> <field1>;
 255 %printer { print ($$); } <field2> <field1>;
 256 ]])
 257
 258 AT_BISON_CHECK([input.y], [1], [],
 259 [[input.y:4.13-29: %destructor redeclaration for <field1>
 260 input.y:1.13-29: previous declaration
 261 input.y:4.13-29: %destructor redeclaration for <field1>
 262 input.y:4.13-29: previous declaration
 263 input.y:5.10-24: %printer redeclaration for <field2>
 264 input.y:2.10-24: previous declaration
 265 input.y:5.10-24: %printer redeclaration for <field2>
 266 input.y:5.10-24: previous declaration
 267 input.y:11.13-29: %destructor redeclaration for <field1>
 268 input.y:4.13-29: previous declaration
 269 input.y:11.13-29: %destructor redeclaration for <field2>
 270 input.y:1.13-29: previous declaration
 271 input.y:12.10-24: %printer redeclaration for <field1>
 272 input.y:2.10-24: previous declaration
 273 input.y:12.10-24: %printer redeclaration for <field2>
 274 input.y:5.10-24: previous declaration
 275 ]])
 276
 277 AT_CLEANUP
 278
 279
 280 ## ---------------------------------------- ##
 281 ## Unused values with default %destructor.  ##
 282 ## ---------------------------------------- ##
 283
 284 AT_SETUP([Unused values with default %destructor])
 285
 286 AT_DATA([[input.y]],
 287 [[%destructor { destroy ($$); } <>
 288 %type <tag> tagged
 289
 290 %%
 291
 292 start: end end tagged tagged { $<tag>1; $3; } ;
 293 end: { } ;
 294 tagged: { } ;
 295 ]])
 296
 297 AT_BISON_CHECK([input.y], [0], [],
 298 [[input.y:6.8-45: warning: unset value: $$
 299 input.y:6.8-45: warning: unused value: $2
 300 input.y:7.6-8: warning: unset value: $$
 301 ]])
 302
 303 AT_DATA([[input.y]],
 304 [[%destructor { destroy ($$); } <*>
 305 %type <tag> tagged
 306
 307 %%
 308
 309 start: end end tagged tagged { $<tag>1; $3; } ;
 310 end: { } ;
 311 tagged: { } ;
 312 ]])
 313
 314 AT_BISON_CHECK([input.y], [0], [],
 315 [[input.y:6.8-45: warning: unused value: $4
 316 input.y:8.9-11: warning: unset value: $$
 317 ]])
 318
 319 AT_CLEANUP
 320
 321
 322 ## ----------------------------------------- ##
 323 ## Unused values with per-type %destructor.  ##
 324 ## ----------------------------------------- ##
 325
 326 AT_SETUP([Unused values with per-type %destructor])
 327
 328 AT_DATA([[input.y]],
 329 [[%destructor { destroy ($$); } <field1>
 330 %type <field1> start end
 331
 332 %%
 333
 334 start: end end { $1; } ;
 335 end: { }  ;
 336 ]])
 337
 338 AT_BISON_CHECK([input.y], [0], [],
 339 [[input.y:6.8-22: warning: unset value: $$
 340 input.y:6.8-22: warning: unused value: $2
 341 input.y:7.6-8: warning: unset value: $$
 342 ]])
 343
 344 AT_CLEANUP
 345
 346
 347 ## ---------------------- ##
 348 ## Incompatible Aliases.  ##
 349 ## ---------------------- ##
 350
 351 AT_SETUP([Incompatible Aliases])
 352
 353 AT_DATA([input.y],
 354 [[%token foo "foo"
 355
 356 %type <bar>       foo
 357 %printer {bar}    foo
 358 %destructor {bar} foo
 359 %left             foo
 360
 361 %type <baz>       "foo"
 362 %printer {baz}    "foo"
 363 %destructor {baz} "foo"
 364 %left             "foo"
 365
 366 %%
 367 exp: foo;
 368 ]])
 369
 370 AT_BISON_CHECK([input.y], [1], [],
 371 [[input.y:8.7-11: %type redeclaration for foo
 372 input.y:3.7-11: previous declaration
 373 input.y:10.13-17: %destructor redeclaration for foo
 374 input.y:5.13-17: previous declaration
 375 input.y:9.10-14: %printer redeclaration for foo
 376 input.y:4.10-14: previous declaration
 377 input.y:11.1-5: %left redeclaration for foo
 378 input.y:6.1-5: previous declaration
 379 ]])
 380
 381 AT_CLEANUP
 382
 383
 384
 385 ## ----------------------- ##
 386 ## Torturing the Scanner.  ##
 387 ## ----------------------- ##
 388
 389 # Be sure to compile and run, so that the C compiler checks what
 390 # we do.
 391
 392 AT_SETUP([Torturing the Scanner])
 393
 394 AT_BISON_OPTION_PUSHDEFS
 395 AT_DATA([input.y], [])
 396 AT_BISON_CHECK([input.y], [1], [],
 397 [[input.y:1.1: syntax error, unexpected end of file
 398 ]])
 399
 400
 401 AT_DATA([input.y],
 402 [{}
 403 ])
 404 AT_BISON_CHECK([input.y], [1], [],
 405 [[input.y:1.1-2: syntax error, unexpected {...}
 406 ]])
 407
 408
 409 AT_DATA_GRAMMAR([input.y],
 410 [[%{
 411 /* This is seen in GCC: a %{ and %} in middle of a comment. */
 412 const char *foo = "So %{ and %} can be here too.";
 413
 414 #if 0
 415 /* These examples test Bison while not stressing C compilers too much.
 416    Many C compilers mishandle backslash-newlines, so this part of the
 417    test is inside "#if 0".  The comment and string are written so that
 418    the "#endif" will be seen regardless of the C compiler bugs that we
 419    know about, namely:
 420
 421      HP C (as of late 2002) mishandles *\[newline]\[newline]/ within a
 422      comment.
 423
 424      The Apple Darwin compiler (as of late 2002) mishandles
 425      \\[newline]' within a character constant.
 426
 427    */
 428
 429 /\
 430 * A comment with backslash-newlines in it. %} *\
 431 \
 432 /
 433 /* { Close the above comment, if the C compiler mishandled it.  */
 434
 435 char str[] = "\\
 436 " A string with backslash-newlines in it %{ %} \\
 437 \
 438 "";
 439
 440 char apostrophe = '\'';
 441 #endif
 442
 443 #include <stdio.h>
 444 #include <stdlib.h>
 445 #include <assert.h>
 446 %}
 447 /* %{ and %} can be here too. */
 448
 449 %{
 450 /* Exercise pre-prologue dependency to %union.  */
 451 typedef int value;
 452 %}
 453
 454 /* Exercise M4 quoting: '@:>@@:>@', 0.  */
 455
 456 /* Also exercise %union. */
 457 %union
 458 {
 459   value ival; /* A comment to exercise an old bug. */
 460 };
 461
 462
 463 /* Exercise post-prologue dependency to %union.  */
 464 %{
 465 static YYSTYPE value_as_yystype (value val);
 466
 467 /* Exercise quotes in declarations.  */
 468 char quote[] = "@:>@@:>@,";
 469 %}
 470
 471 %{
 472 ]AT_YYERROR_DECLARE[
 473 ]AT_YYLEX_DECLARE[
 474 %}
 475
 476 %type <ival> '@<:@'
 477
 478 /* Exercise quotes in strings.  */
 479 %token FAKE "fake @<:@@:>@ \a\b\f\n\r\t\v\"\'\?\\\u005B\U0000005c ??!??'??(??)??-??/??<??=??> \x1\1"
 480
 481 %%
 482 /* Exercise M4 quoting: '@:>@@:>@', @<:@, 1.  */
 483 exp: '@<:@' '\1' two '$' '@' '{' oline output.or.oline.opt
 484   {
 485     /* Exercise quotes in braces.  */
 486     char tmp[] = "@<:@%c@:>@,\n";
 487     printf (tmp, $1);
 488   }
 489 ;
 490
 491 two: '\x000000000000000000000000000000000000000000000000000000000000000000002';
 492 oline: '@' 'o' 'l' 'i' 'n' 'e' '@' '_' '_' 'o' 'l' 'i' 'n' 'e' '_' '_';
 493 output.or.oline.opt: ;|oline;;|output;;;
 494 output: '#' 'o' 'u' 't' 'p' 'u' 't' ' ';
 495 %%
 496 /* Exercise M4 quoting: '@:>@@:>@', @<:@, 2.  */
 497
 498 static YYSTYPE
 499 value_as_yystype (value val)
 500 {
 501   YYSTYPE res;
 502   res.ival = val;
 503   return res;
 504 }
 505 ]AT_YYERROR_DEFINE[
 506 static int
 507 yylex (void)
 508 {
 509   static char const input[] = "@<:@\1\2$@{@oline@__@&t@oline__\
 510 #output "; /* "
 511   */
 512   static size_t toknum;
 513   assert (toknum < sizeof input);
 514   yylval = value_as_yystype (input[toknum]);
 515   return input[toknum++];
 516 }
 517 ]])
 518
 519 # Pacify Emacs' font-lock-mode: "
 520
 521 AT_DATA([main.c],
 522 [[typedef int value;
 523 #include "input.h"
 524
 525 int yyparse (void);
 526
 527 int
 528 main (void)
 529 {
 530   return yyparse ();
 531 }
 532 ]])
 533 AT_BISON_OPTION_POPDEFS
 534
 535 AT_BISON_CHECK([-d -v -o input.c input.y])
 536 AT_COMPILE([input.o])
 537 AT_COMPILE([main.o])
 538 AT_COMPILE([input], [input.o main.o])
 539 AT_PARSER_CHECK([./input], 0,
 540 [[[@<:@],
 541 ]])
 542
 543 AT_CLEANUP
 544
 545
 546 ## ---------------------- ##
 547 ## Typed symbol aliases.  ##
 548 ## ---------------------- ##
 549
 550 AT_SETUP([Typed symbol aliases])
 551
 552 # Bison 2.0 broke typed symbol aliases - ensure they work.
 553
 554 AT_DATA_GRAMMAR([input.y],
 555 [[%union
 556 {
 557   int val;
 558 };
 559 %token <val> MY_TOKEN "MY TOKEN"
 560 %type <val> exp
 561 %%
 562 exp: "MY TOKEN";
 563 %%
 564 ]])
 565
 566 AT_BISON_CHECK([-o input.c input.y])
 567
 568 AT_CLEANUP
 569
 570
 571 ## --------- ##
 572 ## Require.  ##
 573 ## --------- ##
 574
 575 m4_define([AT_CHECK_REQUIRE],
 576 [AT_SETUP([Require $1])
 577 AT_DATA_GRAMMAR([input.y],
 578 [[%require "$1";
 579 %%
 580 empty_file:;
 581 ]])
 582 AT_BISON_CHECK([-o input.c input.y], $2, [], ignore)
 583 AT_CLEANUP
 584 ])
 585
 586 AT_CHECK_REQUIRE(1.0, 0)
 587 AT_CHECK_REQUIRE(AT_PACKAGE_VERSION, 0)
 588 ## FIXME: Some day augment this version number.
 589 AT_CHECK_REQUIRE(100.0, 63)
 590
 591
 592 ## ------------------------------------- ##
 593 ## String aliases for character tokens.  ##
 594 ## ------------------------------------- ##
 595
 596 AT_SETUP([String aliases for character tokens])
 597
 598 # Bison once thought a character token and its alias were different symbols
 599 # with the same user token number.
 600
 601 AT_DATA_GRAMMAR([input.y],
 602 [[%token 'a' "a"
 603 %%
 604 start: 'a';
 605 %%
 606 ]])
 607
 608 AT_BISON_CHECK([-o input.c input.y])
 609
 610 AT_CLEANUP
 611
 612
 613 ## -------------- ##
 614 ## Symbol names.  ##
 615 ## -------------- ##
 616
 617 AT_SETUP([Symbols])
 618
 619 AT_BISON_OPTION_PUSHDEFS
 620 AT_DATA_GRAMMAR([input.y],
 621 [[%token WITH-DASH
 622 %token WITHOUT_DASH "WITHOUT-DASH"
 623 %token WITH.PERIOD
 624 %token WITHOUT_PERIOD "WITHOUT.PERIOD"
 625 %code {
 626   ]AT_YYERROR_DECLARE[
 627   ]AT_YYLEX_DECLARE[
 628 }
 629 %%
 630 start: with-dash without_dash with.period without_period;
 631 with-dash: WITH-DASH;
 632 without_dash: "WITHOUT-DASH";
 633 with.period: WITH.PERIOD;
 634 without_period: "WITHOUT.PERIOD";
 635 %%
 636 ]AT_YYERROR_DEFINE[
 637 ]AT_YYLEX_DEFINE[
 638 ]])
 639 AT_BISON_OPTION_POPDEFS
 640
 641 # POSIX Yacc accept periods, but not dashes.
 642 AT_BISON_CHECK([--yacc input.y], [1], [],
 643 [[input.y:9.8-16: POSIX Yacc forbids dashes in symbol names: WITH-DASH
 644 input.y:18.8-16: POSIX Yacc forbids dashes in symbol names: with-dash
 645 ]])
 646
 647 # So warn about them.
 648 AT_BISON_CHECK([-Wyacc input.y], [], [],
 649 [[input.y:9.8-16: warning: POSIX Yacc forbids dashes in symbol names: WITH-DASH
 650 input.y:18.8-16: warning: POSIX Yacc forbids dashes in symbol names: with-dash
 651 ]])
 652
 653 # Dashes are fine for GNU Bison.
 654 AT_BISON_CHECK([-o input.c input.y])
 655
 656 # Make sure we don't export silly token identifiers with periods or dashes.
 657 AT_COMPILE([input.o])
 658
 659
 660 # Periods are genuine letters, they can start identifiers.
 661 # Digits and dashes cannot.
 662 AT_DATA_GRAMMAR([input.y],
 663 [[%token .GOOD
 664          -GOOD
 665          1NV4L1D
 666          -123
 667 %%
 668 start: .GOOD GOOD
 669 ]])
 670 AT_BISON_CHECK([-o input.c input.y], [1], [],
 671 [[input.y:10.10: invalid character: '-'
 672 input.y:11.10-16: invalid identifier: '1NV4L1D'
 673 input.y:12.10: invalid character: '-'
 674 ]])
 675
 676 AT_CLEANUP
 677
 678
 679 ## ----------------- ##
 680 ## Numbered tokens.  ##
 681 ## ----------------- ##
 682
 683 AT_SETUP([Numbered tokens])
 684
 685 AT_DATA_GRAMMAR([redecl.y],
 686 [[%token DECIMAL_1     11259375
 687          HEXADECIMAL_1 0xabcdef
 688          HEXADECIMAL_2 0xFEDCBA
 689          DECIMAL_2     16702650
 690 %%
 691 start: DECIMAL_1 HEXADECIMAL_2;
 692 ]])
 693
 694 AT_BISON_CHECK([redecl.y], [1], [],
 695 [[redecl.y:10.10-22: user token number 11259375 redeclaration for HEXADECIMAL_1
 696 redecl.y:9.8-16: previous declaration for DECIMAL_1
 697 redecl.y:12.10-18: user token number 16702650 redeclaration for DECIMAL_2
 698 redecl.y:11.10-22: previous declaration for HEXADECIMAL_2
 699 ]])
 700
 701 AT_DATA_GRAMMAR([too-large.y],
 702 [[%token TOO_LARGE_DEC 999999999999999999999
 703          TOO_LARGE_HEX 0xFFFFFFFFFFFFFFFFFFF
 704 %%
 705 start: TOO_LARGE_DEC TOO_LARGE_HEX
 706 %%
 707 ]])
 708
 709 AT_BISON_CHECK([too-large.y], [1], [],
 710 [[too-large.y:9.22-42: integer out of range: '999999999999999999999'
 711 too-large.y:10.24-44: integer out of range: '0xFFFFFFFFFFFFFFFFFFF'
 712 ]])
 713
 714 AT_CLEANUP
 715
 716
 717 ## --------------------- ##
 718 ## Unclosed constructs.  ##
 719 ## --------------------- ##
 720
 721 AT_SETUP([Unclosed constructs])
 722
 723 # Bison's scan-gram.l once forgot to STRING_FINISH some unclosed constructs, so
 724 # they were prepended to whatever it STRING_GROW'ed next.  It also threw them
 725 # away rather than returning them to the parser.  The effect was confusing
 726 # subsequent error messages.
 727
 728 AT_DATA([input.y],
 729 [[%token A "a
 730 %token B "b"
 731 %token AB "ab" // Used to complain that "ab" was already used.
 732 %token C '1
 733 %token TWO "2"
 734 %token TICK_TWELVE "'12" // Used to complain that "'12" was already used.
 735
 736 %%
 737
 738 start: ;
 739
 740 // Used to report a syntax error because it didn't see any kind of symbol
 741 // identifier.
 742 %type <f> 'a
 743 ;
 744 %type <f> "a
 745 ;
 746 // Used to report a syntax error because it didn't see braced code.
 747 %destructor { free ($$)
 748 ]])
 749
 750 AT_BISON_CHECK([-o input.c input.y], 1, [],
 751 [[input.y:1.10-2.0: missing '"' at end of line
 752 input.y:4.10-5.0: missing "'" at end of line
 753 input.y:14.11-15.0: missing "'" at end of line
 754 input.y:16.11-17.0: missing '"' at end of line
 755 input.y:19.13-20.0: missing '}' at end of file
 756 input.y:20.1: syntax error, unexpected end of file
 757 ]])
 758
 759 AT_CLEANUP
 760
 761
 762 ## ------------------------- ##
 763 ## %start after first rule.  ##
 764 ## ------------------------- ##
 765
 766 AT_SETUP([%start after first rule])
 767
 768 # Bison once complained that a %start after the first rule was a redeclaration
 769 # of the start symbol.
 770
 771 AT_DATA([input.y],
 772 [[%%
 773 false_start: ;
 774 start: false_start ;
 775 %start start;
 776 ]])
 777
 778 AT_BISON_CHECK([-o input.c input.y])
 779
 780 AT_CLEANUP
 781
 782
 783 ## --------------------- ##
 784 ## %prec takes a token.  ##
 785 ## --------------------- ##
 786
 787 AT_SETUP([%prec takes a token])
 788
 789 # Bison once allowed %prec sym where sym was a nonterminal.
 790
 791 AT_DATA([input.y],
 792 [[%%
 793 start: PREC %prec PREC ;
 794 PREC: ;
 795 ]])
 796
 797 AT_BISON_CHECK([input.y], [1], [],
 798 [[input.y:3.1-4: rule given for PREC, which is a token
 799 ]])
 800
 801 AT_CLEANUP
 802
 803
 804 ## ------------------------------- ##
 805 ## %prec's token must be defined.  ##
 806 ## ------------------------------- ##
 807
 808 AT_SETUP([[%prec's token must be defined]])
 809
 810 # According to POSIX, a %prec token must be defined separately.
 811
 812 AT_DATA([[input.y]],
 813 [[%%
 814 start: %prec PREC ;
 815 ]])
 816
 817 AT_BISON_CHECK([[input.y]], [[0]], [],
 818 [[input.y:2.8-17: warning: token for %prec is not defined: PREC
 819 ]])
 820
 821 AT_CLEANUP
 822
 823
 824 ## -------------------------------- ##
 825 ## Reject unused %code qualifiers.  ##
 826 ## -------------------------------- ##
 827
 828 AT_SETUP([Reject unused %code qualifiers])
 829
 830 AT_DATA([input-c.y],
 831 [[%code q {}
 832 %code bad {}
 833 %code bad {}
 834 %code format {}
 835 %%
 836 start: ;
 837 ]])
 838 AT_BISON_CHECK([[input-c.y]], [[1]], [],
 839 [[input-c.y:1.7: %code qualifier 'q' is not used
 840 input-c.y:2.7-9: %code qualifier 'bad' is not used
 841 input-c.y:3.7-9: %code qualifier 'bad' is not used
 842 input-c.y:4.7-12: %code qualifier 'format' is not used
 843 ]])
 844
 845 AT_DATA([input-c-glr.y],
 846 [[%code q {}
 847 %code bad {}
 848  %code bad {}
 849 %%
 850 start: ;
 851 ]])
 852 AT_BISON_CHECK([[input-c-glr.y]], [[1]], [],
 853 [[input-c-glr.y:1.7: %code qualifier 'q' is not used
 854 input-c-glr.y:2.7-9: %code qualifier 'bad' is not used
 855 input-c-glr.y:3.8-10: %code qualifier 'bad' is not used
 856 ]])
 857
 858 AT_DATA([input-c++.y],
 859 [[%code q {}
 860 %code bad {}
 861  %code q {}
 862 %%
 863 start: ;
 864 ]])
 865 AT_BISON_CHECK([[input-c++.y]], [[1]], [],
 866 [[input-c++.y:1.7: %code qualifier 'q' is not used
 867 input-c++.y:2.7-9: %code qualifier 'bad' is not used
 868 input-c++.y:3.8: %code qualifier 'q' is not used
 869 ]])
 870
 871 AT_DATA([input-c++-glr.y],
 872 [[%code bad {}
 873 %code q {}
 874 %code q {}
 875 %%
 876 start: ;
 877 ]])
 878 AT_BISON_CHECK([[input-c++-glr.y]], [[1]], [],
 879 [[input-c++-glr.y:1.7-9: %code qualifier 'bad' is not used
 880 input-c++-glr.y:2.7: %code qualifier 'q' is not used
 881 input-c++-glr.y:3.7: %code qualifier 'q' is not used
 882 ]])
 883
 884 AT_DATA([special-char-@@.y],
 885 [[%code bad {}
 886 %code q {}
 887 %code q {}
 888 %%
 889 start: ;
 890 ]])
 891 AT_BISON_CHECK([[special-char-@@.y]], [[1]], [],
 892 [[special-char-@@.y:1.7-9: %code qualifier 'bad' is not used
 893 special-char-@@.y:2.7: %code qualifier 'q' is not used
 894 special-char-@@.y:3.7: %code qualifier 'q' is not used
 895 ]])
 896
 897 AT_DATA([special-char-@:>@.y],
 898 [[%code bad {}
 899 %code q {}
 900 %code q {}
 901 %%
 902 start: ;
 903 ]])
 904 AT_BISON_CHECK([[special-char-@:>@.y]], [[1]], [],
 905 [[special-char-@:>@.y:1.7-9: %code qualifier 'bad' is not used
 906 special-char-@:>@.y:2.7: %code qualifier 'q' is not used
 907 special-char-@:>@.y:3.7: %code qualifier 'q' is not used
 908 ]])
 909
 910 AT_CLEANUP
 911
 912
 913 ## ---------------- ##
 914 ## %define errors.  ##
 915 ## ---------------- ##
 916
 917 AT_SETUP([%define errors])
 918
 919 AT_DATA([input-redefined.y],
 920 [[%define var "value1"
 921 %define var "value1"
 922  %define var "value2"
 923 %define special1 "@:>@"
 924 %define special2 "@<:@"
 925 %%
 926 start: ;
 927 ]])
 928
 929 AT_BISON_CHECK([[input-redefined.y]], [[1]], [],
 930 [[input-redefined.y:2.9-11: %define variable 'var' redefined
 931 input-redefined.y:1.9-11: previous definition
 932 input-redefined.y:3.10-12: %define variable 'var' redefined
 933 input-redefined.y:2.9-11: previous definition
 934 ]])
 935
 936 AT_DATA([input-unused.y],
 937 [[%define var "value"
 938 %%
 939 start: ;
 940 ]])
 941
 942 AT_BISON_CHECK([[input-unused.y]], [[1]], [],
 943 [[input-unused.y:1.9-11: %define variable 'var' is not used
 944 ]])
 945
 946 AT_CLEANUP
 947
 948
 949 ## ----------------------------------- ##
 950 ## %define, --define, --force-define.  ##
 951 ## ----------------------------------- ##
 952
 953 AT_SETUP([[%define, --define, --force-define]])
 954
 955 AT_DATA([[skel.c]],
 956 [[m4@&t@_divert_push(0)@
 957 @output(b4_parser_file_name@)@
 958 [var-dd: ]b4_percent_define_get([[var-dd]])[
 959 var-ff: ]b4_percent_define_get([[var-ff]])[
 960 var-dfg: ]b4_percent_define_get([[var-dfg]])[
 961 var-fd: ]b4_percent_define_get([[var-fd]])
 962 m4@&t@_divert_pop(0)
 963 ]])
 964 AT_DATA([[input.y]],
 965 [[%define var-dfg "gram"
 966 %%
 967 start: ;
 968 ]])
 969 AT_BISON_CHECK([[-Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \
 970                  -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \
 971                  -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \
 972                  -Fvar-fd=cmd-f -Dvar-fd=cmd-d   \
 973                  --skeleton ./skel.c input.y]])
 974 AT_CHECK([[cat input.tab.c]], [[0]],
 975 [[var-dd: cmd-d2
 976 var-ff: cmd-f2
 977 var-dfg: cmd-f
 978 var-fd: cmd-d
 979 ]])
 980
 981 AT_DATA([[input-dg.y]],
 982 [[%define var "gram"
 983 %%
 984 start: ;
 985 ]])
 986 AT_BISON_CHECK([[-Dvar=cmd-d input-dg.y]], [[1]], [],
 987 [[input-dg.y:1.9-11: %define variable 'var' redefined
 988 <command line>:2: previous definition
 989 ]])
 990
 991 AT_DATA([[input-unused.y]],
 992 [[%%
 993 start: ;
 994 ]])
 995 AT_BISON_CHECK([[-Dunused-d -Funused-f input-unused.y]], [[1]], [],
 996 [[<command line>:2: %define variable 'unused-d' is not used
 997 <command line>:3: %define variable 'unused-f' is not used
 998 ]])
 999
1000 AT_CLEANUP
1001
1002 ## --------------------------- ##
1003 ## %define Boolean variables.  ##
1004 ## --------------------------- ##
1005
1006 AT_SETUP([[%define Boolean variables]])
1007
1008 AT_DATA([Input.y],
1009 [[%language "Java"
1010 %define public "maybe"
1011 %define parser_class_name "Input"
1012 %%
1013 start: ;
1014 ]])
1015
1016 AT_BISON_CHECK([[Input.y]], [1], [],
1017 [[Input.y:2.9-14: invalid value for %define Boolean variable 'public'
1018 ]])
1019
1020 AT_CLEANUP
1021
1022 ## ------------------------ ##
1023 ## %define enum variables.  ##
1024 ## ------------------------ ##
1025
1026 AT_SETUP([[%define enum variables]])
1027
1028 # Front-end.
1029 AT_DATA([[input.y]],
1030 [[%define lr.default-reductions bogus
1031 %%
1032 start: ;
1033 ]])
1034 AT_BISON_CHECK([[input.y]], [[1]], [[]],
1035 [[input.y:1.9-29: invalid value for %define variable 'lr.default-reductions': 'bogus'
1036 input.y:1.9-29: accepted value: 'most'
1037 input.y:1.9-29: accepted value: 'consistent'
1038 input.y:1.9-29: accepted value: 'accepting'
1039 ]])
1040
1041 # Back-end.
1042 AT_DATA([[input.y]],
1043 [[%define api.push-pull neither
1044 %%
1045 start: ;
1046 ]])
1047 AT_BISON_CHECK([[input.y]], [1], [],
1048 [[input.y:1.9-21: invalid value for %define variable 'api.push-pull': 'neither'
1049 input.y:1.9-21: accepted value: 'pull'
1050 input.y:1.9-21: accepted value: 'push'
1051 input.y:1.9-21: accepted value: 'both'
1052 ]])
1053
1054 AT_CLEANUP
1055
1056 ## -------------------------------- ##
1057 ## %define backward compatibility.  ##
1058 ## -------------------------------- ##
1059
1060 AT_SETUP([[%define backward compatibility]])
1061
1062 # The error messages tell us whether underscores in these variables are
1063 # being converted to dashes.
1064
1065 AT_DATA([[input.y]],
1066 [[%define api.push_pull "neither"
1067 %%
1068 start: ;
1069 ]])
1070 AT_BISON_CHECK([[input.y]], [1], [],
1071 [[input.y:1.9-21: invalid value for %define variable 'api.push-pull': 'neither'
1072 input.y:1.9-21: accepted value: 'pull'
1073 input.y:1.9-21: accepted value: 'push'
1074 input.y:1.9-21: accepted value: 'both'
1075 ]])
1076
1077 AT_DATA([[input.y]],
1078 [[%define lr.keep_unreachable_states maybe
1079 %%
1080 start: ;
1081 ]])
1082 AT_BISON_CHECK([[input.y]], [1], [],
1083 [[input.y:1.9-34: invalid value for %define Boolean variable 'lr.keep-unreachable-states'
1084 ]])
1085
1086 AT_DATA([[input.y]],
1087 [[%define foo_bar "baz"
1088 %%
1089 start: ;
1090 ]])
1091 AT_BISON_CHECK([[input.y]], [[1]], [],
1092 [[input.y:1.9-15: %define variable 'foo_bar' is not used
1093 ]])
1094
1095 AT_CLEANUP
1096
1097 ## ------------------------- ##
1098 ## Unused %define api.pure.  ##
1099 ## ------------------------- ##
1100
1101 AT_SETUP([[Unused %define api.pure]])
1102
1103 # AT_CHECK_API_PURE(DECLS, VALUE)
1104 # -------------------------------
1105 # Make sure Bison reports that `%define api.pure VALUE' is unused when DECLS
1106 # are specified.
1107 m4_define([AT_CHECK_API_PURE],
1108 [
1109 AT_DATA([[input.y]],
1110 [[%define api.pure ]$2[
1111 ]$1[
1112 %%
1113 start: ;
1114 ]])
1115
1116 AT_BISON_CHECK([[input.y]], [[1]], [],
1117 [[input.y:1.9-16: %define variable 'api.pure' is not used
1118 ]])
1119 ])
1120
1121 AT_CHECK_API_PURE([[%language "c++" %defines]], [[]])
1122 AT_CHECK_API_PURE([[%language "c++" %defines]], [[false]])
1123 AT_CHECK_API_PURE([[%language "c++" %defines %glr-parser]], [[""]])
1124 AT_CHECK_API_PURE([[%language "c++" %defines %glr-parser]], [[false]])
1125 AT_CHECK_API_PURE([[%language "java"]], [[true]])
1126 AT_CHECK_API_PURE([[%language "java"]], [[false]])
1127
1128 AT_CLEANUP
1129
1130 ## -------------------------------- ##
1131 ## C++ namespace reference errors.  ##
1132 ## -------------------------------- ##
1133
1134 AT_SETUP([[C++ namespace reference errors]])
1135
1136 # AT_CHECK_NAMESPACE_ERROR(NAMESPACE-DECL, ERROR, [ERROR], ...)
1137 # -------------------------------------------------------------
1138 # Make sure Bison reports all ERROR's for %define namespace "NAMESPACE-DECL".
1139 m4_define([AT_CHECK_NAMESPACE_ERROR],
1140 [
1141 AT_DATA([[input.y]],
1142 [[%language "C++"
1143 %defines
1144 %define namespace "]$1["
1145 %%
1146 start: ;
1147 ]])
1148
1149 AT_BISON_CHECK([[input.y]], [1], [],
1150 [m4_foreach([b4_arg], m4_dquote(m4_shift($@)),
1151 [[input.y:3.9-17: ]b4_arg[
1152 ]])])
1153 ])
1154
1155 AT_CHECK_NAMESPACE_ERROR([[]],
1156                          [[namespace reference is empty]])
1157 AT_CHECK_NAMESPACE_ERROR([[                             ]],
1158                          [[namespace reference is empty]])
1159 AT_CHECK_NAMESPACE_ERROR([[foo::::bar]],
1160                          [[namespace reference has consecutive "::"]])
1161 AT_CHECK_NAMESPACE_ERROR([[foo::        ::bar]],
1162                          [[namespace reference has consecutive "::"]])
1163 AT_CHECK_NAMESPACE_ERROR([[::::bar]],
1164                          [[namespace reference has consecutive "::"]])
1165 AT_CHECK_NAMESPACE_ERROR([[:: ::bar]],
1166                          [[namespace reference has consecutive "::"]])
1167 AT_CHECK_NAMESPACE_ERROR([[foo::bar::   ::]],
1168                          [[namespace reference has consecutive "::"]],
1169                          [[namespace reference has a trailing "::"]])
1170 AT_CHECK_NAMESPACE_ERROR([[foo::bar::]],
1171                          [[namespace reference has a trailing "::"]])
1172 AT_CHECK_NAMESPACE_ERROR([[foo::bar::   ]],
1173                          [[namespace reference has a trailing "::"]])
1174 AT_CHECK_NAMESPACE_ERROR([[::]],
1175                          [[namespace reference has a trailing "::"]])
1176
1177 AT_CLEANUP
1178
1179 ## ------------------------ ##
1180 ## Bad character literals.  ##
1181 ## ------------------------ ##
1182
1183 # Bison used to accept character literals that were empty or contained
1184 # too many characters.
1185
1186 # FIXME: AT_DATA or some variant of AT_DATA may eventually permit
1187 # the final newline to be omitted.  See the threads starting at
1188 # <http://lists.gnu.org/archive/html/bison-patches/2009-07/msg00019.html>.
1189
1190 AT_SETUP([[Bad character literals]])
1191
1192 AT_DATA([empty.y],
1193 [[%%
1194 start: '';
1195 start: '
1196 ]])
1197 AT_CHECK([[perl -e "print 'start: \'';" >> empty.y || exit 77]])
1198
1199 AT_BISON_CHECK([empty.y], [1], [],
1200 [[empty.y:2.8-9: warning: empty character literal
1201 empty.y:3.8-4.0: warning: empty character literal
1202 empty.y:3.8-4.0: missing "'" at end of line
1203 empty.y:4.8: warning: empty character literal
1204 empty.y:4.8: missing "'" at end of file
1205 ]])
1206
1207 AT_DATA([two.y],
1208 [[%%
1209 start: 'ab';
1210 start: 'ab
1211 ]])
1212 AT_CHECK([[perl -e "print 'start: \'ab';" >> two.y || exit 77]])
1213
1214 AT_BISON_CHECK([two.y], [1], [],
1215 [[two.y:2.8-11: warning: extra characters in character literal
1216 two.y:3.8-4.0: warning: extra characters in character literal
1217 two.y:3.8-4.0: missing "'" at end of line
1218 two.y:4.8-10: warning: extra characters in character literal
1219 two.y:4.8-10: missing "'" at end of file
1220 ]])
1221
1222 AT_DATA([three.y],
1223 [[%%
1224 start: 'abc';
1225 start: 'abc
1226 ]])
1227 AT_CHECK([[perl -e "print 'start: \'abc';" >> three.y || exit 77]])
1228
1229 AT_BISON_CHECK([three.y], [1], [],
1230 [[three.y:2.8-12: warning: extra characters in character literal
1231 three.y:3.8-4.0: warning: extra characters in character literal
1232 three.y:3.8-4.0: missing "'" at end of line
1233 three.y:4.8-11: warning: extra characters in character literal
1234 three.y:4.8-11: missing "'" at end of file
1235 ]])
1236
1237 AT_CLEANUP
1238
1239 ## ------------------------- ##
1240 ## Bad escapes in literals.  ##
1241 ## ------------------------- ##
1242
1243 AT_SETUP([[Bad escapes in literals]])
1244
1245 AT_DATA([input.y],
1246 [[%%
1247 start: '\777' '\0' '\xfff' '\x0'
1248        '\uffff' '\u0000' '\Uffffffff' '\U00000000'
1249        '\ ' '\A';
1250 ]])
1251
1252 # It is not easy to create special characters, we cannot even trust tr.
1253 # Beside we cannot even expect "echo '\0'" to output two characters
1254 # (well three with \n): at least Bash 3.2 converts the two-character
1255 # sequence "\0" into a single NUL character.
1256 AT_CHECK([[perl -e 'print "start: \"\\\t\\\f\\\0\\\1\" ;";' >> input.y \
1257            || exit 77]])
1258
1259 AT_BISON_CHECK([input.y], [1], [],
1260 [[input.y:2.9-12: invalid number after \-escape: 777
1261 input.y:2.8-13: warning: empty character literal
1262 input.y:2.16-17: invalid number after \-escape: 0
1263 input.y:2.15-18: warning: empty character literal
1264 input.y:2.21-25: invalid number after \-escape: xfff
1265 input.y:2.20-26: warning: empty character literal
1266 input.y:2.29-31: invalid number after \-escape: x0
1267 input.y:2.28-32: warning: empty character literal
1268 input.y:3.9-14: invalid number after \-escape: uffff
1269 input.y:3.8-15: warning: empty character literal
1270 input.y:3.18-23: invalid number after \-escape: u0000
1271 input.y:3.17-24: warning: empty character literal
1272 input.y:3.27-36: invalid number after \-escape: Uffffffff
1273 input.y:3.26-37: warning: empty character literal
1274 input.y:3.40-49: invalid number after \-escape: U00000000
1275 input.y:3.39-50: warning: empty character literal
1276 input.y:4.9-10: invalid character after \-escape: ' '
1277 input.y:4.8-11: warning: empty character literal
1278 input.y:4.14-15: invalid character after \-escape: A
1279 input.y:4.13-16: warning: empty character literal
1280 input.y:5.9-16: invalid character after \-escape: \t
1281 input.y:5.17: invalid character after \-escape: \f
1282 input.y:5.18: invalid character after \-escape: \0
1283 input.y:5.19: invalid character after \-escape: \001
1284 ]])
1285
1286 AT_CLEANUP
1287
1288 ## ------------------------- ##
1289 ## LAC: Errors for %define.  ##
1290 ## ------------------------- ##
1291
1292 AT_SETUP([[LAC: Errors for %define]])
1293
1294 AT_DATA([[input.y]],
1295 [[%%
1296 start: ;
1297 ]])
1298
1299 # parse.lac.* options are useless if LAC isn't actually activated.
1300 AT_BISON_CHECK([[-Dparse.lac.es-capacity-initial=1 input.y]],
1301                [[1]], [],
1302 [[<command line>:2: %define variable 'parse.lac.es-capacity-initial' is not used
1303 ]])
1304 AT_BISON_CHECK([[-Dparse.lac.memory-trace=full input.y]],
1305                [[1]], [],
1306 [[<command line>:2: %define variable 'parse.lac.memory-trace' is not used
1307 ]])
1308
1309 AT_CLEANUP
1310
1311 ## --------------------------------------------- ##
1312 ## -Werror is not affected by -Wnone and -Wall.  ##
1313 ## --------------------------------------------- ##
1314
1315 AT_SETUP([[-Werror is not affected by -Wnone and -Wall]])
1316
1317 AT_DATA([[input.y]],
1318 [[%%
1319 foo-bar: ;
1320 ]])
1321
1322 # -Werror is not enabled by -Wall or equivalent.
1323 AT_BISON_CHECK([[-Wall input.y]], [[0]], [[]],
1324 [[input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar
1325 ]])
1326 AT_BISON_CHECK([[-W input.y]], [[0]], [[]],
1327 [[input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar
1328 ]])
1329 AT_BISON_CHECK([[-Wno-none input.y]], [[0]], [[]],
1330 [[input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar
1331 ]])
1332
1333 # -Werror is not disabled by -Wnone or equivalent.
1334 AT_BISON_CHECK([[-Werror,none,yacc input.y]], [[1]], [[]], [[stderr]])
1335 AT_CHECK([[sed 's/^.*bison:/bison:/' stderr]], [[0]],
1336 [[bison: warnings being treated as errors
1337 input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar
1338 ]])
1339 [mv stderr experr]
1340 AT_BISON_CHECK([[-Werror,no-all,yacc input.y]], [[1]], [[]], [[experr]])
1341
1342 AT_CLEANUP
1343
1344
1345 ## ------------------------------------------------------ ##
1346 ## %name-prefix and %define api.prefix are incompatible.  ##
1347 ## ------------------------------------------------------ ##
1348
1349 AT_SETUP([[%name-prefix and %define api.prefix are incompatible]])
1350
1351 # AT_TEST(DIRECTIVES, OPTIONS, ERROR-LOCATION)
1352 # --------------------------------------------
1353 m4_pushdef([AT_TEST],
1354 [AT_DATA([[input.y]],
1355 [[$1
1356 %%
1357 exp:;
1358 ]])
1359 AT_BISON_CHECK([[$2 input.y]], [[1]], [[]],
1360 [[$3: '%name-prefix' and '%define api.prefix' cannot be used together
1361 ]])
1362 ])
1363
1364 AT_TEST([%define api.prefix foo %name-prefix "bar"], [], [input.y:1.9-18])
1365 AT_TEST([], [-Dapi.prefix=foo -p bar], [<command line>:2])
1366 AT_TEST([%name-prefix "bar"], [-Dapi.prefix=foo], [<command line>:2])
1367 AT_TEST([%define api.prefix foo], [-p bar], [input.y:1.9-18])
1368
1369 m4_popdef([AT_TEST])
1370
1371 AT_CLEANUP
1372
1373
1374 ## -------------- ##
1375 ## Stray $ or @.  ##
1376 ## -------------- ##
1377
1378 AT_SETUP([[Stray $ or @]])
1379
1380 AT_DATA_GRAMMAR([[input.y]],
1381 [[%token TOK
1382 %destructor     { $%; @%; } <*>;
1383 %initial-action { $%; @%; };
1384 %printer        { $%; @%; } <*>;
1385 %%
1386 exp: TOK        { $%; @%; };
1387 ]])
1388
1389 AT_BISON_CHECK([[input.y]], 0, [],
1390 [[input.y:10.19: warning: stray '$'
1391 input.y:10.23: warning: stray '@'
1392 input.y:11.19: warning: stray '$'
1393 input.y:11.23: warning: stray '@'
1394 input.y:12.19: warning: stray '$'
1395 input.y:12.23: warning: stray '@'
1396 input.y:14.19: warning: stray '$'
1397 input.y:14.23: warning: stray '@'
1398 ]])
1399
1400 AT_CLEANUP
1401
1402
1403
1404 ## ---------------- ##
1405 ## Code injection.  ##
1406 ## ---------------- ##
1407
1408
1409 AT_SETUP([[Code injection]])
1410
1411 m4_pattern_allow([^m4_errprintn$])
1412
1413 # AT_TEST([MACRO])
1414 # ----------------
1415 # Try to have MACRO be run by bison.
1416 m4_pushdef([AT_TEST],
1417 [AT_DATA([[input.y]],
1418 [[%type <$1(DEAD %type)> exp
1419 %token <$1(DEAD %token)> a
1420 %initial-action
1421 {
1422   $$;
1423   $<$1(DEAD %initial-action)>$
1424 };
1425 %printer
1426 {
1427   $$
1428   $<$1(DEAD %printer)>$
1429 } <> <*>;
1430 %lex-param
1431 {
1432   $1(DEAD %lex-param)
1433 };
1434 %parse-param
1435 {
1436   $1(DEAD %parse-param)
1437 };
1438 %%
1439 exp:
1440   a a[last]
1441   {
1442     $$;
1443     $][1;
1444     $<$1(DEAD action 1)>$
1445     $<$1(DEAD action 2)>1
1446     $<$1(DEAD action 3)>last
1447     $<$1(DEAD action 4)>0
1448     ;
1449   };
1450 ]])
1451
1452 # FIXME: Provide a means to iterate over all the skeletons.
1453 AT_BISON_CHECK([[-d               input.y]])
1454 AT_BISON_CHECK([[-d -S glr.c      input.y]])
1455 AT_BISON_CHECK([[-d -S lalr1.cc   input.y]])
1456 AT_BISON_CHECK([[-d -S glr.cc     input.y]])
1457 AT_BISON_CHECK([[   -S lalr1.java input.y]])
1458 ])
1459
1460 AT_TEST([m4_errprintn])
1461 AT_TEST([@:>@m4_errprintn])
1462
1463 m4_popdef([AT_TEST])
1464
1465 AT_CLEANUP