tests/input.at

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