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