share/bison/lalr1.cc

   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* yylocationp)
 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* yylocationp)
 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* yylocationp)
 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_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 << "):" << 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[::yyundef_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)