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