tests/input.at

   1 # Checking the Bison reader.                    -*- Autotest -*-
   2
   3 # Copyright (C) 2002-2015, 2018-2020 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 number of arguments.  ##
  25 ## ----------------------------- ##
  26
  27 AT_SETUP([Invalid number of arguments])
  28
  29 AT_BISON_CHECK([], [1], [],
  30 [[bison: missing operand
  31 Try 'bison --help' for more information.
  32 ]])
  33
  34 AT_BISON_CHECK([1.y 2.y], [1], [],
  35 [[bison: extra operand '2.y'
  36 Try 'bison --help' for more information.
  37 ]])
  38
  39 # For some reason, on some systems we use the system's getopt, not the
  40 # one we ship in gnulib.  So we can get two different error messages.
  41 # See https://lists.gnu.org/archive/html/bison-patches/2018-10/msg00154.html
  42 AT_BISON_CHECK([--skeleton], [1], [], [stderr])
  43 AT_CHECK([[sed -e \
  44   "s/requires an argument -- skeleton/'--skeleton' requires an argument/" \
  45   stderr]], 0,
  46 [[bison: option '--skeleton' requires an argument
  47 Try 'bison --help' for more information.
  48 ]])
  49
  50 AT_CLEANUP
  51
  52
  53
  54 ## ----------------- ##
  55 ## Invalid options.  ##
  56 ## ----------------- ##
  57
  58 AT_SETUP([Invalid options])
  59
  60 AT_DATA([input.y],
  61 [[%%
  62 exp: '0'
  63 ]])
  64
  65 # We used to accept these, as -f, --report and others were sharing
  66 # their code with -W.
  67 AT_BISON_CHECK([-ferror=caret input.y], [1], [], [ignore])
  68 AT_BISON_CHECK([--report=error=itemsets input.y], [1], [], [ignore])
  69
  70 # We used to accept any character after "-Werror", instead of ensuring
  71 # this is "=".
  72 AT_BISON_CHECK([-Werror?all input.y], [1], [], [ignore])
  73
  74 AT_CLEANUP
  75
  76
  77 ## ---------------- ##
  78 ## Invalid inputs.  ##
  79 ## ---------------- ##
  80
  81 # The truly bad guys no human would write, but easily uncovered by
  82 # fuzzers.
  83 AT_SETUP([Invalid inputs])
  84
  85 AT_DATA([input.y],
  86 [[\000\001\002\377?
  87 "\000"
  88 %%
  89 ?
  90 default: 'a' }
  91 %&
  92 %a-does-not-exist
  93 %-
  94 %{
  95 ]])
  96 AT_PERL_REQUIRE([[-pi -e 's/\\(\d{3})/chr(oct($1))/ge' input.y]])
  97
  98 AT_BISON_CHECK([-fcaret input.y], [1], [], [stderr])
  99
 100 # Autotest's diffing, when there are NUL bytes, just reports "binary
 101 # files differ".  So don't leave NUL bytes.
 102 AT_PERL_CHECK([[-p -e 's{([\0\377])}{sprintf "\\x%02x", ord($1)}ge' stderr]], [],
 103 [[input.y:1.1-2: error: invalid characters: '\0\001\002\377?'
 104     1 | \x00\x01\x02\xff?
 105       | ^~
 106 input.y:2.2: error: invalid null character
 107     2 | "\x00"
 108       |  ^
 109 input.y:4.1: error: invalid character: '?'
 110     4 | ?
 111       | ^
 112 input.y:5.14: error: invalid character: '}'
 113     5 | default: 'a' }
 114       |              ^
 115 input.y:6.1: error: invalid character: '%'
 116     6 | %&
 117       | ^
 118 input.y:6.2: error: invalid character: '&'
 119     6 | %&
 120       |  ^
 121 input.y:7.1-17: error: invalid directive: '%a-does-not-exist'
 122     7 | %a-does-not-exist
 123       | ^~~~~~~~~~~~~~~~~
 124 input.y:8.1: error: invalid character: '%'
 125     8 | %-
 126       | ^
 127 input.y:8.2: error: invalid character: '-'
 128     8 | %-
 129       |  ^
 130 input.y:9.1-10.0: error: missing '%}' at end of file
 131     9 | %{
 132       | ^~
 133 ]])
 134
 135 AT_CLEANUP
 136
 137
 138 AT_SETUP([Invalid inputs with {}])
 139
 140 # We used to SEGV here.  See
 141 # http://lists.gnu.org/archive/html/bug-bison/2005-07/msg00053.html
 142
 143 AT_DATA([input.y],
 144 [[
 145 %destructor
 146 %initial-action
 147 %lex-param
 148 %parse-param
 149 %printer
 150 %union
 151 ]])
 152
 153 AT_BISON_CHECK([input.y], [1], [],
 154 [[input.y:3.1-15: error: expected {...} before %initial-action
 155 ]])
 156
 157 AT_CLEANUP
 158
 159
 160 ## -------------------------- ##
 161 ## Yacc warnings on symbols.  ##
 162 ## -------------------------- ##
 163
 164 AT_SETUP([Yacc warnings on symbols])
 165
 166 AT_DATA([input.y],
 167 [[%nterm exp
 168 %token NUM 0x40 "number"
 169 %%
 170 exp: "number";
 171 ]])
 172
 173 AT_BISON_CHECK([-fcaret -Wyacc input.y], [0], [],
 174 [[input.y:1.1-6: warning: POSIX Yacc does not support %nterm [-Wyacc]
 175     1 | %nterm exp
 176       | ^~~~~~
 177 input.y:2.12-15: warning: POSIX Yacc does not support hexadecimal literals [-Wyacc]
 178     2 | %token NUM 0x40 "number"
 179       |            ^~~~
 180 input.y:2.17-24: warning: POSIX Yacc does not support string literals [-Wyacc]
 181     2 | %token NUM 0x40 "number"
 182       |                 ^~~~~~~~
 183 input.y:4.6-13: warning: POSIX Yacc does not support string literals [-Wyacc]
 184     4 | exp: "number";
 185       |      ^~~~~~~~
 186 ]])
 187
 188 AT_CLEANUP
 189
 190
 191 ## --------------- ##
 192 ## Yacc warnings.  ##
 193 ## --------------- ##
 194
 195 AT_SETUP([Yacc warnings])
 196
 197 AT_DATA([input.y],
 198 [[%destructor {} <int>
 199 %printer {} <int>
 200 %type <int> exp a b
 201 %%
 202 exp: a b             { $$ = $1 + $2; };
 203 a: <int>{ $$ = 42; } { $$ = $1; };
 204 b: %empty            { $$ = 42; };
 205 ]])
 206
 207 AT_BISON_CHECK([-fcaret -Wyacc input.y], [0], [],
 208 [[input.y:1.1-11: warning: POSIX Yacc does not support %destructor [-Wyacc]
 209     1 | %destructor {} <int>
 210       | ^~~~~~~~~~~
 211 input.y:2.1-8: warning: POSIX Yacc does not support %printer [-Wyacc]
 212     2 | %printer {} <int>
 213       | ^~~~~~~~
 214 input.y:6.9-20: warning: POSIX Yacc does not support typed midrule actions [-Wyacc]
 215     6 | a: <int>{ $$ = 42; } { $$ = $1; };
 216       |         ^~~~~~~~~~~~
 217 input.y:7.4-9: warning: POSIX Yacc does not support %empty [-Wyacc]
 218     7 | b: %empty            { $$ = 42; };
 219       |    ^~~~~~
 220 ]])
 221
 222 AT_CLEANUP
 223
 224
 225 ## -------------- ##
 226 ## Yacc's %type.  ##
 227 ## -------------- ##
 228
 229 AT_SETUP([Yacc's %type])
 230
 231 AT_DATA([input.y],
 232 [[%token TOKEN1
 233 %nterm nterm1
 234 %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 235 %token TOKEN2
 236 %nterm nterm2
 237 %%
 238 expr: nterm1 nterm2 nterm3
 239 nterm1: TOKEN1
 240 nterm2: TOKEN2
 241 nterm3: "TOKEN3"
 242 ]])
 243
 244 AT_BISON_CHECK([-fcaret -Wyacc input.y], [0], [],
 245 [[input.y:2.1-6: warning: POSIX Yacc does not support %nterm [-Wyacc]
 246     2 | %nterm nterm1
 247       | ^~~~~~
 248 input.y:3.14-19: warning: POSIX yacc reserves %type to nonterminals [-Wyacc]
 249     3 | %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 250       |              ^~~~~~
 251 input.y:3.28-35: warning: POSIX Yacc does not support string literals [-Wyacc]
 252     3 | %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 253       |                            ^~~~~~~~
 254 input.y:3.28-35: warning: POSIX yacc reserves %type to nonterminals [-Wyacc]
 255     3 | %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 256       |                            ^~~~~~~~
 257 input.y:3.58-60: warning: POSIX yacc reserves %type to nonterminals [-Wyacc]
 258     3 | %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 259       |                                                          ^~~
 260 input.y:5.1-6: warning: POSIX Yacc does not support %nterm [-Wyacc]
 261     5 | %nterm nterm2
 262       | ^~~~~~
 263 input.y:3.21-26: warning: POSIX yacc reserves %type to nonterminals [-Wyacc]
 264     3 | %type <ival> TOKEN1 TOKEN2 "TOKEN3" nterm1 nterm2 nterm3 '+'
 265       |                     ^~~~~~
 266 input.y:10.9-16: warning: POSIX Yacc does not support string literals [-Wyacc]
 267    10 | nterm3: "TOKEN3"
 268       |         ^~~~~~~~
 269 ]])
 270
 271 AT_CLEANUP
 272
 273
 274 ## ----------------------------- ##
 275 ## Invalid symbol declarations.  ##
 276 ## ----------------------------- ##
 277
 278 AT_SETUP([Invalid symbol declarations])
 279
 280 AT_DATA([input.y],
 281 [[%nterm expr "expression";
 282 %nterm term 123;
 283 %nterm fact 124 "factor";
 284 %nterm '+' '*';
 285 %nterm "number";
 286 %token "tok1" 1;
 287 %left "tok2" 2;
 288 %type "tok3" 3;
 289 %%
 290 expr: expr '+' term | term;
 291 term: term '*' fact | fact;
 292 fact: "number";
 293 ]])
 294
 295 AT_BISON_CHECK([-fcaret input.y], [1], [],
 296 [[input.y:1.13-24: error: nonterminals cannot be given a string alias
 297     1 | %nterm expr "expression";
 298       |             ^~~~~~~~~~~~
 299 input.y:2.13-15: error: nonterminals cannot be given a token code
 300     2 | %nterm term 123;
 301       |             ^~~
 302 input.y:3.13-15: error: nonterminals cannot be given a token code
 303     3 | %nterm fact 124 "factor";
 304       |             ^~~
 305 input.y:3.17-24: error: nonterminals cannot be given a string alias
 306     3 | %nterm fact 124 "factor";
 307       |                 ^~~~~~~~
 308 input.y:4.8-10: error: character literals cannot be nonterminals
 309     4 | %nterm '+' '*';
 310       |        ^~~
 311 input.y:5.8-15: error: expected character literal or identifier or <tag> before string
 312     5 | %nterm "number";
 313       |        ^~~~~~~~
 314 input.y:6.8-13: error: expected character literal or identifier or <tag> before string
 315     6 | %token "tok1" 1;
 316       |        ^~~~~~
 317 input.y:7.14: error: unexpected integer literal
 318     7 | %left "tok2" 2;
 319       |              ^
 320 input.y:8.14: error: unexpected integer literal
 321     8 | %type "tok3" 3;
 322       |              ^
 323 ]])
 324
 325 AT_CLEANUP
 326
 327
 328 ## ---------------------------- ##
 329 ## Redefining the error token.  ##
 330 ## ---------------------------- ##
 331
 332 AT_SETUP([Redefining the error token])
 333
 334 # We used to crash when trying to display the original definition of
 335 # "error", which is a builtin without any location.
 336 AT_BISON_OPTION_PUSHDEFS
 337
 338 AT_DATA([input.y],
 339 [[%token error 123
 340 %token error 124
 341 %%
 342 exp:
 343 ]])
 344
 345 AT_BISON_CHECK([-fcaret input.y], [1], [],
 346 [[input.y:2.8-12: warning: symbol error redeclared [-Wother]
 347     2 | %token error 124
 348       |        ^~~~~
 349 input.y:1.8-12: note: previous declaration
 350     1 | %token error 123
 351       |        ^~~~~
 352 input.y:2.14-16: error: redefining code of token error
 353     2 | %token error 124
 354       |              ^~~
 355 ]])
 356
 357 # While at it, make sure we properly used the user's number for
 358 # "error".  I don't see what it buys us, but...
 359 AT_DATA([input.y],
 360 [[%{
 361 #include <assert.h>
 362 #include <stdio.h>
 363 ]AT_YYERROR_DEFINE[
 364 ]AT_YYLEX_DEFINE[
 365 %}
 366
 367 %token error 123
 368 %%
 369 exp:
 370 %%
 371 int main (void)
 372 {
 373   assert (YYerror == 123);
 374   assert (YYTRANSLATE (YYEOF) == YYSYMBOL_YYEOF);
 375   assert (YYTRANSLATE (YYerror) == YYSYMBOL_YYerror);
 376   assert (YYTRANSLATE (YYUNDEF) == YYSYMBOL_YYUNDEF);
 377   return 0;
 378 }
 379 ]])
 380
 381 AT_FULL_COMPILE([input])
 382 AT_PARSER_CHECK([input], 0)
 383
 384 AT_BISON_OPTION_POPDEFS
 385 AT_CLEANUP
 386
 387
 388 ## ------------------ ##
 389 ## Dangling aliases.  ##
 390 ## ------------------ ##
 391
 392 AT_SETUP([Dangling aliases])
 393
 394 AT_DATA([input.y],
 395 [[%token FOO "foo"
 396 %type <val> "bar"
 397 %%
 398 expr: "foo" "bar" "baz"
 399 ]])
 400
 401 AT_BISON_CHECK([-fcaret -Wdangling input.y], [0], [],
 402 [[input.y:2.13-17: warning: string literal "bar" not attached to a symbol [-Wdangling-alias]
 403     2 | %type <val> "bar"
 404       |             ^~~~~
 405 input.y:4.19-23: warning: string literal "baz" not attached to a symbol [-Wdangling-alias]
 406     4 | expr: "foo" "bar" "baz"
 407       |                   ^~~~~
 408 ]])
 409
 410 AT_CLEANUP
 411
 412
 413 ## --------------------- ##
 414 ## Symbol declarations.  ##
 415 ## --------------------- ##
 416
 417 # Check the parsing of %token, %nterm, %type and %left...
 418 AT_SETUP([Symbol declarations])
 419
 420 AT_DATA([dump-symbols.m4],
 421 [[m4@&t@_define([b4_api_PREFIX], [YY])
 422
 423 m4@&t@_define([b4_symbol_dump],
 424 [$1, d@&t@nl
 425 b4_symbol_if([$1], [is_token], [Token], [Nonterminal]), d@&t@nl
 426 b4_symbol([$1], [tag]), d@&t@nl
 427 b4_symbol([$1], [id]), d@&t@nl
 428 b4_symbol([$1], [code]), d@&t@nl
 429 b4_symbol([$1], [type]),
 430 ])
 431
 432 b4_output_begin([symbols.csv])
 433 number, class, tag, id, code, type,
 434 b4_symbol_foreach([b4_symbol_dump])d@&t@nl
 435 b4_output_end
 436 ]])
 437
 438 AT_DATA([input.y],
 439 [[%token 'a' A1 1 "A1" A2 A3 "A3" A4 4
 440       <type_b> 'b' B5 5 "B5" B6 B7 "B8" B9 9
 441       <type_c> 'c' C10 10 "C10" C11 C12 "C12" C13 13
 442
 443 %left 'd' D20 20 "D20" D21 D22 "D22" D23 23
 444       <type_e> 'e' E25 25 "E25" E26 E27 "E28" E29 29
 445       <type_f> 'f' F30 30 "F30" F31 F32 "F32" F33 33
 446
 447 %type 'g' G40 "D40" G21 G22 G23
 448       <type_h> 'h' H25 "H25" H26 H27 "H28" H29
 449       <type_i> 'i' I30 "I30" I31 I32 "I32" I33
 450
 451 %nterm j60 j61 j62 j63
 452       <type_k> k75 k76 k77 k79
 453       <type_l> l80 l81 l82 l83
 454 %%
 455 exp:;
 456 ]])
 457
 458 AT_BISON_CHECK([-Wno-other -S./dump-symbols.m4 input.y])
 459 AT_CHECK([cat symbols.csv], [],
 460 [[number, class, tag, id, code, type,
 461 0, Token, "end of file", YYEOF, 0, ,
 462 1, Token, error, YYerror, 256, ,
 463 2, Token, "invalid token", YYUNDEF, 257, ,
 464 3, Token, 'a', , 97, ,
 465 4, Token, "A1", A1, 1, ,
 466 5, Token, A2, A2, 258, ,
 467 6, Token, "A3", A3, 259, ,
 468 7, Token, A4, A4, 4, ,
 469 8, Token, 'b', , 98, type_b,
 470 9, Token, "B5", B5, 5, type_b,
 471 10, Token, B6, B6, 260, type_b,
 472 11, Token, "B8", B7, 261, type_b,
 473 12, Token, B9, B9, 9, type_b,
 474 13, Token, 'c', , 99, type_c,
 475 14, Token, "C10", C10, 10, type_c,
 476 15, Token, C11, C11, 262, type_c,
 477 16, Token, "C12", C12, 263, type_c,
 478 17, Token, C13, C13, 13, type_c,
 479 18, Token, 'd', , 100, ,
 480 19, Token, D20, D20, 20, ,
 481 20, Token, "D20", , 264, ,
 482 21, Token, D21, D21, 265, ,
 483 22, Token, D22, D22, 266, ,
 484 23, Token, "D22", , 267, ,
 485 24, Token, D23, D23, 23, ,
 486 25, Token, 'e', , 101, type_e,
 487 26, Token, E25, E25, 25, type_e,
 488 27, Token, "E25", , 268, type_e,
 489 28, Token, E26, E26, 269, type_e,
 490 29, Token, E27, E27, 270, type_e,
 491 30, Token, "E28", , 271, type_e,
 492 31, Token, E29, E29, 29, type_e,
 493 32, Token, 'f', , 102, type_f,
 494 33, Token, F30, F30, 30, type_f,
 495 34, Token, "F30", , 272, type_f,
 496 35, Token, F31, F31, 273, type_f,
 497 36, Token, F32, F32, 274, type_f,
 498 37, Token, "F32", , 275, type_f,
 499 38, Token, F33, F33, 33, type_f,
 500 39, Token, 'g', , 103, ,
 501 40, Token, "D40", , 276, ,
 502 41, Token, 'h', , 104, type_h,
 503 42, Token, "H25", , 277, type_h,
 504 43, Token, "H28", , 278, type_h,
 505 44, Token, 'i', , 105, type_i,
 506 45, Token, "I30", , 279, type_i,
 507 46, Token, "I32", , 280, type_i,
 508 47, Nonterminal, $accept, , -1, ,
 509 48, Nonterminal, exp, exp, -1, ,
 510 ]])
 511
 512 AT_CLEANUP
 513
 514
 515 ## ------------ ##
 516 ## Invalid $n.  ##
 517 ## ------------ ##
 518
 519 AT_SETUP([Invalid $n and @n])
 520
 521 AT_DATA([input.y],
 522 [[%%
 523 exp: %empty { $$ = $1 ; };
 524 exp: %empty { @$ = @1 ; };
 525 ]])
 526
 527 AT_BISON_CHECK([-fcaret input.y], [1], [],
 528 [[input.y:2.20-21: error: integer out of range: '$1'
 529     2 | exp: %empty { $$ = $1 ; };
 530       |                    ^~
 531 input.y:3.20-21: error: integer out of range: '@1'
 532     3 | exp: %empty { @$ = @1 ; };
 533       |                    ^~
 534 ]])
 535
 536 AT_CLEANUP
 537
 538
 539 ## -------------- ##
 540 ## Type Clashes.  ##
 541 ## -------------- ##
 542
 543 AT_SETUP([Type Clashes])
 544
 545 AT_DATA([input.y],
 546 [[%union { int bar; }
 547 %token foo
 548 %type <bar> exp
 549 %%
 550 exp: foo { $$; } foo { $2; } foo
 551    | foo
 552    | %empty
 553    ;
 554 ]])
 555
 556 AT_BISON_CHECK([-fcaret input.y], [1], [],
 557 [[input.y:5.12-13: error: $$ for the midrule at $2 of 'exp' has no declared type
 558     5 | exp: foo { $$; } foo { $2; } foo
 559       |            ^~
 560 input.y:5.24-25: error: $2 of 'exp' has no declared type
 561     5 | exp: foo { $$; } foo { $2; } foo
 562       |                        ^~
 563 input.y:5.6-32: warning: type clash on default action: <bar> != <> [-Wother]
 564     5 | exp: foo { $$; } foo { $2; } foo
 565       |      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
 566 input.y:6.6-8: warning: type clash on default action: <bar> != <> [-Wother]
 567     6 |    | foo
 568       |      ^~~
 569 input.y:7.6-11: warning: empty rule for typed nonterminal, and no action [-Wother]
 570     7 |    | %empty
 571       |      ^~~~~~
 572 ]])
 573
 574 AT_CLEANUP
 575
 576
 577 # _AT_UNUSED_VALUES_DECLARATIONS()
 578 # --------------------------------
 579 # Generate the token, type, and destructor
 580 # declarations for the unused values tests.
 581 m4_define([_AT_UNUSED_VALUES_DECLARATIONS],
 582 [[[%token <integer> INT;
 583 %type <integer> a b c d e f g h i j k l m n o;
 584 %destructor { destroy ($$); } <integer>;]]])
 585
 586
 587 # AT_CHECK_UNUSED_VALUES(DECLARATIONS_AFTER, CHECK_MIDRULE_VALUES)
 588 # ----------------------------------------------------------------
 589 # Generate a grammar to test unused values, and compile it.  If
 590 # DECLARATIONS_AFTER is set, then the token, type, and destructor
 591 # declarations are generated after the rules rather than before.  If
 592 # CHECK_MIDRULE_VALUES is set, then --warnings=midrule-values is set.
 593 m4_define([AT_CHECK_UNUSED_VALUES],
 594 [AT_DATA([input.y],
 595 m4_ifval([$1], [
 596
 597
 598 ], [_AT_UNUSED_VALUES_DECLARATIONS
 599 ])[[%%
 600 start:
 601   'a' a { $][2; } | 'b' b { $][2; } | 'c' c { $][2; } | 'd' d { $][2; }
 602 | 'e' e { $][2; } | 'f' f { $][2; } | 'g' g { $][2; } | 'h' h { $][2; }
 603 | 'i' i { $][2; } | 'j' j { $][2; } | 'k' k { $][2; } | 'l' l { $][2; }
 604 | 'm' m { $][2; } | 'n' n { $][2; } | 'o' o { $][2; }
 605 ;
 606
 607 a: INT | INT { } INT { } INT { };
 608 b: INT | %empty;
 609 c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 610 d: INT | INT { } INT { $][1; } INT { $<integer>2; };
 611 e: INT | INT { } INT {  } INT { $][1; };
 612 f: INT | INT { } INT {  } INT { $][$ = $][1 + $][3 + $][5; };
 613 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 614 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 615 i: INT | INT INT { } { $][$ = $][1 + $][2; };
 616 j: INT | INT INT { $<integer>$ = 1; } { $][$ = $][1 + $][2; };
 617 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 618 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; };
 619 m: INT | INT <integer>{ $][$ = $][1; } INT <integer>{ $][$ = $][2 + $][3; } INT { $][$ = $][4 + $][5; };
 620 n: INT | INT <integer>{ } INT <integer>{ } INT { };
 621 o: INT | INT <integer>{ } INT <integer>{ } INT { $][$ = $][1 + $][2 + $][3 + $][4 + $][5; };
 622 ]]m4_ifval([$1], [
 623 _AT_UNUSED_VALUES_DECLARATIONS])
 624 )
 625
 626 AT_BISON_CHECK(m4_ifval([$2], [--warnings=midrule-values ])[-fcaret input.y],
 627                [0], [],
 628 [[input.y:12.10-32: warning: unset value: $][$ [-Wother]
 629    12 | a: INT | INT { } INT { } INT { };
 630       |          ^~~~~~~~~~~~~~~~~~~~~~~
 631 input.y:12.10-12: warning: unused value: $][1 [-Wother]
 632    12 | a: INT | INT { } INT { } INT { };
 633       |          ^~~
 634 input.y:12.18-20: warning: unused value: $][3 [-Wother]
 635    12 | a: INT | INT { } INT { } INT { };
 636       |                  ^~~
 637 input.y:12.26-28: warning: unused value: $][5 [-Wother]
 638    12 | a: INT | INT { } INT { } INT { };
 639       |                          ^~~
 640 input.y:13.10-15: warning: empty rule for typed nonterminal, and no action [-Wother]
 641    13 | b: INT | %empty;
 642       |          ^~~~~~
 643 ]]m4_ifval([$2], [[[input.y:14.14-20: warning: unset value: $][$ [-Wmidrule-values]
 644    14 | c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 645       |              ^~~~~~~
 646 input.y:14.26-41: warning: unset value: $][$ [-Wmidrule-values]
 647    14 | c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 648       |                          ^~~~~~~~~~~~~~~~
 649 ]]])[[input.y:14.10-62: warning: unset value: $][$ [-Wother]
 650    14 | c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 651       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 652 input.y:14.22-24: warning: unused value: $][3 [-Wother]
 653    14 | c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 654       |                      ^~~
 655 input.y:14.43-45: warning: unused value: $][5 [-Wother]
 656    14 | c: INT | INT { $][1; } INT { $<integer>2; } INT { $<integer>4; };
 657       |                                           ^~~
 658 ]]m4_ifval([$2], [[[input.y:15.14-16: warning: unset value: $][$ [-Wmidrule-values]
 659    15 | d: INT | INT { } INT { $][1; } INT { $<integer>2; };
 660       |              ^~~
 661 ]]])[[input.y:15.10-49: warning: unset value: $][$ [-Wother]
 662    15 | d: INT | INT { } INT { $][1; } INT { $<integer>2; };
 663       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 664 input.y:15.18-20: warning: unused value: $][3 [-Wother]
 665    15 | d: INT | INT { } INT { $][1; } INT { $<integer>2; };
 666       |                  ^~~
 667 input.y:15.30-32: warning: unused value: $][5 [-Wother]
 668    15 | d: INT | INT { } INT { $][1; } INT { $<integer>2; };
 669       |                              ^~~
 670 input.y:16.10-37: warning: unset value: $][$ [-Wother]
 671    16 | e: INT | INT { } INT {  } INT { $][1; };
 672       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
 673 input.y:16.18-20: warning: unused value: $][3 [-Wother]
 674    16 | e: INT | INT { } INT {  } INT { $][1; };
 675       |                  ^~~
 676 input.y:16.27-29: warning: unused value: $][5 [-Wother]
 677    16 | e: INT | INT { } INT {  } INT { $][1; };
 678       |                           ^~~
 679 input.y:18.10-58: warning: unset value: $][$ [-Wother]
 680    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 681       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 682 input.y:18.10-12: warning: unused value: $][1 [-Wother]
 683    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 684       |          ^~~
 685 ]]m4_ifval([$2], [[[input.y:18.14-29: warning: unused value: $][2 [-Wmidrule-values]
 686    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 687       |              ^~~~~~~~~~~~~~~~
 688 ]]])[[input.y:18.31-33: warning: unused value: $][3 [-Wother]
 689    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 690       |                               ^~~
 691 ]]m4_ifval([$2], [[[input.y:18.35-50: warning: unused value: $][4 [-Wmidrule-values]
 692    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 693       |                                   ^~~~~~~~~~~~~~~~
 694 ]]])[[input.y:18.52-54: warning: unused value: $][5 [-Wother]
 695    18 | g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { };
 696       |                                                    ^~~
 697 input.y:19.10-72: warning: unset value: $][$ [-Wother]
 698    19 | h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 699       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 700 input.y:19.10-12: warning: unused value: $][1 [-Wother]
 701    19 | h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 702       |          ^~~
 703 input.y:19.31-33: warning: unused value: $][3 [-Wother]
 704    19 | h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 705       |                               ^~~
 706 ]]m4_ifval([$2], [[[input.y:19.35-64: warning: unused value: $][4 [-Wmidrule-values]
 707    19 | h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 708       |                                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 709 ]]])[[input.y:19.66-68: warning: unused value: $][5 [-Wother]
 710    19 | h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { };
 711       |                                                                  ^~~
 712 ]]m4_ifval([$2], [[[input.y:21.18-37: warning: unused value: $][3 [-Wmidrule-values]
 713    21 | j: INT | INT INT { $<integer>$ = 1; } { $][$ = $][1 + $][2; };
 714       |                  ^~~~~~~~~~~~~~~~~~~~
 715 ]]])[[input.y:22.10-68: warning: unset value: $][$ [-Wother]
 716    22 | k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 717       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 718 input.y:22.10-12: warning: unused value: $][1 [-Wother]
 719    22 | k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 720       |          ^~~
 721 input.y:22.14-16: warning: unused value: $][2 [-Wother]
 722    22 | k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 723       |              ^~~
 724 ]]m4_ifval([$2], [[[input.y:22.35-64: warning: unused value: $][4 [-Wmidrule-values]
 725    22 | k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { };
 726       |                                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 727 ]]])[[input.y:25.23-25: warning: unset value: $][$ [-Wother]
 728    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 729       |                       ^~~
 730 input.y:25.40-42: warning: unset value: $][$ [-Wother]
 731    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 732       |                                        ^~~
 733 input.y:25.10-50: warning: unset value: $][$ [-Wother]
 734    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 735       |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 736 input.y:25.10-12: warning: unused value: $][1 [-Wother]
 737    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 738       |          ^~~
 739 input.y:25.23-25: warning: unused value: $][2 [-Wother]
 740    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 741       |                       ^~~
 742 input.y:25.27-29: warning: unused value: $][3 [-Wother]
 743    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 744       |                           ^~~
 745 input.y:25.40-42: warning: unused value: $][4 [-Wother]
 746    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 747       |                                        ^~~
 748 input.y:25.44-46: warning: unused value: $][5 [-Wother]
 749    25 | n: INT | INT <integer>{ } INT <integer>{ } INT { };
 750       |                                            ^~~
 751 input.y:26.23-25: warning: unset value: $][$ [-Wother]
 752    26 | o: INT | INT <integer>{ } INT <integer>{ } INT { $][$ = $][1 + $][2 + $][3 + $][4 + $][5; };
 753       |                       ^~~
 754 input.y:26.40-42: warning: unset value: $][$ [-Wother]
 755    26 | o: INT | INT <integer>{ } INT <integer>{ } INT { $][$ = $][1 + $][2 + $][3 + $][4 + $][5; };
 756       |                                        ^~~
 757 ]])
 758
 759 ])
 760
 761 ## --------------- ##
 762 ## Unused values.  ##
 763 ## --------------- ##
 764
 765 AT_SETUP([Unused values])
 766 AT_CHECK_UNUSED_VALUES
 767 AT_CHECK_UNUSED_VALUES(, [1])
 768 AT_CLEANUP
 769
 770
 771 ## ------------------------------------------ ##
 772 ## Unused values before symbol declarations.  ##
 773 ## ------------------------------------------ ##
 774
 775 AT_SETUP([Unused values before symbol declarations])
 776 AT_CHECK_UNUSED_VALUES([1])
 777 AT_CHECK_UNUSED_VALUES([1], [1])
 778 AT_CLEANUP
 779
 780
 781 ## ------------------- ##
 782 ## Symbol redeclared.  ##
 783 ## ------------------- ##
 784
 785 AT_SETUP([Symbol redeclared])
 786
 787 AT_DATA([[input.y]],
 788 [[%token FOO FOO
 789 %token BAR 12 BAR 12
 790 %token EOF 0 EOF 0
 791 %%
 792 exp: FOO BAR
 793 ]])
 794
 795 AT_BISON_CHECK([-fcaret input.y], [0], [],
 796 [[input.y:1.12-14: warning: symbol FOO redeclared [-Wother]
 797     1 | %token FOO FOO
 798       |            ^~~
 799 input.y:1.8-10: note: previous declaration
 800     1 | %token FOO FOO
 801       |        ^~~
 802 input.y:2.15-17: warning: symbol BAR redeclared [-Wother]
 803     2 | %token BAR 12 BAR 12
 804       |               ^~~
 805 input.y:2.8-10: note: previous declaration
 806     2 | %token BAR 12 BAR 12
 807       |        ^~~
 808 input.y:3.14-16: warning: symbol EOF redeclared [-Wother]
 809     3 | %token EOF 0 EOF 0
 810       |              ^~~
 811 input.y:3.8-10: note: previous declaration
 812     3 | %token EOF 0 EOF 0
 813       |        ^~~
 814 ]])
 815
 816 AT_CLEANUP
 817
 818
 819 ## --------------------------- ##
 820 ## Symbol class redefinition.  ##
 821 ## --------------------------- ##
 822
 823 AT_SETUP([Symbol class redefinition])
 824
 825 AT_DATA([[input.y]],
 826 [[%token FOO
 827 %nterm FOO BAR
 828 %token BAR
 829 %nterm error // The token error cannot be redefined as an nterm.
 830 %%
 831 FOO: BAR
 832 BAR:
 833 ]])
 834
 835 AT_BISON_CHECK([-fcaret input.y], [1], [],
 836 [[input.y:2.8-10: error: symbol FOO redeclared as a nonterminal
 837     2 | %nterm FOO BAR
 838       |        ^~~
 839 input.y:1.8-10: note: previous definition
 840     1 | %token FOO
 841       |        ^~~
 842 input.y:3.8-10: error: symbol BAR redeclared as a token
 843     3 | %token BAR
 844       |        ^~~
 845 input.y:2.12-14: note: previous definition
 846     2 | %nterm FOO BAR
 847       |            ^~~
 848 input.y:4.8-12: error: symbol error redeclared as a nonterminal
 849     4 | %nterm error // The token error cannot be redefined as an nterm.
 850       |        ^~~~~
 851 input.y:6.1-3: error: rule given for FOO, which is a token
 852     6 | FOO: BAR
 853       | ^~~
 854 ]])
 855
 856 AT_CLEANUP
 857
 858
 859 ## --------------------------------------------- ##
 860 ## Default %printer and %destructor redeclared.  ##
 861 ## --------------------------------------------- ##
 862
 863 AT_SETUP([Default %printer and %destructor redeclared])
 864
 865 # AT_TEST([*])
 866 # ------------
 867 m4_pushdef([AT_TEST],
 868 [AT_DATA([[input.y]],
 869 [[%destructor { destroy ($$); } <$1> <$1>
 870 %printer { print ($$); } <$1> <$1>
 871
 872 %destructor { destroy ($$); } <$1>
 873 %printer { print ($$); } <$1>
 874
 875 %%
 876
 877 start: %empty;
 878
 879 %destructor { destroy ($$); } <$1>;
 880 %printer { print ($$); } <$1>;
 881 ]])
 882
 883 AT_BISON_CHECK([-fcaret input.y], [1], [],
 884 [[input.y:1.13-29: error: %destructor redeclaration for <>
 885     1 | %destructor { destroy ($$); } <> <>
 886       |             ^~~~~~~~~~~~~~~~~
 887 input.y:1.13-29: note: previous declaration
 888     1 | %destructor { destroy ($$); } <> <>
 889       |             ^~~~~~~~~~~~~~~~~
 890 input.y:2.10-24: error: %printer redeclaration for <>
 891     2 | %printer { print ($$); } <> <>
 892       |          ^~~~~~~~~~~~~~~
 893 input.y:2.10-24: note: previous declaration
 894     2 | %printer { print ($$); } <> <>
 895       |          ^~~~~~~~~~~~~~~
 896 input.y:4.13-29: error: %destructor redeclaration for <>
 897     4 | %destructor { destroy ($$); } <>
 898       |             ^~~~~~~~~~~~~~~~~
 899 input.y:1.13-29: note: previous declaration
 900     1 | %destructor { destroy ($$); } <> <>
 901       |             ^~~~~~~~~~~~~~~~~
 902 input.y:5.10-24: error: %printer redeclaration for <>
 903     5 | %printer { print ($$); } <>
 904       |          ^~~~~~~~~~~~~~~
 905 input.y:2.10-24: note: previous declaration
 906     2 | %printer { print ($$); } <> <>
 907       |          ^~~~~~~~~~~~~~~
 908 input.y:11.13-29: error: %destructor redeclaration for <>
 909    11 | %destructor { destroy ($$); } <>;
 910       |             ^~~~~~~~~~~~~~~~~
 911 input.y:1.13-29: note: previous declaration
 912     1 | %destructor { destroy ($$); } <> <>
 913       |             ^~~~~~~~~~~~~~~~~
 914 input.y:12.10-24: error: %printer redeclaration for <>
 915    12 | %printer { print ($$); } <>;
 916       |          ^~~~~~~~~~~~~~~
 917 input.y:2.10-24: note: previous declaration
 918     2 | %printer { print ($$); } <> <>
 919       |          ^~~~~~~~~~~~~~~
 920 ]])
 921 ])
 922
 923 AT_TEST([], [], [])
 924 AT_TEST([], [*], [*])
 925 m4_popdef([AT_TEST])
 926
 927 AT_CLEANUP
 928
 929
 930 ## ---------------------------------------------- ##
 931 ## Per-type %printer and %destructor redeclared.  ##
 932 ## ---------------------------------------------- ##
 933
 934 AT_SETUP([Per-type %printer and %destructor redeclared])
 935
 936 AT_DATA([[input.y]],
 937 [[%destructor { destroy ($$); } <field1> <field2>
 938 %printer { print ($$); } <field1> <field2>
 939
 940 %destructor { destroy ($$); } <field1> <field1>
 941 %printer { print ($$); } <field2> <field2>
 942
 943 %%
 944
 945 start: %empty;
 946
 947 %destructor { destroy ($$); } <field2> <field1>;
 948 %printer { print ($$); } <field2> <field1>;
 949 ]])
 950
 951 AT_BISON_CHECK([input.y], [1], [],
 952 [[input.y:4.13-29: error: %destructor redeclaration for <field1>
 953 input.y:1.13-29: note: previous declaration
 954 input.y:4.13-29: error: %destructor redeclaration for <field1>
 955 input.y:1.13-29: note: previous declaration
 956 input.y:5.10-24: error: %printer redeclaration for <field2>
 957 input.y:2.10-24: note: previous declaration
 958 input.y:5.10-24: error: %printer redeclaration for <field2>
 959 input.y:2.10-24: note: previous declaration
 960 input.y:11.13-29: error: %destructor redeclaration for <field2>
 961 input.y:1.13-29: note: previous declaration
 962 input.y:11.13-29: error: %destructor redeclaration for <field1>
 963 input.y:1.13-29: note: previous declaration
 964 input.y:12.10-24: error: %printer redeclaration for <field2>
 965 input.y:2.10-24: note: previous declaration
 966 input.y:12.10-24: error: %printer redeclaration for <field1>
 967 input.y:2.10-24: note: previous declaration
 968 ]])
 969
 970 AT_CLEANUP
 971
 972
 973 ## ------------------- ##
 974 ## Undefined symbols.  ##
 975 ## ------------------- ##
 976
 977 AT_SETUP([Undefined symbols])
 978
 979 AT_DATA([[input.y]],
 980 [[%printer {} foo baz
 981 %destructor {} bar
 982 %type <foo> qux
 983 %%
 984 exp: bar;
 985 ]])
 986
 987 AT_BISON_CHECK([-fcaret input.y], [1], [],
 988 [[input.y:1.13-15: warning: symbol 'foo' is used, but is not defined as a token and has no rules [-Wother]
 989     1 | %printer {} foo baz
 990       |             ^~~
 991 input.y:1.17-19: warning: symbol 'baz' is used, but is not defined as a token and has no rules [-Wother]
 992     1 | %printer {} foo baz
 993       |                 ^~~
 994 input.y:2.16-18: error: symbol 'bar' is used, but is not defined as a token and has no rules
 995     2 | %destructor {} bar
 996       |                ^~~
 997 input.y:3.13-15: warning: symbol 'qux' is used, but is not defined as a token and has no rules [-Wother]
 998     3 | %type <foo> qux
 999       |             ^~~
1000 ]])
1001
1002 AT_CLEANUP
1003
1004
1005 ## ----------------------------------------------------- ##
1006 ## Unassociated types used for a printer or destructor.  ##
1007 ## ----------------------------------------------------- ##
1008
1009 AT_SETUP([Unassociated types used for a printer or destructor])
1010
1011 AT_DATA([[input.y]],
1012 [[%token <type1> tag1
1013 %type <type2> tag2
1014
1015 %printer { } <type1> <type3>
1016 %destructor { } <type2> <type4>
1017
1018 %%
1019
1020 exp: tag1 { $1; }
1021    | tag2 { $1; }
1022
1023 tag2: "a" { $$; }
1024 ]])
1025
1026 AT_BISON_CHECK([input.y], [0], [],
1027 [[input.y:4.22-28: warning: type <type3> is used, but is not associated to any symbol [-Wother]
1028 input.y:5.25-31: warning: type <type4> is used, but is not associated to any symbol [-Wother]
1029 ]])
1030
1031 AT_CLEANUP
1032
1033
1034 ## --------------------------------- ##
1035 ## Useless printers or destructors.  ##
1036 ## --------------------------------- ##
1037
1038 AT_SETUP([Useless printers or destructors])
1039
1040 # AT_TEST([INPUT], [STDERR])
1041 # --------------------------
1042 m4_pushdef([AT_TEST],
1043 [AT_DATA([[input.y]],
1044 [$1
1045 ])
1046 AT_BISON_CHECK([input.y], [0], [], [$2
1047 ])])
1048
1049 AT_TEST([[%token <type1> token1
1050 %token <type2> token2
1051 %token <type3> token3
1052 %token <type4> token4
1053 %token <type5> token51 token52
1054 %token <type6> token61 token62
1055 %token <type7> token7
1056
1057 %printer {} token1
1058 %destructor {} token2
1059 %printer {} token51
1060 %destructor {} token61
1061
1062 %printer {} token7
1063
1064 %printer {} <type1>
1065 %destructor {} <type2>
1066 %printer {} <type3>
1067 %destructor {} <type4>
1068
1069 %printer {} <type5>
1070 %destructor {} <type6>
1071
1072 %destructor {} <type7>
1073
1074 %%
1075 exp: "a";]],
1076 [[input.y:16.13-19: warning: useless %printer for type <type1> [-Wother]
1077 input.y:17.16-22: warning: useless %destructor for type <type2> [-Wother]]])
1078
1079 # If everybody is typed, <> is useless.
1080 AT_TEST([[%type <type> exp
1081 %token <type> a
1082 %printer {} <> <*>
1083 %%
1084 exp: a;]],
1085 [[input.y:3.13-14: warning: useless %printer for type <> [-Wother]]])
1086
1087 # If nobody is typed, <*> is useless.
1088 AT_TEST([[%token a
1089 %printer {} <> <*>
1090 %%
1091 exp: a;]],
1092 [[input.y:2.16-18: warning: useless %printer for type <*> [-Wother]]])
1093
1094 m4_popdef([AT_TEST])
1095
1096 AT_CLEANUP
1097
1098
1099 ## ---------------------------------------- ##
1100 ## Unused values with default %destructor.  ##
1101 ## ---------------------------------------- ##
1102
1103 AT_SETUP([Unused values with default %destructor])
1104
1105 AT_DATA([[input.y]],
1106 [[%destructor { destroy ($$); } <>
1107 %type <tag> tagged
1108
1109 %%
1110
1111 start: end end tagged tagged { $<tag>1; $3; } ;
1112 end: { } ;
1113 tagged: { } ;
1114 ]])
1115
1116 AT_BISON_CHECK([-fcaret input.y], [0], [],
1117 [[input.y:6.8-45: warning: unset value: $$ [-Wother]
1118     6 | start: end end tagged tagged { $<tag>1; $3; } ;
1119       |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1120 input.y:6.12-14: warning: unused value: $2 [-Wother]
1121     6 | start: end end tagged tagged { $<tag>1; $3; } ;
1122       |            ^~~
1123 input.y:7.6-8: warning: unset value: $$ [-Wother]
1124     7 | end: { } ;
1125       |      ^~~
1126 ]])
1127
1128 AT_DATA([[input.y]],
1129 [[%destructor { destroy ($$); } <*>
1130 %type <tag> tagged
1131
1132 %%
1133
1134 start: end end tagged tagged { $<tag>1; $3; } ;
1135 end: { } ;
1136 tagged: { } ;
1137 ]])
1138
1139 AT_BISON_CHECK([input.y], [0], [],
1140 [[input.y:6.23-28: warning: unused value: $4 [-Wother]
1141 input.y:8.9-11: warning: unset value: $$ [-Wother]
1142 ]])
1143
1144 AT_CLEANUP
1145
1146
1147 ## ----------------------------------------- ##
1148 ## Unused values with per-type %destructor.  ##
1149 ## ----------------------------------------- ##
1150
1151 AT_SETUP([Unused values with per-type %destructor])
1152
1153 AT_DATA([[input.y]],
1154 [[%destructor { destroy ($$); } <field1>
1155 %type <field1> start end
1156
1157 %%
1158
1159 start: end end { $1; } ;
1160 end: { }  ;
1161 ]])
1162
1163 AT_BISON_CHECK([-fcaret input.y], [0], [],
1164 [[input.y:6.8-22: warning: unset value: $$ [-Wother]
1165     6 | start: end end { $1; } ;
1166       |        ^~~~~~~~~~~~~~~
1167 input.y:6.12-14: warning: unused value: $2 [-Wother]
1168     6 | start: end end { $1; } ;
1169       |            ^~~
1170 input.y:7.6-8: warning: unset value: $$ [-Wother]
1171     7 | end: { }  ;
1172       |      ^~~
1173 ]])
1174
1175 AT_CLEANUP
1176
1177
1178 ## ------------------ ##
1179 ## Duplicate string.  ##
1180 ## ------------------ ##
1181
1182
1183 AT_SETUP([Duplicate string])
1184
1185 AT_BISON_OPTION_PUSHDEFS
1186 AT_DATA([input.y],
1187 [[/* 'Bison -v' used to dump core when two tokens are defined with the same
1188    string, as LE and GE below. */
1189
1190 %token NUM
1191 %token LE "<="
1192 %token GE "<="
1193
1194 %%
1195 exp: '(' exp ')' | NUM ;
1196 %%
1197 ]])
1198 AT_BISON_OPTION_POPDEFS
1199
1200 AT_BISON_CHECK([-v -o input.c input.y], 0, [],
1201 [[input.y:6.11-14: warning: symbol "<=" used more than once as a literal string [-Wother]
1202 ]])
1203
1204 AT_CLEANUP
1205
1206
1207 ## ------------------ ##
1208 ## Token collisions.  ##
1209 ## ------------------ ##
1210
1211 AT_SETUP([Token collisions])
1212
1213 AT_DATA([[input.y]],
1214 [[%token FOO 42 "foo"
1215          BAR 42 "foo"
1216 %%
1217 exp: FOO BAR;
1218 ]])
1219
1220 AT_BISON_CHECK([-fcaret input.y], [1], [],
1221 [[input.y:2.17-21: warning: symbol "foo" used more than once as a literal string [-Wother]
1222     2 |          BAR 42 "foo"
1223       |                 ^~~~~
1224 input.y:2.10-12: error: code 42 reassigned to token BAR
1225     2 |          BAR 42 "foo"
1226       |          ^~~
1227 input.y:1.15-19: note: previous declaration for "foo"
1228     1 | %token FOO 42 "foo"
1229       |               ^~~~~
1230 ]])
1231
1232 AT_CLEANUP
1233
1234
1235 ## ---------------------- ##
1236 ## Incompatible Aliases.  ##
1237 ## ---------------------- ##
1238
1239 AT_SETUP([Incompatible Aliases])
1240
1241 m4_pushdef([AT_TEST],
1242 [AT_DATA([input.y], [$1])
1243 AT_BISON_CHECK([-fcaret input.y], [1], [], [$2])
1244 ])
1245
1246 # Use the string-alias first to check the order between "first
1247 # declaration" and second.
1248
1249 AT_TEST([[%token foo "foo"
1250 %type <bar> "foo"
1251 %type <baz> foo
1252 %%
1253 exp: foo;
1254 ]],
1255 [[input.y:3.13-15: error: %type redeclaration for foo
1256     3 | %type <baz> foo
1257       |             ^~~
1258 input.y:2.13-17: note: previous declaration
1259     2 | %type <bar> "foo"
1260       |             ^~~~~
1261 ]])
1262
1263 AT_TEST([[%token foo "foo"
1264 %printer {bar} "foo"
1265 %printer {baz} foo
1266 %%
1267 exp: foo;
1268 ]],
1269 [[input.y:3.10-14: error: %printer redeclaration for foo
1270     3 | %printer {baz} foo
1271       |          ^~~~~
1272 input.y:2.10-14: note: previous declaration
1273     2 | %printer {bar} "foo"
1274       |          ^~~~~
1275 ]])
1276
1277 AT_TEST([[%token foo "foo"
1278 %destructor {bar} "foo"
1279 %destructor {baz} foo
1280 %%
1281 exp: foo;
1282 ]],
1283 [[input.y:3.13-17: error: %destructor redeclaration for foo
1284     3 | %destructor {baz} foo
1285       |             ^~~~~
1286 input.y:2.13-17: note: previous declaration
1287     2 | %destructor {bar} "foo"
1288       |             ^~~~~
1289 ]])
1290
1291 AT_TEST([[%token foo "foo"
1292 %left "foo"
1293 %left foo
1294 %%
1295 exp: foo;
1296 ]],
1297 [[input.y:3.1-5: error: %left redeclaration for foo
1298     3 | %left foo
1299       | ^~~~~
1300 input.y:2.1-5: note: previous declaration
1301     2 | %left "foo"
1302       | ^~~~~
1303 ]])
1304
1305 # This time, declare the alias after its use.
1306
1307 # Precedence/associativity.
1308 AT_TEST([[%left "foo"
1309 %left foo
1310 %token foo "foo"
1311 %%
1312 exp: foo;
1313 ]],
1314 [[input.y:2.1-5: error: %left redeclaration for foo
1315     2 | %left foo
1316       | ^~~~~
1317 input.y:1.1-5: note: previous declaration
1318     1 | %left "foo"
1319       | ^~~~~
1320 ]])
1321
1322 # Printer.
1323 AT_TEST([[%printer {} "foo"
1324 %printer {} foo
1325 %token foo "foo"
1326 %%
1327 exp: foo;
1328 ]],
1329 [[input.y:2.10-11: error: %printer redeclaration for foo
1330     2 | %printer {} foo
1331       |          ^~
1332 input.y:1.10-11: note: previous declaration
1333     1 | %printer {} "foo"
1334       |          ^~
1335 ]])
1336
1337 # Destructor.
1338 AT_TEST([[%destructor {} "foo"
1339 %destructor {} foo
1340 %token foo "foo"
1341 %%
1342 exp: foo;
1343 ]],
1344 [[input.y:2.13-14: error: %destructor redeclaration for foo
1345     2 | %destructor {} foo
1346       |             ^~
1347 input.y:1.13-14: note: previous declaration
1348     1 | %destructor {} "foo"
1349       |             ^~
1350 ]])
1351
1352 m4_popdef([AT_TEST])
1353 AT_CLEANUP
1354
1355
1356
1357 ## ----------------------- ##
1358 ## Torturing the Scanner.  ##
1359 ## ----------------------- ##
1360
1361 # Be sure to compile and run, so that the C compiler checks what
1362 # we do.
1363
1364 AT_SETUP([Torturing the Scanner])
1365
1366 AT_BISON_OPTION_PUSHDEFS
1367 AT_DATA([input.y], [])
1368 AT_BISON_CHECK([input.y], [1], [],
1369 [[input.y:1.1: error: unexpected end of file
1370 ]])
1371
1372
1373 AT_DATA([input.y],
1374 [{}
1375 ])
1376 AT_BISON_CHECK([-fcaret  input.y], [1], [],
1377 [[input.y:1.1-2: error: unexpected {...}
1378     1 | {}
1379       | ^~
1380 ]])
1381
1382
1383 # Clang chokes on some of our comments, because it tries to "parse"
1384 # some documentation directives in the comments:
1385 #
1386 # input.c:166:50: error: '\a' command does not have a valid word argument [-Werror,-Wdocumentation]
1387 #     FAKE = 258                     /* "fake [] \a\b\f\n\r\t\v\"'?\\[\\ ??!??'??(??)??-??/??<??=??> \001\001"  */
1388 #                                                ~~^
1389 AT_DATA_GRAMMAR([input.y],
1390 [[%code requires {
1391 #if defined __clang__ && 10 <= __clang_major__
1392 # pragma clang diagnostic ignored "-Wdocumentation"
1393 #endif
1394 }
1395
1396 %{
1397 /* This is seen in GCC: a %{ and %} in middle of a comment. */
1398 const char *foo = "So %{ and %} can be here too.";
1399
1400 #if 0
1401 /* These examples test Bison while not stressing C compilers too much.
1402    Many C compilers mishandle backslash-newlines, so this part of the
1403    test is inside "#if 0".  The comment and string are written so that
1404    the "#endif" will be seen regardless of the C compiler bugs that we
1405    know about, namely:
1406
1407      HP C (as of late 2002) mishandles *\[newline]\[newline]/ within a
1408      comment.
1409
1410      The Apple Darwin compiler (as of late 2002) mishandles
1411      \\[newline]' within a character constant.
1412
1413    */
1414
1415 /\
1416 * A comment with backslash-newlines in it. %} *\
1417 \
1418 /
1419 /* { Close the above comment, if the C compiler mishandled it.  */
1420
1421 char str[] = "\\
1422 " A string with backslash-newlines in it %{ %} \\
1423 \
1424 "";
1425
1426 char apostrophe = '\'';
1427 #endif
1428
1429 #include <stdio.h>
1430 #include <stdlib.h>
1431 #include <assert.h>
1432 %}
1433 /* %{ and %} can be here too. */
1434
1435 %{
1436 /* Exercise pre-prologue dependency to %union.  */
1437 typedef int value;
1438 %}
1439
1440 /* Exercise M4 quoting: '@:>@@:>@', 0.  */
1441
1442 /* Also exercise %union. */
1443 %union
1444 {
1445   value ival; /* A comment to exercise an old bug. */
1446 };
1447
1448
1449 /* Exercise post-prologue dependency to %union.  */
1450 %{
1451 static YYSTYPE value_as_yystype (value val);
1452
1453 /* Exercise quotes in declarations.  */
1454 char quote[] = "@:>@@:>@,";
1455 %}
1456
1457 %{
1458 ]AT_YYERROR_DECLARE[
1459 ]AT_YYLEX_DECLARE[
1460 %}
1461
1462 %type <ival> '@<:@'
1463
1464 /* Exercise quotes in strings.  */
1465 %token FAKE "fake @<:@@:>@ \a\b\f\n\r\t\v\"\'\?\\\u005B\U0000005c ??!??'??(??)??-??/??<??=??> \x1\1"
1466
1467 /* Beware of the generated comments that embed string aliases that
1468    might close the comment.  */
1469 %token COMMENT_CLOSE "*/"
1470 %token COMMENT       "/* comment */"
1471
1472 %%
1473 /* Exercise M4 quoting: '@:>@@:>@', @<:@, 1.  */
1474 exp: '@<:@' '\1' two '$' '@' '{' oline output.or.oline.opt
1475   {
1476     /* Exercise quotes in braces.  */
1477     char tmp[] = "@<:@%c@:>@,\n";
1478     printf (tmp, $1);
1479   }
1480 ;
1481
1482 two: '\x000000000000000000000000000000000000000000000000000000000000000000002';
1483 oline: '@' 'o' 'l' 'i' 'n' 'e' '@' '_' '_' 'o' 'l' 'i' 'n' 'e' '_' '_';
1484 output.or.oline.opt: %empty;|oline;;|output;;;
1485 output: '#' 'o' 'u' 't' 'p' 'u' 't' ' ';
1486 %%
1487 /* Exercise M4 quoting: '@:>@@:>@', @<:@, 2.  */
1488
1489 static YYSTYPE
1490 value_as_yystype (value val)
1491 {
1492   YYSTYPE res;
1493   res.ival = val;
1494   return res;
1495 }
1496 ]AT_YYERROR_DEFINE[
1497 static int
1498 yylex (void)
1499 {
1500   static char const input[] = "@<:@\1\2$@{@oline@__@&t@oline__\
1501 #output "; /* "
1502   */
1503   enum { input_elts = sizeof input };
1504   (void) input_elts;
1505   static int toknum;
1506   assert (0 <= toknum && toknum < input_elts);
1507   yylval = value_as_yystype (input[toknum]);
1508   return input[toknum++];
1509 }
1510 ]])
1511
1512 # Pacify Emacs'font-lock-mode: "
1513
1514 AT_DATA([main.c],
1515 [[typedef int value;
1516 #include "input.h"
1517
1518 int yyparse (void);
1519 ]AT_MAIN_DEFINE[
1520 ]])
1521 AT_BISON_OPTION_POPDEFS
1522
1523 AT_BISON_CHECK([-d -v -o input.c input.y])
1524 AT_COMPILE([input.o])
1525 AT_COMPILE([main.o])
1526 AT_COMPILE([input], [input.o main.o])
1527 AT_PARSER_CHECK([input], 0,
1528 [[[@<:@],
1529 ]])
1530
1531 AT_CLEANUP
1532
1533
1534 ## ---------------------- ##
1535 ## Typed symbol aliases.  ##
1536 ## ---------------------- ##
1537
1538 AT_SETUP([Typed symbol aliases])
1539
1540 # Bison 2.0 broke typed symbol aliases - ensure they work.
1541 AT_BISON_OPTION_PUSHDEFS
1542
1543 AT_DATA_GRAMMAR([input.y],
1544 [[%union
1545 {
1546   int val;
1547 };
1548 %token <val> MY_TOKEN "MY TOKEN"
1549 %type <val> exp
1550 %%
1551 exp: "MY TOKEN";
1552 %%
1553 ]])
1554
1555 AT_BISON_CHECK([-o input.c input.y])
1556
1557 AT_BISON_OPTION_POPDEFS
1558 AT_CLEANUP
1559
1560
1561 ## --------- ##
1562 ## Require.  ##
1563 ## --------- ##
1564
1565 m4_define([AT_CHECK_REQUIRE],
1566 [AT_SETUP([Require $1])
1567 AT_BISON_OPTION_PUSHDEFS
1568 AT_DATA_GRAMMAR([input.y],
1569 [[%require "$1";
1570 %%
1571 empty_file: %empty;
1572 ]])
1573 AT_BISON_CHECK([-o input.c input.y], $2, [], ignore)
1574 AT_BISON_OPTION_POPDEFS
1575 AT_CLEANUP
1576 ])
1577
1578 AT_CHECK_REQUIRE(1.0, 0)
1579 AT_CHECK_REQUIRE(AT_PACKAGE_VERSION, 0)
1580 ## FIXME: Some day augment this version number.
1581 AT_CHECK_REQUIRE(100.0, 63)
1582
1583
1584 ## ------------------------------------- ##
1585 ## String aliases for character tokens.  ##
1586 ## ------------------------------------- ##
1587
1588 AT_SETUP([String aliases for character tokens])
1589
1590 # Bison once thought a character token and its alias were different
1591 # symbols with the same code.
1592
1593 AT_BISON_OPTION_PUSHDEFS
1594 AT_DATA_GRAMMAR([input.y],
1595 [[%token 'a' "a"
1596 %%
1597 start: 'a';
1598 %%
1599 ]])
1600
1601 AT_BISON_CHECK([-o input.c input.y])
1602
1603 AT_BISON_OPTION_POPDEFS
1604 AT_CLEANUP
1605
1606
1607 ## -------------- ##
1608 ## Symbol names.  ##
1609 ## -------------- ##
1610
1611 AT_SETUP([Symbols])
1612
1613 AT_BISON_OPTION_PUSHDEFS
1614 AT_DATA_GRAMMAR([input.y],
1615 [[%token WITH-DASH
1616 %token WITHOUT_DASH "WITHOUT-DASH"
1617 %token WITH.PERIOD
1618 %token WITHOUT_PERIOD "WITHOUT.PERIOD"
1619 %code {
1620   ]AT_YYERROR_DECLARE[
1621   ]AT_YYLEX_DECLARE[
1622 }
1623 %%
1624 start: with-dash without_dash with.period without_period;
1625 with-dash: WITH-DASH;
1626 without_dash: "WITHOUT-DASH";
1627 with.period: WITH.PERIOD;
1628 without_period: "WITHOUT.PERIOD";
1629 %%
1630 ]AT_YYERROR_DEFINE[
1631 ]AT_YYLEX_DEFINE[
1632 ]])
1633
1634 # POSIX Yacc accept periods, but not dashes.
1635 AT_BISON_CHECK([--yacc input.y], [], [],
1636 [[input.y:1.1-5: warning: POSIX Yacc does not support %code [-Wyacc]
1637 input.y:9.8-16: warning: POSIX Yacc forbids dashes in symbol names: WITH-DASH [-Wyacc]
1638 input.y:10.21-34: warning: POSIX Yacc does not support string literals [-Wyacc]
1639 input.y:12.23-38: warning: POSIX Yacc does not support string literals [-Wyacc]
1640 input.y:13.1-5: warning: POSIX Yacc does not support %code [-Wyacc]
1641 input.y:20.8-16: warning: POSIX Yacc forbids dashes in symbol names: with-dash [-Wyacc]
1642 input.y:22.15-28: warning: POSIX Yacc does not support string literals [-Wyacc]
1643 input.y:24.17-32: warning: POSIX Yacc does not support string literals [-Wyacc]
1644 ]])
1645
1646 # Dashes are fine for GNU Bison.
1647 AT_BISON_CHECK([-o input.c input.y])
1648
1649 # Make sure we don't export silly token identifiers with periods or dashes.
1650 AT_COMPILE([input.o])
1651
1652
1653 # Periods are genuine letters, they can start identifiers.
1654 # Digits and dashes cannot.
1655 AT_DATA_GRAMMAR([input.y],
1656 [[%token .GOOD
1657          -GOOD
1658          1NV4L1D
1659          -123
1660 %%
1661 start: .GOOD GOOD
1662 ]])
1663 AT_BISON_CHECK([-o input.c input.y], [1], [],
1664 [[input.y:10.10: error: invalid character: '-'
1665 input.y:11.10-16: error: invalid identifier: '1NV4L1D'
1666 input.y:12.10: error: invalid character: '-'
1667 ]])
1668
1669 AT_BISON_OPTION_POPDEFS
1670 AT_CLEANUP
1671
1672
1673 ## ----------------- ##
1674 ## Numbered tokens.  ##
1675 ## ----------------- ##
1676
1677 AT_SETUP([Numbered tokens])
1678
1679 AT_BISON_OPTION_PUSHDEFS
1680 AT_DATA_GRAMMAR([redecl.y],
1681 [[%token DECIMAL_1     11259375
1682          HEXADECIMAL_1 0xabcdef
1683          HEXADECIMAL_2 0xFEDCBA
1684          DECIMAL_2     16702650
1685 %%
1686 start: DECIMAL_1 HEXADECIMAL_2;
1687 ]])
1688
1689 AT_BISON_CHECK([redecl.y], [1], [],
1690 [[redecl.y:10.10-22: error: code 11259375 reassigned to token HEXADECIMAL_1
1691 redecl.y:9.8-16: note: previous declaration for DECIMAL_1
1692 redecl.y:12.10-18: error: code 16702650 reassigned to token DECIMAL_2
1693 redecl.y:11.10-22: note: previous declaration for HEXADECIMAL_2
1694 ]])
1695
1696 AT_DATA_GRAMMAR([too-large.y],
1697 [[%token TOO_LARGE_DEC 999999999999999999999
1698          TOO_LARGE_HEX 0xFFFFFFFFFFFFFFFFFFF
1699 %%
1700 start: TOO_LARGE_DEC TOO_LARGE_HEX
1701 %%
1702 ]])
1703
1704 AT_BISON_CHECK([too-large.y], [1], [],
1705 [[too-large.y:9.22-42: error: integer out of range: '999999999999999999999'
1706 too-large.y:9.22-42: error: code of token TOO_LARGE_DEC too large
1707 too-large.y:10.24-44: error: integer out of range: '0xFFFFFFFFFFFFFFFFFFF'
1708 too-large.y:10.24-44: error: code of token TOO_LARGE_HEX too large
1709 ]])
1710
1711 AT_BISON_OPTION_POPDEFS
1712 AT_CLEANUP
1713
1714
1715 ## --------------------- ##
1716 ## Unclosed constructs.  ##
1717 ## --------------------- ##
1718
1719 AT_SETUP([Unclosed constructs])
1720
1721 # Bison's scan-gram.l once forgot to STRING_FINISH () some unclosed
1722 # constructs, so they were prepended to whatever it STRING_GROW ()'ed
1723 # next.  It also threw them away rather than returning them to the
1724 # parser.  The effect was confusing subsequent error messages.
1725
1726 AT_DATA([input.y],
1727 [[%token A "a
1728 %token B "b"
1729 %token AB "ab" // Used to complain that "ab" was already used.
1730 %token C '1
1731 %token TWO "2"
1732 %token TICK_TWELVE "'12" // Used to complain that "'12" was already used.
1733
1734 %%
1735
1736 start: %empty;
1737
1738 // Used to report a syntax error because it didn't see any kind of symbol
1739 // identifier.
1740 %type <f> 'a
1741 ;
1742 %type <f> "a
1743 ;
1744 // Used to report a syntax error because it didn't see braced code.
1745 %destructor { free ($$)
1746 ]])
1747
1748 AT_BISON_CHECK([-fcaret -o input.c input.y], 1, [],
1749 [[input.y:1.10-2.0: error: missing '"' at end of line
1750     1 | %token A "a
1751       |          ^~
1752 input.y:4.10-5.0: error: missing "'" at end of line
1753     4 | %token C '1
1754       |          ^~
1755 input.y:14.11-15.0: error: missing "'" at end of line
1756    14 | %type <f> 'a
1757       |           ^~
1758 input.y:16.11-17.0: error: missing '"' at end of line
1759    16 | %type <f> "a
1760       |           ^~
1761 input.y:19.13-20.0: error: missing '}' at end of file
1762    19 | %destructor { free ($$)
1763       |             ^~~~~~~~~~~
1764 input.y:20.1: error: unexpected end of file
1765 ]])
1766
1767 AT_CLEANUP
1768
1769
1770 ## ------------------------- ##
1771 ## %start after first rule.  ##
1772 ## ------------------------- ##
1773
1774 AT_SETUP([%start after first rule])
1775
1776 # Bison once complained that a %start after the first rule was a
1777 # redeclaration of the start symbol.
1778
1779 AT_DATA([input.y],
1780 [[%%
1781 false_start: %empty;
1782 start: false_start ;
1783 %start start;
1784 ]])
1785
1786 AT_BISON_CHECK([-o input.c input.y])
1787
1788 AT_CLEANUP
1789
1790
1791 ## --------------------- ##
1792 ## %prec takes a token.  ##
1793 ## --------------------- ##
1794
1795 AT_SETUP([%prec takes a token])
1796
1797 # Bison once allowed %prec sym where sym was a nonterminal.
1798
1799 AT_DATA([input.y],
1800 [[%%
1801 start: PREC %prec PREC ;
1802 PREC: %empty;
1803 ]])
1804
1805 AT_BISON_CHECK([input.y], [1], [],
1806 [[input.y:3.1-4: error: rule given for PREC, which is a token
1807 ]])
1808
1809 AT_CLEANUP
1810
1811
1812 ## ------------------------------- ##
1813 ## %prec's token must be defined.  ##
1814 ## ------------------------------- ##
1815
1816 AT_SETUP([[%prec's token must be defined]])
1817
1818 # According to POSIX, a %prec token must be defined separately.
1819
1820 AT_DATA([[input.y]],
1821 [[%%
1822 start: %prec PREC ;
1823 ]])
1824
1825 AT_BISON_CHECK([[input.y]], [[0]], [],
1826 [[input.y:2.8-17: warning: token for %prec is not defined: PREC [-Wother]
1827 ]])
1828
1829 AT_CLEANUP
1830
1831
1832 ## -------------------------------- ##
1833 ## Reject unused %code qualifiers.  ##
1834 ## -------------------------------- ##
1835
1836 AT_SETUP([Reject unused %code qualifiers])
1837
1838 AT_DATA([input-c.y],
1839 [[%code q {}
1840 %code bad {}
1841 %code bad {}
1842 %code format {}
1843 %%
1844 start: %empty;
1845 ]])
1846 AT_BISON_CHECK([[input-c.y]], [[1]], [],
1847 [[input-c.y:1.7: error: %code qualifier 'q' is not used
1848 input-c.y:2.7-9: error: %code qualifier 'bad' is not used
1849 input-c.y:3.7-9: error: %code qualifier 'bad' is not used
1850 input-c.y:4.7-12: error: %code qualifier 'format' is not used
1851 ]])
1852
1853 AT_DATA([input-c-glr.y],
1854 [[%code q {}
1855 %code bad {}
1856  %code bad {}
1857 %%
1858 start: %empty;
1859 ]])
1860 AT_BISON_CHECK([[input-c-glr.y]], [[1]], [],
1861 [[input-c-glr.y:1.7: error: %code qualifier 'q' is not used
1862 input-c-glr.y:2.7-9: error: %code qualifier 'bad' is not used
1863 input-c-glr.y:3.8-10: error: %code qualifier 'bad' is not used
1864 ]])
1865
1866 AT_DATA([input-c++.y],
1867 [[%code q {}
1868 %code bad {}
1869  %code q {}
1870 %%
1871 start: %empty;
1872 ]])
1873 AT_BISON_CHECK([[input-c++.y]], [[1]], [],
1874 [[input-c++.y:1.7: error: %code qualifier 'q' is not used
1875 input-c++.y:2.7-9: error: %code qualifier 'bad' is not used
1876 input-c++.y:3.8: error: %code qualifier 'q' is not used
1877 ]])
1878
1879 AT_DATA([input-c++-glr.y],
1880 [[%code bad {}
1881 %code q {}
1882 %code q {}
1883 %%
1884 start: %empty;
1885 ]])
1886 AT_BISON_CHECK([[input-c++-glr.y]], [[1]], [],
1887 [[input-c++-glr.y:1.7-9: error: %code qualifier 'bad' is not used
1888 input-c++-glr.y:2.7: error: %code qualifier 'q' is not used
1889 input-c++-glr.y:3.7: error: %code qualifier 'q' is not used
1890 ]])
1891
1892 AT_DATA([special-char-@@.y],
1893 [[%code bad {}
1894 %code q {}
1895 %code q {}
1896 %%
1897 start: %empty;
1898 ]])
1899 AT_BISON_CHECK([[special-char-@@.y]], [[1]], [],
1900 [[special-char-@@.y:1.7-9: error: %code qualifier 'bad' is not used
1901 special-char-@@.y:2.7: error: %code qualifier 'q' is not used
1902 special-char-@@.y:3.7: error: %code qualifier 'q' is not used
1903 ]])
1904
1905 AT_DATA([special-char-@:>@.y],
1906 [[%code bad {}
1907 %code q {}
1908 %code q {}
1909 %%
1910 start: %empty;
1911 ]])
1912 AT_BISON_CHECK([[special-char-@:>@.y]], [[1]], [],
1913 [[special-char-@:>@.y:1.7-9: error: %code qualifier 'bad' is not used
1914 special-char-@:>@.y:2.7: error: %code qualifier 'q' is not used
1915 special-char-@:>@.y:3.7: error: %code qualifier 'q' is not used
1916 ]])
1917
1918 AT_CLEANUP
1919
1920
1921 ## ---------------- ##
1922 ## Multiple %code.  ##
1923 ## ---------------- ##
1924
1925 AT_SETUP([Multiple %code])
1926
1927 # Make sure that repeated arguments to %code are separated by
1928 # end-of-lines.  At some point, a missing eol would leave synclines
1929 # appended to the previous value.  Here, we use CPP directive to
1930 # introduce dependency on the absence/presence of the eol.
1931 AT_BISON_OPTION_PUSHDEFS
1932
1933 AT_DATA([input.y],
1934 [[%code {#include <assert.h>}
1935 %code {#define A B}
1936 %code {#define B C}
1937 %code {#define C D}
1938 %code {#define D 42}
1939 %code {
1940   ]AT_YYERROR_DECLARE[
1941   ]AT_YYLEX_DECLARE[
1942 }
1943 %%
1944 start: %empty;
1945 %%
1946 ]AT_YYERROR_DEFINE[
1947 ]AT_YYLEX_DEFINE[
1948 int main (void)
1949 {
1950   assert (A == 42);
1951   return 0;
1952 }
1953 ]])
1954 AT_FULL_COMPILE([input])
1955 AT_PARSER_CHECK([input])
1956
1957 AT_BISON_OPTION_POPDEFS
1958 AT_CLEANUP
1959
1960
1961 ## ---------------- ##
1962 ## %define errors.  ##
1963 ## ---------------- ##
1964
1965 AT_SETUP([%define errors])
1966
1967 AT_DATA([input-redefined.y],
1968 [[%define var "value1"
1969 %define var "value1"
1970  %define var "value2"
1971 %define special1 "@:>@"
1972 %define special2 "@<:@"
1973 %%
1974 start: %empty;
1975 ]])
1976
1977 AT_BISON_CHECK([[input-redefined.y]], [[1]], [],
1978 [[input-redefined.y:2.1-20: warning: %define variable 'var' redefined [-Wother]
1979 input-redefined.y:1.1-20: note: previous definition
1980 input-redefined.y:3.2-21: error: %define variable 'var' redefined
1981 input-redefined.y:2.1-20: note: previous definition
1982 input-redefined.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
1983 ]])
1984
1985 AT_DATA([input-unused.y],
1986 [[%define var "value"
1987 %%
1988 start: %empty;
1989 ]])
1990
1991 AT_BISON_CHECK([[input-unused.y]], [[1]], [],
1992 [[input-unused.y:1.1-19: error: %define variable 'var' is not used
1993 ]])
1994
1995 AT_CLEANUP
1996
1997
1998 ## ----------------------------------- ##
1999 ## %define, --define, --force-define.  ##
2000 ## ----------------------------------- ##
2001
2002 AT_SETUP([[%define, --define, --force-define]])
2003
2004 AT_DATA([[skel.c]],
2005 [[m4@&t@_divert_push(0)@
2006 @output(b4_parser_file_name@)@
2007 [var-dd: ]b4_percent_define_get([[var-dd]])[
2008 var-ff: ]b4_percent_define_get([[var-ff]])[
2009 var-dfg: ]b4_percent_define_get([[var-dfg]])[
2010 var-fd: ]b4_percent_define_get([[var-fd]])
2011 m4@&t@_divert_pop(0)
2012 ]])
2013 AT_DATA([[input.y]],
2014 [[%define var-dfg "gram"
2015 %%
2016 start: %empty;
2017 ]])
2018 AT_BISON_CHECK([[-Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \
2019                  -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \
2020                  -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \
2021                  -Fvar-fd=cmd-f -Dvar-fd=cmd-d   \
2022                  --skeleton ./skel.c input.y]])
2023 AT_CHECK([[cat input.tab.c]], [[0]],
2024 [[var-dd: cmd-d2
2025 var-ff: cmd-f2
2026 var-dfg: cmd-f
2027 var-fd: cmd-d
2028 ]])
2029
2030 AT_DATA([[input-dg.y]],
2031 [[%define var "gram"
2032 %%
2033 start: %empty;
2034 ]])
2035 AT_BISON_CHECK([[-Dvar=cmd-d input-dg.y]], [[1]], [],
2036 [[input-dg.y:1.1-18: error: %define variable 'var' redefined
2037 <command line>:3: note: previous definition
2038 input-dg.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2039 ]])
2040
2041 AT_DATA([[input-dg.y]],
2042 [[%define var "gram"
2043 %%
2044 start: %empty;
2045 ]])
2046 AT_BISON_CHECK([[-fcaret -Dvar=cmd-d input-dg.y]], [[1]], [],
2047 [[input-dg.y:1.1-18: error: %define variable 'var' redefined
2048     1 | %define var "gram"
2049       | ^~~~~~~~~~~~~~~~~~
2050 <command line>:4: note: previous definition
2051 input-dg.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2052 ]])
2053
2054 AT_DATA([[input-unused.y]],
2055 [[%%
2056 start: %empty;
2057 ]])
2058 AT_BISON_CHECK([[-Dunused-d -Funused-f input-unused.y]], [[1]], [],
2059 [[<command line>:3: error: %define variable 'unused-d' is not used
2060 <command line>:4: error: %define variable 'unused-f' is not used
2061 ]])
2062
2063 AT_CLEANUP
2064
2065
2066 ## --------------------------- ##
2067 ## %define Boolean variables.  ##
2068 ## --------------------------- ##
2069
2070 AT_SETUP([["%define" Boolean variables]])
2071
2072 AT_DATA([Input.y],
2073 [[%language "Java"
2074 %define api.parser.class {Input}
2075 %define api.parser.public {maybe}
2076 %%
2077 start: %empty;
2078 ]])
2079
2080 AT_BISON_CHECK([[Input.y]], [1], [],
2081 [[Input.y:3.1-33: error: invalid value for %define Boolean variable 'api.parser.public'
2082 ]])
2083
2084 AT_CLEANUP
2085
2086
2087 ## ------------------------ ##
2088 ## %define code variables.  ##
2089 ## ------------------------ ##
2090
2091 AT_SETUP([["%define" code variables]])
2092
2093 m4_pushdef([AT_TEST],
2094 [AT_DATA([input.yy],
2095 [[%skeleton "lalr1.cc" %locations
2096 %define api.location.type ]$1[quux]$2[
2097 %define api.namespace     ]$1[quux]$2[
2098 %define api.prefix        ]$1[quux]$2[
2099 %define api.token.prefix  ]$1[quux]$2[
2100 %token TOK // Otherwise api.token.prefix is unused.
2101 %%
2102 start: TOK;
2103 ]])
2104
2105 AT_BISON_CHECK([[input.yy]], [0], [],
2106 [[input.yy:2.$3: warning: %define variable 'api.location.type' requires '{...}' values [-Wdeprecated]
2107 input.yy:4.$3: warning: %define variable 'api.prefix' requires '{...}' values [-Wdeprecated]
2108 input.yy:5.$3: warning: %define variable 'api.token.prefix' requires '{...}' values [-Wdeprecated]
2109 input.yy:3.$3: warning: %define variable 'api.namespace' requires '{...}' values [-Wdeprecated]
2110 ]])
2111 ])
2112
2113 AT_TEST([],  [],  [1-30])
2114 AT_TEST(["], ["], [1-32])
2115 m4_popdef([AT_TEST])
2116
2117 AT_CLEANUP
2118
2119
2120 ## --------------------------- ##
2121 ## %define keyword variables.  ##
2122 ## --------------------------- ##
2123
2124 AT_SETUP([["%define" keyword variables]])
2125
2126 m4_pushdef([AT_TEST],
2127 [AT_DATA([input.y],
2128 [[%define api.pure                ]$1[true]$2[
2129 %define api.push-pull             ]$1[both]$2[
2130 %define lr.default-reduction      ]$1[most]$2[
2131 %define lr.keep-unreachable-state ]$1[true]$2[
2132 %define lr.type                   ]$1[lalr]$2[
2133 %%
2134 exp: %empty
2135 ]])
2136
2137 AT_BISON_CHECK([[input.y]], [0], [],
2138 [[input.y:5.1-40: warning: %define variable 'lr.type' requires keyword values [-Wdeprecated]
2139 input.y:3.1-40: warning: %define variable 'lr.default-reduction' requires keyword values [-Wdeprecated]
2140 input.y:4.1-40: warning: %define variable 'lr.keep-unreachable-state' requires keyword values [-Wdeprecated]
2141 input.y:1.1-38: warning: %define variable 'api.pure' requires keyword values [-Wdeprecated]
2142 input.y:2.1-40: warning: %define variable 'api.push-pull' requires keyword values [-Wdeprecated]
2143 ]])
2144 ])
2145
2146 AT_TEST(["], ["])
2147 AT_TEST([{], [}])
2148 m4_popdef([AT_TEST])
2149
2150 AT_CLEANUP
2151
2152
2153 ## ------------------------ ##
2154 ## %define enum variables.  ##
2155 ## ------------------------ ##
2156
2157 AT_SETUP([["%define" enum variables]])
2158
2159 # Check errors from the front-end, and the back-end.  Since the
2160 # front-end quits before calling the back-end, these tests cannot be
2161 # fused.
2162
2163 # Front-end.
2164 AT_DATA([[input.y]],
2165 [[%define lr.default-reduction bogus
2166 %%
2167 start: %empty;
2168 ]])
2169 AT_BISON_CHECK([[-fcaret input.y]], [[1]], [[]],
2170 [[input.y:1.1-34: error: invalid value for %define variable 'lr.default-reduction': 'bogus'
2171     1 | %define lr.default-reduction bogus
2172       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2173 input.y:1.1-34: note: accepted value: 'most'
2174 input.y:1.1-34: note: accepted value: 'consistent'
2175 input.y:1.1-34: note: accepted value: 'accepting'
2176 ]])
2177
2178 # Check escapes.
2179 AT_DATA([[input.y]],
2180 [[%define lr.default-reduction {[$@]}
2181 %%
2182 start: %empty;
2183 ]])
2184 AT_BISON_CHECK([[-fcaret input.y]], [[1]], [[]],
2185 [[input.y:1.1-35: warning: %define variable 'lr.default-reduction' requires keyword values [-Wdeprecated]
2186     1 | %define lr.default-reduction {[$@]}
2187       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2188 input.y:1.1-35: error: invalid value for %define variable 'lr.default-reduction': '[$@]'
2189     1 | %define lr.default-reduction {[$@]}
2190       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2191 input.y:1.1-35: note: accepted value: 'most'
2192 input.y:1.1-35: note: accepted value: 'consistent'
2193 input.y:1.1-35: note: accepted value: 'accepting'
2194 ]])
2195
2196
2197 # Back-end.
2198 AT_DATA([[input.y]],
2199 [[%define api.push-pull neither
2200 %%
2201 start: %empty;
2202 ]])
2203 AT_BISON_CHECK([[-fcaret input.y]], [[1]], [[]],
2204 [[input.y:1.1-29: error: invalid value for %define variable 'api.push-pull': 'neither'
2205     1 | %define api.push-pull neither
2206       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2207 input.y:1.1-29: note: accepted value: 'pull'
2208 input.y:1.1-29: note: accepted value: 'push'
2209 input.y:1.1-29: note: accepted value: 'both'
2210 ]])
2211
2212 AT_CLEANUP
2213
2214
2215
2216 ## ------------------------ ##
2217 ## %define file variables.  ##
2218 ## ------------------------ ##
2219
2220 AT_SETUP([["%define" file variables]])
2221
2222 AT_DATA([[input.y]],
2223 [[%skeleton "lalr1.cc"
2224 %locations
2225 %define api.location.file {bogus}
2226 %%
2227 start: %empty;
2228 ]])
2229 AT_BISON_CHECK([[-fcaret input.y]], [[1]], [[]],
2230 [[input.y:3.1-33: error: %define variable 'api.location.file' requires 'none' or '"..."' values
2231     3 | %define api.location.file {bogus}
2232       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2233 ]])
2234
2235 AT_CLEANUP
2236
2237
2238 ## -------------------------------- ##
2239 ## %define backward compatibility.  ##
2240 ## -------------------------------- ##
2241
2242 AT_SETUP([["%define" backward compatibility]])
2243
2244 # The error messages tell us whether the variables are properly updated.
2245 AT_DATA([[input.y]],
2246 [[%define api.push_pull both
2247 %define lr.keep_unreachable_states maybe
2248 %define namespace "foo"
2249 %define variant
2250 %define parser_class_name {parser}
2251 %define filename_type {filename}
2252 %%
2253 start: %empty;
2254 ]])
2255 AT_BISON_CHECK([[-fcaret input.y]], [1], [],
2256 [[input.y:1.1-26: warning: deprecated directive: '%define api.push_pull both', use '%define api.push-pull both' [-Wdeprecated]
2257     1 | %define api.push_pull both
2258       | ^~~~~~~~~~~~~~~~~~~~~~~~~~
2259       | %define api.push-pull both
2260 input.y:2.1-40: warning: deprecated directive: '%define lr.keep_unreachable_states maybe', use '%define lr.keep-unreachable-state maybe' [-Wdeprecated]
2261     2 | %define lr.keep_unreachable_states maybe
2262       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2263       | %define lr.keep-unreachable-state maybe
2264 input.y:3.1-23: warning: deprecated directive: '%define namespace "foo"', use '%define api.namespace {foo}' [-Wdeprecated]
2265     3 | %define namespace "foo"
2266       | ^~~~~~~~~~~~~~~~~~~~~~~
2267       | %define api.namespace {foo}
2268 input.y:4.1-15: warning: deprecated directive: '%define variant', use '%define api.value.type variant' [-Wdeprecated]
2269     4 | %define variant
2270       | ^~~~~~~~~~~~~~~
2271       | %define api.value.type variant
2272 input.y:5.1-34: warning: deprecated directive: '%define parser_class_name {parser}', use '%define api.parser.class {parser}' [-Wdeprecated]
2273     5 | %define parser_class_name {parser}
2274       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2275       | %define api.parser.class {parser}
2276 input.y:6.1-32: warning: deprecated directive: '%define filename_type {filename}', use '%define api.filename.type {filename}' [-Wdeprecated]
2277     6 | %define filename_type {filename}
2278       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2279       | %define api.filename.type {filename}
2280 input.y:2.1-40: error: invalid value for %define Boolean variable 'lr.keep-unreachable-state'
2281     2 | %define lr.keep_unreachable_states maybe
2282       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2283 input.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2284 ]])
2285
2286 AT_CLEANUP
2287
2288
2289 ## ------------------------- ##
2290 ## Unused %define api.pure.  ##
2291 ## ------------------------- ##
2292
2293 AT_SETUP([[Unused %define api.pure]])
2294
2295 # AT_TEST(DECLS, VALUE, LOCATION)
2296 # -------------------------------
2297 # Make sure Bison reports that '%define api.pure VALUE' is unused when DECLS
2298 # are specified.
2299 m4_pushdef([AT_TEST],
2300 [
2301 AT_DATA([[input.y]],
2302 [[%define api.pure ]$2[
2303 ]$1[
2304 %%
2305 start: %empty;
2306 ]])
2307
2308 AT_BISON_CHECK([[input.y]], [[1]], [],
2309 [[input.y:]$3[: error: %define variable 'api.pure' is not used
2310 ]])
2311 ])
2312
2313 AT_TEST([[%language "c++"]],             [[]],      [[1.1-16]])
2314 AT_TEST([[%language "c++"]],             [[false]], [[1.1-22]])
2315 AT_TEST([[%language "c++" %glr-parser]], [[""]],    [[1.1-19]])
2316 AT_TEST([[%language "c++" %glr-parser]], [[false]], [[1.1-22]])
2317 AT_TEST([[%language "java"]],            [[true]],  [[1.1-21]])
2318 AT_TEST([[%language "java"]],            [[false]], [[1.1-22]])
2319
2320 m4_popdef([AT_TEST])
2321
2322 AT_CLEANUP
2323
2324
2325 ## -------------------------------- ##
2326 ## C++ namespace reference errors.  ##
2327 ## -------------------------------- ##
2328
2329 AT_SETUP([[C++ namespace reference errors]])
2330
2331 # AT_CHECK_NAMESPACE_ERROR(NAMESPACE-DECL, ERROR, [ERROR], ...)
2332 # -------------------------------------------------------------
2333 # Make sure Bison reports all ERROR's for %define namespace "NAMESPACE-DECL".
2334 m4_define([AT_CHECK_NAMESPACE_ERROR],
2335 [
2336 AT_DATA([[input.y]],
2337 [[%language "C++"
2338 %defines
2339 %define api.namespace {]$1[}
2340 %%
2341 start: %empty;
2342 ]])
2343
2344 AT_BISON_CHECK([[input.y]], [1], [],
2345 [m4_foreach([b4_arg], m4_dquote(m4_shift($@)),
2346 [b4_arg
2347 ])])
2348 ])
2349
2350 AT_CHECK_NAMESPACE_ERROR([[]],
2351                          [[input.y:3.1-24: error: namespace reference is empty]])
2352 AT_CHECK_NAMESPACE_ERROR([[ @tb@@tb@  @tb@ @tb@]],
2353                          [[input.y:3.1-57: error: namespace reference is empty]])
2354 AT_CHECK_NAMESPACE_ERROR([[foo::::bar]],
2355                          [[input.y:3.1-34: error: namespace reference has consecutive "::"]])
2356 AT_CHECK_NAMESPACE_ERROR([[foo:: @tb@::bar]],
2357                          [[input.y:3.1-38: error: namespace reference has consecutive "::"]])
2358 AT_CHECK_NAMESPACE_ERROR([[::::bar]],
2359                          [[input.y:3.1-31: error: namespace reference has consecutive "::"]])
2360 AT_CHECK_NAMESPACE_ERROR([[:: ::bar]],
2361                          [[input.y:3.1-32: error: namespace reference has consecutive "::"]])
2362 AT_CHECK_NAMESPACE_ERROR([[foo::bar::@tb@::]],
2363                          [[input.y:3.1-43: error: namespace reference has consecutive "::"]],
2364                          [[input.y:3.1-43: error: namespace reference has a trailing "::"]])
2365 AT_CHECK_NAMESPACE_ERROR([[foo::bar::]],
2366                          [[input.y:3.1-34: error: namespace reference has a trailing "::"]])
2367 AT_CHECK_NAMESPACE_ERROR([[foo::bar:: @tb@]],
2368                          [[input.y:3.1-41: error: namespace reference has a trailing "::"]])
2369 AT_CHECK_NAMESPACE_ERROR([[::]],
2370                          [[input.y:3.1-26: error: namespace reference has a trailing "::"]])
2371
2372 AT_CLEANUP
2373
2374
2375 ## ------------------------ ##
2376 ## Bad character literals.  ##
2377 ## ------------------------ ##
2378
2379 # Bison used to accept character literals that were empty or contained
2380 # too many characters.
2381
2382 AT_SETUP([[Bad character literals]])
2383
2384 AT_DATA_NO_FINAL_EOL([empty.y],
2385 [[%%
2386 start: '';
2387 start: '
2388 start: ']])
2389
2390 AT_BISON_CHECK([-fcaret empty.y], [1], [],
2391 [[empty.y:2.8-9: error: empty character literal
2392     2 | start: '';
2393       |        ^~
2394 empty.y:3.8-4.0: error: missing "'" at end of line
2395     3 | start: '
2396       |        ^
2397 empty.y:3.8-4.0: error: empty character literal
2398     3 | start: '
2399       |        ^
2400 empty.y:4.8: error: missing "'" at end of file
2401     4 | start: '
2402       |        ^
2403 empty.y:4.8: error: empty character literal
2404     4 | start: '
2405       |        ^
2406 ]])
2407
2408 AT_DATA_NO_FINAL_EOL([two.y],
2409 [[%%
2410 start: 'ab';
2411 start: 'ab
2412 start: 'ab]])
2413
2414 AT_BISON_CHECK([two.y], [1], [],
2415 [[two.y:2.8-11: error: extra characters in character literal
2416 two.y:3.8-4.0: error: missing "'" at end of line
2417 two.y:3.8-4.0: error: extra characters in character literal
2418 two.y:4.8-10: error: missing "'" at end of file
2419 two.y:4.8-10: error: extra characters in character literal
2420 ]])
2421
2422 AT_DATA_NO_FINAL_EOL([three.y],
2423 [[%%
2424 start: 'abc';
2425 start: 'abc
2426 start: 'abc]])
2427
2428 AT_BISON_CHECK([three.y], [1], [],
2429 [[three.y:2.8-12: error: extra characters in character literal
2430 three.y:3.8-4.0: error: missing "'" at end of line
2431 three.y:3.8-4.0: error: extra characters in character literal
2432 three.y:4.8-11: error: missing "'" at end of file
2433 three.y:4.8-11: error: extra characters in character literal
2434 ]])
2435
2436 AT_CLEANUP
2437
2438
2439 ## ------------------------- ##
2440 ## Bad escapes in literals.  ##
2441 ## ------------------------- ##
2442
2443 AT_SETUP([[Bad escapes in literals]])
2444
2445 AT_DATA([input.y],
2446 [[%%
2447 start: '\777' '\0' '\xfff' '\x0'
2448        '\uffff' '\u0000' '\Uffffffff' '\U00000000'
2449        '\ ' '\A';
2450 ]])
2451
2452 # It is not easy to create special characters, we cannot even trust tr.
2453 # Beside we cannot even expect "echo '\0'" to output two characters
2454 # (well three with \n): at least Bash 3.2 converts the two-character
2455 # sequence "\0" into a single NUL character.
2456 AT_PERL_REQUIRE([[-e 'print "start: \"\\\t\\\f\\\0\\\1\" ;";' >> input.y]])
2457
2458 AT_BISON_CHECK([input.y], [1], [],
2459 [[input.y:2.9-12: error: invalid number after \-escape: 777
2460 input.y:2.16-17: error: invalid number after \-escape: 0
2461 input.y:2.21-25: error: invalid number after \-escape: xfff
2462 input.y:2.29-31: error: invalid number after \-escape: x0
2463 input.y:3.9-14: error: invalid number after \-escape: uffff
2464 input.y:3.18-23: error: invalid number after \-escape: u0000
2465 input.y:3.27-36: error: invalid number after \-escape: Uffffffff
2466 input.y:3.40-49: error: invalid number after \-escape: U00000000
2467 input.y:4.9-10: error: invalid character after \-escape: ' '
2468 input.y:4.14-15: error: invalid character after \-escape: A
2469 input.y:5.9-16: error: invalid character after \-escape: \t
2470 input.y:5.17: error: invalid character after \-escape: \f
2471 input.y:5.18: error: invalid character after \-escape: \0
2472 input.y:5.19: error: invalid character after \-escape: \001
2473 ]])
2474
2475 AT_CLEANUP
2476
2477
2478 ## ------------------------- ##
2479 ## LAC: Errors for %define.  ##
2480 ## ------------------------- ##
2481
2482 AT_SETUP([[LAC: Errors for %define]])
2483 AT_KEYWORDS([lac])
2484
2485 AT_DATA([[input.y]],
2486 [[%%
2487 start: %empty;
2488 ]])
2489
2490 # Only "full" and "none" are accepted for parse.lac
2491 # Unknown values (such as "unsupported") are rejected
2492 AT_BISON_CHECK([[-Dparse.lac=none input.y]])
2493 AT_BISON_CHECK([[-Dparse.lac=none -L c++ input.y]])
2494 AT_BISON_CHECK([[-Dparse.lac=full input.y]])
2495 AT_BISON_CHECK([[-Dparse.lac=full -L c++ input.y]])
2496 AT_BISON_CHECK([[-Dparse.lac=unsupported input.y]],
2497                [[1]], [],
2498 [[<command line>:3: error: invalid value for %define variable 'parse.lac': 'unsupported'
2499 <command line>:3: note: accepted value: 'full'
2500 <command line>:3: note: accepted value: 'none'
2501 ]])
2502 AT_BISON_CHECK([[-Dparse.lac=unsupported -L c++ input.y]],
2503                [[1]], [],
2504 [[<command line>:3: error: invalid value for %define variable 'parse.lac': 'unsupported'
2505 <command line>:3: note: accepted value: 'full'
2506 <command line>:3: note: accepted value: 'none'
2507 ]])
2508
2509 # parse.lac.* options are useless if LAC isn't actually activated.
2510 AT_BISON_CHECK([[-Dparse.lac.es-capacity-initial=1 input.y]],
2511                [[1]], [],
2512 [[<command line>:3: error: %define variable 'parse.lac.es-capacity-initial' is not used
2513 ]])
2514 AT_BISON_CHECK([[-Dparse.lac.memory-trace=full input.y]],
2515                [[1]], [],
2516 [[<command line>:3: error: %define variable 'parse.lac.memory-trace' is not used
2517 ]])
2518
2519 # parse.lac.* options are useless in C++ even if LAC isn't actually activated.
2520 AT_BISON_CHECK([[-Dparse.lac.es-capacity-initial=1 -L C++ -Dparse.lac=full input.y]],
2521                [[1]], [],
2522 [[<command line>:3: error: %define variable 'parse.lac.es-capacity-initial' is not used
2523 ]])
2524 AT_BISON_CHECK([[-Dparse.lac.memory-trace=full -L C++ -Dparse.lac=full input.y]],
2525                [[1]], [],
2526 [[<command line>:3: error: %define variable 'parse.lac.memory-trace' is not used
2527 ]])
2528
2529 AT_CLEANUP
2530
2531
2532 ## ---------------------- ##
2533 ## -Werror combinations.  ##
2534 ## ---------------------- ##
2535
2536 AT_SETUP([[-Werror combinations]])
2537
2538 AT_DATA([[input.y]],
2539 [[%%
2540 a: '0' { $$ = $; };
2541 ]])
2542
2543 # -Werror is not enabled by -Wall or equivalent.
2544 AT_BISON_CHECK([[-Wall input.y]], [[0]], [[]],
2545 [[input.y:2.15: warning: stray '$' [-Wother]
2546 ]])
2547 AT_BISON_CHECK([[-W input.y]], [[0]], [[]],
2548 [[input.y:2.15: warning: stray '$' [-Wother]
2549 ]])
2550 AT_BISON_CHECK([[-Wno-none input.y]], [[0]], [[]],
2551 [[input.y:2.15: warning: stray '$' [-Wother]
2552 ]])
2553
2554 # -Werror is not disabled by -Wnone or equivalent.
2555 AT_BISON_CHECK([[-Werror,none,other input.y]], [[1]], [[]],
2556 [[input.y:2.15: error: stray '$' [-Werror=other]
2557 ]])
2558 AT_BISON_CHECK([[-Werror,no-all,other input.y]], [[1]], [[]],
2559 [[input.y:2.15: error: stray '$' [-Werror=other]
2560 ]])
2561
2562 # Check that -Wno-error keeps warnings enabled, but non fatal.
2563 AT_BISON_CHECK([[-Werror -Wno-error=other input.y]], [[0]], [[]],
2564 [[input.y:2.15: warning: stray '$' [-Wother]
2565 ]])
2566
2567 AT_BISON_CHECK([[-Wno-error=other -Werror input.y]], [[0]], [[]],
2568 [[input.y:2.15: warning: stray '$' [-Wother]
2569 ]])
2570
2571 AT_BISON_CHECK([[-Werror=other -Wno-other input.y]], [[0]], [[]],
2572 [[]])
2573
2574 AT_CLEANUP
2575
2576
2577 ## ------------------------------------------------------ ##
2578 ## %name-prefix and %define api.prefix are incompatible.  ##
2579 ## ------------------------------------------------------ ##
2580
2581 AT_SETUP([[%name-prefix and api.prefix are incompatible]])
2582
2583 # AT_TEST(DIRECTIVES, OPTIONS, ERROR-LOCATION)
2584 # --------------------------------------------
2585 m4_pushdef([AT_TEST],
2586 [AT_DATA([[input.y]],
2587 [[$1
2588 %%
2589 exp: %empty;
2590 ]])
2591 AT_BISON_CHECK([[$2 -Wno-deprecated input.y]], [[1]], [[]],
2592 [[$3: error: '%name-prefix' and '%define api.prefix' cannot be used together
2593 ]])
2594 ])
2595
2596 AT_TEST([%define api.prefix {foo} %name-prefix "bar"], [], [input.y:1.1-24])
2597 AT_TEST([], [-Dapi.prefix={foo} -p bar],                   [<command line>:3])
2598 AT_TEST([%name-prefix "bar"], [-Dapi.prefix={foo}],        [<command line>:3])
2599 AT_TEST([%define api.prefix {foo}], [-p bar],              [input.y:1.1-24])
2600
2601 m4_popdef([AT_TEST])
2602
2603 AT_CLEANUP
2604
2605
2606 ## ----------------------- ##
2607 ## Redefined %union name.  ##
2608 ## ----------------------- ##
2609
2610 AT_SETUP([[Redefined %union name]])
2611
2612 # AT_TEST(DIRECTIVES, EXIT-STATUS, ERROR)
2613 # ---------------------------------------
2614 m4_pushdef([AT_TEST],
2615 [AT_DATA([[input.y]],
2616 [$1
2617 %%
2618 exp: %empty;
2619 ])
2620
2621 AT_BISON_CHECK([[input.y]], [$2], [[]],
2622 [$3])
2623 ])
2624
2625 AT_TEST([[%union foo {};
2626 %union {};
2627 %union foo {};
2628 %define api.value.union.name foo]],
2629 [0],
2630 [[input.y:3.8-10: warning: %define variable 'api.value.union.name' redefined [-Wother]
2631 input.y:1.8-10: note: previous definition
2632 input.y:4.1-32: warning: %define variable 'api.value.union.name' redefined [-Wother]
2633 input.y:3.8-10: note: previous definition
2634 input.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2635 ]])
2636
2637 AT_TEST([[%define api.value.union.name {foo}]], [1],
2638 [[input.y:1.1-34: error: %define variable 'api.value.union.name' requires keyword values
2639 input.y:1.1-34: error: %define variable 'api.value.union.name' is not used
2640 ]])
2641
2642 AT_TEST([[%define api.value.union.name "foo"]], [1],
2643 [[input.y:1.1-34: error: %define variable 'api.value.union.name' requires keyword values
2644 input.y:1.1-34: error: %define variable 'api.value.union.name' is not used
2645 ]])
2646
2647 m4_popdef([AT_TEST])
2648 AT_CLEANUP
2649
2650
2651
2652
2653 ## -------------- ##
2654 ## Stray $ or @.  ##
2655 ## -------------- ##
2656
2657 AT_SETUP([[Stray $ or @]])
2658 AT_BISON_OPTION_PUSHDEFS
2659
2660 # Give %printer and %destructor "<*> exp TOK" instead of "<*>" to
2661 # check that the warnings are reported once, not three times.
2662
2663 AT_DATA_GRAMMAR([[input.y]],
2664 [[%type <TYPE> exp
2665 %token <TYPE> TOK TOK2
2666 %destructor     { $%; @%; } <*> exp TOK;
2667 %initial-action { $%; @%; };
2668 %printer        { $%; @%; } <*> exp TOK;
2669 %{ $ @ %} // Should not warn.
2670 %%
2671 exp: TOK        { $%; @%; $$ = $1; }
2672    | 'a'        { $<->1; $$ = 1; }
2673    | 'b'        { $<foo->bar>$; }
2674 %%
2675 $ @ // Should not warn.
2676 ]])
2677
2678 AT_BISON_CHECK([[-Wall input.y]], 0, [],
2679 [[input.y:11.19: warning: stray '$' [-Wother]
2680 input.y:11.23: warning: stray '@' [-Wother]
2681 input.y:12.19: warning: stray '$' [-Wother]
2682 input.y:12.23: warning: stray '@' [-Wother]
2683 input.y:13.19: warning: stray '$' [-Wother]
2684 input.y:13.23: warning: stray '@' [-Wother]
2685 input.y:16.19: warning: stray '$' [-Wother]
2686 input.y:16.23: warning: stray '@' [-Wother]
2687 input.y:17.19: warning: stray '$' [-Wother]
2688 ]])
2689
2690 AT_BISON_OPTION_POPDEFS
2691 AT_CLEANUP
2692
2693
2694
2695 ## ---------------- ##
2696 ## Code injection.  ##
2697 ## ---------------- ##
2698
2699
2700 AT_SETUP([[Code injection]])
2701
2702 m4_pattern_allow([^m4_errprintn$])
2703
2704 # AT_TEST([MACRO])
2705 # ----------------
2706 # Try to have MACRO be run by bison.
2707 m4_pushdef([AT_TEST],
2708 [AT_DATA([[input.y]],
2709 [[%type <$1(DEAD %type)> exp
2710 %token <$1(DEAD %token)> a
2711 %token b
2712 %initial-action
2713 {
2714   $$;
2715   $<$1(DEAD %initial-action)>$
2716 };
2717 %printer
2718 {
2719   $$
2720   $<$1(DEAD %printer)>$
2721 } <> <*>;
2722 %lex-param
2723 {
2724   $1(DEAD %lex-param)
2725 };
2726 %parse-param
2727 {
2728   $1(DEAD %parse-param)
2729 };
2730 %%
2731 exp:
2732   a a[name] b
2733   {
2734     $$;
2735     $][1;
2736     $<$1(DEAD action 1)>$
2737     $<$1(DEAD action 2)>1
2738     $<$1(DEAD action 3)>name
2739     $<$1(DEAD action 4)>0
2740     ;
2741   };
2742 ]])
2743
2744 # FIXME: Provide a means to iterate over all the skeletons.
2745 AT_BISON_CHECK([[-d               input.y]])
2746 AT_BISON_CHECK([[-d -S glr.c      input.y]])
2747 AT_BISON_CHECK([[-d -S lalr1.cc   input.y]])
2748 AT_BISON_CHECK([[-d -S glr.cc     input.y]])
2749 AT_BISON_CHECK([[   -S lalr1.java input.y]])
2750 ])
2751
2752 AT_TEST([m4_errprintn])
2753 AT_TEST([@:>@m4_errprintn])
2754
2755 m4_popdef([AT_TEST])
2756
2757 AT_CLEANUP
2758
2759
2760 ##----------------------- ##
2761 ## Deprecated directives. ##
2762 ## ---------------------- ##
2763
2764 AT_SETUP([[Deprecated directives]])
2765
2766 AT_KEYWORDS([[deprec]])
2767
2768 AT_BISON_OPTION_PUSHDEFS
2769 AT_DATA_GRAMMAR([[input.y]],
2770 [[
2771 %default_prec
2772 %error_verbose
2773 %expect_rr 0
2774 %file-prefix = "foo"
2775 %file-prefix
2776  =
2777 "bar"
2778         %fixed-output_files
2779         %fixed_output-files
2780 %fixed-output-files
2781 %name-prefix= "foo"
2782 %no-default_prec
2783 %no_default-prec
2784 %no_lines
2785 %output = "output.c"
2786 %pure_parser
2787 %token_table
2788 %error-verbose
2789 %glr-parser
2790 %name-prefix "bar"
2791 %%
2792 exp : '0'
2793 ]])
2794
2795 AT_DATA([errors-all],
2796 [[input.y:10.1-13: warning: deprecated directive: '%default_prec', use '%default-prec' [-Wdeprecated]
2797 fix-it:"input.y":{10:1-10:14}:"%default-prec"
2798 input.y:11.1-14: warning: deprecated directive: '%error_verbose', use '%define parse.error verbose' [-Wdeprecated]
2799 fix-it:"input.y":{11:1-11:15}:"%define parse.error verbose"
2800 input.y:12.1-10: warning: deprecated directive: '%expect_rr', use '%expect-rr' [-Wdeprecated]
2801 fix-it:"input.y":{12:1-12:11}:"%expect-rr"
2802 input.y:13.1-14: warning: deprecated directive: '%file-prefix =', use '%file-prefix' [-Wdeprecated]
2803 fix-it:"input.y":{13:1-13:15}:"%file-prefix"
2804 input.y:14.1-16.5: warning: duplicate directive: '%file-prefix\n =' [-Wother]
2805 input.y:13.1-20: note: previous declaration
2806 fix-it:"input.y":{14:1-16:6}:""
2807 input.y:17.9-27: warning: deprecated directive: '%fixed-output_files', use '%output "y.tab.c"' [-Wdeprecated]
2808 fix-it:"input.y":{17:2-17:21}:"%output \"y.tab.c\""
2809 input.y:18.9-27: warning: deprecated directive: '%fixed_output-files', use '%output "y.tab.c"' [-Wdeprecated]
2810 fix-it:"input.y":{18:9-18:28}:"%output \"y.tab.c\""
2811 input.y:19.1-19: warning: deprecated directive: '%fixed-output-files', use '%output "y.tab.c"' [-Wdeprecated]
2812 fix-it:"input.y":{19:1-19:20}:"%output \"y.tab.c\""
2813 input.y:20.1-19: warning: deprecated directive: '%name-prefix= "foo"', use '%define api.prefix {foo}' [-Wdeprecated]
2814 fix-it:"input.y":{20:1-20:20}:"%define api.prefix {foo}"
2815 input.y:21.1-16: warning: deprecated directive: '%no-default_prec', use '%no-default-prec' [-Wdeprecated]
2816 fix-it:"input.y":{21:1-21:17}:"%no-default-prec"
2817 input.y:22.1-16: warning: deprecated directive: '%no_default-prec', use '%no-default-prec' [-Wdeprecated]
2818 fix-it:"input.y":{22:1-22:17}:"%no-default-prec"
2819 input.y:23.1-9: warning: deprecated directive: '%no_lines', use '%no-lines' [-Wdeprecated]
2820 fix-it:"input.y":{23:1-23:10}:"%no-lines"
2821 input.y:24.1-9: warning: deprecated directive: '%output =', use '%output' [-Wdeprecated]
2822 fix-it:"input.y":{24:1-24:10}:"%output"
2823 input.y:25.1-12: warning: deprecated directive: '%pure_parser', use '%define api.pure' [-Wdeprecated]
2824 fix-it:"input.y":{25:1-25:13}:"%define api.pure"
2825 input.y:26.1-12: warning: deprecated directive: '%token_table', use '%token-table' [-Wdeprecated]
2826 fix-it:"input.y":{26:1-26:13}:"%token-table"
2827 input.y:27.1-14: warning: %define variable 'parse.error' redefined [-Wother]
2828 input.y:11.1-14: note: previous definition
2829 fix-it:"input.y":{27:1-27:15}:""
2830 input.y:29.1-18: warning: duplicate directive: '%name-prefix "bar"' [-Wother]
2831 input.y:13.1-20: note: previous declaration
2832 fix-it:"input.y":{29:1-29:19}:""
2833 input.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2834 ]])
2835
2836 AT_CHECK([cp errors-all experr])
2837 AT_BISON_CHECK([[-ffixit input.y]], [], [], [experr])
2838
2839 AT_CHECK([[sed -e '/^fix-it:/d' errors-all >experr]])
2840 AT_BISON_CHECK([[input.y]], [], [], [experr])
2841
2842
2843 # Update the input file.  Make sure we generated nothing.
2844 AT_CHECK([rm -f output.c])
2845 AT_CHECK([cp input.y input.y.orig])
2846 AT_CHECK([sed -e '/fix-it/d' <errors-all >experr])
2847 AT_CHECK([echo "bison: file 'input.y' was updated (backup: 'input.y~')" >>experr])
2848 AT_BISON_CHECK([[--update input.y]], [], [[]], [experr])
2849
2850 # Check the backup.
2851 AT_CHECK([diff input.y.orig input.y~])
2852
2853 # Check we did not generate any file.
2854 AT_CHECK([test ! -f output.c])
2855
2856 # Check the update.
2857 AT_CHECK([sed -e '1,8d' input.y], [],
2858 [[
2859 %default-prec
2860 %define parse.error verbose
2861 %expect-rr 0
2862 %file-prefix "foo"
2863         %output "y.tab.c"
2864         %output "y.tab.c"
2865 %output "y.tab.c"
2866 %define api.prefix {foo}
2867 %no-default-prec
2868 %no-default-prec
2869 %no-lines
2870 %output "output.c"
2871 %define api.pure
2872 %token-table
2873 %glr-parser
2874 %%
2875 exp : '0'
2876 ]])
2877
2878 AT_BISON_CHECK([[input.y]])
2879
2880 AT_BISON_OPTION_POPDEFS
2881 AT_CLEANUP
2882
2883
2884 ## ---------------------------- ##
2885 ## Unput's effect on locations. ##
2886 ## ---------------------------- ##
2887
2888 # When the scanner detects a deprecated construct, it unputs the
2889 # correct version, but it should *not* have any impact on the scanner
2890 # cursor. If it does, the locations of directives on the same line
2891 # become erroneous.
2892
2893 AT_SETUP([[Unput's effect on locations]])
2894
2895 AT_KEYWORDS([[deprec]])
2896
2897 AT_BISON_OPTION_PUSHDEFS
2898 AT_DATA_GRAMMAR([[input.y]],
2899 [[
2900 %glr-parser
2901 %expect_rr 42 %expect_rr 42
2902               %expect_rr 42
2903 %error_verbose %error_verbose
2904                %error_verbose
2905 %% exp: '0'
2906 ]])
2907
2908 AT_BISON_CHECK([[input.y]], [[1]], [[]],
2909 [[input.y:11.1-10: warning: deprecated directive: '%expect_rr', use '%expect-rr' [-Wdeprecated]
2910 input.y:11.15-24: warning: deprecated directive: '%expect_rr', use '%expect-rr' [-Wdeprecated]
2911 input.y:12.15-24: warning: deprecated directive: '%expect_rr', use '%expect-rr' [-Wdeprecated]
2912 input.y:13.1-14: warning: deprecated directive: '%error_verbose', use '%define parse.error verbose' [-Wdeprecated]
2913 input.y:13.16-29: warning: %define variable 'parse.error' redefined [-Wother]
2914 input.y:13.1-14: note: previous definition
2915 input.y:14.16-29: warning: %define variable 'parse.error' redefined [-Wother]
2916 input.y:13.16-29: note: previous definition
2917 input.y: error: reduce/reduce conflicts: 0 found, 42 expected
2918 input.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2919 ]])
2920
2921 AT_BISON_OPTION_POPDEFS
2922 AT_CLEANUP
2923
2924
2925 ## -------------------------- ##
2926 ## Non-deprecated directives. ##
2927 ## -------------------------- ##
2928
2929 AT_SETUP([[Non-deprecated directives]])
2930
2931 AT_KEYWORDS([[deprec]])
2932
2933 AT_BISON_OPTION_PUSHDEFS
2934 AT_DATA_GRAMMAR([[input.y]],
2935 [[
2936 %default-prec
2937 %define parse.error verbose
2938 %expect-rr 42
2939 %file-prefix "foo"
2940 %file-prefix
2941 "bar"
2942 %no-default-prec
2943 %no-lines
2944 %output "foo"
2945 %token-table
2946 %% exp : '0'
2947 ]])
2948
2949 AT_BISON_CHECK([[input.y]], [[0]], [[]],
2950 [[input.y:14.1-15.5: warning: duplicate directive: '%file-prefix' [-Wother]
2951 input.y:13.1-18: note: previous declaration
2952 input.y: warning: %expect-rr applies only to GLR parsers [-Wother]
2953 input.y: warning: fix-its can be applied.  Rerun with option '--update'. [-Wother]
2954 ]])
2955
2956 AT_BISON_OPTION_POPDEFS
2957 AT_CLEANUP
2958
2959
2960 ## -------------------- ##
2961 ## Cannot type action.  ##
2962 ## -------------------- ##
2963
2964 AT_SETUP([[Cannot type action]])
2965
2966 AT_BISON_OPTION_PUSHDEFS
2967 AT_DATA_GRAMMAR([[input.y]],
2968 [[%%
2969 exp: <int> {}
2970 ]])
2971
2972 AT_BISON_CHECK([[-fcaret input.y]], [[0]], [[]],
2973 [[input.y:10.6-13: warning: only midrule actions can be typed: int [-Wother]
2974    10 | exp: <int> {}
2975       |      ^~~~~~~~
2976 ]])
2977
2978 AT_BISON_OPTION_POPDEFS
2979 AT_CLEANUP
2980
2981
2982
2983 ## -------------------------------------- ##
2984 ## Character literals and api.token.raw.  ##
2985 ## -------------------------------------- ##
2986
2987 AT_SETUP([[Character literals and api.token.raw]])
2988
2989 AT_BISON_OPTION_PUSHDEFS
2990 AT_DATA_GRAMMAR([[input.y]],
2991 [[%define api.token.raw
2992 %token 'a'
2993 %%
2994 exp: 'b' "c" {}
2995 ]])
2996
2997 AT_BISON_CHECK([[-fcaret input.y]], [[1]], [[]],
2998 [[input.y:10.8-10: error: character literals cannot be used together with api.token.raw
2999    10 | %token 'a'
3000       |        ^~~
3001 input.y:9.1-21: note: definition of api.token.raw
3002     9 | %define api.token.raw
3003       | ^~~~~~~~~~~~~~~~~~~~~
3004 input.y:12.6-8: error: character literals cannot be used together with api.token.raw
3005    12 | exp: 'b' "c" {}
3006       |      ^~~
3007 input.y:9.1-21: note: definition of api.token.raw
3008     9 | %define api.token.raw
3009       | ^~~~~~~~~~~~~~~~~~~~~
3010 ]])
3011
3012 AT_BISON_OPTION_POPDEFS
3013 AT_CLEANUP
3014
3015
3016
3017 ## ------------------------------ ##
3018 ## %token-table and parse.error.  ##
3019 ## ------------------------------ ##
3020
3021 AT_SETUP([[%token-table and parse.error]])
3022
3023 # AT_TEST(DIRECTIVES, ERROR-LOCATION)
3024 # -----------------------------------
3025 m4_pushdef([AT_TEST],
3026 [AT_DATA([[input.y]],
3027 [[$1
3028 %%
3029 exp: %empty;
3030 ]])
3031 AT_BISON_CHECK([[input.y]], [[1]], [[]],
3032 [$2: error: '%token-table' and '%define parse.error (custom|detailed)' cannot be used together
3033 ])
3034 ])
3035
3036 AT_TEST([%define parse.error custom %token-table],  [[input.y:1.1-26]])
3037 AT_TEST([%define parse.error detailed %token-table],[[input.y:1.1-28]])
3038
3039 m4_popdef([AT_TEST])
3040
3041 AT_CLEANUP
3042
3043 ## --------------------------------------- ##
3044 ## Invalid file prefix mapping arguments.  ##
3045 ## --------------------------------------- ##
3046
3047 AT_SETUP([[Invalid file prefix mapping arguments]])
3048
3049 # AT_TEST(DIRECTIVES, OPTIONS, ERROR-LOCATION)
3050 # --------------------------------------------
3051 m4_pushdef([AT_TEST],
3052 [AT_DATA([[input.y]],
3053 [[
3054 %%
3055 exp: %empty;
3056 ]])
3057 AT_BISON_CHECK([[$1 input.y]], [[1]], [[]],
3058 [[$3: error: invalid argument for '--file-prefix-map': $2
3059 ]])
3060 ])
3061
3062 AT_TEST([-M foo], [foo], [<command line>:4])
3063 AT_TEST([--file-prefix-map foo], [foo], [<command line>:4])
3064 AT_TEST([-M foo=bar -M baz], [baz], [<command line>:6])
3065 AT_TEST([-M foo= -M baz], [baz], [<command line>:6])
3066
3067 m4_popdef([AT_TEST])
3068
3069 AT_CLEANUP