1 # C++ skeleton for Bison 2 3 # Copyright (C) 2002-2012 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 m4_include(b4_pkgdatadir/[c++.m4]) 19 20 m4_define([b4_parser_class_name], 21 [b4_percent_define_get([[parser_class_name]])]) 22 23 # The header is mandatory. 24 b4_defines_if([], 25 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) 26 27 b4_percent_define_ifdef([[api.location.type]], [], 28 [# Backward compatibility. 29 m4_define([b4_location_constructors]) 30 m4_include(b4_pkgdatadir/[location.cc])]) 31 m4_include(b4_pkgdatadir/[stack.hh]) 32 33 b4_defines_if( 34 [b4_output_begin([b4_spec_defines_file]) 35 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++], 36 [2002-2012]) 37 [ 38 /** 39 ** \file ]b4_spec_defines_file[ 40 ** Define the ]b4_namespace_ref[::parser class. 41 */ 42 43 /* C++ LALR(1) parser skeleton written by Akim Demaille. */ 44 45 ]b4_cpp_guard_open([b4_spec_defines_file])[ 46 47 ]b4_percent_code_get([[requires]])[ 48 49 #include <string> 50 #include <iostream> 51 #include "stack.hh" 52 ]b4_percent_define_ifdef([[api.location.type]], [], 53 [[#include "location.hh"]])[ 54 55 ]b4_YYDEBUG_define[ 56 57 ]b4_namespace_open[ 58 59 /// A Bison parser. 60 class ]b4_parser_class_name[ 61 { 62 public: 63 /// Symbol semantic values. 64 #ifndef ]b4_api_PREFIX[STYPE 65 ]m4_ifdef([b4_stype], 66 [ union semantic_type 67 { 68 b4_user_stype 69 };], 70 [m4_if(b4_tag_seen_flag, 0, 71 [[ typedef int semantic_type;]], 72 [[ typedef ]b4_api_PREFIX[STYPE semantic_type;]])])[ 73 #else 74 typedef ]b4_api_PREFIX[STYPE semantic_type; 75 #endif 76 /// Symbol locations. 77 typedef ]b4_percent_define_get([[api.location.type]], 78 [[location]])[ location_type; 79 /// Tokens. 80 struct token 81 { 82 ]b4_token_enums(b4_tokens)[ 83 }; 84 /// Token type. 85 typedef token::yytokentype token_type; 86 87 /// Build a parser object. 88 ]b4_parser_class_name[ (]b4_parse_param_decl[); 89 virtual ~]b4_parser_class_name[ (); 90 91 /// Parse. 92 /// \returns 0 iff parsing succeeded. 93 virtual int parse (); 94 95 #if ]b4_api_PREFIX[DEBUG 96 /// The current debugging stream. 97 std::ostream& debug_stream () const; 98 /// Set the current debugging stream. 99 void set_debug_stream (std::ostream &); 100 101 /// Type for debugging levels. 102 typedef int debug_level_type; 103 /// The current debugging level. 104 debug_level_type debug_level () const; 105 /// Set the current debugging level. 106 void set_debug_level (debug_level_type l); 107 #endif 108 109 private: 110 /// Report a syntax error. 111 /// \param loc where the syntax error is found. 112 /// \param msg a description of the syntax error. 113 virtual void error (const location_type& loc, const std::string& msg); 114 115 /// Generate an error message. 116 /// \param state the state where the error occurred. 117 /// \param tok the lookahead token. 118 virtual std::string yysyntax_error_ (int yystate, int tok); 119 120 #if ]b4_api_PREFIX[DEBUG 121 /// \brief Report a symbol value on the debug stream. 122 /// \param yytype The token type. 123 /// \param yyvaluep Its semantic value. 124 /// \param yylocationp Its location. 125 virtual void yy_symbol_value_print_ (int yytype, 126 const semantic_type* yyvaluep, 127 const location_type* yylocationp); 128 /// \brief Report a symbol on the debug stream. 129 /// \param yytype The token type. 130 /// \param yyvaluep Its semantic value. 131 /// \param yylocationp Its location. 132 virtual void yy_symbol_print_ (int yytype, 133 const semantic_type* yyvaluep, 134 const location_type* yylocationp); 135 #endif 136 137 138 /// State numbers. 139 typedef int state_type; 140 /// State stack type. 141 typedef stack<state_type> state_stack_type; 142 /// Semantic value stack type. 143 typedef stack<semantic_type> semantic_stack_type; 144 /// location stack type. 145 typedef stack<location_type> location_stack_type; 146 147 /// The state stack. 148 state_stack_type yystate_stack_; 149 /// The semantic value stack. 150 semantic_stack_type yysemantic_stack_; 151 /// The location stack. 152 location_stack_type yylocation_stack_; 153 154 /// Whether the given \c yypact_ value indicates a defaulted state. 155 /// \param yyvalue the value to check 156 static bool yy_pact_value_is_default_ (int yyvalue); 157 158 /// Whether the given \c yytable_ value indicates a syntax error. 159 /// \param yyvalue the value to check 160 static bool yy_table_value_is_error_ (int yyvalue); 161 162 /// Internal symbol numbers. 163 typedef ]b4_int_type_for([b4_translate])[ token_number_type; 164 /* Tables. */ 165 /// For a state, the index in \a yytable_ of its portion. 166 static const ]b4_int_type_for([b4_pact])[ yypact_[]; 167 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; 168 169 /// For a state, default reduction number. 170 /// Unless\a yytable_ specifies something else to do. 171 /// Zero means the default is an error. 172 static const ]b4_int_type_for([b4_defact])[ yydefact_[]; 173 174 static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[]; 175 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[]; 176 177 /// What to do in a state. 178 /// \a yytable_[yypact_[s]]: what to do in state \a s. 179 /// - if positive, shift that token. 180 /// - if negative, reduce the rule which number is the opposite. 181 /// - if zero, do what YYDEFACT says. 182 static const ]b4_int_type_for([b4_table])[ yytable_[]; 183 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; 184 185 static const ]b4_int_type_for([b4_check])[ yycheck_[]; 186 187 /// For a state, its accessing symbol. 188 static const ]b4_int_type_for([b4_stos])[ yystos_[]; 189 190 /// For a rule, its LHS. 191 static const ]b4_int_type_for([b4_r1])[ yyr1_[]; 192 /// For a rule, its RHS length. 193 static const ]b4_int_type_for([b4_r2])[ yyr2_[]; ]b4_error_verbose_if([ 194 195 /// Convert the symbol name \a n to a form suitable for a diagnostic. 196 static std::string yytnamerr_ (const char *n);])[ 197 198 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ 199 /// For a symbol, its name in clear. 200 static const char* const yytname_[]; 201 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ 202 /// A type to store symbol numbers and -1. 203 typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type; 204 /// A `-1'-separated list of the rules' RHS. 205 static const rhs_number_type yyrhs_[]; 206 /// For each rule, the index of the first RHS symbol in \a yyrhs_. 207 static const ]b4_int_type_for([b4_prhs])[ yyprhs_[]; 208 /// For each rule, its source line number. 209 static const ]b4_int_type_for([b4_rline])[ yyrline_[]; 210 /// For each scanner token number, its symbol number. 211 static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[]; 212 /// Report on the debug stream that the rule \a r is going to be reduced. 213 virtual void yy_reduce_print_ (int r); 214 /// Print the state stack on the debug stream. 215 virtual void yystack_print_ (); 216 217 /* Debugging. */ 218 int yydebug_; 219 std::ostream* yycdebug_; 220 #endif 221 222 /// Convert a scanner token number \a t to a symbol number. 223 token_number_type yytranslate_ (int t); 224 225 /// \brief Reclaim the memory associated to a symbol. 226 /// \param yymsg Why this token is reclaimed. 227 /// If null, do not display the symbol, just free it. 228 /// \param yytype The symbol type. 229 /// \param yyvaluep Its semantic value. 230 /// \param yylocationp Its location. 231 inline void yydestruct_ (const char* yymsg, 232 int yytype, 233 semantic_type* yyvaluep, 234 location_type* yylocationp); 235 236 /// Pop \a n symbols the three stacks. 237 inline void yypop_ (unsigned int n = 1); 238 239 /* Constants. */ 240 static const int yyeof_; 241 /* LAST_ -- Last index in TABLE_. */ 242 static const int yylast_; 243 static const int yynnts_; 244 static const int yyempty_; 245 static const int yyfinal_; 246 static const int yyterror_; 247 static const int yyerrcode_; 248 static const int yyntokens_; 249 static const unsigned int yyuser_token_number_max_; 250 static const token_number_type yyundef_token_; 251 ]b4_parse_param_vars[ 252 }; 253 ]b4_namespace_close[ 254 255 ]b4_percent_define_flag_if([[global_tokens_and_yystype]], 256 [b4_token_defines(b4_tokens) 257 258 #ifndef ]b4_api_PREFIX[STYPE 259 /* Redirection for backward compatibility. */ 260 # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type 261 #endif 262 ])[ 263 ]b4_percent_code_get([[provides]])[ 264 ]b4_cpp_guard_close([b4_spec_defines_file]) 265 b4_output_end() 266 ]) 267 268 269 b4_output_begin([b4_parser_file_name]) 270 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++], 271 [2002-2012]) 272 b4_percent_code_get([[top]])[]dnl 273 m4_if(b4_prefix, [yy], [], 274 [ 275 // Take the name prefix into account. 276 #define yylex b4_prefix[]lex])[ 277 278 /* First part of user declarations. */ 279 ]b4_user_pre_prologue[ 280 281 ]b4_defines_if([[ 282 #include "@basename(]b4_spec_defines_file[@)"]])[ 283 284 /* User implementation prologue. */ 285 ]b4_user_post_prologue[ 286 ]b4_percent_code_get[ 287 288 ]b4_null_define[ 289 290 #ifndef YY_ 291 # if defined YYENABLE_NLS && YYENABLE_NLS 292 # if ENABLE_NLS 293 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */ 294 # define YY_(msgid) dgettext ("bison-runtime", msgid) 295 # endif 296 # endif 297 # ifndef YY_ 298 # define YY_(msgid) msgid 299 # endif 300 #endif 301 302 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 303 ]b4_yylloc_default_define[ 304 305 /* Suppress unused-variable warnings by "using" E. */ 306 #define YYUSE(e) ((void) (e)) 307 308 /* Enable debugging if requested. */ 309 #if ]b4_api_PREFIX[DEBUG 310 311 /* A pseudo ostream that takes yydebug_ into account. */ 312 # define YYCDEBUG if (yydebug_) (*yycdebug_) 313 314 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 315 do { \ 316 if (yydebug_) \ 317 { \ 318 *yycdebug_ << Title << ' '; \ 319 yy_symbol_print_ ((Type), (Value), (Location)); \ 320 *yycdebug_ << std::endl; \ 321 } \ 322 } while (false) 323 324 # define YY_REDUCE_PRINT(Rule) \ 325 do { \ 326 if (yydebug_) \ 327 yy_reduce_print_ (Rule); \ 328 } while (false) 329 330 # define YY_STACK_PRINT() \ 331 do { \ 332 if (yydebug_) \ 333 yystack_print_ (); \ 334 } while (false) 335 336 #else /* !]b4_api_PREFIX[DEBUG */ 337 338 # define YYCDEBUG if (false) std::cerr 339 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) YYUSE(Type) 340 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0) 341 # define YY_STACK_PRINT() static_cast<void>(0) 342 343 #endif /* !]b4_api_PREFIX[DEBUG */ 344 345 #define yyerrok (yyerrstatus_ = 0) 346 #define yyclearin (yychar = yyempty_) 347 348 #define YYACCEPT goto yyacceptlab 349 #define YYABORT goto yyabortlab 350 #define YYERROR goto yyerrorlab 351 #define YYRECOVERING() (!!yyerrstatus_) 352 353 ]b4_namespace_open[]b4_error_verbose_if([[ 354 355 /* Return YYSTR after stripping away unnecessary quotes and 356 backslashes, so that it's suitable for yyerror. The heuristic is 357 that double-quoting is unnecessary unless the string contains an 358 apostrophe, a comma, or backslash (other than backslash-backslash). 359 YYSTR is taken from yytname. */ 360 std::string 361 ]b4_parser_class_name[::yytnamerr_ (const char *yystr) 362 { 363 if (*yystr == '"') 364 { 365 std::string yyr = ""; 366 char const *yyp = yystr; 367 368 for (;;) 369 switch (*++yyp) 370 { 371 case '\'': 372 case ',': 373 goto do_not_strip_quotes; 374 375 case '\\': 376 if (*++yyp != '\\') 377 goto do_not_strip_quotes; 378 /* Fall through. */ 379 default: 380 yyr += *yyp; 381 break; 382 383 case '"': 384 return yyr; 385 } 386 do_not_strip_quotes: ; 387 } 388 389 return yystr; 390 } 391 ]])[ 392 393 /// Build a parser object. 394 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ 395 :])[ 396 #if ]b4_api_PREFIX[DEBUG 397 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), 398 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ 399 #endif]b4_parse_param_cons[ 400 { 401 } 402 403 ]b4_parser_class_name::~b4_parser_class_name[ () 404 { 405 } 406 407 #if ]b4_api_PREFIX[DEBUG 408 /*--------------------------------. 409 | Print this symbol on YYOUTPUT. | 410 `--------------------------------*/ 411 412 inline void 413 ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, 414 const semantic_type* yyvaluep, const location_type* yylocationp) 415 { 416 YYUSE (yylocationp); 417 YYUSE (yyvaluep); 418 std::ostream& yyo = debug_stream (); 419 std::ostream& yyoutput = yyo; 420 YYUSE (yyoutput); 421 switch (yytype) 422 { 423 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl 424 [ default: 425 break; 426 } 427 } 428 429 430 void 431 ]b4_parser_class_name[::yy_symbol_print_ (int yytype, 432 const semantic_type* yyvaluep, const location_type* yylocationp) 433 { 434 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") 435 << ' ' << yytname_[yytype] << " (" 436 << *yylocationp << ": "; 437 yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); 438 *yycdebug_ << ')'; 439 } 440 #endif 441 442 void 443 ]b4_parser_class_name[::yydestruct_ (const char* yymsg, 444 int yytype, semantic_type* yyvaluep, location_type* yylocationp) 445 { 446 YYUSE (yylocationp); 447 YYUSE (yymsg); 448 YYUSE (yyvaluep); 449 450 if (yymsg) 451 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 452 453 switch (yytype) 454 { 455 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ 456 default: 457 break; 458 } 459 } 460 461 void 462 ]b4_parser_class_name[::yypop_ (unsigned int n) 463 { 464 yystate_stack_.pop (n); 465 yysemantic_stack_.pop (n); 466 yylocation_stack_.pop (n); 467 } 468 469 #if ]b4_api_PREFIX[DEBUG 470 std::ostream& 471 ]b4_parser_class_name[::debug_stream () const 472 { 473 return *yycdebug_; 474 } 475 476 void 477 ]b4_parser_class_name[::set_debug_stream (std::ostream& o) 478 { 479 yycdebug_ = &o; 480 } 481 482 483 ]b4_parser_class_name[::debug_level_type 484 ]b4_parser_class_name[::debug_level () const 485 { 486 return yydebug_; 487 } 488 489 void 490 ]b4_parser_class_name[::set_debug_level (debug_level_type l) 491 { 492 yydebug_ = l; 493 } 494 #endif 495 496 inline bool 497 ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue) 498 { 499 return yyvalue == yypact_ninf_; 500 } 501 502 inline bool 503 ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue) 504 { 505 return yyvalue == yytable_ninf_; 506 } 507 508 int 509 ]b4_parser_class_name[::parse () 510 { 511 /// Lookahead and lookahead in internal form. 512 int yychar = yyempty_; 513 int yytoken = 0; 514 515 // State. 516 int yyn; 517 int yylen = 0; 518 int yystate = 0; 519 520 // Error handling. 521 int yynerrs_ = 0; 522 int yyerrstatus_ = 0; 523 524 /// Semantic value of the lookahead. 525 static semantic_type yyval_default; 526 semantic_type yylval = yyval_default; 527 /// Location of the lookahead. 528 location_type yylloc; 529 /// The locations where the error started and ended. 530 location_type yyerror_range[3]; 531 532 /// $$. 533 semantic_type yyval; 534 /// @@$. 535 location_type yyloc; 536 537 int yyresult; 538 539 // FIXME: This shoud be completely indented. It is not yet to 540 // avoid gratuitous conflicts when merging into the master branch. 541 try 542 { 543 YYCDEBUG << "Starting parse" << std::endl; 544 545 ]m4_ifdef([b4_initial_action], [ 546 b4_dollar_pushdef([yylval], [], [yylloc])dnl 547 /* User initialization code. */ 548 b4_user_initial_action 549 b4_dollar_popdef])[]dnl 550 551 [ /* Initialize the stacks. The initial state will be pushed in 552 yynewstate, since the latter expects the semantical and the 553 location values to have been already stored, initialize these 554 stacks with a primary value. */ 555 yystate_stack_ = state_stack_type (0); 556 yysemantic_stack_ = semantic_stack_type (0); 557 yylocation_stack_ = location_stack_type (0); 558 yysemantic_stack_.push (yylval); 559 yylocation_stack_.push (yylloc); 560 561 /* New state. */ 562 yynewstate: 563 yystate_stack_.push (yystate); 564 YYCDEBUG << "Entering state " << yystate << std::endl; 565 566 /* Accept? */ 567 if (yystate == yyfinal_) 568 goto yyacceptlab; 569 570 goto yybackup; 571 572 /* Backup. */ 573 yybackup: 574 575 /* Try to take a decision without lookahead. */ 576 yyn = yypact_[yystate]; 577 if (yy_pact_value_is_default_ (yyn)) 578 goto yydefault; 579 580 /* Read a lookahead token. */ 581 if (yychar == yyempty_) 582 { 583 YYCDEBUG << "Reading a token: "; 584 yychar = ]b4_c_function_call([yylex], [int], 585 [b4_api_PREFIX[STYPE*], [&yylval]][]dnl 586 b4_locations_if([, [[location*], [&yylloc]]])dnl 587 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; 588 } 589 590 /* Convert token to internal form. */ 591 if (yychar <= yyeof_) 592 { 593 yychar = yytoken = yyeof_; 594 YYCDEBUG << "Now at end of input." << std::endl; 595 } 596 else 597 { 598 yytoken = yytranslate_ (yychar); 599 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 600 } 601 602 /* If the proper action on seeing token YYTOKEN is to reduce or to 603 detect an error, take that action. */ 604 yyn += yytoken; 605 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) 606 goto yydefault; 607 608 /* Reduce or error. */ 609 yyn = yytable_[yyn]; 610 if (yyn <= 0) 611 { 612 if (yy_table_value_is_error_ (yyn)) 613 goto yyerrlab; 614 yyn = -yyn; 615 goto yyreduce; 616 } 617 618 /* Shift the lookahead token. */ 619 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 620 621 /* Discard the token being shifted. */ 622 yychar = yyempty_; 623 624 yysemantic_stack_.push (yylval); 625 yylocation_stack_.push (yylloc); 626 627 /* Count tokens shifted since error; after three, turn off error 628 status. */ 629 if (yyerrstatus_) 630 --yyerrstatus_; 631 632 yystate = yyn; 633 goto yynewstate; 634 635 /*-----------------------------------------------------------. 636 | yydefault -- do the default action for the current state. | 637 `-----------------------------------------------------------*/ 638 yydefault: 639 yyn = yydefact_[yystate]; 640 if (yyn == 0) 641 goto yyerrlab; 642 goto yyreduce; 643 644 /*-----------------------------. 645 | yyreduce -- Do a reduction. | 646 `-----------------------------*/ 647 yyreduce: 648 yylen = yyr2_[yyn]; 649 /* If YYLEN is nonzero, implement the default value of the action: 650 `$$ = $1'. Otherwise, use the top of the stack. 651 652 Otherwise, the following line sets YYVAL to garbage. 653 This behavior is undocumented and Bison 654 users should not rely upon it. */ 655 if (yylen) 656 yyval = yysemantic_stack_[yylen - 1]; 657 else 658 yyval = yysemantic_stack_[0]; 659 660 // Compute the default @@$. 661 { 662 slice<location_type, location_stack_type> slice (yylocation_stack_, yylen); 663 YYLLOC_DEFAULT (yyloc, slice, yylen); 664 } 665 666 // Perform the reduction. 667 YY_REDUCE_PRINT (yyn); 668 switch (yyn) 669 { 670 ]b4_user_actions[ 671 default: 672 break; 673 } 674 675 /* User semantic actions sometimes alter yychar, and that requires 676 that yytoken be updated with the new translation. We take the 677 approach of translating immediately before every use of yytoken. 678 One alternative is translating here after every semantic action, 679 but that translation would be missed if the semantic action 680 invokes YYABORT, YYACCEPT, or YYERROR immediately after altering 681 yychar. In the case of YYABORT or YYACCEPT, an incorrect 682 destructor might then be invoked immediately. In the case of 683 YYERROR, subsequent parser actions might lead to an incorrect 684 destructor call or verbose syntax error message before the 685 lookahead is translated. */ 686 YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); 687 688 yypop_ (yylen); 689 yylen = 0; 690 YY_STACK_PRINT (); 691 692 yysemantic_stack_.push (yyval); 693 yylocation_stack_.push (yyloc); 694 695 /* Shift the result of the reduction. */ 696 yyn = yyr1_[yyn]; 697 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; 698 if (0 <= yystate && yystate <= yylast_ 699 && yycheck_[yystate] == yystate_stack_[0]) 700 yystate = yytable_[yystate]; 701 else 702 yystate = yydefgoto_[yyn - yyntokens_]; 703 goto yynewstate; 704 705 /*------------------------------------. 706 | yyerrlab -- here on detecting error | 707 `------------------------------------*/ 708 yyerrlab: 709 /* Make sure we have latest lookahead translation. See comments at 710 user semantic actions for why this is necessary. */ 711 yytoken = yytranslate_ (yychar); 712 713 /* If not already recovering from an error, report this error. */ 714 if (!yyerrstatus_) 715 { 716 ++yynerrs_; 717 if (yychar == yyempty_) 718 yytoken = yyempty_; 719 error (yylloc, yysyntax_error_ (yystate, yytoken)); 720 } 721 722 yyerror_range[1] = yylloc; 723 if (yyerrstatus_ == 3) 724 { 725 /* If just tried and failed to reuse lookahead token after an 726 error, discard it. */ 727 if (yychar <= yyeof_) 728 { 729 /* Return failure if at end of input. */ 730 if (yychar == yyeof_) 731 YYABORT; 732 } 733 else 734 { 735 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc); 736 yychar = yyempty_; 737 } 738 } 739 740 /* Else will try to reuse lookahead token after shifting the error 741 token. */ 742 goto yyerrlab1; 743 744 745 /*---------------------------------------------------. 746 | yyerrorlab -- error raised explicitly by YYERROR. | 747 `---------------------------------------------------*/ 748 yyerrorlab: 749 750 /* Pacify compilers like GCC when the user code never invokes 751 YYERROR and the label yyerrorlab therefore never appears in user 752 code. */ 753 if (false) 754 goto yyerrorlab; 755 756 yyerror_range[1] = yylocation_stack_[yylen - 1]; 757 /* Do not reclaim the symbols of the rule which action triggered 758 this YYERROR. */ 759 yypop_ (yylen); 760 yylen = 0; 761 yystate = yystate_stack_[0]; 762 goto yyerrlab1; 763 764 /*-------------------------------------------------------------. 765 | yyerrlab1 -- common code for both syntax error and YYERROR. | 766 `-------------------------------------------------------------*/ 767 yyerrlab1: 768 yyerrstatus_ = 3; /* Each real token shifted decrements this. */ 769 770 for (;;) 771 { 772 yyn = yypact_[yystate]; 773 if (!yy_pact_value_is_default_ (yyn)) 774 { 775 yyn += yyterror_; 776 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) 777 { 778 yyn = yytable_[yyn]; 779 if (0 < yyn) 780 break; 781 } 782 } 783 784 /* Pop the current state because it cannot handle the error token. */ 785 if (yystate_stack_.height () == 1) 786 YYABORT; 787 788 yyerror_range[1] = yylocation_stack_[0]; 789 yydestruct_ ("Error: popping", 790 yystos_[yystate], 791 &yysemantic_stack_[0], &yylocation_stack_[0]); 792 yypop_ (); 793 yystate = yystate_stack_[0]; 794 YY_STACK_PRINT (); 795 } 796 797 yyerror_range[2] = yylloc; 798 // Using YYLLOC is tempting, but would change the location of 799 // the lookahead. YYLOC is available though. 800 YYLLOC_DEFAULT (yyloc, yyerror_range, 2); 801 yysemantic_stack_.push (yylval); 802 yylocation_stack_.push (yyloc); 803 804 /* Shift the error token. */ 805 YY_SYMBOL_PRINT ("Shifting", yystos_[yyn], 806 &yysemantic_stack_[0], &yylocation_stack_[0]); 807 808 yystate = yyn; 809 goto yynewstate; 810 811 /* Accept. */ 812 yyacceptlab: 813 yyresult = 0; 814 goto yyreturn; 815 816 /* Abort. */ 817 yyabortlab: 818 yyresult = 1; 819 goto yyreturn; 820 821 yyreturn: 822 if (yychar != yyempty_) 823 { 824 /* Make sure we have latest lookahead translation. See comments 825 at user semantic actions for why this is necessary. */ 826 yytoken = yytranslate_ (yychar); 827 yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, 828 &yylloc); 829 } 830 831 /* Do not reclaim the symbols of the rule which action triggered 832 this YYABORT or YYACCEPT. */ 833 yypop_ (yylen); 834 while (1 < yystate_stack_.height ()) 835 { 836 yydestruct_ ("Cleanup: popping", 837 yystos_[yystate_stack_[0]], 838 &yysemantic_stack_[0], 839 &yylocation_stack_[0]); 840 yypop_ (); 841 } 842 843 return yyresult; 844 } 845 catch (...) 846 { 847 YYCDEBUG << "Exception caught: cleaning lookahead and stack" 848 << std::endl; 849 // Do not try to display the values of the reclaimed symbols, 850 // as their printer might throw an exception. 851 if (yychar != yyempty_) 852 { 853 /* Make sure we have latest lookahead translation. See 854 comments at user semantic actions for why this is 855 necessary. */ 856 yytoken = yytranslate_ (yychar); 857 yydestruct_ (YY_NULL, yytoken, &yylval, &yylloc); 858 } 859 860 while (1 < yystate_stack_.height ()) 861 { 862 yydestruct_ (YY_NULL, 863 yystos_[yystate_stack_[0]], 864 &yysemantic_stack_[0], 865 &yylocation_stack_[0]); 866 yypop_ (); 867 } 868 throw; 869 } 870 } 871 872 // Generate an error message. 873 std::string 874 ]b4_parser_class_name[::yysyntax_error_ (]dnl 875 b4_error_verbose_if([int yystate, int yytoken], 876 [int, int])[) 877 {]b4_error_verbose_if([[ 878 std::string yyres; 879 // Number of reported tokens (one for the "unexpected", one per 880 // "expected"). 881 size_t yycount = 0; 882 // Its maximum. 883 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 884 // Arguments of yyformat. 885 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 886 887 /* There are many possibilities here to consider: 888 - If this state is a consistent state with a default action, then 889 the only way this function was invoked is if the default action 890 is an error action. In that case, don't check for expected 891 tokens because there are none. 892 - The only way there can be no lookahead present (in yytoken) is 893 if this state is a consistent state with a default action. 894 Thus, detecting the absence of a lookahead is sufficient to 895 determine that there is no unexpected or expected token to 896 report. In that case, just report a simple "syntax error". 897 - Don't assume there isn't a lookahead just because this state is 898 a consistent state with a default action. There might have 899 been a previous inconsistent state, consistent state with a 900 non-default action, or user semantic action that manipulated 901 yychar. 902 - Of course, the expected token list depends on states to have 903 correct lookahead information, and it depends on the parser not 904 to perform extra reductions after fetching a lookahead from the 905 scanner and before detecting a syntax error. Thus, state 906 merging (from LALR or IELR) and default reductions corrupt the 907 expected token list. However, the list is correct for 908 canonical LR with one exception: it will still contain any 909 token that will not be accepted due to an error action in a 910 later state. 911 */ 912 if (yytoken != yyempty_) 913 { 914 yyarg[yycount++] = yytname_[yytoken]; 915 int yyn = yypact_[yystate]; 916 if (!yy_pact_value_is_default_ (yyn)) 917 { 918 /* Start YYX at -YYN if negative to avoid negative indexes in 919 YYCHECK. In other words, skip the first -YYN actions for 920 this state because they are default actions. */ 921 int yyxbegin = yyn < 0 ? -yyn : 0; 922 /* Stay within bounds of both yycheck and yytname. */ 923 int yychecklim = yylast_ - yyn + 1; 924 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; 925 for (int yyx = yyxbegin; yyx < yyxend; ++yyx) 926 if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ 927 && !yy_table_value_is_error_ (yytable_[yyx + yyn])) 928 { 929 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 930 { 931 yycount = 1; 932 break; 933 } 934 else 935 yyarg[yycount++] = yytname_[yyx]; 936 } 937 } 938 } 939 940 char const* yyformat = YY_NULL; 941 switch (yycount) 942 { 943 #define YYCASE_(N, S) \ 944 case N: \ 945 yyformat = S; \ 946 break 947 YYCASE_(0, YY_("syntax error")); 948 YYCASE_(1, YY_("syntax error, unexpected %s")); 949 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 950 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 951 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 952 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 953 #undef YYCASE_ 954 } 955 956 // Argument number. 957 size_t yyi = 0; 958 for (char const* yyp = yyformat; *yyp; ++yyp) 959 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) 960 { 961 yyres += yytnamerr_ (yyarg[yyi++]); 962 ++yyp; 963 } 964 else 965 yyres += *yyp; 966 return yyres;]], [[ 967 return YY_("syntax error");]])[ 968 } 969 970 971 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 972 STATE-NUM. */ 973 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; 974 const ]b4_int_type_for([b4_pact])[ 975 ]b4_parser_class_name[::yypact_[] = 976 { 977 ]b4_pact[ 978 }; 979 980 /* YYDEFACT[S] -- default reduction number in state S. Performed when 981 YYTABLE doesn't specify something else to do. Zero means the 982 default is an error. */ 983 const ]b4_int_type_for([b4_defact])[ 984 ]b4_parser_class_name[::yydefact_[] = 985 { 986 ]b4_defact[ 987 }; 988 989 /* YYPGOTO[NTERM-NUM]. */ 990 const ]b4_int_type_for([b4_pgoto])[ 991 ]b4_parser_class_name[::yypgoto_[] = 992 { 993 ]b4_pgoto[ 994 }; 995 996 /* YYDEFGOTO[NTERM-NUM]. */ 997 const ]b4_int_type_for([b4_defgoto])[ 998 ]b4_parser_class_name[::yydefgoto_[] = 999 { 1000 ]b4_defgoto[ 1001 }; 1002 1003 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1004 positive, shift that token. If negative, reduce the rule which 1005 number is the opposite. If YYTABLE_NINF_, syntax error. */ 1006 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; 1007 const ]b4_int_type_for([b4_table])[ 1008 ]b4_parser_class_name[::yytable_[] = 1009 { 1010 ]b4_table[ 1011 }; 1012 1013 /* YYCHECK. */ 1014 const ]b4_int_type_for([b4_check])[ 1015 ]b4_parser_class_name[::yycheck_[] = 1016 { 1017 ]b4_check[ 1018 }; 1019 1020 /* STOS_[STATE-NUM] -- The (internal number of the) accessing 1021 symbol of state STATE-NUM. */ 1022 const ]b4_int_type_for([b4_stos])[ 1023 ]b4_parser_class_name[::yystos_[] = 1024 { 1025 ]b4_stos[ 1026 }; 1027 1028 #if ]b4_api_PREFIX[DEBUG 1029 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding 1030 to YYLEX-NUM. */ 1031 const ]b4_int_type_for([b4_toknum])[ 1032 ]b4_parser_class_name[::yytoken_number_[] = 1033 { 1034 ]b4_toknum[ 1035 }; 1036 #endif 1037 1038 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1039 const ]b4_int_type_for([b4_r1])[ 1040 ]b4_parser_class_name[::yyr1_[] = 1041 { 1042 ]b4_r1[ 1043 }; 1044 1045 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1046 const ]b4_int_type_for([b4_r2])[ 1047 ]b4_parser_class_name[::yyr2_[] = 1048 { 1049 ]b4_r2[ 1050 }; 1051 1052 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ 1053 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 1054 First, the terminals, then, starting at \a yyntokens_, nonterminals. */ 1055 const char* 1056 const ]b4_parser_class_name[::yytname_[] = 1057 { 1058 ]b4_tname[ 1059 }; 1060 1061 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ 1062 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 1063 const ]b4_parser_class_name[::rhs_number_type 1064 ]b4_parser_class_name[::yyrhs_[] = 1065 { 1066 ]b4_rhs[ 1067 }; 1068 1069 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 1070 YYRHS. */ 1071 const ]b4_int_type_for([b4_prhs])[ 1072 ]b4_parser_class_name[::yyprhs_[] = 1073 { 1074 ]b4_prhs[ 1075 }; 1076 1077 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 1078 const ]b4_int_type_for([b4_rline])[ 1079 ]b4_parser_class_name[::yyrline_[] = 1080 { 1081 ]b4_rline[ 1082 }; 1083 1084 // Print the state stack on the debug stream. 1085 void 1086 ]b4_parser_class_name[::yystack_print_ () 1087 { 1088 *yycdebug_ << "Stack now"; 1089 for (state_stack_type::const_iterator i = yystate_stack_.begin (); 1090 i != yystate_stack_.end (); ++i) 1091 *yycdebug_ << ' ' << *i; 1092 *yycdebug_ << std::endl; 1093 } 1094 1095 // Report on the debug stream that the rule \a yyrule is going to be reduced. 1096 void 1097 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule) 1098 { 1099 unsigned int yylno = yyrline_[yyrule]; 1100 int yynrhs = yyr2_[yyrule]; 1101 /* Print the symbols being reduced, and their result. */ 1102 *yycdebug_ << "Reducing stack by rule " << yyrule - 1 1103 << " (line " << yylno << "):" << std::endl; 1104 /* The symbols being reduced. */ 1105 for (int yyi = 0; yyi < yynrhs; yyi++) 1106 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", 1107 yyrhs_[yyprhs_[yyrule] + yyi], 1108 &]b4_rhs_value(yynrhs, yyi + 1)[, 1109 &]b4_rhs_location(yynrhs, yyi + 1)[); 1110 } 1111 #endif // ]b4_api_PREFIX[DEBUG 1112 1113 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 1114 ]b4_parser_class_name[::token_number_type 1115 ]b4_parser_class_name[::yytranslate_ (int t) 1116 { 1117 static 1118 const token_number_type 1119 translate_table[] = 1120 { 1121 ]b4_translate[ 1122 }; 1123 if ((unsigned int) t <= yyuser_token_number_max_) 1124 return translate_table[t]; 1125 else 1126 return yyundef_token_; 1127 } 1128 1129 const int ]b4_parser_class_name[::yyeof_ = 0; 1130 const int ]b4_parser_class_name[::yylast_ = ]b4_last[; 1131 const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[; 1132 const int ]b4_parser_class_name[::yyempty_ = -2; 1133 const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[; 1134 const int ]b4_parser_class_name[::yyterror_ = 1; 1135 const int ]b4_parser_class_name[::yyerrcode_ = 256; 1136 const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[; 1137 1138 const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[; 1139 const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[; 1140 1141 ]b4_namespace_close[ 1142 ]b4_epilogue[]dnl 1143 b4_output_end() 1144