OLD | NEW |
(Empty) | |
| 1 # C++ skeleton for Bison |
| 2 |
| 3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 |
| 4 # Free Software Foundation, Inc. |
| 5 |
| 6 # This program is free software: you can redistribute it and/or modify |
| 7 # it under the terms of the GNU General Public License as published by |
| 8 # the Free Software Foundation, either version 3 of the License, or |
| 9 # (at your option) any later version. |
| 10 # |
| 11 # This program is distributed in the hope that it will be useful, |
| 12 # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 # GNU General Public License for more details. |
| 15 # |
| 16 # You should have received a copy of the GNU General Public License |
| 17 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 18 |
| 19 m4_include(b4_pkgdatadir/[c++.m4]) |
| 20 |
| 21 m4_define([b4_parser_class_name], |
| 22 [b4_percent_define_get([[parser_class_name]])]) |
| 23 |
| 24 # The header is mandatory. |
| 25 b4_defines_if([], |
| 26 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) |
| 27 |
| 28 # Backward compatibility. |
| 29 m4_define([b4_location_constructors]) |
| 30 m4_include(b4_pkgdatadir/[location.cc]) |
| 31 |
| 32 # We do want M4 expansion after # for CPP macros. |
| 33 m4_changecom() |
| 34 m4_divert_push(0)dnl |
| 35 b4_defines_if( |
| 36 [@output(b4_spec_defines_file@) |
| 37 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++], |
| 38 [2002, 2003, 2004, 2005, 2006, 2007, 2008]) |
| 39 dnl 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 ]b4_percent_code_get([[requires]])[ |
| 47 |
| 48 #include <string> |
| 49 #include <iostream> |
| 50 #include "stack.hh" |
| 51 |
| 52 ]b4_namespace_open[ |
| 53 class position; |
| 54 class location; |
| 55 ]b4_namespace_close[ |
| 56 |
| 57 #include "location.hh" |
| 58 |
| 59 /* Enabling traces. */ |
| 60 #ifndef YYDEBUG |
| 61 # define YYDEBUG ]b4_debug_flag[ |
| 62 #endif |
| 63 |
| 64 /* Enabling verbose error messages. */ |
| 65 #ifdef YYERROR_VERBOSE |
| 66 # undef YYERROR_VERBOSE |
| 67 # define YYERROR_VERBOSE 1 |
| 68 #else |
| 69 # define YYERROR_VERBOSE ]b4_error_verbose_flag[ |
| 70 #endif |
| 71 |
| 72 /* Enabling the token table. */ |
| 73 #ifndef YYTOKEN_TABLE |
| 74 # define YYTOKEN_TABLE ]b4_token_table[ |
| 75 #endif |
| 76 |
| 77 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
| 78 If N is 0, then set CURRENT to the empty location which ends |
| 79 the previous symbol: RHS[0] (always defined). */ |
| 80 |
| 81 #ifndef YYLLOC_DEFAULT |
| 82 # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| 83 do { \ |
| 84 if (N) \ |
| 85 { \ |
| 86 (Current).begin = (Rhs)[1].begin; \ |
| 87 (Current).end = (Rhs)[N].end; \ |
| 88 } \ |
| 89 else \ |
| 90 { \ |
| 91 (Current).begin = (Current).end = (Rhs)[0].end; \ |
| 92 } \ |
| 93 } while (false) |
| 94 #endif |
| 95 |
| 96 ]b4_namespace_open[ |
| 97 |
| 98 /// A Bison parser. |
| 99 class ]b4_parser_class_name[ |
| 100 { |
| 101 public: |
| 102 /// Symbol semantic values. |
| 103 #ifndef YYSTYPE |
| 104 ]m4_ifdef([b4_stype], |
| 105 [ union semantic_type |
| 106 { |
| 107 b4_user_stype |
| 108 };], |
| 109 [m4_if(b4_tag_seen_flag, 0, |
| 110 [[ typedef int semantic_type;]], |
| 111 [[ typedef YYSTYPE semantic_type;]])])[ |
| 112 #else |
| 113 typedef YYSTYPE semantic_type; |
| 114 #endif |
| 115 /// Symbol locations. |
| 116 typedef ]b4_percent_define_get([[location_type]])[ location_type; |
| 117 /// Tokens. |
| 118 struct token |
| 119 { |
| 120 ]b4_token_enums(b4_tokens)[ |
| 121 }; |
| 122 /// Token type. |
| 123 typedef token::yytokentype token_type; |
| 124 |
| 125 /// Build a parser object. |
| 126 ]b4_parser_class_name[ (]b4_parse_param_decl[); |
| 127 virtual ~]b4_parser_class_name[ (); |
| 128 |
| 129 /// Parse. |
| 130 /// \returns 0 iff parsing succeeded. |
| 131 virtual int parse (); |
| 132 |
| 133 #if YYDEBUG |
| 134 /// The current debugging stream. |
| 135 std::ostream& debug_stream () const; |
| 136 /// Set the current debugging stream. |
| 137 void set_debug_stream (std::ostream &); |
| 138 |
| 139 /// Type for debugging levels. |
| 140 typedef int debug_level_type; |
| 141 /// The current debugging level. |
| 142 debug_level_type debug_level () const; |
| 143 /// Set the current debugging level. |
| 144 void set_debug_level (debug_level_type l); |
| 145 #endif |
| 146 |
| 147 private: |
| 148 /// Report a syntax error. |
| 149 /// \param loc where the syntax error is found. |
| 150 /// \param msg a description of the syntax error. |
| 151 virtual void error (const location_type& loc, const std::string& msg); |
| 152 |
| 153 /// Generate an error message. |
| 154 /// \param state the state where the error occurred. |
| 155 /// \param tok the lookahead token. |
| 156 virtual std::string yysyntax_error_ (int yystate]dnl |
| 157 b4_error_verbose_if([, int tok])[); |
| 158 |
| 159 #if YYDEBUG |
| 160 /// \brief Report a symbol value on the debug stream. |
| 161 /// \param yytype The token type. |
| 162 /// \param yyvaluep Its semantic value. |
| 163 /// \param yylocationp Its location. |
| 164 virtual void yy_symbol_value_print_ (int yytype, |
| 165 const semantic_type* yyvaluep, |
| 166 const location_type* yylocationp); |
| 167 /// \brief Report a symbol on the debug stream. |
| 168 /// \param yytype The token type. |
| 169 /// \param yyvaluep Its semantic value. |
| 170 /// \param yylocationp Its location. |
| 171 virtual void yy_symbol_print_ (int yytype, |
| 172 const semantic_type* yyvaluep, |
| 173 const location_type* yylocationp); |
| 174 #endif |
| 175 |
| 176 |
| 177 /// State numbers. |
| 178 typedef int state_type; |
| 179 /// State stack type. |
| 180 typedef stack<state_type> state_stack_type; |
| 181 /// Semantic value stack type. |
| 182 typedef stack<semantic_type> semantic_stack_type; |
| 183 /// location stack type. |
| 184 typedef stack<location_type> location_stack_type; |
| 185 |
| 186 /// The state stack. |
| 187 state_stack_type yystate_stack_; |
| 188 /// The semantic value stack. |
| 189 semantic_stack_type yysemantic_stack_; |
| 190 /// The location stack. |
| 191 location_stack_type yylocation_stack_; |
| 192 |
| 193 /// Internal symbol numbers. |
| 194 typedef ]b4_int_type_for([b4_translate])[ token_number_type; |
| 195 /* Tables. */ |
| 196 /// For a state, the index in \a yytable_ of its portion. |
| 197 static const ]b4_int_type_for([b4_pact])[ yypact_[]; |
| 198 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; |
| 199 |
| 200 /// For a state, default rule to reduce. |
| 201 /// Unless\a yytable_ specifies something else to do. |
| 202 /// Zero means the default is an error. |
| 203 static const ]b4_int_type_for([b4_defact])[ yydefact_[]; |
| 204 |
| 205 static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[]; |
| 206 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[]; |
| 207 |
| 208 /// What to do in a state. |
| 209 /// \a yytable_[yypact_[s]]: what to do in state \a s. |
| 210 /// - if positive, shift that token. |
| 211 /// - if negative, reduce the rule which number is the opposite. |
| 212 /// - if zero, do what YYDEFACT says. |
| 213 static const ]b4_int_type_for([b4_table])[ yytable_[]; |
| 214 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; |
| 215 |
| 216 static const ]b4_int_type_for([b4_check])[ yycheck_[]; |
| 217 |
| 218 /// For a state, its accessing symbol. |
| 219 static const ]b4_int_type_for([b4_stos])[ yystos_[]; |
| 220 |
| 221 /// For a rule, its LHS. |
| 222 static const ]b4_int_type_for([b4_r1])[ yyr1_[]; |
| 223 /// For a rule, its RHS length. |
| 224 static const ]b4_int_type_for([b4_r2])[ yyr2_[]; |
| 225 |
| 226 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
| 227 /// For a symbol, its name in clear. |
| 228 static const char* const yytname_[]; |
| 229 #endif |
| 230 |
| 231 #if YYERROR_VERBOSE |
| 232 /// Convert the symbol name \a n to a form suitable for a diagnostic. |
| 233 virtual std::string yytnamerr_ (const char *n); |
| 234 #endif |
| 235 |
| 236 #if YYDEBUG |
| 237 /// A type to store symbol numbers and -1. |
| 238 typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type; |
| 239 /// A `-1'-separated list of the rules' RHS. |
| 240 static const rhs_number_type yyrhs_[]; |
| 241 /// For each rule, the index of the first RHS symbol in \a yyrhs_. |
| 242 static const ]b4_int_type_for([b4_prhs])[ yyprhs_[]; |
| 243 /// For each rule, its source line number. |
| 244 static const ]b4_int_type_for([b4_rline])[ yyrline_[]; |
| 245 /// For each scanner token number, its symbol number. |
| 246 static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[]; |
| 247 /// Report on the debug stream that the rule \a r is going to be reduced. |
| 248 virtual void yy_reduce_print_ (int r); |
| 249 /// Print the state stack on the debug stream. |
| 250 virtual void yystack_print_ (); |
| 251 |
| 252 /* Debugging. */ |
| 253 int yydebug_; |
| 254 std::ostream* yycdebug_; |
| 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 ]b4_parse_param_vars[ |
| 286 }; |
| 287 ]b4_namespace_close[ |
| 288 |
| 289 ]b4_percent_define_flag_if([[global_tokens_and_yystype]], |
| 290 [b4_token_defines(b4_tokens) |
| 291 |
| 292 #ifndef YYSTYPE |
| 293 /* Redirection for backward compatibility. */ |
| 294 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type |
| 295 #endif |
| 296 ]) |
| 297 b4_percent_code_get([[provides]])[]dnl |
| 298 |
| 299 [#endif /* ! defined PARSER_HEADER_H */] |
| 300 ])dnl |
| 301 @output(b4_parser_file_name@) |
| 302 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++], |
| 303 [2002, 2003, 2004, 2005, 2006, 2007, 2008]) |
| 304 b4_percent_code_get([[top]])[]dnl |
| 305 m4_if(b4_prefix, [yy], [], |
| 306 [ |
| 307 // Take the name prefix into account. |
| 308 #define yylex b4_prefix[]lex])[ |
| 309 |
| 310 /* First part of user declarations. */ |
| 311 ]b4_user_pre_prologue |
| 312 |
| 313 b4_defines_if([[ |
| 314 #include "@basename(]b4_spec_defines_file[@)"]])[ |
| 315 |
| 316 /* User implementation prologue. */ |
| 317 ]b4_user_post_prologue |
| 318 b4_percent_code_get[]dnl |
| 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 /* Enable debugging if requested. */ |
| 336 #if YYDEBUG |
| 337 |
| 338 /* A pseudo ostream that takes yydebug_ into account. */ |
| 339 # define YYCDEBUG if (yydebug_) (*yycdebug_) |
| 340 |
| 341 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
| 342 do { \ |
| 343 if (yydebug_) \ |
| 344 { \ |
| 345 *yycdebug_ << Title << ' '; \ |
| 346 yy_symbol_print_ ((Type), (Value), (Location)); \ |
| 347 *yycdebug_ << std::endl; \ |
| 348 } \ |
| 349 } while (false) |
| 350 |
| 351 # define YY_REDUCE_PRINT(Rule) \ |
| 352 do { \ |
| 353 if (yydebug_) \ |
| 354 yy_reduce_print_ (Rule); \ |
| 355 } while (false) |
| 356 |
| 357 # define YY_STACK_PRINT() \ |
| 358 do { \ |
| 359 if (yydebug_) \ |
| 360 yystack_print_ (); \ |
| 361 } while (false) |
| 362 |
| 363 #else /* !YYDEBUG */ |
| 364 |
| 365 # define YYCDEBUG if (false) std::cerr |
| 366 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
| 367 # define YY_REDUCE_PRINT(Rule) |
| 368 # define YY_STACK_PRINT() |
| 369 |
| 370 #endif /* !YYDEBUG */ |
| 371 |
| 372 #define yyerrok (yyerrstatus_ = 0) |
| 373 #define yyclearin (yychar = yyempty_) |
| 374 |
| 375 #define YYACCEPT goto yyacceptlab |
| 376 #define YYABORT goto yyabortlab |
| 377 #define YYERROR goto yyerrorlab |
| 378 #define YYRECOVERING() (!!yyerrstatus_) |
| 379 |
| 380 ]b4_namespace_open[ |
| 381 #if YYERROR_VERBOSE |
| 382 |
| 383 /* Return YYSTR after stripping away unnecessary quotes and |
| 384 backslashes, so that it's suitable for yyerror. The heuristic is |
| 385 that double-quoting is unnecessary unless the string contains an |
| 386 apostrophe, a comma, or backslash (other than backslash-backslash). |
| 387 YYSTR is taken from yytname. */ |
| 388 std::string |
| 389 ]b4_parser_class_name[::yytnamerr_ (const char *yystr) |
| 390 { |
| 391 if (*yystr == '"') |
| 392 { |
| 393 std::string yyr = ""; |
| 394 char const *yyp = yystr; |
| 395 |
| 396 for (;;) |
| 397 switch (*++yyp) |
| 398 { |
| 399 case '\'': |
| 400 case ',': |
| 401 goto do_not_strip_quotes; |
| 402 |
| 403 case '\\': |
| 404 if (*++yyp != '\\') |
| 405 goto do_not_strip_quotes; |
| 406 /* Fall through. */ |
| 407 default: |
| 408 yyr += *yyp; |
| 409 break; |
| 410 |
| 411 case '"': |
| 412 return yyr; |
| 413 } |
| 414 do_not_strip_quotes: ; |
| 415 } |
| 416 |
| 417 return yystr; |
| 418 } |
| 419 |
| 420 #endif |
| 421 |
| 422 /// Build a parser object. |
| 423 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset(
[b4_parse_param], [ |
| 424 :])[ |
| 425 #if YYDEBUG |
| 426 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), |
| 427 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ |
| 428 #endif]b4_parse_param_cons[ |
| 429 { |
| 430 } |
| 431 |
| 432 ]b4_parser_class_name::~b4_parser_class_name[ () |
| 433 { |
| 434 } |
| 435 |
| 436 #if YYDEBUG |
| 437 /*--------------------------------. |
| 438 | Print this symbol on YYOUTPUT. | |
| 439 `--------------------------------*/ |
| 440 |
| 441 inline void |
| 442 ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, |
| 443 const semantic_type* yyvaluep, const location_type* y
ylocationp) |
| 444 { |
| 445 YYUSE (yylocationp); |
| 446 YYUSE (yyvaluep); |
| 447 switch (yytype) |
| 448 { |
| 449 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl |
| 450 [ default: |
| 451 break; |
| 452 } |
| 453 } |
| 454 |
| 455 |
| 456 void |
| 457 ]b4_parser_class_name[::yy_symbol_print_ (int yytype, |
| 458 const semantic_type* yyvaluep, const location_type* y
ylocationp) |
| 459 { |
| 460 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") |
| 461 << ' ' << yytname_[yytype] << " (" |
| 462 << *yylocationp << ": "; |
| 463 yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); |
| 464 *yycdebug_ << ')'; |
| 465 } |
| 466 #endif |
| 467 |
| 468 void |
| 469 ]b4_parser_class_name[::yydestruct_ (const char* yymsg, |
| 470 int yytype, semantic_type* yyvaluep, location_type* y
ylocationp) |
| 471 { |
| 472 YYUSE (yylocationp); |
| 473 YYUSE (yymsg); |
| 474 YYUSE (yyvaluep); |
| 475 |
| 476 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
| 477 |
| 478 switch (yytype) |
| 479 { |
| 480 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ |
| 481 default: |
| 482 break; |
| 483 } |
| 484 } |
| 485 |
| 486 void |
| 487 ]b4_parser_class_name[::yypop_ (unsigned int n) |
| 488 { |
| 489 yystate_stack_.pop (n); |
| 490 yysemantic_stack_.pop (n); |
| 491 yylocation_stack_.pop (n); |
| 492 } |
| 493 |
| 494 #if YYDEBUG |
| 495 std::ostream& |
| 496 ]b4_parser_class_name[::debug_stream () const |
| 497 { |
| 498 return *yycdebug_; |
| 499 } |
| 500 |
| 501 void |
| 502 ]b4_parser_class_name[::set_debug_stream (std::ostream& o) |
| 503 { |
| 504 yycdebug_ = &o; |
| 505 } |
| 506 |
| 507 |
| 508 ]b4_parser_class_name[::debug_level_type |
| 509 ]b4_parser_class_name[::debug_level () const |
| 510 { |
| 511 return yydebug_; |
| 512 } |
| 513 |
| 514 void |
| 515 ]b4_parser_class_name[::set_debug_level (debug_level_type l) |
| 516 { |
| 517 yydebug_ = l; |
| 518 } |
| 519 #endif |
| 520 |
| 521 int |
| 522 ]b4_parser_class_name[::parse () |
| 523 { |
| 524 /// Lookahead and lookahead in internal form. |
| 525 int yychar = yyempty_; |
| 526 int yytoken = 0; |
| 527 |
| 528 /* State. */ |
| 529 int yyn; |
| 530 int yylen = 0; |
| 531 int yystate = 0; |
| 532 |
| 533 /* Error handling. */ |
| 534 int yynerrs_ = 0; |
| 535 int yyerrstatus_ = 0; |
| 536 |
| 537 /// Semantic value of the lookahead. |
| 538 semantic_type yylval; |
| 539 /// Location of the lookahead. |
| 540 location_type yylloc; |
| 541 /// The locations where the error started and ended. |
| 542 location_type yyerror_range[2]; |
| 543 |
| 544 /// $$. |
| 545 semantic_type yyval; |
| 546 /// @@$. |
| 547 location_type yyloc; |
| 548 |
| 549 int yyresult; |
| 550 |
| 551 YYCDEBUG << "Starting parse" << std::endl; |
| 552 |
| 553 ]m4_ifdef([b4_initial_action], [ |
| 554 m4_pushdef([b4_at_dollar], [yylloc])dnl |
| 555 m4_pushdef([b4_dollar_dollar], [yylval])dnl |
| 556 /* User initialization code. */ |
| 557 b4_user_initial_action |
| 558 m4_popdef([b4_dollar_dollar])dnl |
| 559 m4_popdef([b4_at_dollar])])dnl |
| 560 |
| 561 [ /* Initialize the stacks. The initial state will be pushed in |
| 562 yynewstate, since the latter expects the semantical and the |
| 563 location values to have been already stored, initialize these |
| 564 stacks with a primary value. */ |
| 565 yystate_stack_ = state_stack_type (0); |
| 566 yysemantic_stack_ = semantic_stack_type (0); |
| 567 yylocation_stack_ = location_stack_type (0); |
| 568 yysemantic_stack_.push (yylval); |
| 569 yylocation_stack_.push (yylloc); |
| 570 |
| 571 /* New state. */ |
| 572 yynewstate: |
| 573 yystate_stack_.push (yystate); |
| 574 YYCDEBUG << "Entering state " << yystate << std::endl; |
| 575 |
| 576 /* Accept? */ |
| 577 if (yystate == yyfinal_) |
| 578 goto yyacceptlab; |
| 579 |
| 580 goto yybackup; |
| 581 |
| 582 /* Backup. */ |
| 583 yybackup: |
| 584 |
| 585 /* Try to take a decision without lookahead. */ |
| 586 yyn = yypact_[yystate]; |
| 587 if (yyn == yypact_ninf_) |
| 588 goto yydefault; |
| 589 |
| 590 /* Read a lookahead token. */ |
| 591 if (yychar == yyempty_) |
| 592 { |
| 593 YYCDEBUG << "Reading a token: "; |
| 594 yychar = ]b4_c_function_call([yylex], [int], |
| 595 [[YYSTYPE*], [&yylval]][]dnl |
| 596 b4_locations_if([, [[location*], [&yylloc]]])dnl |
| 597 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; |
| 598 } |
| 599 |
| 600 |
| 601 /* Convert token to internal form. */ |
| 602 if (yychar <= yyeof_) |
| 603 { |
| 604 yychar = yytoken = yyeof_; |
| 605 YYCDEBUG << "Now at end of input." << std::endl; |
| 606 } |
| 607 else |
| 608 { |
| 609 yytoken = yytranslate_ (yychar); |
| 610 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
| 611 } |
| 612 |
| 613 /* If the proper action on seeing token YYTOKEN is to reduce or to |
| 614 detect an error, take that action. */ |
| 615 yyn += yytoken; |
| 616 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) |
| 617 goto yydefault; |
| 618 |
| 619 /* Reduce or error. */ |
| 620 yyn = yytable_[yyn]; |
| 621 if (yyn <= 0) |
| 622 { |
| 623 if (yyn == 0 || yyn == yytable_ninf_) |
| 624 goto yyerrlab; |
| 625 yyn = -yyn; |
| 626 goto yyreduce; |
| 627 } |
| 628 |
| 629 /* Shift the lookahead token. */ |
| 630 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
| 631 |
| 632 /* Discard the token being shifted. */ |
| 633 yychar = yyempty_; |
| 634 |
| 635 yysemantic_stack_.push (yylval); |
| 636 yylocation_stack_.push (yylloc); |
| 637 |
| 638 /* Count tokens shifted since error; after three, turn off error |
| 639 status. */ |
| 640 if (yyerrstatus_) |
| 641 --yyerrstatus_; |
| 642 |
| 643 yystate = yyn; |
| 644 goto yynewstate; |
| 645 |
| 646 /*-----------------------------------------------------------. |
| 647 | yydefault -- do the default action for the current state. | |
| 648 `-----------------------------------------------------------*/ |
| 649 yydefault: |
| 650 yyn = yydefact_[yystate]; |
| 651 if (yyn == 0) |
| 652 goto yyerrlab; |
| 653 goto yyreduce; |
| 654 |
| 655 /*-----------------------------. |
| 656 | yyreduce -- Do a reduction. | |
| 657 `-----------------------------*/ |
| 658 yyreduce: |
| 659 yylen = yyr2_[yyn]; |
| 660 /* If YYLEN is nonzero, implement the default value of the action: |
| 661 `$$ = $1'. Otherwise, use the top of the stack. |
| 662 |
| 663 Otherwise, the following line sets YYVAL to garbage. |
| 664 This behavior is undocumented and Bison |
| 665 users should not rely upon it. */ |
| 666 if (yylen) |
| 667 yyval = yysemantic_stack_[yylen - 1]; |
| 668 else |
| 669 yyval = yysemantic_stack_[0]; |
| 670 |
| 671 { |
| 672 slice<location_type, location_stack_type> slice (yylocation_stack_, yylen)
; |
| 673 YYLLOC_DEFAULT (yyloc, slice, yylen); |
| 674 } |
| 675 YY_REDUCE_PRINT (yyn); |
| 676 switch (yyn) |
| 677 { |
| 678 ]b4_user_actions[ |
| 679 default: |
| 680 break; |
| 681 } |
| 682 YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); |
| 683 |
| 684 yypop_ (yylen); |
| 685 yylen = 0; |
| 686 YY_STACK_PRINT (); |
| 687 |
| 688 yysemantic_stack_.push (yyval); |
| 689 yylocation_stack_.push (yyloc); |
| 690 |
| 691 /* Shift the result of the reduction. */ |
| 692 yyn = yyr1_[yyn]; |
| 693 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; |
| 694 if (0 <= yystate && yystate <= yylast_ |
| 695 && yycheck_[yystate] == yystate_stack_[0]) |
| 696 yystate = yytable_[yystate]; |
| 697 else |
| 698 yystate = yydefgoto_[yyn - yyntokens_]; |
| 699 goto yynewstate; |
| 700 |
| 701 /*------------------------------------. |
| 702 | yyerrlab -- here on detecting error | |
| 703 `------------------------------------*/ |
| 704 yyerrlab: |
| 705 /* If not already recovering from an error, report this error. */ |
| 706 if (!yyerrstatus_) |
| 707 { |
| 708 ++yynerrs_; |
| 709 error (yylloc, yysyntax_error_ (yystate]dnl |
| 710 b4_error_verbose_if([, yytoken])[)); |
| 711 } |
| 712 |
| 713 yyerror_range[0] = yylloc; |
| 714 if (yyerrstatus_ == 3) |
| 715 { |
| 716 /* If just tried and failed to reuse lookahead token after an |
| 717 error, discard it. */ |
| 718 |
| 719 if (yychar <= yyeof_) |
| 720 { |
| 721 /* Return failure if at end of input. */ |
| 722 if (yychar == yyeof_) |
| 723 YYABORT; |
| 724 } |
| 725 else |
| 726 { |
| 727 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc); |
| 728 yychar = yyempty_; |
| 729 } |
| 730 } |
| 731 |
| 732 /* Else will try to reuse lookahead token after shifting the error |
| 733 token. */ |
| 734 goto yyerrlab1; |
| 735 |
| 736 |
| 737 /*---------------------------------------------------. |
| 738 | yyerrorlab -- error raised explicitly by YYERROR. | |
| 739 `---------------------------------------------------*/ |
| 740 yyerrorlab: |
| 741 |
| 742 /* Pacify compilers like GCC when the user code never invokes |
| 743 YYERROR and the label yyerrorlab therefore never appears in user |
| 744 code. */ |
| 745 if (false) |
| 746 goto yyerrorlab; |
| 747 |
| 748 yyerror_range[0] = yylocation_stack_[yylen - 1]; |
| 749 /* Do not reclaim the symbols of the rule which action triggered |
| 750 this YYERROR. */ |
| 751 yypop_ (yylen); |
| 752 yylen = 0; |
| 753 yystate = yystate_stack_[0]; |
| 754 goto yyerrlab1; |
| 755 |
| 756 /*-------------------------------------------------------------. |
| 757 | yyerrlab1 -- common code for both syntax error and YYERROR. | |
| 758 `-------------------------------------------------------------*/ |
| 759 yyerrlab1: |
| 760 yyerrstatus_ = 3; /* Each real token shifted decrements this. */ |
| 761 |
| 762 for (;;) |
| 763 { |
| 764 yyn = yypact_[yystate]; |
| 765 if (yyn != yypact_ninf_) |
| 766 { |
| 767 yyn += yyterror_; |
| 768 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) |
| 769 { |
| 770 yyn = yytable_[yyn]; |
| 771 if (0 < yyn) |
| 772 break; |
| 773 } |
| 774 } |
| 775 |
| 776 /* Pop the current state because it cannot handle the error token. */ |
| 777 if (yystate_stack_.height () == 1) |
| 778 YYABORT; |
| 779 |
| 780 yyerror_range[0] = yylocation_stack_[0]; |
| 781 yydestruct_ ("Error: popping", |
| 782 yystos_[yystate], |
| 783 &yysemantic_stack_[0], &yylocation_stack_[0]); |
| 784 yypop_ (); |
| 785 yystate = yystate_stack_[0]; |
| 786 YY_STACK_PRINT (); |
| 787 } |
| 788 |
| 789 yyerror_range[1] = yylloc; |
| 790 // Using YYLLOC is tempting, but would change the location of |
| 791 // the lookahead. 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 != 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 |
| 835 b4_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_ni
nf_ = 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 << "):" << std::endl; |
| 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[::yyunde
f_token_ = ]b4_undef_token_number[; |
| 1053 |
| 1054 ]b4_namespace_close[ |
| 1055 |
| 1056 ]b4_epilogue |
| 1057 dnl |
| 1058 @output(b4_dir_prefix[]stack.hh@) |
| 1059 b4_copyright([Stack handling for Bison parsers in C++], |
| 1060 [2002, 2003, 2004, 2005, 2006, 2007, 2008])[ |
| 1061 |
| 1062 #ifndef BISON_STACK_HH |
| 1063 # define BISON_STACK_HH |
| 1064 |
| 1065 #include <deque> |
| 1066 |
| 1067 ]b4_namespace_open[ |
| 1068 template <class T, class S = std::deque<T> > |
| 1069 class stack |
| 1070 { |
| 1071 public: |
| 1072 |
| 1073 // Hide our reversed order. |
| 1074 typedef typename S::reverse_iterator iterator; |
| 1075 typedef typename S::const_reverse_iterator const_iterator; |
| 1076 |
| 1077 stack () : seq_ () |
| 1078 { |
| 1079 } |
| 1080 |
| 1081 stack (unsigned int n) : seq_ (n) |
| 1082 { |
| 1083 } |
| 1084 |
| 1085 inline |
| 1086 T& |
| 1087 operator [] (unsigned int i) |
| 1088 { |
| 1089 return seq_[i]; |
| 1090 } |
| 1091 |
| 1092 inline |
| 1093 const T& |
| 1094 operator [] (unsigned int i) const |
| 1095 { |
| 1096 return seq_[i]; |
| 1097 } |
| 1098 |
| 1099 inline |
| 1100 void |
| 1101 push (const T& t) |
| 1102 { |
| 1103 seq_.push_front (t); |
| 1104 } |
| 1105 |
| 1106 inline |
| 1107 void |
| 1108 pop (unsigned int n = 1) |
| 1109 { |
| 1110 for (; n; --n) |
| 1111 seq_.pop_front (); |
| 1112 } |
| 1113 |
| 1114 inline |
| 1115 unsigned int |
| 1116 height () const |
| 1117 { |
| 1118 return seq_.size (); |
| 1119 } |
| 1120 |
| 1121 inline const_iterator begin () const { return seq_.rbegin (); } |
| 1122 inline const_iterator end () const { return seq_.rend (); } |
| 1123 |
| 1124 private: |
| 1125 |
| 1126 S seq_; |
| 1127 }; |
| 1128 |
| 1129 /// Present a slice of the top of a stack. |
| 1130 template <class T, class S = stack<T> > |
| 1131 class slice |
| 1132 { |
| 1133 public: |
| 1134 |
| 1135 slice (const S& stack, |
| 1136 unsigned int range) : stack_ (stack), |
| 1137 range_ (range) |
| 1138 { |
| 1139 } |
| 1140 |
| 1141 inline |
| 1142 const T& |
| 1143 operator [] (unsigned int i) const |
| 1144 { |
| 1145 return stack_[range_ - i]; |
| 1146 } |
| 1147 |
| 1148 private: |
| 1149 |
| 1150 const S& stack_; |
| 1151 unsigned int range_; |
| 1152 }; |
| 1153 ]b4_namespace_close[ |
| 1154 |
| 1155 #endif // not BISON_STACK_HH[]dnl |
| 1156 ] |
| 1157 m4_divert_pop(0) |
OLD | NEW |