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