data/lalr1.cc

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