tests/c++.at

   1 # Checking the C++ Features.                    -*- Autotest -*-
   2
   3 # Copyright (C) 2004-2005, 2007-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([[C++ Features.]])
  19
  20
  21 ## --------------- ##
  22 ## C++ Locations.  ##
  23 ## --------------- ##
  24
  25 AT_SETUP([C++ Locations])
  26
  27 AT_BISON_OPTION_PUSHDEFS([%locations %skeleton "lalr1.cc"])
  28 AT_DATA_GRAMMAR([[input.y]],
  29 [[%code {#include <sstream>}
  30 %locations
  31 %debug
  32 %skeleton "lalr1.cc"
  33 %code
  34 {
  35 ]AT_YYERROR_DECLARE[
  36 ]AT_YYLEX_DECLARE[
  37 }
  38 %%
  39 exp: %empty;
  40 %%
  41 ]AT_YYERROR_DEFINE[
  42 ]AT_YYLEX_DEFINE[
  43
  44 template <typename T>
  45 bool
  46 check (const T& in, const std::string& s)
  47 {
  48   std::stringstream os;
  49   os << in;
  50   if (os.str () != s)
  51     {
  52       std::cerr << "fail: " << os.str () << ", expected: " << s << std::endl;
  53       return false;
  54     }
  55   return true;
  56 }
  57
  58 int
  59 main (void)
  60 {
  61   int fail = 0;
  62   ]AT_YYLTYPE[ loc;  fail += check (loc, "1.1");
  63   loc += 10;         fail += check (loc, "1.1-10");
  64   loc += -5;         fail += check (loc, "1.1-5");
  65   loc -= 5;          fail += check (loc, "1.1");
  66   // Check that we don't go below.
  67   // http://lists.gnu.org/archive/html/bug-bison/2013-02/msg00000.html
  68   loc -= 10;         fail += check (loc, "1.1");
  69
  70   loc.columns (10); loc.lines (10); fail += check (loc, "1.1-11.0");
  71   loc.lines (-2);                   fail += check (loc, "1.1-9.0");
  72   loc.lines (-10);                  fail += check (loc, "1.1");
  73   return !fail;
  74 }
  75 ]])
  76
  77 AT_FULL_COMPILE([input])
  78 AT_PARSER_CHECK([./input], 0)
  79 AT_BISON_OPTION_POPDEFS
  80 AT_CLEANUP
  81
  82
  83 ## --------------------------- ##
  84 ## C++ Variant-based Symbols.  ##
  85 ## --------------------------- ##
  86
  87 AT_SETUP([C++ Variant-based Symbols])
  88
  89 AT_KEYWORDS([variant])
  90
  91 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc" %debug $1])
  92 # Store strings and integers in a list of strings.
  93 AT_DATA_GRAMMAR([list.y],
  94 [[%skeleton "lalr1.cc"
  95 %define api.value.type variant
  96 %define parse.assert
  97 %debug
  98
  99 %code top
 100 {
 101   // Get access to stack_symbol_type for the tests.
 102 # define private public
 103 }
 104 %code provides
 105 {
 106   ]AT_YYLEX_DECLARE[
 107 }
 108
 109 %token <int> INT "int"
 110 %type < std::list<int> > exp
 111
 112 %printer { yyo << $$; } <int>
 113 %printer
 114   {
 115     for (std::list<int>::const_iterator i = $$.begin (); i != $$.end (); ++i)
 116       {
 117         if (i != $$.begin ())
 118           yyo << ", ";
 119         yyo << *i;
 120       }
 121   } < std::list<int> >
 122
 123 %code requires { #include <list> }
 124 %code { int yylex (yy::parser::semantic_type* yylval); }
 125
 126 %%
 127 exp: "int" { $$.push_back ($1); }
 128 %%
 129 ]AT_YYERROR_DEFINE[
 130 ]AT_YYLEX_DEFINE[
 131
 132 int main()
 133 {
 134   {
 135     yy::parser::symbol_type s = yy::parser::make_INT(12);
 136     std::cerr << s.value.as<int>() << std::endl;
 137   }
 138
 139   {
 140     yy::parser::symbol_type s = yy::parser::make_INT(123);
 141     yy::parser::stack_symbol_type ss(1, s);
 142     std::cerr << ss.value.as<int>() << std::endl;
 143   }
 144
 145   {
 146     yy::parser::stack_type st;
 147     for (int i = 0; i < 100; ++i)
 148       {
 149         yy::parser::symbol_type s(yy::parser::make_INT(i));
 150         yy::parser::stack_symbol_type ss(1, s);
 151         st.push(ss);
 152       }
 153   }
 154 }
 155 ]])
 156
 157 AT_FULL_COMPILE([list])
 158 AT_PARSER_CHECK([./list], 0, [],
 159 [12
 160 123
 161 ])
 162
 163 AT_BISON_OPTION_POPDEFS
 164 AT_CLEANUP
 165
 166
 167 ## ---------- ##
 168 ## Variants.  ##
 169 ## ---------- ##
 170
 171 # AT_TEST([DIRECTIVES])
 172 # ---------------------
 173 # Check the support of variants in C++, with the additional DIRECTIVES.
 174 m4_pushdef([AT_TEST],
 175 [AT_SETUP([Variants $1])
 176
 177 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc" %debug $1])
 178 # Store strings and integers in a list of strings.
 179 AT_DATA_GRAMMAR([list.y],
 180 [[%debug
 181 %skeleton "lalr1.cc"
 182 %define api.value.type variant
 183 ]m4_bpatsubst([$1], [\\n], [
 184 ])[
 185
 186 %code requires // code for the .hh file
 187 {
 188 #include <list>
 189 #include <string>
 190 typedef std::list<std::string> strings_type;
 191 }
 192
 193 %code // code for the .cc file
 194 {
 195 #include <cstdlib> // abort, getenv
 196 #include <iostream>
 197 #include <sstream>
 198
 199   namespace yy
 200   {
 201     static]AT_TOKEN_CTOR_IF([[
 202     parser::symbol_type yylex ()]], [[
 203     parser::token_type yylex (parser::semantic_type* yylval]AT_LOCATION_IF([,
 204                               parser::location_type* yylloc])[)]])[;
 205   }
 206
 207   // Printing a list of strings (for %printer).
 208   // Koening look up will look into std, since that's an std::list.
 209   namespace std
 210   {
 211     std::ostream&
 212     operator<<(std::ostream& o, const strings_type& s)
 213     {
 214       o << '(';
 215       for (strings_type::const_iterator i = s.begin (); i != s.end (); ++i)
 216         {
 217           if (i != s.begin ())
 218             o << ", ";
 219           o << *i;
 220         }
 221       return o << ')';
 222     }
 223   }
 224
 225   // Conversion to string.
 226   template <typename T>
 227     inline
 228     std::string
 229     string_cast (const T& t)
 230   {
 231     std::ostringstream o;
 232     o << t;
 233     return o.str ();
 234   }
 235 }
 236
 237 %token <::std::string> TEXT;
 238 %token <int> NUMBER;
 239 %token END_OF_FILE 0;
 240
 241 %type <::std::string> item;
 242 // Using the template type to exercize its parsing.
 243 // Starting with :: to ensure we don't output "<::" which starts by the
 244 // digraph for the left square bracket.
 245 %type <::std::list<std::string>> list result;
 246
 247 %printer { yyo << $][$; }
 248   <int> <::std::string> <::std::list<std::string>>;
 249 %%
 250
 251 result:
 252   list          { std::cout << $][1 << std::endl; }
 253 ;
 254
 255 list:
 256   /* nothing */ { /* Generates an empty string list */ }
 257 | list item     { std::swap ($][$,$][1); $$.push_back ($][2); }
 258 | list error    { std::swap ($][$,$][1); }
 259 ;
 260
 261 item:
 262   TEXT          { std::swap ($][$,$][1); }
 263 | NUMBER        { if ($][1 == 3) YYERROR; else $][$ = string_cast ($][1); }
 264 ;
 265 %%
 266 ]AT_TOKEN_CTOR_IF([],
 267 [[#ifdef TWO_STAGE_BUILD
 268 # define BUILD(Type, Value) build<Type> () = Value
 269 #else
 270 # define BUILD(Type, Value) build (Value)
 271 #endif
 272 ]])[
 273 #define STAGE_MAX 5
 274 namespace yy
 275 {
 276   static]AT_TOKEN_CTOR_IF([[
 277   parser::symbol_type yylex ()]], [[
 278   parser::token_type yylex (parser::semantic_type* yylval]AT_LOCATION_IF([,
 279                             parser::location_type* yylloc])[)]])[
 280   {]AT_LOCATION_IF([
 281     typedef parser::location_type location;])[
 282     static int stage = -1;
 283     ++stage;
 284     if (stage == STAGE_MAX)
 285       {]AT_TOKEN_CTOR_IF([[
 286         return parser::make_END_OF_FILE (]AT_LOCATION_IF([location ()])[);]],
 287 [AT_LOCATION_IF([
 288         *yylloc = location ();])[
 289         return parser::token::END_OF_FILE;]])[
 290       }
 291     else if (stage % 2)
 292       {]AT_TOKEN_CTOR_IF([[
 293         return parser::make_NUMBER (stage]AT_LOCATION_IF([, location ()])[);]],
 294 [[
 295         yylval->BUILD (int, stage);]AT_LOCATION_IF([
 296         *yylloc = location ();])[
 297         return parser::token::NUMBER;]])[
 298       }
 299     else
 300       {]AT_TOKEN_CTOR_IF([[
 301         return parser::make_TEXT (string_cast (stage)]AT_LOCATION_IF([, location ()])[);]], [[
 302         yylval->BUILD (std::string, string_cast (stage));]AT_LOCATION_IF([
 303         *yylloc = location ();])[
 304         return parser::token::TEXT;]])[
 305       }
 306     abort ();
 307   }
 308 }
 309
 310 ]AT_YYERROR_DEFINE[
 311 ]AT_MAIN_DEFINE[
 312 ]])
 313
 314 AT_FULL_COMPILE([list])
 315 AT_PARSER_CHECK([./list], 0,
 316 [(0, 1, 2, 4)
 317 ])
 318
 319 AT_BISON_OPTION_POPDEFS
 320 AT_CLEANUP
 321 ])
 322
 323 AT_TEST([])
 324 AT_TEST([%define parse.assert])
 325 AT_TEST([%locations %define parse.assert])
 326 AT_TEST([[%define parse.assert %code {\n#define TWO_STAGE_BUILD\n}]])
 327 AT_TEST([[%define parse.assert %define api.token.constructor]])
 328 AT_TEST([[%define parse.assert %define api.token.constructor %define api.token.prefix {TOK_}]])
 329 AT_TEST([[%locations %define parse.assert %define api.token.constructor %define api.token.prefix {TOK_}]])
 330
 331 m4_popdef([AT_TEST])
 332
 333
 334 ## ----------------------- ##
 335 ## Doxygen Documentation.  ##
 336 ## ----------------------- ##
 337
 338 m4_define([AT_CHECK_DOXYGEN],
 339 [m4_case([$1],
 340          [Public],  [m4_pushdef([AT_DOXYGEN_PRIVATE], [NO])],
 341          [Private], [m4_pushdef([AT_DOXYGEN_PRIVATE], [YES])],
 342          [m4_fatal([invalid argument: $1])])
 343 AT_SETUP([Doxygen $1 Documentation])
 344
 345 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc"])
 346 AT_DATA([input.yy],
 347 [[%skeleton "lalr1.cc"
 348 %locations
 349 %debug
 350 %%
 351 exp: /* empty */;
 352 %%
 353 ]AT_YYERROR_DEFINE[
 354 ]])
 355
 356 AT_BISON_CHECK([-o input.cc input.yy], 0)
 357
 358 AT_DATA([Doxyfile],
 359 [# The PROJECT_NAME tag is a single word (or a sequence of words
 360 # surrounded by quotes) that should identify the project.
 361 PROJECT_NAME = "Bison C++ Parser"
 362
 363 # The QUIET tag can be used to turn on/off the messages that are
 364 # generated by doxygen. Possible values are YES and NO. If left blank
 365 # NO is used.
 366 QUIET = YES
 367
 368 # The WARNINGS tag can be used to turn on/off the warning messages
 369 # that are generated by doxygen. Possible values are YES and NO. If
 370 # left blank NO is used.
 371 WARNINGS     = YES
 372 # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate
 373 # warnings for undocumented members. If EXTRACT_ALL is set to YES then
 374 # this flag will automatically be disabled.
 375 WARN_IF_UNDOCUMENTED   = YES
 376 # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings
 377 # for potential errors in the documentation, such as not documenting
 378 # some parameters in a documented function, or documenting parameters
 379 # that don't exist or using markup commands wrongly.
 380 WARN_IF_DOC_ERROR      = YES
 381 # The WARN_FORMAT tag determines the format of the warning messages
 382 # that doxygen can produce. The string should contain the $file,
 383 # $line, and $text tags, which will be replaced by the file and line
 384 # number from which the warning originated and the warning text.
 385 WARN_FORMAT            = "$file:$line: $text"
 386
 387 # If the EXTRACT_ALL tag is set to YES doxygen will assume all
 388 # entities in documentation are documented, even if no documentation
 389 # was available.  Private class members and static file members will
 390 # be hidden unless the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set
 391 # to YES
 392 EXTRACT_ALL            = YES
 393
 394 # If the EXTRACT_PRIVATE tag is set to YES all private members of a
 395 # class will be included in the documentation.
 396 EXTRACT_PRIVATE        = AT_DOXYGEN_PRIVATE
 397
 398 # If the EXTRACT_STATIC tag is set to YES all static members of a file
 399 # will be included in the documentation.
 400 EXTRACT_STATIC         = AT_DOXYGEN_PRIVATE
 401 ])
 402
 403 AT_CHECK([doxygen --version || exit 77], 0, ignore)
 404 AT_CHECK([doxygen], 0, [], [ignore])
 405
 406 AT_BISON_OPTION_POPDEFS
 407 AT_CLEANUP
 408
 409 m4_popdef([AT_DOXYGEN_PRIVATE])
 410 ])# AT_CHECK_DOXYGEN
 411
 412 AT_CHECK_DOXYGEN([Public])
 413 AT_CHECK_DOXYGEN([Private])
 414
 415
 416 ## ------------ ##
 417 ## Namespaces.  ##
 418 ## ------------ ##
 419
 420 # AT_TEST(NAMESPACE-DECL, [COMPILE-ERROR])
 421 # ----------------------------------------
 422 # See if Bison can handle %define namespace "NAMESPACE-DECL".  If COMPILE-ERROR
 423 # is specified, then Bison should accept the input, but compilation will fail,
 424 # so don't check compilation.
 425 m4_pushdef([AT_TEST],
 426 [AT_BISON_OPTION_PUSHDEFS([%language "C++" %define api.namespace {$1}])
 427 AT_DATA_GRAMMAR([[input.y]],
 428 [[%language "C++"
 429 %define api.namespace {]$1[}
 430 %union { int i; }
 431 %define global_tokens_and_yystype
 432 %locations
 433
 434 %code {
 435   // YYSTYPE contains a namespace reference.
 436   int yylex (YYSTYPE *lval, const ]$1[::parser::location_type*) {
 437     lval->i = 3;
 438     return 0;
 439   }
 440 }
 441
 442 %%
 443
 444 start: ;
 445
 446 %%
 447
 448 void
 449 ]$1[::parser::error (const ]$1[::parser::location_type &loc,
 450                      const std::string &msg)
 451 {
 452   std::cerr << "At " << loc << ": " << msg << std::endl;
 453 }
 454
 455 ]AT_MAIN_DEFINE[
 456 ]])
 457
 458
 459 AT_BISON_CHECK([[-o input.cc input.y]])
 460
 461 m4_if([$#], [1],
 462 [AT_COMPILE_CXX([[input]], [[input.cc]])
 463 AT_PARSER_CHECK([[./input]])])
 464 AT_BISON_OPTION_POPDEFS
 465 ])
 466
 467 AT_SETUP([[Relative namespace references]])
 468 AT_TEST([[foo]])
 469 AT_TEST([[foo::bar]])
 470 AT_TEST([[foo::bar::baz]])
 471 AT_CLEANUP
 472
 473 AT_SETUP([[Absolute namespace references]])
 474 AT_TEST([[::foo]])
 475 AT_TEST([[::foo::bar]])
 476 AT_TEST([[::foo::bar::baz]])
 477 AT_TEST([[@tb@::foo]])
 478 AT_TEST([[  @tb@ ::foo::bar]])
 479 AT_TEST([[  ::foo::bar::baz]])
 480 AT_CLEANUP
 481
 482 AT_SETUP([[Syntactically invalid namespace references]])
 483 AT_TEST([[:foo:bar]], [[-]])
 484 AT_TEST([[foo: :bar]], [[-]])
 485 # This one is interesting because '[3]' is encoded as '@<:@3@:>@', which
 486 # contains single occurrences of ':'.
 487 AT_TEST([[foo[3]::bar::baz]], [[-]])
 488 AT_TEST([[foo::bar,baz]], [[-]])
 489 AT_TEST([[foo::bar::(baz /* Pacify Emacs ) */]], [[-]])
 490 AT_CLEANUP
 491
 492 m4_popdef([AT_TEST])
 493
 494 ## -------------------------------------- ##
 495 ## Syntax error discarding no lookahead.  ##
 496 ## -------------------------------------- ##
 497
 498 # After a syntax error, lalr1.cc used to not check whether there
 499 # actually is a lookahead before discarding the lookahead.  As a result,
 500 # it mistakenly invoked the destructor for the previous lookahead.
 501
 502 AT_SETUP([[Syntax error discarding no lookahead]])
 503
 504 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc"])
 505
 506 AT_DATA_GRAMMAR([[input.yy]],
 507 [[%skeleton "lalr1.cc"
 508
 509 %code {
 510   #include <string>
 511   int yylex (yy::parser::semantic_type *);
 512   #define USE(Args)
 513 }
 514
 515 %define parse.error verbose
 516
 517 %nonassoc 'a' ;
 518
 519 %destructor {
 520   std::cerr << "Discarding 'a'." << std::endl;
 521 } 'a'
 522
 523 %%
 524
 525 start: error-reduce consistent-error 'a' { USE ($3); };
 526
 527 error-reduce:
 528   'a' 'a' consistent-error 'a' { USE (($1, $2, $4)); }
 529 | 'a' error { std::cerr << "Reducing 'a'." << std::endl; USE ($1); }
 530 ;
 531
 532 consistent-error:
 533   'a'
 534 | /*empty*/ %prec 'a'
 535 ;
 536
 537 // Provide another context in which all rules are useful so that this
 538 // test case looks a little more realistic.
 539 start: 'b' consistent-error ;
 540
 541 %%
 542
 543 int
 544 yylex (yy::parser::semantic_type *)
 545 {
 546   static char const *input = "aa";
 547   return *input++;
 548 }
 549
 550 void
 551 yy::parser::error (const std::string &m)
 552 {
 553   std::cerr << m << std::endl;
 554 }
 555
 556 ]AT_MAIN_DEFINE[
 557 ]])
 558
 559 AT_BISON_CHECK([[-o input.cc input.yy]])
 560 AT_COMPILE_CXX([[input]])
 561 # This used to print "Discarding 'a'." again at the end.
 562 AT_PARSER_CHECK([[./input]], [[1]], [[]],
 563 [[syntax error
 564 Discarding 'a'.
 565 Reducing 'a'.
 566 ]])
 567
 568 AT_BISON_OPTION_POPDEFS
 569 AT_CLEANUP
 570
 571
 572 ## --------------------------- ##
 573 ## Syntax error as exception.  ##
 574 ## --------------------------- ##
 575
 576 AT_SETUP([[Syntax error as exception]])
 577
 578 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc"])
 579
 580 AT_DATA_GRAMMAR([[input.yy]],
 581 [[%skeleton "lalr1.cc"
 582
 583 %code
 584 {
 585   #include <cstdlib>
 586   int yylex (yy::parser::semantic_type *);
 587 }
 588
 589 %define api.value.type variant
 590 %define parse.error verbose
 591 %define parse.trace
 592 %%
 593
 594 start:
 595   thing
 596 | start thing
 597 ;
 598
 599 thing:
 600   error   { std::cerr << "caught error" << std::endl; }
 601 | item
 602 ;
 603
 604 item:
 605   'a'
 606 | 's'
 607   {
 608     throw yy::parser::syntax_error ("invalid expression");
 609   }
 610
 611 %%
 612
 613 int
 614 yylex (yy::parser::semantic_type *)
 615 {
 616   // 's': syntax error, 'l': lexical error.
 617   static char const *input = "asal";
 618   switch (int res = *input++)
 619   {
 620     case 'l':
 621       throw yy::parser::syntax_error ("invalid character");
 622     default:
 623       return res;
 624   }
 625 }
 626
 627 void
 628 yy::parser::error (const std::string &m)
 629 {
 630   std::cerr << "error: " << m << std::endl;
 631 }
 632 ]AT_MAIN_DEFINE[
 633 ]])
 634
 635 AT_BISON_CHECK([[-o input.cc input.yy]])
 636 AT_COMPILE_CXX([[input]])
 637
 638 AT_PARSER_CHECK([[./input]], [[0]], [[]],
 639 [[error: invalid expression
 640 caught error
 641 error: invalid character
 642 caught error
 643 ]])
 644
 645 AT_BISON_OPTION_POPDEFS
 646 AT_CLEANUP
 647
 648
 649 ## ------------------ ##
 650 ## Exception safety.  ##
 651 ## ------------------ ##
 652
 653 # AT_TEST([BISON-DIRECTIVES])
 654 # ---------------------------
 655 # Check that no object is leaked when exceptions are thrown.
 656 m4_pushdef([AT_TEST],
 657 [AT_SETUP([[Exception safety $1]])
 658
 659 AT_BISON_OPTION_PUSHDEFS([%skeleton "lalr1.cc" $1])
 660
 661 AT_DATA_GRAMMAR([[input.yy]],
 662 [[%skeleton "lalr1.cc"
 663 %debug
 664 %error-verbose
 665 $1
 666 %code requires
 667 {
 668   #include <cassert>
 669   #include <cstdlib> // size_t and getenv.
 670   #include <iostream>
 671   #include <list>
 672
 673   bool debug = false;
 674
 675   /// A class that counts its number of instances.
 676   struct Object
 677   {
 678     char val;
 679
 680     Object (char v)
 681       : val (v)
 682     {
 683       Object::instances.push_back(this);
 684       log (this, "Object::Object");
 685     }
 686
 687     Object ()
 688       : val ('?')
 689     {
 690       Object::instances.push_back(this);
 691       log (this, "Object::Object");
 692     }
 693
 694     Object& operator= (char v)
 695     {
 696       val = v;
 697       return *this;
 698     }
 699
 700     ~Object ()
 701     {
 702       Object::instances.remove (this);
 703       log (this, "Object::~Object");
 704     }
 705
 706     // Static part.
 707     typedef std::list<const Object*> objects;
 708     static objects instances;
 709
 710     static bool
 711     empty ()
 712     {
 713       return instances.empty ();
 714     }
 715
 716     static void
 717     log (Object const *o, const std::string& msg)
 718     {
 719       if (debug)
 720         {
 721           if (o)
 722             std::cerr << o << "->";
 723           std::cerr << msg << " {";
 724           const char* sep = " ";
 725           for (objects::const_iterator i = instances.begin(),
 726                                        i_end = instances.end();
 727                i != i_end;
 728                ++i)
 729             {
 730               std::cerr << sep << *i;
 731               sep = ", ";
 732             }
 733           std::cerr << " }" << std::endl;
 734         }
 735     }
 736   };
 737 }
 738
 739 %code
 740 {
 741   #include <cassert>
 742   #include <cstring> // strchr
 743   #include <stdexcept>
 744   int yylex (yy::parser::semantic_type *);
 745   Object::objects Object::instances;
 746   static char const *input;
 747 }
 748
 749 ]AT_VARIANT_IF([[
 750 %printer
 751 {
 752   yyo << &$$ << " '" << $$.val << '\'';
 753   if ($$.val == 'p')
 754     throw std::runtime_error ("printer");
 755 } <Object>;
 756
 757 %token <Object> 'a' 'E' 'e' 'p' 'R' 's' 'T'
 758 %type  <Object> list item
 759 ]], [[
 760 %union
 761 {
 762   Object *obj;
 763 }
 764 %destructor { delete $$; } <obj>;
 765 %printer
 766 {
 767   yyo << $$ << " '" << $$->val << '\'';
 768   if ($$->val == 'p')
 769     throw std::runtime_error ("printer");
 770 } <obj>;
 771
 772 %token <obj> 'a' 'E' 'e' 'p' 'R' 's' 'T'
 773 %type  <obj> list item
 774 ]])[
 775
 776 %initial-action
 777 {
 778   if (strchr (input, 'i'))
 779     throw std::runtime_error ("initial-action");
 780 }
 781
 782 %%
 783
 784 start: list {]AT_VARIANT_IF([], [ delete $][1]; )[};
 785
 786 list:
 787   item       { $][$ = $][1; }
 788   // Right recursion to load the stack.
 789 | item list  { $][$ = $][1; ]AT_VARIANT_IF([], [delete $][2]; )[}
 790 ;
 791
 792 item:
 793   'a'  { $$][ = $][1; }
 794 | 'e'  { YYUSE ($][$); YYUSE($][1); error ("syntax error"); }
 795 // Not just 'E', otherwise we reduce when 'E' is the lookahead, and
 796 // then the stack is emptied, defeating the point of the test.
 797 | 'E' 'a' { YYUSE($][1); $][$ = $][2; }
 798 | 'R'  { $][$ = 0; ]AT_VARIANT_IF([], [delete $][1]; )[YYERROR; }
 799 | 'p'  { $][$ = $][1; }
 800 | 's'  { $][$ = $][1; throw std::runtime_error ("reduction"); }
 801 | 'T'  { $][$ = 0; ]AT_VARIANT_IF([], [delete $][1]; )[YYABORT; }
 802 | error { $][$ = 0; yyerrok; }
 803 ;
 804 %%
 805
 806 int
 807 yylex (yy::parser::semantic_type *lvalp)
 808 {
 809   // 'a': no error.
 810   // 'e': user action calls error.
 811   // 'E': syntax error, with yyerror that throws.
 812   // 'i': initial action throws.
 813   // 'l': yylex throws.
 814   // 'R': call YYERROR in the action
 815   // 's': reduction throws.
 816   // 'T': call YYABORT in the action
 817   switch (int res = *input++)
 818   {
 819   case 'l':
 820     throw std::runtime_error ("yylex");
 821   default:
 822     lvalp]AT_VARIANT_IF([->build (res)], [->obj = new Object (res)])[;
 823     // Fall through.
 824   case 0:
 825     return res;
 826   }
 827 }
 828
 829 /* A C++ error reporting function.  */
 830 void
 831 yy::parser::error (const std::string& m)
 832 {
 833   throw std::runtime_error (m);
 834 }
 835
 836 int
 837 main (int argc, const char *argv[])
 838 {
 839   switch (argc)
 840   {
 841     case 2:
 842       input = argv[1];
 843       break;
 844     case 3:
 845       assert (std::string(argv[1]) == "--debug");
 846       debug = 1;
 847       input = argv[2];
 848       break;
 849     default:
 850       abort ();
 851   }
 852
 853   yy::parser parser;
 854   debug |= !!getenv ("YYDEBUG");
 855   parser.set_debug_level (debug);
 856   int res = 2;
 857   try
 858   {
 859     res = parser.parse ();
 860   }
 861   catch (const std::exception& e)
 862   {
 863     std::cerr << "exception caught: " << e.what () << std::endl;
 864   }
 865   catch (...)
 866   {
 867     std::cerr << "unknown exception caught" << std::endl;
 868   }
 869   Object::log (YY_NULL, "end");
 870   assert (Object::empty());
 871   return res;
 872 }
 873 ]])
 874 AT_BISON_CHECK([[-o input.cc --report=all input.yy]])
 875 AT_COMPILE_CXX([[input]])
 876
 877 AT_PARSER_CHECK([[./input aaaas]], [[2]], [[]],
 878 [[exception caught: reduction
 879 ]])
 880
 881 AT_PARSER_CHECK([[./input aaaal]], [[2]], [[]],
 882 [[exception caught: yylex
 883 ]])
 884
 885 AT_PARSER_CHECK([[./input i]], [[2]], [[]],
 886 [[exception caught: initial-action
 887 ]])
 888
 889 AT_PARSER_CHECK([[./input aaaap]])
 890
 891 AT_PARSER_CHECK([[./input --debug aaaap]], [[2]], [[]], [[stderr]])
 892 AT_CHECK([[grep '^exception caught: printer$' stderr]], [], [ignore])
 893
 894 AT_PARSER_CHECK([[./input aaaae]], [[2]], [[]],
 895 [[exception caught: syntax error
 896 ]])
 897
 898 AT_PARSER_CHECK([[./input aaaaE]], [[2]], [[]],
 899 [[exception caught: syntax error, unexpected $end, expecting 'a'
 900 ]])
 901
 902 AT_PARSER_CHECK([[./input aaaaT]], [[1]])
 903
 904 # There is error-recovery, so exit success.
 905 AT_PARSER_CHECK([[./input aaaaR]], [[0]])
 906
 907 AT_BISON_OPTION_POPDEFS
 908
 909 AT_CLEANUP
 910 ])
 911
 912 AT_TEST
 913 AT_TEST([%define api.value.type variant])
 914
 915 m4_popdef([AT_TEST])
 916
 917 ## ------------------------------------ ##
 918 ## C++ GLR parser identifier shadowing  ##
 919 ## ------------------------------------ ##
 920
 921 AT_SETUP([[C++ GLR parser identifier shadowing]])
 922
 923 AT_DATA_GRAMMAR([input.yy], [
 924 %skeleton "glr.cc"
 925
 926 %union
 927 {
 928   int ival;
 929 }
 930
 931 %token <ival> ZERO;
 932
 933 %code
 934 {
 935   int yylex (yy::parser::semantic_type *yylval);
 936 }
 937
 938 %%
 939 exp: ZERO
 940
 941 %%
 942
 943 int yylex (yy::parser::semantic_type *yylval)
 944 {
 945   // Note: this argument is unused, but named on purpose.  There used to be a
 946   // bug with a macro that erroneously expanded this identifier to
 947   // yystackp->yyval.
 948   YYUSE (yylval);
 949   return yy::parser::token::ZERO;
 950 }
 951
 952 void yy::parser::error (std::string const&)
 953 {}
 954
 955 int main()
 956 {}
 957 ])
 958
 959 AT_BISON_CHECK([[-o input.cc input.yy]])
 960 AT_COMPILE_CXX([[input]])
 961
 962 AT_CLEANUP