data/lalr1.cc

   1 # C++ skeleton for Bison
   2
   3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   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
  22 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
  23 # --------------------------------------------------------------
  24 # Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
  25 m4_define([b4_integral_parser_table_declare],
  26 [m4_ifval([$3], [b4_c_comment([$3], [  ])
  27 ])dnl
  28   static const b4_int_type_for([$2]) yy$1_[[]];dnl
  29 ])
  30
  31 # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
  32 # ---------------------------------------------
  33 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
  34 m4_define([b4_integral_parser_table_define],
  35 [  const b4_int_type_for([$2])
  36   b4_parser_class_name::yy$1_[[]] =
  37   {
  38   $2
  39   };dnl
  40 ])
  41
  42
  43 # b4_symbol_value_template(VAL, [TYPE])
  44 # -------------------------------------
  45 # Same as b4_symbol_value, but used in a template method.  It makes
  46 # a difference when using variants.
  47 m4_copy([b4_symbol_value], [b4_symbol_value_template])
  48
  49
  50 # b4_lhs_value([TYPE])
  51 # --------------------
  52 # Expansion of $<TYPE>$.
  53 m4_define([b4_lhs_value],
  54           [b4_symbol_value([yylhs.value], [$1])])
  55
  56
  57 # b4_lhs_location()
  58 # -----------------
  59 # Expansion of @$.
  60 m4_define([b4_lhs_location],
  61           [yylhs.location])
  62
  63
  64 # b4_rhs_data(RULE-LENGTH, NUM)
  65 # -----------------------------
  66 # Return the data corresponding to the symbol #NUM, where the current
  67 # rule has RULE-LENGTH symbols on RHS.
  68 m4_define([b4_rhs_data],
  69           [yystack_@{b4_subtract($@)@}])
  70
  71
  72 # b4_rhs_state(RULE-LENGTH, NUM)
  73 # ------------------------------
  74 # The state corresponding to the symbol #NUM, where the current
  75 # rule has RULE-LENGTH symbols on RHS.
  76 m4_define([b4_rhs_state],
  77           [b4_rhs_data([$1], [$2]).state])
  78
  79
  80 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  81 # --------------------------------------
  82 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  83 # symbols on RHS.
  84 m4_define([b4_rhs_value],
  85           [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
  86
  87
  88 # b4_rhs_location(RULE-LENGTH, NUM)
  89 # ---------------------------------
  90 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  91 # on RHS.
  92 m4_define([b4_rhs_location],
  93           [b4_rhs_data([$1], [$2]).location])
  94
  95
  96 # b4_symbol_action(SYMBOL-NUM, KIND)
  97 # ----------------------------------
  98 # Run the action KIND (destructor or printer) for SYMBOL-NUM.
  99 # Same as in C, but using references instead of pointers.
 100 m4_define([b4_symbol_action],
 101 [b4_symbol_if([$1], [has_$2],
 102 [m4_pushdef([b4_dollar_dollar],
 103     [b4_symbol_value_template([yysym.value],
 104                               b4_symbol_if([$1], [has_type],
 105                                            [b4_symbol([$1], [type])]))])dnl
 106 m4_pushdef([b4_at_dollar], [yysym.location])dnl
 107       b4_symbol_case_([$1])
 108 b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
 109         b4_symbol([$1], [$2])
 110 b4_syncline([@oline@], [@ofile@])
 111         break;
 112
 113 m4_popdef([b4_at_dollar])dnl
 114 m4_popdef([b4_dollar_dollar])dnl
 115 ])])
 116
 117
 118 m4_pushdef([b4_copyright_years],
 119            [2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009])
 120
 121 m4_define([b4_parser_class_name],
 122           [b4_percent_define_get([[parser_class_name]])])
 123
 124 # The header is mandatory.
 125 b4_defines_if([],
 126               [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
 127
 128 b4_locations_if(
 129 [# Backward compatibility.
 130 m4_define([b4_location_constructors])
 131 m4_include(b4_pkgdatadir/[location.cc])])
 132 m4_include(b4_pkgdatadir/[stack.hh])
 133 b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
 134
 135 # We do want M4 expansion after # for CPP macros.
 136 m4_changecom()
 137 m4_divert_push(0)dnl
 138 @output(b4_spec_defines_file@)@
 139 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
 140 dnl FIXME: This is wrong, we want computed header guards.
 141 [
 142 /* C++ LALR(1) parser skeleton written by Akim Demaille.  */
 143
 144 #ifndef PARSER_HEADER_H
 145 # define PARSER_HEADER_H
 146
 147 ]b4_percent_code_get([[requires]])[
 148
 149 ]b4_assert_if([#include <cassert>])[
 150 #include <string>
 151 #include <iostream>
 152 #include "stack.hh"
 153
 154 ]b4_namespace_open[
 155 ]b4_locations_if([  class position;
 156   class location;])[
 157 ]b4_variant_if([b4_variant_define])[
 158 ]b4_namespace_close[
 159
 160 ]b4_locations_if([#include "location.hh"])[
 161
 162 /* Enabling traces.  */
 163 #ifndef YYDEBUG
 164 # define YYDEBUG ]b4_debug_if([1], [0])[
 165 #endif
 166
 167 /* Enabling verbose error messages.  */
 168 #ifdef YYERROR_VERBOSE
 169 # undef YYERROR_VERBOSE
 170 # define YYERROR_VERBOSE 1
 171 #else
 172 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
 173 #endif
 174
 175 /* Enabling the token table.  */
 176 #ifndef YYTOKEN_TABLE
 177 # define YYTOKEN_TABLE ]b4_token_table[
 178 #endif
 179
 180 ]b4_locations_if([dnl
 181 [/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 182    If N is 0, then set CURRENT to the empty location which ends
 183    the previous symbol: RHS[0] (always defined).  */
 184
 185 #ifndef YYLLOC_DEFAULT
 186 # define YYLLOC_DEFAULT(Current, Rhs, N)                        \
 187 do {                                                            \
 188   if (N)                                                        \
 189     {                                                           \
 190       (Current).begin = (Rhs)[1].location.begin;                \
 191       (Current).end   = (Rhs)[N].location.end;                  \
 192     }                                                           \
 193   else                                                          \
 194     {                                                           \
 195       (Current).begin = (Current).end = (Rhs)[0].location.end;  \
 196     }                                                           \
 197 } while (false)
 198 #endif]])[
 199
 200 ]b4_namespace_open[
 201
 202   /// A Bison parser.
 203   class ]b4_parser_class_name[
 204   {
 205   public:
 206 ]b4_public_types_declare[
 207     /// Build a parser object.
 208     ]b4_parser_class_name[ (]b4_parse_param_decl[);
 209     virtual ~]b4_parser_class_name[ ();
 210
 211     /// Parse.
 212     /// \returns  0 iff parsing succeeded.
 213     virtual int parse ();
 214
 215 #if YYDEBUG
 216     /// The current debugging stream.
 217     std::ostream& debug_stream () const;
 218     /// Set the current debugging stream.
 219     void set_debug_stream (std::ostream &);
 220
 221     /// Type for debugging levels.
 222     typedef int debug_level_type;
 223     /// The current debugging level.
 224     debug_level_type debug_level () const;
 225     /// Set the current debugging level.
 226     void set_debug_level (debug_level_type l);
 227 #endif
 228
 229     /// Report a syntax error.]b4_locations_if([
 230     /// \param loc    where the syntax error is found.])[
 231     /// \param msg    a description of the syntax error.
 232     virtual void error (]b4_locations_if([const location_type& loc, ])[const std::string& msg);
 233
 234   private:
 235     /// Generate an error message.
 236     /// \param state   the state where the error occurred.
 237     /// \param tok     the lookahead token.
 238     virtual std::string yysyntax_error_ (int yystate, int tok);
 239
 240     /// State numbers.
 241     typedef int state_type;
 242
 243     /// Internal symbol numbers.
 244     typedef ]b4_int_type_for([b4_translate])[ token_number_type;
 245     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
 246     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 247
 248     /* Tables.  */
 249 ]b4_parser_tables_declare[
 250
 251 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 252     /// For a symbol, its name in clear.
 253     static const char* const yytname_[];
 254 #endif]b4_error_verbose_if([
 255
 256     /// Convert the symbol name \a n to a form suitable for a diagnostic.
 257     static std::string yytnamerr_ (const char *n);])[
 258
 259 #if YYDEBUG
 260 ]b4_integral_parser_table_declare([rline], [b4_rline],
 261      [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
 262     /// Report on the debug stream that the rule \a r is going to be reduced.
 263     virtual void yy_reduce_print_ (int r);
 264     /// Print the state stack on the debug stream.
 265     virtual void yystack_print_ ();
 266
 267     /* Debugging.  */
 268     int yydebug_;
 269     std::ostream* yycdebug_;
 270 #endif
 271
 272     /// Convert a scanner token number \a t to a symbol number.
 273     static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
 274
 275 #if YYDEBUG
 276     /// \brief Display a symbol type, value and location.
 277     /// \param yyo    The output stream.
 278     /// \param yysym  The symbol.
 279     template <typename Exact>
 280     void yy_print_ (std::ostream& yyo,
 281                     const symbol_base_type<Exact>& yysym) const;
 282 #endif
 283
 284     /// \brief Reclaim the memory associated to a symbol.
 285     /// \param yymsg     Why this token is reclaimed.
 286     ///                  If null, print nothing.
 287     /// \param s         The symbol.
 288     template <typename Exact>
 289     inline void yy_destroy_ (const char* yymsg,
 290                              symbol_base_type<Exact>& yysym) const;
 291
 292   private:
 293     /// Element of the stack: a state and its attributes.
 294     struct stack_symbol_type : symbol_base_type<stack_symbol_type>
 295     {
 296       /// The parent class.
 297       typedef symbol_base_type<stack_symbol_type> super_type;
 298
 299       /// Default constructor.
 300       inline stack_symbol_type ();
 301
 302       /// Constructor.
 303       inline stack_symbol_type (]b4_args([state_type s],
 304                                          [const semantic_type& v],
 305                                          b4_locations_if([const location_type& l]))[);
 306
 307       /// The state.
 308       state_type state;
 309
 310       /// Return the type corresponding to this state.
 311       inline int type_get_ () const;
 312     };
 313
 314     /// Stack type.
 315     typedef stack<stack_symbol_type> stack_type;
 316
 317     /// The stack.
 318     stack_type yystack_;
 319
 320     /// Push a new state on the stack.
 321     /// \param m    a debug message to display
 322     ///             if null, no trace is output.
 323     /// \param s    the symbol
 324     /// \warning the contents of \a s.value is stolen.
 325     inline void yypush_ (const char* m, stack_symbol_type& s);
 326
 327     /// Push a new look ahead token on the state on the stack.
 328     /// \param m    a debug message to display
 329     ///             if null, no trace is output.
 330     /// \param s    the state
 331     /// \param sym  the symbol (for its value and location).
 332     /// \warning the contents of \a s.value is stolen.
 333     inline void yypush_ (const char* m, state_type s, symbol_type& sym);
 334
 335     /// Pop \a n symbols the three stacks.
 336     inline void yypop_ (unsigned int n = 1);
 337
 338     /* Constants.  */
 339     enum
 340     {
 341       yyeof_ = 0,
 342       yylast_ = ]b4_last[,           //< Last index in yytable_.
 343       yynnts_ = ]b4_nterms_number[,  //< Number of nonterminal symbols.
 344       yyempty_ = -2,
 345       yyfinal_ = ]b4_final_state_number[, //< Termination state number.
 346       yyterror_ = 1,
 347       yyerrcode_ = 256,
 348       yyntokens_ = ]b4_tokens_number[,   //< Number of tokens.
 349     };
 350
 351 ]b4_parse_param_vars[
 352   };
 353
 354 ]b4_lex_symbol_if([b4_yytranslate_define
 355 b4_public_types_define])[
 356 ]b4_namespace_close[
 357
 358 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
 359 [b4_token_defines(b4_tokens)
 360
 361 #ifndef YYSTYPE
 362  /* Redirection for backward compatibility.  */
 363 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
 364 #endif
 365 ])
 366 b4_percent_code_get([[provides]])[]dnl
 367
 368 [#endif /* ! defined PARSER_HEADER_H */]
 369 @output(b4_parser_file_name@)@
 370 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
 371 b4_percent_code_get([[top]])[]dnl
 372 m4_if(b4_prefix, [yy], [],
 373 [
 374 // Take the name prefix into account.
 375 #define yylex   b4_prefix[]lex])[
 376
 377 /* First part of user declarations.  */
 378 ]b4_user_pre_prologue[
 379
 380 #include "@basename(]b4_spec_defines_file[@)"
 381
 382 /* User implementation prologue.  */
 383 ]b4_user_post_prologue
 384 b4_percent_code_get[]dnl
 385
 386 [#ifndef YY_
 387 # if YYENABLE_NLS
 388 #  if ENABLE_NLS
 389 #   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
 390 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 391 #  endif
 392 # endif
 393 # ifndef YY_
 394 #  define YY_(msgid) msgid
 395 # endif
 396 #endif
 397
 398 /* Suppress unused-variable warnings by "using" E.  */
 399 #define YYUSE(e) ((void) (e))
 400
 401 /* Enable debugging if requested.  */
 402 #if YYDEBUG
 403
 404 /* A pseudo ostream that takes yydebug_ into account.  */
 405 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 406
 407 # define YY_SYMBOL_PRINT(Title, Symbol)         \
 408   do {                                          \
 409     if (yydebug_)                               \
 410     {                                           \
 411       *yycdebug_ << Title << ' ';               \
 412       yy_print_ (*yycdebug_, Symbol);           \
 413       *yycdebug_ << std::endl;                  \
 414     }                                           \
 415   } while (false)
 416
 417 # define YY_REDUCE_PRINT(Rule)          \
 418   do {                                  \
 419     if (yydebug_)                       \
 420       yy_reduce_print_ (Rule);          \
 421   } while (false)
 422
 423 # define YY_STACK_PRINT()               \
 424   do {                                  \
 425     if (yydebug_)                       \
 426       yystack_print_ ();                \
 427   } while (false)
 428
 429 #else /* !YYDEBUG */
 430
 431 # define YYCDEBUG if (false) std::cerr
 432 # define YY_SYMBOL_PRINT(Title, Symbol)  static_cast<void>(0)
 433 # define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
 434 # define YY_STACK_PRINT()                static_cast<void>(0)
 435
 436 #endif /* !YYDEBUG */
 437
 438 #define yyerrok         (yyerrstatus_ = 0)
 439 #define yyclearin       (yyempty = true)
 440
 441 #define YYACCEPT        goto yyacceptlab
 442 #define YYABORT         goto yyabortlab
 443 #define YYERROR         goto yyerrorlab
 444 #define YYRECOVERING()  (!!yyerrstatus_)
 445
 446 ]b4_namespace_open[]b4_error_verbose_if([[
 447
 448   /* Return YYSTR after stripping away unnecessary quotes and
 449      backslashes, so that it's suitable for yyerror.  The heuristic is
 450      that double-quoting is unnecessary unless the string contains an
 451      apostrophe, a comma, or backslash (other than backslash-backslash).
 452      YYSTR is taken from yytname.  */
 453   std::string
 454   ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
 455   {
 456     if (*yystr == '"')
 457       {
 458         std::string yyr = "";
 459         char const *yyp = yystr;
 460
 461         for (;;)
 462           switch (*++yyp)
 463             {
 464             case '\'':
 465             case ',':
 466               goto do_not_strip_quotes;
 467
 468             case '\\':
 469               if (*++yyp != '\\')
 470                 goto do_not_strip_quotes;
 471               /* Fall through.  */
 472             default:
 473               yyr += *yyp;
 474               break;
 475
 476             case '"':
 477               return yyr;
 478             }
 479       do_not_strip_quotes: ;
 480       }
 481
 482     return yystr;
 483   }
 484 ]])[
 485
 486   /// Build a parser object.
 487   ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
 488     :])[
 489 #if YYDEBUG
 490     ]m4_ifset([b4_parse_param], [  ], [ :])[yydebug_ (false),
 491       yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
 492 #endif]b4_parse_param_cons[
 493   {
 494   }
 495
 496   ]b4_parser_class_name::~b4_parser_class_name[ ()
 497   {
 498   }
 499
 500
 501   /*---------------.
 502   | Symbol types.  |
 503   `---------------*/
 504
 505 ]b4_lex_symbol_if([], [b4_public_types_define])[
 506
 507   // stack_symbol_type.
 508   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
 509     : super_type ()
 510     , state ()
 511   {
 512   }
 513
 514   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_args(
 515                  [state_type s],
 516                  [const semantic_type& v],
 517                  b4_locations_if([const location_type& l]))[)
 518     : super_type (v]b4_locations_if([, l])[)
 519     , state (s)
 520   {
 521   }
 522
 523   int
 524   ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
 525   {
 526     return yystos_[state];
 527   }
 528
 529
 530   template <typename Exact>
 531   void
 532   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
 533                                        symbol_base_type<Exact>& yysym) const
 534   {
 535     int yytype = yysym.type_get ();
 536     YYUSE (yymsg);
 537     if (yymsg)
 538       YY_SYMBOL_PRINT (yymsg, yysym);
 539
 540     // User destructor.
 541     switch (yytype)
 542       {
 543 ]b4_symbol_foreach([b4_symbol_destructor])dnl
 544 [       default:
 545           break;
 546       }]b4_variant_if([
 547
 548     // Type destructor.
 549   b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
 550   }
 551
 552 #if YYDEBUG
 553   template <typename Exact>
 554   void
 555   ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
 556                                      const symbol_base_type<Exact>& yysym) const
 557   {
 558     int yytype = yysym.type_get ();
 559     yyo << (yytype < yyntokens_ ? "token" : "nterm")
 560         << ' ' << yytname_[yytype] << " ("]b4_locations_if([
 561         << yysym.location << ": "])[;
 562     switch (yytype)
 563       {
 564 ]b4_symbol_foreach([b4_symbol_printer])dnl
 565 [       default:
 566           break;
 567       }
 568     yyo << ')';
 569   }
 570 #endif
 571
 572   void
 573   ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
 574                                    symbol_type& sym)
 575   {
 576     if (m)
 577       YY_SYMBOL_PRINT (m, sym);
 578 ]b4_variant_if(
 579 [[    yystack_.push (stack_symbol_type (]b4_args(
 580                     [s],
 581                     [semantic_type()],
 582                     b4_locations_if([sym.location]))[));
 583     ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
 584                        [build], [sym.value])],
 585 [[    yystack_.push (stack_symbol_type (]b4_args(
 586                       [s],
 587                       [sym.value],
 588                       b4_locations_if([sym.location]))[));]])[
 589   }
 590
 591   void
 592   ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
 593   {
 594     if (m)
 595       YY_SYMBOL_PRINT (m, s);
 596 ]b4_variant_if(
 597 [[    yystack_.push (stack_symbol_type (]b4_args(
 598                        [s.state],
 599                        [semantic_type()],
 600                        b4_locations_if([s.location]))[));
 601     ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
 602                        [build], [s.value])],
 603 [    yystack_.push (s);])[
 604   }
 605
 606   void
 607   ]b4_parser_class_name[::yypop_ (unsigned int n)
 608   {
 609     yystack_.pop (n);
 610   }
 611
 612 #if YYDEBUG
 613   std::ostream&
 614   ]b4_parser_class_name[::debug_stream () const
 615   {
 616     return *yycdebug_;
 617   }
 618
 619   void
 620   ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
 621   {
 622     yycdebug_ = &o;
 623   }
 624
 625
 626   ]b4_parser_class_name[::debug_level_type
 627   ]b4_parser_class_name[::debug_level () const
 628   {
 629     return yydebug_;
 630   }
 631
 632   void
 633   ]b4_parser_class_name[::set_debug_level (debug_level_type l)
 634   {
 635     yydebug_ = l;
 636   }
 637 #endif
 638
 639   int
 640   ]b4_parser_class_name[::parse ()
 641   {
 642     /// Whether yyla contains a lookahead.
 643     bool yyempty = true;
 644
 645     /* State.  */
 646     int yyn;
 647     int yylen = 0;
 648     int yystate = 0;
 649
 650     /* Error handling.  */
 651     int yynerrs_ = 0;
 652     int yyerrstatus_ = 0;
 653
 654     /// The lookahead symbol.
 655     symbol_type yyla;]b4_locations_if([[
 656
 657     /// The locations where the error started and ended.
 658     stack_symbol_type yyerror_range[2];]])[
 659
 660     /// $$ and @@$.
 661     stack_symbol_type yylhs;
 662
 663     /// The return value of parse().
 664     int yyresult;
 665
 666     YYCDEBUG << "Starting parse" << std::endl;
 667
 668 ]m4_ifdef([b4_initial_action], [
 669 m4_pushdef([b4_at_dollar],     [yyla.location])dnl
 670 m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
 671     /* User initialization code.  */
 672     b4_user_initial_action
 673 m4_popdef([b4_dollar_dollar])dnl
 674 m4_popdef([b4_at_dollar])])dnl
 675
 676   [  /* Initialize the stack.  The initial state will be set in
 677        yynewstate, since the latter expects the semantical and the
 678        location values to have been already stored, initialize these
 679        stacks with a primary value.  */
 680     yystack_ = stack_type (0);
 681     yypush_ (0, 0, yyla);
 682
 683     // A new state was pushed on the stack.
 684     // Invariant: yystate == yystack_[0].state, i.e.,
 685     // yystate was just pushed onto the state stack.
 686   yynewstate:
 687     YYCDEBUG << "Entering state " << yystate << std::endl;
 688
 689     /* Accept?  */
 690     if (yystate == yyfinal_)
 691       goto yyacceptlab;
 692
 693     goto yybackup;
 694
 695     /* Backup.  */
 696   yybackup:
 697
 698     /* Try to take a decision without lookahead.  */
 699     yyn = yypact_[yystate];
 700     if (yyn == yypact_ninf_)
 701       goto yydefault;
 702
 703     /* Read a lookahead token.  */
 704     if (yyempty)
 705       {
 706         YYCDEBUG << "Reading a token: ";
 707 ]b4_lex_symbol_if(
 708 [        yyla = b4_c_function_call([yylex], [symbol_type],
 709                                    m4_ifdef([b4_lex_param], b4_lex_param));],
 710 [        yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
 711                                      [[YYSTYPE*], [&yyla.value]][]dnl
 712 b4_locations_if([, [[location*], [&yyla.location]]])dnl
 713 m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
 714         yyempty = false;
 715       }
 716     YY_SYMBOL_PRINT ("Next token is", yyla);
 717
 718     /* If the proper action on seeing token YYLA.TYPE is to reduce or
 719        to detect an error, take that action.  */
 720     yyn += yyla.type;
 721     if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
 722       goto yydefault;
 723
 724     /* Reduce or error.  */
 725     yyn = yytable_[yyn];
 726     if (yyn <= 0)
 727       {
 728         if (yyn == 0 || yyn == yytable_ninf_)
 729           goto yyerrlab;
 730         yyn = -yyn;
 731         goto yyreduce;
 732       }
 733
 734     /* Discard the token being shifted.  */
 735     yyempty = true;
 736
 737     /* Count tokens shifted since error; after three, turn off error
 738        status.  */
 739     if (yyerrstatus_)
 740       --yyerrstatus_;
 741
 742     /* Shift the lookahead token.  */
 743     yystate = yyn;
 744     yypush_ ("Shifting", yystate, yyla);
 745     goto yynewstate;
 746
 747   /*-----------------------------------------------------------.
 748   | yydefault -- do the default action for the current state.  |
 749   `-----------------------------------------------------------*/
 750   yydefault:
 751     yyn = yydefact_[yystate];
 752     if (yyn == 0)
 753       goto yyerrlab;
 754     goto yyreduce;
 755
 756   /*-----------------------------.
 757   | yyreduce -- Do a reduction.  |
 758   `-----------------------------*/
 759   yyreduce:
 760     yylen = yyr2_[yyn];]b4_variant_if([
 761     /* Variants are always initialized to an empty instance of the
 762        correct type. The default $$=$1 action is NOT applied when using
 763        variants.  */
 764     ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build]),[
 765     /* If YYLEN is nonzero, implement the default value of the action:
 766        `$$ = $1'.  Otherwise, use the top of the stack.
 767
 768        Otherwise, the following line sets YYLHS.VALUE to garbage.
 769        This behavior is undocumented and Bison
 770        users should not rely upon it.  */
 771     if (yylen)
 772       yylhs.value = yystack_@{yylen - 1@}.value;
 773     else
 774       yylhs.value = yystack_@{0@}.value;])[
 775 ]b4_locations_if([dnl
 776 [
 777     // Compute the default @@$.
 778     {
 779       slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
 780       YYLLOC_DEFAULT (yylhs.location, slice, yylen);
 781     }]])[
 782
 783     // Perform the reduction.
 784     YY_REDUCE_PRINT (yyn);
 785     switch (yyn)
 786       {
 787 ]b4_user_actions[
 788         default:
 789           break;
 790       }
 791     // Compute post-reduction state.
 792     yyn = yyr1_[yyn];
 793     yystate = yypgoto_[yyn - yyntokens_] + yystack_[yylen].state;
 794     if (0 <= yystate && yystate <= yylast_
 795         && yycheck_[yystate] == yystack_[yylen].state)
 796       yystate = yytable_[yystate];
 797     else
 798       yystate = yydefgoto_[yyn - yyntokens_];
 799     yylhs.state = yystate;
 800     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 801 ]b4_variant_if([[
 802     // Destroy the rhs symbols.
 803     for (int i = 0; i < yylen; ++i)
 804       // Destroy a variant which value may have been swapped with
 805       // yylhs.value (for instance if the action was "std::swap($$,
 806       // $1)").  The value of yylhs.value (hence possibly one of these
 807       // rhs symbols) depends on the default contruction for this
 808       // type.  In the case of pointers for instance, no
 809       // initialization is done, so the value is junk.  Therefore do
 810       // not try to report the value of symbols about to be destroyed
 811       // in the debug trace, it's possibly junk.  Hence yymsg = 0.
 812       // Besides, that keeps exactly the same traces as with the other
 813       // Bison skeletons.
 814       yy_destroy_ (0, yystack_[i]);]])[
 815
 816     yypop_ (yylen);
 817     yylen = 0;
 818     YY_STACK_PRINT ();
 819
 820     /* Shift the result of the reduction.  */
 821     yypush_ (0, yylhs);
 822     goto yynewstate;
 823
 824   /*--------------------------------------.
 825   | yyerrlab -- here on detecting error.  |
 826   `--------------------------------------*/
 827   yyerrlab:
 828     /* If not already recovering from an error, report this error.  */
 829     if (!yyerrstatus_)
 830       {
 831         ++yynerrs_;
 832         error (]b4_args(b4_locations_if([yyla.location]),
 833                         [yysyntax_error_ (yystate, yyla.type)])[);
 834       }
 835
 836 ]b4_locations_if([[
 837     yyerror_range[0].location = yyla.location;]])[
 838     if (yyerrstatus_ == 3)
 839       {
 840         /* If just tried and failed to reuse lookahead token after an
 841            error, discard it.  */
 842
 843         /* Return failure if at end of input.  */
 844         if (yyla.type == yyeof_)
 845           YYABORT;
 846         else
 847           {
 848             yy_destroy_ ("Error: discarding", yyla);
 849             yyempty = true;
 850           }
 851       }
 852
 853     /* Else will try to reuse lookahead token after shifting the error
 854        token.  */
 855     goto yyerrlab1;
 856
 857
 858   /*---------------------------------------------------.
 859   | yyerrorlab -- error raised explicitly by YYERROR.  |
 860   `---------------------------------------------------*/
 861   yyerrorlab:
 862
 863     /* Pacify compilers like GCC when the user code never invokes
 864        YYERROR and the label yyerrorlab therefore never appears in user
 865        code.  */
 866     if (false)
 867       goto yyerrorlab;
 868
 869 ]b4_locations_if([[
 870     yyerror_range[0].location = yystack_[yylen - 1].location;]])[
 871     /* Do not reclaim the symbols of the rule which action triggered
 872        this YYERROR.  */
 873     yypop_ (yylen);
 874     yylen = 0;
 875     yystate = yystack_[0].state;
 876     goto yyerrlab1;
 877
 878   /*-------------------------------------------------------------.
 879   | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 880   `-------------------------------------------------------------*/
 881   yyerrlab1:
 882     yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
 883     {
 884       stack_symbol_type error_token;
 885       for (;;)
 886         {
 887           yyn = yypact_[yystate];
 888           if (yyn != yypact_ninf_)
 889             {
 890               yyn += yyterror_;
 891               if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
 892                 {
 893                   yyn = yytable_[yyn];
 894                   if (0 < yyn)
 895                     break;
 896                 }
 897             }
 898
 899           // Pop the current state because it cannot handle the error token.
 900           if (yystack_.size () == 1)
 901             YYABORT;
 902 ]b4_locations_if([[
 903           yyerror_range[0].location = yystack_[0].location;]])[
 904           yy_destroy_ ("Error: popping", yystack_[0]);
 905           yypop_ ();
 906           yystate = yystack_[0].state;
 907           YY_STACK_PRINT ();
 908         }
 909 ]b4_locations_if([[
 910       yyerror_range[1].location = yyla.location;
 911       YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);]])[
 912
 913       /* Shift the error token.  */
 914       error_token.state = yystate = yyn;
 915       yypush_ ("Shifting", error_token);
 916     }
 917     goto yynewstate;
 918
 919     /* Accept.  */
 920   yyacceptlab:
 921     yyresult = 0;
 922     goto yyreturn;
 923
 924     /* Abort.  */
 925   yyabortlab:
 926     yyresult = 1;
 927     goto yyreturn;
 928
 929   yyreturn:
 930     if (!yyempty)
 931       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
 932
 933     /* Do not reclaim the symbols of the rule which action triggered
 934        this YYABORT or YYACCEPT.  */
 935     yypop_ (yylen);
 936     while (yystack_.size () != 1)
 937       {
 938         yy_destroy_ ("Cleanup: popping", yystack_[0]);
 939         yypop_ ();
 940       }
 941
 942     return yyresult;
 943   }
 944
 945   // Generate an error message.
 946   std::string
 947   ]b4_parser_class_name[::yysyntax_error_ (]dnl
 948 b4_error_verbose_if([int yystate, int yytoken],
 949                     [int, int])[)
 950   {
 951     std::string yyres;]b4_error_verbose_if([[
 952     int yyn = yypact_[yystate];
 953     if (yypact_ninf_ < yyn && yyn <= yylast_)
 954       {
 955         /* Start YYX at -YYN if negative to avoid negative indexes in
 956            YYCHECK.  */
 957         int yyxbegin = yyn < 0 ? -yyn : 0;
 958
 959         /* Stay within bounds of both yycheck and yytname.  */
 960         int yychecklim = yylast_ - yyn + 1;
 961         int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 962
 963         // Number of reported tokens (one for the "unexpected", one per
 964         // "expected").
 965         size_t yycount = 0;
 966         // Its maximum.
 967         enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 968         // Arguments of yyformat.
 969         char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 970         yyarg[yycount++] = yytname_[yytoken];
 971         for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
 972           if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_)
 973           {
 974             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 975             {
 976               yycount = 1;
 977               break;
 978             }
 979             else
 980               yyarg[yycount++] = yytname_[yyx];
 981           }
 982
 983         char const* yyformat = 0;
 984         switch (yycount)
 985         {
 986 #define YYCASE_(N, S)                           \
 987           case N:                               \
 988             yyformat = S;                       \
 989           break
 990           YYCASE_(1, YY_("syntax error, unexpected %s"));
 991           YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
 992           YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
 993           YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
 994           YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 995 #undef YYCASE_
 996         }
 997         // Argument number.
 998         size_t yyi = 0;
 999         for (char const* yyp = yyformat; *yyp; ++yyp)
1000           if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1001           {
1002             yyres += yytnamerr_ (yyarg[yyi++]);
1003             ++yyp;
1004           }
1005           else
1006             yyres += *yyp;
1007       }
1008     else
1009   ]])dnl
1010 [    yyres = YY_("syntax error");
1011     return yyres;
1012   }
1013
1014
1015   const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1016
1017   const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1018
1019 ]b4_parser_tables_define[
1020
1021 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1022   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1023      First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1024   const char*
1025   const ]b4_parser_class_name[::yytname_[] =
1026   {
1027   ]b4_tname[
1028   };
1029 #endif
1030
1031 #if YYDEBUG
1032 ]b4_integral_parser_table_define([rline], [b4_rline])[
1033
1034   // Print the state stack on the debug stream.
1035   void
1036   ]b4_parser_class_name[::yystack_print_ ()
1037   {
1038     *yycdebug_ << "Stack now";
1039     for (stack_type::const_iterator
1040            i = yystack_.begin (),
1041            i_end = yystack_.end ();
1042          i != i_end; ++i)
1043       *yycdebug_ << ' ' << i->state;
1044     *yycdebug_ << std::endl;
1045   }
1046
1047   // Report on the debug stream that the rule \a yyrule is going to be reduced.
1048   void
1049   ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1050   {
1051     unsigned int yylno = yyrline_[yyrule];
1052     int yynrhs = yyr2_[yyrule];
1053     /* Print the symbols being reduced, and their result.  */
1054     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1055                << " (line " << yylno << "):" << std::endl;
1056     /* The symbols being reduced.  */
1057     for (int yyi = 0; yyi < yynrhs; yyi++)
1058       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1059                        ]b4_rhs_data(yynrhs, yyi + 1)[);
1060   }
1061 #endif // YYDEBUG
1062
1063 ]b4_lex_symbol_if([], [b4_yytranslate_define])[
1064 ]b4_namespace_close[
1065 ]b4_epilogue[]dnl
1066 m4_divert_pop(0)
1067 m4_popdef([b4_copyright_years])dnl