data/lalr1.cc

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