tests/actions.at

   1 e# Executing Actions.                               -*- Autotest -*-
   2
   3 # Copyright (C) 2001-2013 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([[User Actions.]])
  19
  20 ## ------------------ ##
  21 ## Mid-rule actions.  ##
  22 ## ------------------ ##
  23
  24 AT_SETUP([Mid-rule actions])
  25
  26 # Bison once forgot the mid-rule actions.  It was because the action
  27 # was attached to the host rule (the one with the mid-rule action),
  28 # instead of being attached to the empty rule dedicated to this
  29 # action.
  30
  31 AT_BISON_OPTION_PUSHDEFS
  32 AT_DATA_GRAMMAR([[input.y]],
  33 [[%define parse.error verbose
  34 %debug
  35 %code {
  36 ]AT_YYERROR_DECLARE[
  37 ]AT_YYLEX_DECLARE[
  38 }
  39 %%
  40 exp:     { putchar ('0'); }
  41      '1' { putchar ('1'); }
  42      '2' { putchar ('2'); }
  43      '3' { putchar ('3'); }
  44      '4' { putchar ('4'); }
  45      '5' { putchar ('5'); }
  46      '6' { putchar ('6'); }
  47      '7' { putchar ('7'); }
  48      '8' { putchar ('8'); }
  49      '9' { putchar ('9'); }
  50          { putchar ('\n'); }
  51    ;
  52 %%
  53 ]AT_YYERROR_DEFINE[
  54 ]AT_YYLEX_DEFINE(["123456789"])[
  55 ]AT_MAIN_DEFINE[
  56 ]])
  57 AT_BISON_OPTION_POPDEFS
  58
  59 AT_BISON_CHECK([-d -v -o input.c input.y])
  60 AT_COMPILE([input])
  61 AT_PARSER_CHECK([./input], 0,
  62 [[0123456789
  63 ]])
  64
  65 AT_CLEANUP
  66
  67 ## ----------------------- ##
  68 ## Implicitly empty rule.  ##
  69 ## ----------------------- ##
  70
  71 AT_SETUP([Implicitly empty rule])
  72
  73 AT_DATA_GRAMMAR([[1.y]],
  74 [[%%
  75 exp: a b;
  76 a: /* empty. */ {};
  77 // A mid-rule action does not count as an empty rule.
  78 b: {} {};
  79 ]])
  80
  81 AT_BISON_CHECK([-fcaret -Wempty-rule 1.y], [0], [],
  82 [[1.y:11.17-18: warning: empty rule without %empty [-Wempty-rule]
  83  a: /* empty. */ {};
  84                  ^^
  85 ]])
  86
  87 AT_DATA_GRAMMAR([[2.y]],
  88 [[%%
  89 exp: a b c;
  90 a: /* empty. */ {};
  91 b: %empty       {};
  92 c: /* empty. */ {};
  93 ]])
  94
  95 AT_BISON_CHECK([-fcaret 2.y], [0], [],
  96 [[2.y:11.17-18: warning: empty rule without %empty [-Wempty-rule]
  97  a: /* empty. */ {};
  98                  ^^
  99 2.y:13.17-18: warning: empty rule without %empty [-Wempty-rule]
 100  c: /* empty. */ {};
 101                  ^^
 102 ]])
 103
 104 AT_BISON_CHECK([-fcaret -Wno-empty-rule 2.y], [0])
 105
 106 AT_CLEANUP
 107
 108 ## ------------------------ ##
 109 ## Invalid uses of %empty.  ##
 110 ## ------------------------ ##
 111
 112 AT_SETUP([Invalid uses of %empty])
 113
 114 AT_DATA_GRAMMAR([[one.y]],
 115 [[%%
 116 exp:
 117   %empty %empty {}
 118 ;
 119 ]])
 120
 121 AT_BISON_CHECK([-fcaret one.y], [1], [],
 122 [[one.y:11.10-15: error: only one %empty allowed per rule
 123    %empty %empty {}
 124           ^^^^^^
 125 ]])
 126
 127 AT_DATA_GRAMMAR([[two.y]],
 128 [[%%
 129 exp:
 130   'a' %empty    {}
 131 | %empty 'a'    {}
 132 | %empty {}     {}
 133 ;
 134 ]])
 135
 136 AT_BISON_CHECK([-fcaret two.y], [1], [],
 137 [[two.y:11.7-12: error: %empty on non-empty rule
 138    'a' %empty    {}
 139        ^^^^^^
 140 two.y:12.3-8: error: %empty on non-empty rule
 141  | %empty 'a'    {}
 142    ^^^^^^
 143 two.y:13.3-8: error: %empty on non-empty rule
 144  | %empty {}     {}
 145    ^^^^^^
 146 ]])
 147
 148 AT_CLEANUP
 149
 150 ## ---------------------- ##
 151 ## Valid uses of %empty.  ##
 152 ## ---------------------- ##
 153
 154 AT_SETUP([Valid uses of %empty])
 155
 156 AT_BISON_OPTION_PUSHDEFS
 157 AT_DATA_GRAMMAR([[input.y]],
 158 [[
 159 %debug
 160 %code
 161 {
 162 ]AT_YYERROR_DECLARE[
 163 ]AT_YYLEX_DECLARE[
 164 }
 165 %%
 166 exp: %empty {}
 167 %%
 168 ]AT_YYERROR_DEFINE[
 169 ]AT_YYLEX_DEFINE[
 170 ]AT_MAIN_DEFINE[
 171 ]])
 172
 173 AT_FULL_COMPILE([input])
 174 AT_PARSER_CHECK([./input])
 175 AT_BISON_OPTION_POPDEFS
 176 AT_CLEANUP
 177
 178 ## ------------------ ##
 179 ## Initial location.  ##
 180 ## ------------------ ##
 181
 182 # AT_TEST(SKELETON-NAME, DIRECTIVES, [MORE-DIRECTIVES], [LOCATION = 1.1])
 183 # -----------------------------------------------------------------------
 184 # Check that the initial location is correct.
 185 m4_pushdef([AT_TEST],
 186 [AT_SETUP([Initial location: $1 $2])
 187
 188 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" $2])
 189 AT_DATA_GRAMMAR([[input.y]],
 190 [[%locations
 191 %debug
 192 %skeleton "$1"
 193 ]$2[
 194 ]$3[
 195 %code
 196 {
 197 # include <stdio.h>
 198 # include <stdlib.h> /* getenv */
 199 ]AT_YYERROR_DECLARE[
 200 ]AT_YYLEX_DECLARE[
 201 }
 202 %%
 203 exp: { ]AT_SKEL_CC_IF([[std::cerr << @$ << std::endl]],
 204                       [[LOCATION_PRINT(stderr, @$); fputc ('\n', stderr)]])[; }
 205 %%
 206 ]AT_YYERROR_DEFINE[
 207
 208 ]AT_YYLEX_PROTOTYPE[
 209 {]AT_PURE_IF([
 210   YYUSE(lvalp);
 211   YYUSE(llocp);], [AT_SKEL_CC_IF([
 212   YYUSE(lvalp);
 213   YYUSE(llocp);])])[
 214   return 'x';
 215 }
 216
 217 int
 218 main (void)
 219 {]AT_SKEL_CC_IF([[
 220   yy::parser p;
 221   p.set_debug_level (!!getenv("YYDEBUG"));
 222   return p.parse ();]], [[
 223   yydebug = !!getenv("YYDEBUG");
 224   return !!yyparse (]AT_PARAM_IF([0])[);]])[
 225 }
 226 ]])
 227
 228 AT_FULL_COMPILE([input])
 229 AT_PARSER_CHECK([./input], 1, [],
 230 [m4_default([$4], [1.1])
 231 m4_default([$4], [1.1])[: syntax error
 232 ]])
 233 AT_BISON_OPTION_POPDEFS
 234 AT_CLEANUP
 235 ])
 236
 237 ## FIXME: test Java, and iterate over skeletons.
 238 AT_TEST([yacc.c])
 239 AT_TEST([yacc.c], [%define api.pure full])
 240 AT_TEST([yacc.c], [%define api.pure %parse-param { int x }])
 241 AT_TEST([yacc.c], [%define api.push-pull both])
 242 AT_TEST([yacc.c], [%define api.push-pull both %define api.pure full])
 243 AT_TEST([glr.c])
 244 AT_TEST([glr.c], [%define api.pure])
 245 AT_TEST([lalr1.cc])
 246 AT_TEST([glr.cc])
 247
 248 ## A very different test, based on PostgreSQL's implementation of the
 249 ## locations.  See
 250 ## http://lists.gnu.org/archive/html/bug-bison/2012-11/msg00023.html
 251 ##
 252 ## Weirdly enough, to trigger the warning with GCC 4.7, we must not
 253 ## use fprintf, so run the test twice: once to check the warning
 254 ## (absence thereof), and another time to check the value.
 255 AT_TEST([yacc.c], [%define api.pure full],
 256 [[%{
 257 # define YYLTYPE int
 258 # define LOCATION_PRINT(Stream, Loc)      \
 259    (void) (Loc)
 260 # define YYLLOC_DEFAULT(Current, Rhs, N)    \
 261   (Current) = ((Rhs)[N ? 1 : 0])
 262 %}
 263 ]],
 264 [@&t@])
 265
 266 AT_TEST([yacc.c], [%define api.pure full],
 267 [[%{
 268 # define YYLTYPE int
 269 # define LOCATION_PRINT(Stream, Loc)      \
 270     fprintf ((Stream), "%d", (Loc))
 271 # define YYLLOC_DEFAULT(Current, Rhs, N)    \
 272   (Current) = ((Rhs)[N ? 1 : 0])
 273 %}
 274 ]],
 275 [0])
 276
 277
 278 m4_popdef([AT_TEST])
 279
 280
 281
 282 ## ---------------- ##
 283 ## Location Print.  ##
 284 ## ---------------- ##
 285
 286 # AT_TEST(SKELETON-NAME, DIRECTIVES, [MORE-DIRECTIVES], [LOCATION = 1.1])
 287 # -----------------------------------------------------------------------
 288 # Check that the initial location is correct.
 289 m4_pushdef([AT_TEST],
 290 [AT_SETUP([Location print: $1 $2])
 291
 292 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "$1" $2])
 293 AT_DATA_GRAMMAR([[input.y]],
 294 [[%locations
 295 %debug
 296 %skeleton "$1"
 297 ]$2[
 298 ]$3[
 299 %code
 300 {
 301 ]AT_YYERROR_DECLARE[
 302 ]AT_YYLEX_DECLARE[
 303 }
 304 %%
 305 exp: %empty;
 306 %%
 307 ]AT_YYERROR_DEFINE[
 308 ]AT_YYLEX_DEFINE[
 309
 310 int
 311 main (void)
 312 {
 313   ]AT_YYLTYPE[ loc;
 314 ]AT_GLR_CC_IF([loc.initialize();])[
 315 #define TEST(L1, C1, L2, C2)          \
 316   loc.]AT_FIRST_LINE[ = L1;           \
 317   loc.]AT_FIRST_COLUMN[ = C1;         \
 318   loc.]AT_LAST_LINE[ = L2;            \
 319   loc.]AT_LAST_COLUMN[ = C2;          \
 320   ]AT_SKEL_CC_IF([std::cout << loc],
 321                  [LOCATION_PRINT(stdout, loc)])[;\
 322   putchar ('\n');
 323
 324   TEST(1, 1, 1, 1);
 325   TEST(2, 1, 2, 10);
 326   TEST(3, 1, 4, 1);
 327   TEST(5, 1, 6, 10);
 328
 329   TEST(7, 2, 0, 2);
 330   TEST(8, 0, 8, 0);
 331   return 0;
 332 }
 333 ]])
 334
 335 AT_FULL_COMPILE([input])
 336 AT_PARSER_CHECK([./input], 0,
 337 [[1.1
 338 2.1-9
 339 3.1-4.0
 340 5.1-6.9
 341 7.2
 342 8.0
 343 ]])
 344 AT_BISON_OPTION_POPDEFS
 345 AT_CLEANUP
 346 ])
 347
 348 ## FIXME: test Java, and iterate over skeletons.
 349 AT_TEST([yacc.c])
 350 AT_TEST([glr.c])
 351 AT_TEST([lalr1.cc])
 352 AT_TEST([glr.cc])
 353
 354 m4_popdef([AT_TEST])
 355
 356
 357
 358 ## ---------------- ##
 359 ## Exotic Dollars.  ##
 360 ## ---------------- ##
 361
 362 AT_SETUP([Exotic Dollars])
 363
 364 AT_BISON_OPTION_PUSHDEFS
 365 AT_DATA_GRAMMAR([[input.y]],
 366 [[%define parse.error verbose
 367 %debug
 368 %code {
 369 ]AT_YYERROR_DECLARE[
 370 ]AT_YYLEX_DECLARE[
 371 # define USE(Var)
 372 }
 373
 374 %union
 375 {
 376   int val;
 377 };
 378
 379 %type <val> a_1 a_2 a_5
 380             sum_of_the_five_previous_values
 381
 382 %%
 383 exp: a_1 a_2 { $<val>$ = 3; } { $<val>$ = $<val>3 + 1; } a_5
 384      sum_of_the_five_previous_values
 385     {
 386        USE (($1, $2, $<foo>3, $<foo>4, $5));
 387        printf ("%d\n", $6);
 388     }
 389 ;
 390 a_1: { $$ = 1; };
 391 a_2: { $$ = 2; };
 392 a_5: { $$ = 5; };
 393
 394 sum_of_the_five_previous_values:
 395     {
 396        $$ = $<val>0 + $<val>-1 + $<val>-2 + $<val>-3 + $<val>-4;
 397     }
 398 ;
 399
 400 %%
 401 ]AT_YYERROR_DEFINE[
 402 ]AT_YYLEX_DEFINE[
 403 ]AT_MAIN_DEFINE[
 404 ]])
 405
 406 AT_BISON_CHECK([-d -v -o input.c input.y], 0)
 407 AT_COMPILE([input])
 408 AT_PARSER_CHECK([./input], 0,
 409 [[15
 410 ]])
 411
 412 # Make sure that fields after $n or $-n are parsed correctly.  At one
 413 # point while implementing dashes in symbol names, we were dropping
 414 # fields after $-n.
 415 AT_DATA_GRAMMAR([[input.y]],
 416 [[
 417 %{
 418 ]AT_YYERROR_DECLARE[
 419 ]AT_YYLEX_DECLARE[
 420   typedef struct { int val; } stype;
 421 # define YYSTYPE stype
 422 %}
 423
 424 %%
 425 start: one two { $$.val = $1.val + $2.val; } sum ;
 426 one: { $$.val = 1; } ;
 427 two: { $$.val = 2; } ;
 428 sum: { printf ("%d\n", $0.val + $-1.val + $-2.val); } ;
 429
 430 %%
 431 ]AT_YYERROR_DEFINE[
 432 ]AT_YYLEX_DEFINE[
 433 ]AT_MAIN_DEFINE[
 434 ]])
 435
 436 AT_FULL_COMPILE([input])
 437 AT_PARSER_CHECK([[./input]], [[0]],
 438 [[6
 439 ]])
 440
 441 AT_BISON_OPTION_POPDEFS
 442 AT_CLEANUP
 443
 444
 445
 446 ## -------------------------- ##
 447 ## Printers and Destructors.  ##
 448 ## -------------------------- ##
 449
 450 # _AT_CHECK_PRINTER_AND_DESTRUCTOR($1, $2, $3, $4,
 451 #                                  BISON-DIRECTIVE, UNION-FLAG)
 452 # -------------------------------------------------------------
 453 m4_define([_AT_CHECK_PRINTER_AND_DESTRUCTOR],
 454 [# Make sure complex $n work.
 455 m4_if([$1$2$3$4], $[1]$[2]$[3]$[4], [],
 456        [m4_fatal([$0: Invalid arguments: $@])])dnl
 457
 458 # Be sure to pass all the %directives to this macro to have correct
 459 # helping macros.  So don't put any directly in the Bison file.
 460 AT_BISON_OPTION_PUSHDEFS([$5])
 461 AT_DATA_GRAMMAR([[input.y]],
 462 [[%code requires {
 463 #include <stdio.h>
 464 #include <stdlib.h>
 465 #include <string.h>
 466 #include <assert.h>
 467
 468 #define YYINITDEPTH 10
 469 #define YYMAXDEPTH 10
 470 #define RANGE(Location) ]AT_LALR1_CC_IF([(Location).begin.line, (Location).end.line],
 471       [(Location).first_line, (Location).last_line])[
 472
 473 /* Display the symbol type Symbol.  */
 474 #define V(Symbol, Value, Location, Sep) \
 475    fprintf (stderr, #Symbol " (%d@%d-%d)" Sep, Value, RANGE(Location))
 476 }
 477
 478 $5
 479 ]m4_ifval([$6], [%union
 480 {
 481   int ival;
 482 }])
 483 AT_LALR1_CC_IF([%define global_tokens_and_yystype])
 484 m4_ifval([$6], [[%code provides {]], [[%code {]])
 485 AT_LALR1_CC_IF([typedef yy::location YYLTYPE;])[
 486 ]AT_YYLEX_DECLARE[
 487 ]AT_LALR1_CC_IF([], [AT_YYERROR_DECLARE])
 488 [}
 489
 490 ]m4_ifval([$6], [%type <ival> '(' 'x' 'y' ')' ';' thing line input END])[
 491
 492 /* FIXME: This %printer isn't actually tested.  */
 493 %printer
 494   {
 495     ]AT_LALR1_CC_IF([debug_stream () << $$;],
 496                     [fprintf (yyoutput, "%d", $$)])[;
 497   }
 498   input line thing 'x' 'y'
 499
 500 %destructor
 501   { fprintf (stderr, "Freeing nterm input (%d@%d-%d)\n", $$, RANGE (@$)); }
 502   input
 503
 504 %destructor
 505   { fprintf (stderr, "Freeing nterm line (%d@%d-%d)\n", $$, RANGE (@$)); }
 506   line
 507
 508 %destructor
 509   { fprintf (stderr, "Freeing nterm thing (%d@%d-%d)\n", $$, RANGE (@$)); }
 510   thing
 511
 512 %destructor
 513   { fprintf (stderr, "Freeing token 'x' (%d@%d-%d)\n", $$, RANGE (@$)); }
 514   'x'
 515
 516 %destructor
 517   { fprintf (stderr, "Freeing token 'y' (%d@%d-%d)\n", $$, RANGE (@$)); }
 518   'y'
 519
 520 %token END 0
 521 %destructor
 522   { fprintf (stderr, "Freeing token END (%d@%d-%d)\n", $$, RANGE (@$)); }
 523   END
 524
 525 %%
 526 /*
 527    This grammar is made to exercise error recovery.
 528    "Lines" starting with `(' support error recovery, with
 529    ')' as synchronizing token.  Lines starting with 'x' can never
 530    be recovered from if in error.
 531 */
 532
 533 input:
 534   /* Nothing. */
 535     {
 536       $$ = 0;
 537       V(input, $$, @$, ": /* Nothing */\n");
 538     }
 539 | line input /* Right recursive to load the stack so that popping at
 540                 END can be exercised.  */
 541     {
 542       $$ = 2;
 543       V(input, $$, @$, ": ");
 544       V(line,  $1, @1, " ");
 545       V(input, $2, @2, "\n");
 546     }
 547 ;
 548
 549 line:
 550   thing thing thing ';'
 551     {
 552       $$ = $1;
 553       V(line,  $$, @$, ": ");
 554       V(thing, $1, @1, " ");
 555       V(thing, $2, @2, " ");
 556       V(thing, $3, @3, " ");
 557       V(;,     $4, @4, "\n");
 558     }
 559 | '(' thing thing ')'
 560     {
 561       $$ = $1;
 562       V(line,  $$, @$, ": ");
 563       V('(',   $1, @1, " ");
 564       V(thing, $2, @2, " ");
 565       V(thing, $3, @3, " ");
 566       V(')',   $4, @4, "\n");
 567     }
 568 | '(' thing ')'
 569     {
 570       $$ = $1;
 571       V(line,  $$, @$, ": ");
 572       V('(',   $1, @1, " ");
 573       V(thing, $2, @2, " ");
 574       V(')',   $3, @3, "\n");
 575     }
 576 | '(' error ')'
 577     {
 578       $$ = -1;
 579       V(line,  $$, @$, ": ");
 580       V('(',   $1, @1, " ");
 581       fprintf (stderr, "error (@%d-%d) ", RANGE(@2));
 582       V(')',   $3, @3, "\n");
 583     }
 584 ;
 585
 586 thing:
 587   'x'
 588     {
 589       $$ = $1;
 590       V(thing, $$, @$, ": ");
 591       V('x',   $1, @1, "\n");
 592     }
 593 ;
 594 %%
 595 /* Alias to ARGV[1]. */
 596 const char *source = YY_NULL;
 597
 598 ]AT_YYERROR_DEFINE[
 599
 600 static
 601 ]AT_YYLEX_PROTOTYPE[
 602 {
 603   static unsigned int counter = 0;
 604
 605   int c = ]AT_VAL[]m4_ifval([$6], [.ival])[ = counter++;
 606   /* As in BASIC, line numbers go from 10 to 10.  */
 607   ]AT_LOC_FIRST_LINE[ = ]AT_LOC_FIRST_COLUMN[ = 10 * c;
 608   ]AT_LOC_LAST_LINE[ = ]AT_LOC_LAST_COLUMN[ = ]AT_LOC_FIRST_LINE[ + 9;
 609   assert (0 <= c && c <= strlen (source));
 610   if (source[c])
 611     fprintf (stderr, "sending: '%c'", source[c]);
 612   else
 613     fprintf (stderr, "sending: END");
 614   fprintf (stderr, " (%d@%d-%d)\n", c, RANGE (]AT_LOC[));
 615   return source[c];
 616 }
 617 ]AT_LALR1_CC_IF(
 618 [static bool yydebug;
 619 int
 620 yyparse ()
 621 {
 622   yy::parser parser;
 623   parser.set_debug_level (yydebug);
 624   return parser.parse ();
 625 }
 626 ])[
 627
 628 int
 629 main (int argc, const char *argv[])
 630 {
 631   int status;
 632   yydebug = !!getenv ("YYDEBUG");
 633   assert (argc == 2);
 634   source = argv[1];
 635   status = yyparse ();
 636   switch (status)
 637     {
 638       case 0: fprintf (stderr, "Successful parse.\n"); break;
 639       case 1: fprintf (stderr, "Parsing FAILED.\n"); break;
 640       default: fprintf (stderr, "Parsing FAILED (status %d).\n", status); break;
 641     }
 642   return status;
 643 }
 644 ]])
 645
 646 AT_FULL_COMPILE([input])
 647
 648
 649 # Check the location of "empty"
 650 # -----------------------------
 651 # I.e., epsilon-reductions, as in "(x)" which ends by reducing
 652 # an empty "line" nterm.
 653 # FIXME: This location is not satisfying.  Depend on the lookahead?
 654 AT_PARSER_CHECK([./input '(x)'], 0, [],
 655 [[sending: '(' (0@0-9)
 656 sending: 'x' (1@10-19)
 657 thing (1@10-19): 'x' (1@10-19)
 658 sending: ')' (2@20-29)
 659 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29)
 660 sending: END (3@30-39)
 661 input (0@29-29): /* Nothing */
 662 input (2@0-29): line (0@0-29) input (0@29-29)
 663 Freeing token END (3@30-39)
 664 Freeing nterm input (2@0-29)
 665 Successful parse.
 666 ]])
 667
 668
 669 # Check locations in error recovery
 670 # ---------------------------------
 671 # '(y)' is an error, but can be recovered from.  But what's the location
 672 # of the error itself ('y'), and of the resulting reduction ('(error)').
 673 AT_PARSER_CHECK([./input '(y)'], 0, [],
 674 [[sending: '(' (0@0-9)
 675 sending: 'y' (1@10-19)
 676 10.10-19.18: syntax error, unexpected 'y', expecting 'x'
 677 Freeing token 'y' (1@10-19)
 678 sending: ')' (2@20-29)
 679 line (-1@0-29): '(' (0@0-9) error (@10-19) ')' (2@20-29)
 680 sending: END (3@30-39)
 681 input (0@29-29): /* Nothing */
 682 input (2@0-29): line (-1@0-29) input (0@29-29)
 683 Freeing token END (3@30-39)
 684 Freeing nterm input (2@0-29)
 685 Successful parse.
 686 ]])
 687
 688
 689 # Syntax errors caught by the parser
 690 # ----------------------------------
 691 # Exercise the discarding of stack top and input until `error'
 692 # can be reduced.
 693 #
 694 #     '(', 'x', 'x', 'x', 'x', 'x', ')',
 695 #
 696 # Load the stack and provoke an error that cannot be caught by the
 697 # grammar, to check that the stack is cleared.  And make sure the
 698 # lookahead is freed.
 699 #
 700 #     '(', 'x', ')',
 701 #     '(', 'x', ')',
 702 #     'y'
 703 AT_PARSER_CHECK([./input '(xxxxx)(x)(x)y'], 1, [],
 704 [[sending: '(' (0@0-9)
 705 sending: 'x' (1@10-19)
 706 thing (1@10-19): 'x' (1@10-19)
 707 sending: 'x' (2@20-29)
 708 thing (2@20-29): 'x' (2@20-29)
 709 sending: 'x' (3@30-39)
 710 30.30-39.38: syntax error, unexpected 'x', expecting ')'
 711 Freeing nterm thing (2@20-29)
 712 Freeing nterm thing (1@10-19)
 713 Freeing token 'x' (3@30-39)
 714 sending: 'x' (4@40-49)
 715 Freeing token 'x' (4@40-49)
 716 sending: 'x' (5@50-59)
 717 Freeing token 'x' (5@50-59)
 718 sending: ')' (6@60-69)
 719 line (-1@0-69): '(' (0@0-9) error (@10-59) ')' (6@60-69)
 720 sending: '(' (7@70-79)
 721 sending: 'x' (8@80-89)
 722 thing (8@80-89): 'x' (8@80-89)
 723 sending: ')' (9@90-99)
 724 line (7@70-99): '(' (7@70-79) thing (8@80-89) ')' (9@90-99)
 725 sending: '(' (10@100-109)
 726 sending: 'x' (11@110-119)
 727 thing (11@110-119): 'x' (11@110-119)
 728 sending: ')' (12@120-129)
 729 line (10@100-129): '(' (10@100-109) thing (11@110-119) ')' (12@120-129)
 730 sending: 'y' (13@130-139)
 731 input (0@129-129): /* Nothing */
 732 input (2@100-129): line (10@100-129) input (0@129-129)
 733 input (2@70-129): line (7@70-99) input (2@100-129)
 734 input (2@0-129): line (-1@0-69) input (2@70-129)
 735 130.130-139.138: syntax error, unexpected 'y', expecting END
 736 Freeing nterm input (2@0-129)
 737 Freeing token 'y' (13@130-139)
 738 Parsing FAILED.
 739 ]])
 740
 741
 742 # Syntax error caught by the parser where lookahead = END
 743 # --------------------------------------------------------
 744 # Load the stack and provoke an error that cannot be caught by the
 745 # grammar, to check that the stack is cleared.  And make sure the
 746 # lookahead is freed.
 747 #
 748 #     '(', 'x', ')',
 749 #     '(', 'x', ')',
 750 #     'x'
 751 AT_PARSER_CHECK([./input '(x)(x)x'], 1, [],
 752 [[sending: '(' (0@0-9)
 753 sending: 'x' (1@10-19)
 754 thing (1@10-19): 'x' (1@10-19)
 755 sending: ')' (2@20-29)
 756 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29)
 757 sending: '(' (3@30-39)
 758 sending: 'x' (4@40-49)
 759 thing (4@40-49): 'x' (4@40-49)
 760 sending: ')' (5@50-59)
 761 line (3@30-59): '(' (3@30-39) thing (4@40-49) ')' (5@50-59)
 762 sending: 'x' (6@60-69)
 763 thing (6@60-69): 'x' (6@60-69)
 764 sending: END (7@70-79)
 765 70.70-79.78: syntax error, unexpected END, expecting 'x'
 766 Freeing nterm thing (6@60-69)
 767 Freeing nterm line (3@30-59)
 768 Freeing nterm line (0@0-29)
 769 Freeing token END (7@70-79)
 770 Parsing FAILED.
 771 ]])
 772
 773
 774 # Check destruction upon stack overflow
 775 # -------------------------------------
 776 # Upon stack overflow, all symbols on the stack should be destroyed.
 777 # Only check for yacc.c.
 778 AT_YACC_IF([
 779 AT_PARSER_CHECK([./input '(x)(x)(x)(x)(x)(x)(x)'], 2, [],
 780 [[sending: '(' (0@0-9)
 781 sending: 'x' (1@10-19)
 782 thing (1@10-19): 'x' (1@10-19)
 783 sending: ')' (2@20-29)
 784 line (0@0-29): '(' (0@0-9) thing (1@10-19) ')' (2@20-29)
 785 sending: '(' (3@30-39)
 786 sending: 'x' (4@40-49)
 787 thing (4@40-49): 'x' (4@40-49)
 788 sending: ')' (5@50-59)
 789 line (3@30-59): '(' (3@30-39) thing (4@40-49) ')' (5@50-59)
 790 sending: '(' (6@60-69)
 791 sending: 'x' (7@70-79)
 792 thing (7@70-79): 'x' (7@70-79)
 793 sending: ')' (8@80-89)
 794 line (6@60-89): '(' (6@60-69) thing (7@70-79) ')' (8@80-89)
 795 sending: '(' (9@90-99)
 796 sending: 'x' (10@100-109)
 797 thing (10@100-109): 'x' (10@100-109)
 798 sending: ')' (11@110-119)
 799 line (9@90-119): '(' (9@90-99) thing (10@100-109) ')' (11@110-119)
 800 sending: '(' (12@120-129)
 801 sending: 'x' (13@130-139)
 802 thing (13@130-139): 'x' (13@130-139)
 803 sending: ')' (14@140-149)
 804 line (12@120-149): '(' (12@120-129) thing (13@130-139) ')' (14@140-149)
 805 sending: '(' (15@150-159)
 806 sending: 'x' (16@160-169)
 807 thing (16@160-169): 'x' (16@160-169)
 808 sending: ')' (17@170-179)
 809 line (15@150-179): '(' (15@150-159) thing (16@160-169) ')' (17@170-179)
 810 sending: '(' (18@180-189)
 811 sending: 'x' (19@190-199)
 812 thing (19@190-199): 'x' (19@190-199)
 813 sending: ')' (20@200-209)
 814 200.200-209.208: memory exhausted
 815 Freeing nterm thing (19@190-199)
 816 Freeing nterm line (15@150-179)
 817 Freeing nterm line (12@120-149)
 818 Freeing nterm line (9@90-119)
 819 Freeing nterm line (6@60-89)
 820 Freeing nterm line (3@30-59)
 821 Freeing nterm line (0@0-29)
 822 Parsing FAILED (status 2).
 823 ]])
 824 ])
 825
 826 AT_BISON_OPTION_POPDEFS
 827 ])# _AT_CHECK_PRINTER_AND_DESTRUCTOR
 828
 829
 830 # AT_CHECK_PRINTER_AND_DESTRUCTOR([BISON-OPTIONS], [UNION-FLAG], [SKIP_FLAG])
 831 # ---------------------------------------------------------------------------
 832 m4_define([AT_CHECK_PRINTER_AND_DESTRUCTOR],
 833 [AT_SETUP([Printers and Destructors$2]m4_ifval([$1], [[: $1]]))
 834
 835 $3
 836 _AT_CHECK_PRINTER_AND_DESTRUCTOR($[1], $[2], $[3], $[4],
 837 [%define parse.error verbose
 838 %debug
 839 %verbose
 840 %locations
 841 $1], [$2])
 842
 843 AT_CLEANUP
 844 ])
 845
 846
 847 AT_CHECK_PRINTER_AND_DESTRUCTOR([])
 848 AT_CHECK_PRINTER_AND_DESTRUCTOR([], [with union])
 849
 850 AT_CHECK_PRINTER_AND_DESTRUCTOR([%defines %skeleton "lalr1.cc"])
 851 AT_CHECK_PRINTER_AND_DESTRUCTOR([%defines %skeleton "lalr1.cc"], [with union])
 852
 853 AT_CHECK_PRINTER_AND_DESTRUCTOR([%glr-parser])
 854 AT_CHECK_PRINTER_AND_DESTRUCTOR([%glr-parser], [with union])
 855
 856
 857
 858 ## ----------------------------------------- ##
 859 ## Default tagless %printer and %destructor. ##
 860 ## ----------------------------------------- ##
 861
 862 # Check that the right %printer and %destructor are called, that they're not
 863 # called for $end, and that $$ and @$ work correctly.
 864
 865 AT_SETUP([Default tagless %printer and %destructor])
 866 AT_BISON_OPTION_PUSHDEFS([%locations %debug])
 867 AT_DATA_GRAMMAR([[input.y]],
 868 [[%define parse.error verbose
 869 %debug
 870 %locations
 871
 872 %code {
 873 ]AT_YYLEX_DECLARE[
 874 ]AT_YYERROR_DECLARE[
 875 # define USE(SYM)
 876 }
 877
 878 %printer {
 879   fprintf (yyoutput, "<*> printer should not be called.\n");
 880 } <*>
 881
 882 %printer {
 883   fprintf (yyoutput, "<> printer for '%c' @ %d", $$, @$.first_column);
 884 } <>
 885 %destructor {
 886   fprintf (stdout, "<> destructor for '%c' @ %d.\n", $$, @$.first_column);
 887 } <>
 888
 889 %printer {
 890   fprintf (yyoutput, "'b'/'c' printer for '%c' @ %d", $$, @$.first_column);
 891 } 'b' 'c'
 892 %destructor {
 893   fprintf (stdout, "'b'/'c' destructor for '%c' @ %d.\n", $$, @$.first_column);
 894 } 'b' 'c'
 895
 896 %destructor {
 897   fprintf (yyoutput, "<*> destructor should not be called.\n");
 898 } <*>
 899
 900 %%
 901
 902 start: 'a' 'b' 'c' 'd' 'e' { $$ = 'S'; USE(($1, $2, $3, $4, $5)); } ;
 903
 904 %%
 905 ]AT_YYERROR_DEFINE[
 906 ]AT_YYLEX_DEFINE(["abcd"], [[yylval = res]])[
 907 ]AT_MAIN_DEFINE[
 908 ]])
 909
 910 AT_BISON_CHECK([-o input.c input.y], [], [],
 911 [[input.y:30.3-5: warning: useless %destructor for type <*> [-Wother]
 912 input.y:30.3-5: warning: useless %printer for type <*> [-Wother]
 913 ]])
 914 AT_COMPILE([input])
 915 AT_PARSER_CHECK([./input --debug], 1,
 916 [[<> destructor for 'd' @ 4.
 917 'b'/'c' destructor for 'c' @ 3.
 918 'b'/'c' destructor for 'b' @ 2.
 919 <> destructor for 'a' @ 1.
 920 ]],
 921 [[Starting parse
 922 Entering state 0
 923 Reading a token: Next token is token 'a' (1.1: <> printer for 'a' @ 1)
 924 Shifting token 'a' (1.1: <> printer for 'a' @ 1)
 925 Entering state 1
 926 Reading a token: Next token is token 'b' (1.2: 'b'/'c' printer for 'b' @ 2)
 927 Shifting token 'b' (1.2: 'b'/'c' printer for 'b' @ 2)
 928 Entering state 3
 929 Reading a token: Next token is token 'c' (1.3: 'b'/'c' printer for 'c' @ 3)
 930 Shifting token 'c' (1.3: 'b'/'c' printer for 'c' @ 3)
 931 Entering state 5
 932 Reading a token: Next token is token 'd' (1.4: <> printer for 'd' @ 4)
 933 Shifting token 'd' (1.4: <> printer for 'd' @ 4)
 934 Entering state 6
 935 Reading a token: Now at end of input.
 936 1.5: syntax error, unexpected $end, expecting 'e'
 937 Error: popping token 'd' (1.4: <> printer for 'd' @ 4)
 938 Stack now 0 1 3 5
 939 Error: popping token 'c' (1.3: 'b'/'c' printer for 'c' @ 3)
 940 Stack now 0 1 3
 941 Error: popping token 'b' (1.2: 'b'/'c' printer for 'b' @ 2)
 942 Stack now 0 1
 943 Error: popping token 'a' (1.1: <> printer for 'a' @ 1)
 944 Stack now 0
 945 Cleanup: discarding lookahead token $end (1.5: )
 946 Stack now 0
 947 ]])
 948
 949 AT_BISON_OPTION_POPDEFS
 950 AT_CLEANUP
 951
 952
 953
 954 ## ------------------------------------------------------ ##
 955 ## Default tagged and per-type %printer and %destructor.  ##
 956 ## ------------------------------------------------------ ##
 957
 958 AT_SETUP([Default tagged and per-type %printer and %destructor])
 959 AT_BISON_OPTION_PUSHDEFS([%debug])
 960 AT_DATA_GRAMMAR([[input.y]],
 961 [[%define parse.error verbose
 962 %debug
 963
 964 %{
 965 ]AT_YYERROR_DECLARE[
 966 ]AT_YYLEX_DECLARE[
 967 # define USE(SYM)
 968 %}
 969
 970 %printer {
 971   fprintf (yyoutput, "<> printer should not be called.\n");
 972 } <>
 973
 974 %union { int field0; int field1; int field2; }
 975 %type <field0> start 'a' 'g'
 976 %type <field1> 'e'
 977 %type <field2> 'f'
 978 %printer {
 979   fprintf (yyoutput, "<*>/<field2>/e printer");
 980 } <*> 'e' <field2>
 981 %destructor {
 982   fprintf (stdout, "<*>/<field2>/e destructor.\n");
 983 } <*> 'e' <field2>
 984
 985 %type <field1> 'b'
 986 %printer { fprintf (yyoutput, "<field1> printer"); } <field1>
 987 %destructor { fprintf (stdout, "<field1> destructor.\n"); } <field1>
 988
 989 %type <field0> 'c'
 990 %printer { fprintf (yyoutput, "'c' printer"); } 'c'
 991 %destructor { fprintf (stdout, "'c' destructor.\n"); } 'c'
 992
 993 %type <field1> 'd'
 994 %printer { fprintf (yyoutput, "'d' printer"); } 'd'
 995 %destructor { fprintf (stdout, "'d' destructor.\n"); } 'd'
 996
 997 %destructor {
 998   fprintf (yyoutput, "<> destructor should not be called.\n");
 999 } <>
1000
1001 %%
1002
1003 start:
1004   'a' 'b' 'c' 'd' 'e' 'f' 'g'
1005     {
1006       USE(($1, $2, $3, $4, $5, $6, $7));
1007       $$ = 'S';
1008     }
1009   ;
1010
1011 %%
1012 ]AT_YYERROR_DEFINE[
1013 ]AT_YYLEX_DEFINE(["abcdef"])[
1014 ]AT_MAIN_DEFINE[
1015 ]])
1016
1017 AT_BISON_CHECK([-o input.c input.y], [], [],
1018 [[input.y:22.3-4: warning: useless %destructor for type <> [-Wother]
1019 input.y:22.3-4: warning: useless %printer for type <> [-Wother]
1020 ]])
1021 AT_COMPILE([input])
1022 AT_PARSER_CHECK([./input --debug], 1,
1023 [[<*>/<field2>/e destructor.
1024 <*>/<field2>/e destructor.
1025 'd' destructor.
1026 'c' destructor.
1027 <field1> destructor.
1028 <*>/<field2>/e destructor.
1029 ]],
1030 [[Starting parse
1031 Entering state 0
1032 Reading a token: Next token is token 'a' (<*>/<field2>/e printer)
1033 Shifting token 'a' (<*>/<field2>/e printer)
1034 Entering state 1
1035 Reading a token: Next token is token 'b' (<field1> printer)
1036 Shifting token 'b' (<field1> printer)
1037 Entering state 3
1038 Reading a token: Next token is token 'c' ('c' printer)
1039 Shifting token 'c' ('c' printer)
1040 Entering state 5
1041 Reading a token: Next token is token 'd' ('d' printer)
1042 Shifting token 'd' ('d' printer)
1043 Entering state 6
1044 Reading a token: Next token is token 'e' (<*>/<field2>/e printer)
1045 Shifting token 'e' (<*>/<field2>/e printer)
1046 Entering state 7
1047 Reading a token: Next token is token 'f' (<*>/<field2>/e printer)
1048 Shifting token 'f' (<*>/<field2>/e printer)
1049 Entering state 8
1050 Reading a token: Now at end of input.
1051 syntax error, unexpected $end, expecting 'g'
1052 Error: popping token 'f' (<*>/<field2>/e printer)
1053 Stack now 0 1 3 5 6 7
1054 Error: popping token 'e' (<*>/<field2>/e printer)
1055 Stack now 0 1 3 5 6
1056 Error: popping token 'd' ('d' printer)
1057 Stack now 0 1 3 5
1058 Error: popping token 'c' ('c' printer)
1059 Stack now 0 1 3
1060 Error: popping token 'b' (<field1> printer)
1061 Stack now 0 1
1062 Error: popping token 'a' (<*>/<field2>/e printer)
1063 Stack now 0
1064 Cleanup: discarding lookahead token $end ()
1065 Stack now 0
1066 ]])
1067
1068 AT_BISON_OPTION_POPDEFS
1069 AT_CLEANUP
1070
1071
1072
1073 ## ------------------------------------------------------------- ##
1074 ## Default %printer and %destructor for user-defined end token.  ##
1075 ## ------------------------------------------------------------- ##
1076
1077 AT_SETUP([Default %printer and %destructor for user-defined end token])
1078
1079 # AT_TEST(TYPED)
1080 # --------------
1081 m4_pushdef([AT_TEST],
1082 [m4_if($1, 0,
1083   [m4_pushdef([kind], []) m4_pushdef([not_kind], [*])],
1084   [m4_pushdef([kind], [*]) m4_pushdef([not_kind], [])])
1085
1086 AT_BISON_OPTION_PUSHDEFS([%locations %debug])
1087 AT_DATA_GRAMMAR([[input]]$1[[.y]],
1088 [[%define parse.error verbose
1089 %debug
1090 %locations
1091
1092 %code {
1093 ]AT_YYERROR_DECLARE[
1094 ]AT_YYLEX_DECLARE[
1095 # define USE(SYM)
1096 }
1097
1098 %destructor {
1099   fprintf (yyoutput, "<]]not_kind[[> destructor should not be called.\n");
1100 } <]]not_kind[[>
1101
1102 %token END 0
1103 %printer {
1104   fprintf (yyoutput, "<]]kind[[> for '%c' @ %d", $$, @$.first_column);
1105 } <]]kind[[>
1106 %destructor {
1107   fprintf (stdout, "<]]kind[[> for '%c' @ %d.\n", $$, @$.first_column);
1108 } <]]kind[[>
1109
1110 %printer {
1111   fprintf (yyoutput, "<]]not_kind[[> printer should not be called.\n");
1112 } <]]not_kind[[>
1113
1114 ]]m4_if($1, 0, [[[
1115 ]]],
1116 [[[%union { char tag; }
1117 %type <tag> start END]]])[[
1118
1119 %%
1120
1121 start: { $$ = 'S'; } ;
1122
1123 %%
1124 #include <stdlib.h> /* abort */
1125 static int
1126 yylex (void)
1127 {
1128   static int called;
1129   if (called++)
1130     abort ();
1131   yylval]]m4_if($1, 0,, [[[.tag]]])[[ = 'E';
1132   yylloc.first_line = yylloc.last_line = 1;
1133   yylloc.first_column = yylloc.last_column = 1;
1134   return 0;
1135 }
1136 ]AT_YYERROR_DEFINE[
1137 ]AT_MAIN_DEFINE[
1138 ]])
1139 AT_BISON_OPTION_POPDEFS
1140
1141 AT_BISON_CHECK([-o input$1.c input$1.y], [], [],
1142 [m4_if([$1], [0],
1143 [[input0.y:30.3-5: warning: useless %destructor for type <*> [-Wother]
1144 input0.y:30.3-5: warning: useless %printer for type <*> [-Wother]
1145 ]],
1146 [[input1.y:30.3-4: warning: useless %destructor for type <> [-Wother]
1147 input1.y:30.3-4: warning: useless %printer for type <> [-Wother]
1148 ]])])
1149
1150 AT_COMPILE([input$1])
1151
1152 AT_PARSER_CHECK([./input$1 --debug], 0,
1153 [[<]]kind[[> for 'E' @ 1.
1154 <]]kind[[> for 'S' @ 1.
1155 ]],
1156 [[Starting parse
1157 Entering state 0
1158 Reducing stack by rule 1 (line 49):
1159 -> $$ = nterm start (1.1: <]]kind[[> for 'S' @ 1)
1160 Stack now 0
1161 Entering state 1
1162 Reading a token: Now at end of input.
1163 Shifting token END (1.1: <]]kind[[> for 'E' @ 1)
1164 Entering state 2
1165 Stack now 0 1 2
1166 Cleanup: popping token END (1.1: <]]kind[[> for 'E' @ 1)
1167 Cleanup: popping nterm start (1.1: <]]kind[[> for 'S' @ 1)
1168 ]])
1169
1170 m4_popdef([kind])
1171 m4_popdef([not_kind])
1172 ])
1173
1174 AT_TEST(0)
1175 AT_TEST(1)
1176
1177 m4_popdef([AT_TEST])
1178
1179 AT_CLEANUP
1180
1181
1182
1183 ## ------------------------------------------------------------------ ##
1184 ## Default %printer and %destructor are not for error or $undefined.  ##
1185 ## ------------------------------------------------------------------ ##
1186
1187 AT_SETUP([Default %printer and %destructor are not for error or $undefined])
1188
1189 # If Bison were to apply the default %printer and %destructor to the error
1190 # token or to $undefined:
1191 #   - For the error token:
1192 #     - It would generate warnings for unused $n.
1193 #     - It would invoke the %printer and %destructor on the error token's
1194 #       semantic value, which would be initialized from the lookahead, which
1195 #       would be destroyed separately.
1196 #   - For $undefined, who knows what the semantic value would be.
1197 AT_BISON_OPTION_PUSHDEFS([%debug])
1198 AT_DATA_GRAMMAR([[input.y]],
1199 [[%debug
1200
1201 %{
1202 # include <stdio.h>
1203 # include <stdlib.h>
1204 ]AT_YYERROR_DECLARE[
1205 ]AT_YYLEX_DECLARE[
1206 # define USE(SYM)
1207 %}
1208
1209 %printer {
1210   fprintf (yyoutput, "'%c'", $$);
1211 } <> <*>
1212 %destructor {
1213   fprintf (stderr, "DESTROY '%c'\n", $$);
1214 } <> <*>
1215
1216 %%
1217
1218 start:
1219   { $$ = 'S'; }
1220   /* In order to reveal the problems that this bug caused during parsing, add
1221    * $2 to USE.  */
1222   | 'a' error 'b' 'c' { USE(($1, $3, $4)); $$ = 'S'; }
1223   ;
1224
1225 %%
1226 ]AT_YYERROR_DEFINE[
1227 ]AT_YYLEX_DEFINE(["abd"], [yylval = res])[
1228 ]AT_MAIN_DEFINE[
1229 ]])
1230 AT_BISON_OPTION_POPDEFS
1231
1232 AT_BISON_CHECK([-o input.c input.y], [], [],
1233 [[input.y:23.6-8: warning: useless %destructor for type <*> [-Wother]
1234 input.y:23.6-8: warning: useless %printer for type <*> [-Wother]
1235 ]])
1236 AT_COMPILE([input])
1237 AT_PARSER_CHECK([./input --debug], [1], [],
1238 [[Starting parse
1239 Entering state 0
1240 Reading a token: Next token is token 'a' ('a')
1241 Shifting token 'a' ('a')
1242 Entering state 1
1243 Reading a token: Next token is token 'b' ('b')
1244 syntax error
1245 Shifting token error ()
1246 Entering state 3
1247 Next token is token 'b' ('b')
1248 Shifting token 'b' ('b')
1249 Entering state 5
1250 Reading a token: Next token is token $undefined ()
1251 Error: popping token 'b' ('b')
1252 DESTROY 'b'
1253 Stack now 0 1 3
1254 Error: popping token error ()
1255 Stack now 0 1
1256 Shifting token error ()
1257 Entering state 3
1258 Next token is token $undefined ()
1259 Error: discarding token $undefined ()
1260 Error: popping token error ()
1261 Stack now 0 1
1262 Shifting token error ()
1263 Entering state 3
1264 Reading a token: Now at end of input.
1265 Cleanup: discarding lookahead token $end ()
1266 Stack now 0 1 3
1267 Cleanup: popping token error ()
1268 Cleanup: popping token 'a' ('a')
1269 DESTROY 'a'
1270 ]])
1271
1272 AT_CLEANUP
1273
1274
1275
1276 ## ------------------------------------------------------ ##
1277 ## Default %printer and %destructor are not for $accept.  ##
1278 ## ------------------------------------------------------ ##
1279
1280 AT_SETUP([Default %printer and %destructor are not for $accept])
1281
1282 # If YYSTYPE is a union and Bison were to apply the default %printer and
1283 # %destructor to $accept:
1284 #   - The %printer and %destructor code generated for $accept would always be
1285 #     dead code because $accept is currently never shifted onto the stack.
1286 #   - $$ for $accept would always be of type YYSTYPE because it's not possible
1287 #     to declare `%type <field> $accept'.  (Also true for $undefined.)
1288 #   - Thus, the compiler might complain that the user code assumes the wrong
1289 #     type for $$ since the code might assume the type associated with a
1290 #     specific union field, which is especially reasonable in C++ since that
1291 #     type may be a base type.  This test case checks for this problem.  (Also
1292 #     true for $undefined and the error token, so there are three warnings for
1293 #     %printer and three for %destructor.)
1294
1295 AT_BISON_OPTION_PUSHDEFS([%debug])
1296 AT_DATA_GRAMMAR([[input.y]],
1297 [[%debug /* So that %printer is actually compiled.  */
1298
1299 %{
1300 # include <stdio.h>
1301 # include <stdlib.h>
1302 ]AT_YYERROR_DECLARE[
1303 ]AT_YYLEX_DECLARE[
1304 # define USE(SYM)
1305 %}
1306
1307 %printer {
1308   char chr = $$;
1309   fprintf (yyoutput, "'%c'", chr);
1310 } <> <*>
1311 %destructor {
1312   char chr = $$;
1313   fprintf (stderr, "DESTROY '%c'\n", chr);
1314 } <> <*>
1315
1316 %union { char chr; }
1317 %type <chr> start
1318
1319 %%
1320
1321 start: { USE($$); } ;
1322
1323 %%
1324 ]AT_YYERROR_DEFINE[
1325 ]AT_YYLEX_DEFINE[
1326 ]AT_MAIN_DEFINE[
1327 ]])
1328 AT_BISON_OPTION_POPDEFS
1329
1330 AT_BISON_CHECK([-o input.c input.y], [], [],
1331 [[input.y:24.3-4: warning: useless %destructor for type <> [-Wother]
1332 input.y:24.3-4: warning: useless %printer for type <> [-Wother]
1333 ]])
1334 AT_COMPILE([input])
1335
1336 AT_CLEANUP
1337
1338
1339
1340 ## ------------------------------------------------------ ##
1341 ## Default %printer and %destructor for mid-rule values.  ##
1342 ## ------------------------------------------------------ ##
1343
1344 AT_SETUP([Default %printer and %destructor for mid-rule values])
1345
1346 AT_BISON_OPTION_PUSHDEFS([%debug])
1347 AT_DATA_GRAMMAR([[input.y]],
1348 [[%debug /* So that %printer is actually compiled.  */
1349
1350 %{
1351 ]AT_YYERROR_DECLARE[
1352 ]AT_YYLEX_DECLARE[
1353 # define USE(SYM)
1354 # define YYLTYPE int
1355 # define YYLLOC_DEFAULT(Current, Rhs, N) (void)(Rhs)
1356 # define LOCATION_PRINT(File, Loc)
1357 %}
1358
1359 %printer { fprintf (yyoutput, "%d", @$); } <>
1360 %destructor { fprintf (stderr, "DESTROY %d\n", @$); } <>
1361 %printer { fprintf (yyoutput, "<*> printer should not be called"); } <*>
1362 %destructor { fprintf (yyoutput, "<*> destructor should not be called"); } <*>
1363
1364 %%
1365
1366 start:
1367   {           @$ = 1; } // Not set or used.
1368   { USE ($$); @$ = 2; } // Both set and used.
1369   { USE ($$); @$ = 3; } // Only set.
1370   {           @$ = 4; } // Only used.
1371   'c'
1372   { USE (($$, $2, $4, $5)); @$ = 0; }
1373   ;
1374
1375 %%
1376 ]AT_YYERROR_DEFINE[
1377 ]AT_YYLEX_DEFINE[
1378 ]AT_MAIN_DEFINE[
1379 ]])
1380 AT_BISON_OPTION_POPDEFS
1381
1382 AT_BISON_CHECK([-o input.c input.y], 0,,
1383 [[input.y:24.70-72: warning: useless %destructor for type <*> [-Wother]
1384 input.y:24.70-72: warning: useless %printer for type <*> [-Wother]
1385 input.y:33.3-23: warning: unset value: $$ [-Wother]
1386 input.y:32.3-23: warning: unused value: $3 [-Wother]
1387 ]])
1388
1389 AT_BISON_CHECK([-fcaret -o input.c input.y], 0,,
1390 [[input.y:24.70-72: warning: useless %destructor for type <*> [-Wother]
1391  %printer { fprintf (yyoutput, "<*> printer should not be called"); } <*>
1392                                                                       ^^^
1393 input.y:24.70-72: warning: useless %printer for type <*> [-Wother]
1394  %printer { fprintf (yyoutput, "<*> printer should not be called"); } <*>
1395                                                                       ^^^
1396 input.y:33.3-23: warning: unset value: $$ [-Wother]
1397    {           @$ = 4; } // Only used.
1398    ^^^^^^^^^^^^^^^^^^^^^
1399 input.y:32.3-23: warning: unused value: $3 [-Wother]
1400    { USE ($$); @$ = 3; } // Only set.
1401    ^^^^^^^^^^^^^^^^^^^^^
1402 ]])
1403
1404 AT_COMPILE([input])
1405 AT_PARSER_CHECK([./input --debug], 1,,
1406 [[Starting parse
1407 Entering state 0
1408 Reducing stack by rule 1 (line 30):
1409 -> $$ = nterm $@1 (: )
1410 Stack now 0
1411 Entering state 2
1412 Reducing stack by rule 2 (line 31):
1413 -> $$ = nterm @2 (: 2)
1414 Stack now 0 2
1415 Entering state 4
1416 Reducing stack by rule 3 (line 32):
1417 -> $$ = nterm @3 (: 3)
1418 Stack now 0 2 4
1419 Entering state 5
1420 Reducing stack by rule 4 (line 33):
1421 -> $$ = nterm @4 (: 4)
1422 Stack now 0 2 4 5
1423 Entering state 6
1424 Reading a token: Now at end of input.
1425 syntax error
1426 Error: popping nterm @4 (: 4)
1427 DESTROY 4
1428 Stack now 0 2 4 5
1429 Error: popping nterm @3 (: 3)
1430 DESTROY 3
1431 Stack now 0 2 4
1432 Error: popping nterm @2 (: 2)
1433 DESTROY 2
1434 Stack now 0 2
1435 Error: popping nterm $@1 (: )
1436 Stack now 0
1437 Cleanup: discarding lookahead token $end (: )
1438 Stack now 0
1439 ]])
1440
1441 AT_CLEANUP
1442
1443
1444 ## ----------------------- ##
1445 ## @$ implies %locations.  ##
1446 ## ----------------------- ##
1447
1448 # Bison once forgot to check for @$ in actions other than semantic actions.
1449
1450 # AT_CHECK_ACTION_LOCATIONS(ACTION-DIRECTIVE)
1451 # -------------------------------------------
1452 m4_define([AT_CHECK_ACTION_LOCATIONS],
1453 [AT_SETUP([[@$ in ]$1[ implies %locations]])
1454 AT_BISON_OPTION_PUSHDEFS([%debug])
1455 AT_DATA_GRAMMAR([[input.y]],
1456 [[%code {
1457   #include <stdio.h>
1458 ]AT_YYERROR_DECLARE[
1459 ]AT_YYLEX_DECLARE[
1460 }
1461
1462 %debug
1463
1464 ]$1[ {
1465   fprintf (stderr, "%d\n", @$.first_line);
1466 } ]m4_if($1, [%initial-action], [], [[start]])[
1467
1468 %%
1469
1470 start:  ;
1471
1472 %%
1473
1474 static int
1475 yylex (void)
1476 {
1477   return 0;
1478 }
1479
1480 ]AT_YYERROR_DEFINE[
1481 ]AT_MAIN_DEFINE[
1482 ]])
1483
1484 AT_BISON_CHECK([[-o input.c input.y]])
1485 AT_COMPILE([[input]])
1486 AT_BISON_OPTION_POPDEFS
1487 AT_CLEANUP])
1488
1489 AT_CHECK_ACTION_LOCATIONS([[%initial-action]])
1490 AT_CHECK_ACTION_LOCATIONS([[%destructor]])
1491 AT_CHECK_ACTION_LOCATIONS([[%printer]])
1492
1493
1494 ## ------------------------- ##
1495 ## Qualified $$ in actions.  ##
1496 ## ------------------------- ##
1497
1498 # Check that we can use qualified $$ (v.g., $<type>$) not only in rule
1499 # actions, but also where $$ is valid: %destructor/%printer and
1500 # %initial-action.
1501 #
1502 # FIXME: Not actually checking %destructor, but it's the same code as
1503 # %printer...
1504 #
1505 # To do that, use a semantic value that has two fields (sem_type),
1506 # declare symbols to have only one of these types (INT, float), and
1507 # use $<type>$ to get the other one.  Including for symbols that are
1508 # not typed (UNTYPED).
1509
1510 m4_pushdef([AT_TEST],
1511 [AT_SETUP([[Qualified $$ in actions: $1]])
1512
1513 AT_BISON_OPTION_PUSHDEFS([%skeleton "$1" %debug])
1514
1515 AT_DATA_GRAMMAR([[input.y]],
1516 [[%skeleton "$1"
1517 %debug
1518 %code requires
1519 {
1520   typedef struct sem_type
1521   {
1522     int ival;
1523     float fval;
1524   } sem_type;
1525
1526 # define YYSTYPE sem_type
1527
1528 ]AT_SKEL_CC_IF([[
1529 # include <iostream>
1530   static void
1531   report (std::ostream& yyo, int ival, float fval)
1532   {
1533     yyo << "ival: " << ival << ", fval: " <<  fval;
1534   }
1535 ]], [[
1536 # include <stdio.h>
1537   static void
1538   report (FILE* yyo, int ival, float fval)
1539   {
1540     fprintf (yyo, "ival: %d, fval: %1.1f", ival, fval);
1541   }
1542 ]])[
1543 }
1544
1545 %code
1546 {
1547   ]AT_YYERROR_DECLARE[
1548   ]AT_YYLEX_DECLARE[
1549 }
1550
1551 %token UNTYPED
1552 %token <ival> INT
1553 %type <fval> float
1554 %printer { report (yyo, $$,       $<fval>$); } <ival>;
1555 %printer { report (yyo, $<ival>$, $$      ); } <fval>;
1556 %printer { report (yyo, $<ival>$, $<fval>$); } <>;
1557
1558 %initial-action
1559 {
1560   $<ival>$ = 42;
1561   $<fval>$ = 4.2;
1562 }
1563
1564 %%
1565 float: UNTYPED INT
1566 {
1567   $$       = $<fval>1 + $<fval>2;
1568   $<ival>$ = $<ival>1 + $][2;
1569 };
1570 %%
1571 ]AT_YYERROR_DEFINE[
1572 ]AT_YYLEX_DEFINE(AT_SKEL_CC_IF([[{yy::parser::token::UNTYPED,
1573                                  yy::parser::token::INT,
1574                                   EOF}]],
1575                                [[{UNTYPED, INT, EOF}]]),
1576                  [AT_VAL.ival = toknum * 10; AT_VAL.fval = toknum / 10.0;])[
1577 ]AT_MAIN_DEFINE[
1578 ]])
1579
1580 AT_FULL_COMPILE([[input]])
1581 AT_PARSER_CHECK([./input --debug], 0, [], [stderr])
1582 # Don't be too picky on the traces, GLR is not exactly the same.  Keep
1583 # only the lines from the printer.
1584 AT_CHECK([[sed -ne '/ival:/p' stderr]], 0,
1585 [[Reading a token: Next token is token UNTYPED (ival: 10, fval: 0.1)
1586 Shifting token UNTYPED (ival: 10, fval: 0.1)
1587 Reading a token: Next token is token INT (ival: 20, fval: 0.2)
1588 Shifting token INT (ival: 20, fval: 0.2)
1589    $][1 = token UNTYPED (ival: 10, fval: 0.1)
1590    $][2 = token INT (ival: 20, fval: 0.2)
1591 -> $$ = nterm float (ival: 30, fval: 0.3)
1592 Cleanup: popping nterm float (ival: 30, fval: 0.3)
1593 ]])
1594
1595 AT_BISON_OPTION_POPDEFS
1596
1597 AT_CLEANUP
1598 ])
1599
1600 AT_TEST([yacc.c])
1601 AT_TEST([glr.c])
1602 AT_TEST([lalr1.cc])
1603 AT_TEST([glr.cc])
1604
1605 m4_popdef([AT_TEST])
1606
1607 ## ----------------------------------------------- ##
1608 ## Fix user actions without a trailing semicolon.  ##
1609 ## ----------------------------------------------- ##
1610
1611 AT_SETUP([[Fix user actions without a trailing semicolon]])
1612
1613 # This feature is undocumented, but we accidentally broke it in 2.3a,
1614 # and there was a complaint at:
1615 # <http://lists.gnu.org/archive/html/bug-bison/2008-11/msg00001.html>.
1616 AT_BISON_OPTION_PUSHDEFS
1617 AT_DATA([input.y],
1618 [[%%
1619 start: test2 test1 test0 testc;
1620
1621 test2
1622 : 'a' { semi;                   /* TEST:N:2 */ }
1623 | 'b' { if (0) {no_semi}        /* TEST:N:2 */ }
1624 | 'c' { if (0) {semi;}          /* TEST:N:2 */ }
1625 | 'd' { semi;   no_semi         /* TEST:Y:2 */ }
1626 | 'e' { semi(); no_semi()       /* TEST:Y:2 */ }
1627 | 'f' { semi[]; no_semi[]       /* TEST:Y:2 */ }
1628 | 'g' { semi++; no_semi++       /* TEST:Y:2 */ }
1629 | 'h' { {no_semi} no_semi       /* TEST:Y:2 */ }
1630 | 'i' { {semi;}   no_semi       /* TEST:Y:2 */ }
1631 ;
1632 test1
1633   : 'a' { semi;                 // TEST:N:1 ;
1634 } | 'b' { if (0) {no_semi}      // TEST:N:1 ;
1635 } | 'c' { if (0) {semi;}        // TEST:N:1 ;
1636 } | 'd' { semi;   no_semi       // TEST:Y:1 ;
1637 } | 'e' { semi(); no_semi()     // TEST:Y:1 ;
1638 } | 'f' { semi[]; no_semi[]     // TEST:Y:1 ;
1639 } | 'g' { semi++; no_semi++     // TEST:Y:1 ;
1640 } | 'h' { {no_semi} no_semi     // TEST:Y:1 ;
1641 } | 'i' { {semi;}   no_semi     // TEST:Y:1 ;
1642 } ;
1643 test0
1644   : 'a' { semi;                 // TEST:N:1 {}
1645 } | 'b' { if (0) {no_semi}      // TEST:N:1 {}
1646 } | 'c' { if (0) {semi;}        // TEST:N:1 {}
1647 } | 'd' { semi;   no_semi       // TEST:Y:1 {}
1648 } | 'e' { semi(); no_semi()     // TEST:Y:1 {}
1649 } | 'f' { semi[]; no_semi[]     // TEST:Y:1 {}
1650 } | 'g' { semi++; no_semi++     // TEST:Y:1 {}
1651 } | 'h' { {no_semi} no_semi     // TEST:Y:1 {}
1652 } | 'i' { {semi;}   no_semi     // TEST:Y:1 {}
1653 } ;
1654
1655 testc
1656 : 'a' {
1657 #define TEST_MACRO_N \
1658 []"broken\" $ @ $$ @$ [];\
1659 string;"}
1660 | 'b' {
1661 no_semi
1662 #define TEST_MACRO_N \
1663 []"broken\" $ @ $$ @$ [];\
1664 string;"}
1665 ]])
1666 AT_BISON_OPTION_POPDEFS
1667
1668 AT_BISON_CHECK([[-o input.c input.y]], [0], [],
1669 [[input.y:8.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1670 input.y:8.48:     future versions of Bison will not add the ';'
1671 input.y:9.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1672 input.y:9.48:     future versions of Bison will not add the ';'
1673 input.y:10.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1674 input.y:10.48:     future versions of Bison will not add the ';'
1675 input.y:11.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1676 input.y:11.48:     future versions of Bison will not add the ';'
1677 input.y:12.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1678 input.y:12.48:     future versions of Bison will not add the ';'
1679 input.y:13.48: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1680 input.y:13.48:     future versions of Bison will not add the ';'
1681 input.y:20.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1682 input.y:20.1:     future versions of Bison will not add the ';'
1683 input.y:21.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1684 input.y:21.1:     future versions of Bison will not add the ';'
1685 input.y:22.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1686 input.y:22.1:     future versions of Bison will not add the ';'
1687 input.y:23.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1688 input.y:23.1:     future versions of Bison will not add the ';'
1689 input.y:24.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1690 input.y:24.1:     future versions of Bison will not add the ';'
1691 input.y:25.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1692 input.y:25.1:     future versions of Bison will not add the ';'
1693 input.y:31.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1694 input.y:31.1:     future versions of Bison will not add the ';'
1695 input.y:32.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1696 input.y:32.1:     future versions of Bison will not add the ';'
1697 input.y:33.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1698 input.y:33.1:     future versions of Bison will not add the ';'
1699 input.y:34.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1700 input.y:34.1:     future versions of Bison will not add the ';'
1701 input.y:35.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1702 input.y:35.1:     future versions of Bison will not add the ';'
1703 input.y:36.1: warning: a ';' might be needed at the end of action code [-Wdeprecated]
1704 input.y:36.1:     future versions of Bison will not add the ';'
1705 ]])
1706
1707 AT_MATCHES_CHECK([input.c], [[/\* TEST:N:2 \*/ \}$]],       [[3]])
1708 AT_MATCHES_CHECK([input.c], [[/\* TEST:Y:2 \*/ ;\}$]],      [[6]])
1709 AT_MATCHES_CHECK([input.c], [[// TEST:N:1 [;{}]*\n\}$]],    [[6]])
1710 AT_MATCHES_CHECK([input.c], [[// TEST:Y:1 [;{}]*\n;\}$]],  [[12]])
1711 AT_MATCHES_CHECK([input.c], [[#define TEST_MACRO_N \\\n\[\]"broken\\" \$ \@ \$\$ \@\$ \[\];\\\nstring;"\}]], [[2]])
1712
1713 AT_CLEANUP
1714
1715
1716 ## -------------------------------------------------- ##
1717 ## Destroying lookahead assigned by semantic action.  ##
1718 ## -------------------------------------------------- ##
1719
1720 AT_SETUP([[Destroying lookahead assigned by semantic action]])
1721
1722 AT_BISON_OPTION_PUSHDEFS
1723 AT_DATA_GRAMMAR([input.y],
1724 [[
1725 %code {
1726   #include <assert.h>
1727   #include <stdio.h>
1728 ]AT_YYERROR_DECLARE[
1729 ]AT_YYLEX_DECLARE[
1730   #define USE(Var)
1731 }
1732
1733 %destructor { fprintf (stderr, "'a' destructor\n"); } 'a'
1734 %destructor { fprintf (stderr, "'b' destructor\n"); } 'b'
1735
1736 %%
1737
1738 // In a previous version of Bison, yychar assigned by the semantic
1739 // action below was not translated into yytoken before the lookahead was
1740 // discarded and thus before its destructor (selected according to
1741 // yytoken) was called in order to return from yyparse.  This would
1742 // happen even if YYACCEPT was performed in a later semantic action as
1743 // long as only consistent states with default reductions were visited
1744 // in between.  However, we leave YYACCEPT in the same semantic action
1745 // for this test in order to show that skeletons cannot simply translate
1746 // immediately after every semantic action because a semantic action
1747 // that has set yychar might not always return normally.  Instead,
1748 // skeletons must translate before every use of yytoken.
1749 start: 'a' accept { USE($1); } ;
1750 accept: %empty {
1751   assert (yychar == YYEMPTY);
1752   yychar = 'b';
1753   YYACCEPT;
1754 } ;
1755
1756 %%
1757 ]AT_YYERROR_DEFINE[
1758 ]AT_YYLEX_DEFINE(["a"])[
1759 ]AT_MAIN_DEFINE[
1760 ]])
1761 AT_BISON_OPTION_POPDEFS
1762 AT_BISON_CHECK([[-o input.c input.y]])
1763 AT_COMPILE([[input]])
1764 AT_PARSER_CHECK([[./input]], [[0]], [],
1765 [['b' destructor
1766 'a' destructor
1767 ]])
1768
1769 AT_CLEANUP
1770
1771 ## ---------- ##
1772 ## YYBACKUP.  ##
1773 ## ---------- ##
1774
1775 AT_SETUP([[YYBACKUP]])
1776
1777 AT_BISON_OPTION_PUSHDEFS([%pure-parser %debug])
1778
1779 AT_DATA_GRAMMAR([input.y],
1780 [[
1781 %error-verbose
1782 %debug
1783 %pure-parser
1784 %code {
1785 # include <stdio.h>
1786 # include <stdlib.h>
1787 # include <assert.h>
1788
1789   ]AT_YYERROR_DECLARE[
1790   ]AT_YYLEX_DECLARE[
1791 }
1792 %%
1793 input:
1794   exp exp {}
1795 ;
1796
1797 exp:
1798   'a'     { printf ("a: %d\n", $1); }
1799 | 'b'     { YYBACKUP('a', 123); }
1800 | 'c' 'd' { YYBACKUP('a', 456); }
1801 ;
1802
1803 %%
1804 ]AT_YYERROR_DEFINE[
1805 ]AT_YYLEX_DEFINE(["bcd"], [*lvalp = (toknum + 1) * 10])[
1806 ]AT_MAIN_DEFINE[
1807 ]])
1808 AT_BISON_OPTION_POPDEFS
1809
1810 AT_BISON_CHECK([[-o input.c input.y]])
1811 AT_COMPILE([[input]])
1812 AT_PARSER_CHECK([[./input]], [[0]],
1813 [[a: 123
1814 a: 456
1815 ]])
1816
1817 AT_CLEANUP