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   /* Pacify ``unused variable'' warnings.  */
 415   (void) yyvaluep;
 416   (void) yylocationp;
 417   /* Backward compatibility, but should be removed eventually. */
 418   std::ostream& cdebug_ = *yycdebug_;
 419   (void) cdebug_;
 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   /* Pacify ``unused variable'' warnings.  */
 439   (void) yymsg;
 440   (void) yyvaluep;
 441   (void) yylocationp;
 442
 443   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 444
 445   switch (yytype)
 446     {
 447 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 448       default:
 449         break;
 450     }
 451 }
 452
 453 void
 454 yy::]b4_parser_class_name[::yypop_ (unsigned int n)
 455 {
 456   yystate_stack_.pop (n);
 457   yysemantic_stack_.pop (n);
 458   yylocation_stack_.pop (n);
 459 }
 460
 461 std::ostream&
 462 yy::]b4_parser_class_name[::debug_stream () const
 463 {
 464   return *yycdebug_;
 465 }
 466
 467 void
 468 yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
 469 {
 470   yycdebug_ = &o;
 471 }
 472
 473
 474 yy::]b4_parser_class_name[::debug_level_type
 475 yy::]b4_parser_class_name[::debug_level () const
 476 {
 477   return yydebug_;
 478 }
 479
 480 void
 481 yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
 482 {
 483   yydebug_ = l;
 484 }
 485
 486
 487 int
 488 yy::]b4_parser_class_name[::parse ()
 489 {
 490   /// Look-ahead and look-ahead in internal form.
 491   int yychar = yyempty_;
 492   int yytoken = 0;
 493
 494   /* State.  */
 495   int yyn;
 496   int yylen;
 497   int yystate = 0;
 498
 499   /* Error handling. */
 500   int yynerrs_ = 0;
 501   int yyerrstatus_ = 0;
 502
 503   /// Semantic value of the look-ahead.
 504   semantic_type yylval;
 505   /// Location of the look-ahead.
 506   location_type yylloc;
 507   /// The locations where the error started and ended.
 508   location yyerror_range[2];
 509
 510   /// $$.
 511   semantic_type yyval;
 512   /// @@$.
 513   location_type yyloc;
 514
 515   int yyresult;
 516
 517   YYCDEBUG << "Starting parse" << std::endl;
 518
 519 ]m4_ifdef([b4_initial_action], [
 520 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 521 m4_pushdef([b4_dollar_dollar], [yylval])dnl
 522   /* User initialization code. */
 523   b4_initial_action
 524 m4_popdef([b4_dollar_dollar])dnl
 525 m4_popdef([b4_at_dollar])dnl
 526 /* Line __line__ of yacc.c.  */
 527 b4_syncline([@oline@], [@ofile@])])dnl
 528
 529 [  /* Initialize the stacks.  The initial state will be pushed in
 530      yynewstate, since the latter expects the semantical and the
 531      location values to have been already stored, initialize these
 532      stacks with a primary value.  */
 533   yystate_stack_ = state_stack_type (0);
 534   yysemantic_stack_ = semantic_stack_type (0);
 535   yylocation_stack_ = location_stack_type (0);
 536   yysemantic_stack_.push (yylval);
 537   yylocation_stack_.push (yylloc);
 538
 539   /* New state.  */
 540 yynewstate:
 541   yystate_stack_.push (yystate);
 542   YYCDEBUG << "Entering state " << yystate << std::endl;
 543   goto yybackup;
 544
 545   /* Backup.  */
 546 yybackup:
 547
 548   /* Try to take a decision without look-ahead.  */
 549   yyn = yypact_[yystate];
 550   if (yyn == yypact_ninf_)
 551     goto yydefault;
 552
 553   /* Read a look-ahead token.  */
 554   if (yychar == yyempty_)
 555     {
 556       YYCDEBUG << "Reading a token: ";
 557       yychar = ]b4_c_function_call([yylex], [int],
 558 [[YYSTYPE*], [&yylval]][]dnl
 559 b4_location_if([, [[location*], [&yylloc]]])dnl
 560 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 561     }
 562
 563
 564   /* Convert token to internal form.  */
 565   if (yychar <= yyeof_)
 566     {
 567       yychar = yytoken = yyeof_;
 568       YYCDEBUG << "Now at end of input." << std::endl;
 569     }
 570   else
 571     {
 572       yytoken = yytranslate_ (yychar);
 573       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 574     }
 575
 576   /* If the proper action on seeing token YYTOKEN is to reduce or to
 577      detect an error, take that action.  */
 578   yyn += yytoken;
 579   if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
 580     goto yydefault;
 581
 582   /* Reduce or error.  */
 583   yyn = yytable_[yyn];
 584   if (yyn <= 0)
 585     {
 586       if (yyn == 0 || yyn == yytable_ninf_)
 587         goto yyerrlab;
 588       yyn = -yyn;
 589       goto yyreduce;
 590     }
 591
 592   /* Accept?  */
 593   if (yyn == yyfinal_)
 594     goto yyacceptlab;
 595
 596   /* Shift the look-ahead token.  */
 597   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 598
 599   /* Discard the token being shifted unless it is eof.  */
 600   if (yychar != yyeof_)
 601     yychar = yyempty_;
 602
 603   yysemantic_stack_.push (yylval);
 604   yylocation_stack_.push (yylloc);
 605
 606   /* Count tokens shifted since error; after three, turn off error
 607      status.  */
 608   if (yyerrstatus_)
 609     --yyerrstatus_;
 610
 611   yystate = yyn;
 612   goto yynewstate;
 613
 614 /*-----------------------------------------------------------.
 615 | yydefault -- do the default action for the current state.  |
 616 `-----------------------------------------------------------*/
 617 yydefault:
 618   yyn = yydefact_[yystate];
 619   if (yyn == 0)
 620     goto yyerrlab;
 621   goto yyreduce;
 622
 623 /*-----------------------------.
 624 | yyreduce -- Do a reduction.  |
 625 `-----------------------------*/
 626 yyreduce:
 627   yylen = yyr2_[yyn];
 628   /* If LEN_ is nonzero, implement the default value of the action:
 629      `$$ = $1'.  Otherwise, use the top of the stack.
 630
 631      Otherwise, the following line sets YYVAL to garbage.
 632      This behavior is undocumented and Bison
 633      users should not rely upon it.  */
 634   if (yylen)
 635     yyval = yysemantic_stack_[yylen - 1];
 636   else
 637     yyval = yysemantic_stack_[0];
 638
 639   {
 640     slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
 641     YYLLOC_DEFAULT (yyloc, slice, yylen);
 642   }
 643   YY_REDUCE_PRINT (yyn);
 644   switch (yyn)
 645     {
 646       ]b4_actions[
 647       default: break;
 648     }
 649
 650 ]/* Line __line__ of lalr1.cc.  */
 651 b4_syncline([@oline@], [@ofile@])[
 652
 653   yypop_ (yylen);
 654
 655   YY_STACK_PRINT ();
 656
 657   yysemantic_stack_.push (yyval);
 658   yylocation_stack_.push (yyloc);
 659
 660   /* Shift the result of the reduction.  */
 661   yyn = yyr1_[yyn];
 662   yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
 663   if (0 <= yystate && yystate <= yylast_
 664       && yycheck_[yystate] == yystate_stack_[0])
 665     yystate = yytable_[yystate];
 666   else
 667     yystate = yydefgoto_[yyn - yyntokens_];
 668   goto yynewstate;
 669
 670 /*------------------------------------.
 671 | yyerrlab -- here on detecting error |
 672 `------------------------------------*/
 673 yyerrlab:
 674   /* If not already recovering from an error, report this error.  */
 675   if (!yyerrstatus_)
 676     {
 677       ++yynerrs_;
 678       error (yylloc, yysyntax_error_ (yystate]dnl
 679 b4_error_verbose_if([, yytoken])[));
 680     }
 681
 682   yyerror_range[0] = yylloc;
 683   if (yyerrstatus_ == 3)
 684     {
 685       /* If just tried and failed to reuse look-ahead token after an
 686          error, discard it.  */
 687
 688       if (yychar <= yyeof_)
 689         {
 690           /* Return failure if at end of input.  */
 691           if (yychar == yyeof_)
 692             YYABORT;
 693         }
 694       else
 695         {
 696           yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
 697           yychar = yyempty_;
 698         }
 699     }
 700
 701   /* Else will try to reuse look-ahead token after shifting the error
 702      token.  */
 703   goto yyerrlab1;
 704
 705
 706 /*---------------------------------------------------.
 707 | yyerrorlab -- error raised explicitly by YYERROR.  |
 708 `---------------------------------------------------*/
 709 yyerrorlab:
 710
 711   /* Pacify compilers like GCC when the user code never invokes
 712      YYERROR and the label yyerrorlab therefore never appears in user
 713      code.  */
 714   if (false)
 715     goto yyerrorlab;
 716
 717   yyerror_range[0] = yylocation_stack_[yylen - 1];
 718   yypop_ (yylen);
 719   yystate = yystate_stack_[0];
 720   goto yyerrlab1;
 721
 722 /*-------------------------------------------------------------.
 723 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 724 `-------------------------------------------------------------*/
 725 yyerrlab1:
 726   yyerrstatus_ = 3;     /* Each real token shifted decrements this.  */
 727
 728   for (;;)
 729     {
 730       yyn = yypact_[yystate];
 731       if (yyn != yypact_ninf_)
 732         {
 733           yyn += yyterror_;
 734           if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
 735             {
 736               yyn = yytable_[yyn];
 737               if (0 < yyn)
 738                 break;
 739             }
 740         }
 741
 742       /* Pop the current state because it cannot handle the error token.  */
 743       if (yystate_stack_.height () == 1)
 744         YYABORT;
 745
 746       yyerror_range[0] = yylocation_stack_[0];
 747       yydestruct_ ("Error: popping",
 748                    yystos_[yystate],
 749                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 750       yypop_ ();
 751       yystate = yystate_stack_[0];
 752       YY_STACK_PRINT ();
 753     }
 754
 755   if (yyn == yyfinal_)
 756     goto yyacceptlab;
 757
 758   yyerror_range[1] = yylloc;
 759   // Using YYLLOC is tempting, but would change the location of
 760   // the look-ahead.  YYLOC is available though.
 761   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
 762   yysemantic_stack_.push (yylval);
 763   yylocation_stack_.push (yyloc);
 764
 765   /* Shift the error token. */
 766   YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
 767                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 768
 769   yystate = yyn;
 770   goto yynewstate;
 771
 772   /* Accept.  */
 773 yyacceptlab:
 774   yyresult = 0;
 775   goto yyreturn;
 776
 777   /* Abort.  */
 778 yyabortlab:
 779   yyresult = 1;
 780   goto yyreturn;
 781
 782 yyreturn:
 783   if (yychar != yyeof_ && yychar != yyempty_)
 784     yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
 785
 786   while (yystate_stack_.height () != 1)
 787     {
 788       yydestruct_ ("Cleanup: popping",
 789                    yystos_[yystate_stack_[0]],
 790                    &yysemantic_stack_[0],
 791                    &yylocation_stack_[0]);
 792       yypop_ ();
 793     }
 794
 795   return yyresult;
 796 }
 797
 798 // Generate an error message.
 799 std::string
 800 yy::]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
 801 b4_error_verbose_if([, int tok])[)
 802 {
 803   std::string res;
 804 #if YYERROR_VERBOSE
 805   int yyn = yypact_[yystate];
 806   if (yypact_ninf_ < yyn && yyn < yylast_)
 807     {
 808       /* Start YYX at -YYN if negative to avoid negative indexes in
 809          YYCHECK.  */
 810       int yyxbegin = yyn < 0 ? -yyn : 0;
 811
 812       /* Stay within bounds of both yycheck and yytname.  */
 813       int yychecklim = yylast_ - yyn;
 814       int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 815       int count = 0;
 816       for (int x = yyxbegin; x < yyxend; ++x)
 817         if (yycheck_[x + yyn] == x && x != yyterror_)
 818           ++count;
 819
 820       // FIXME: This method of building the message is not compatible
 821       // with internationalization.  It should work like yacc.c does it.
 822       // That is, first build a string that looks like this:
 823       // "syntax error, unexpected %s or %s or %s"
 824       // Then, invoke YY_ on this string.
 825       // Finally, use the string as a format to output
 826       // yytname_[tok], etc.
 827       // Until this gets fixed, this message appears in English only.
 828       res = "syntax error, unexpected ";
 829       res += yytnamerr_ (yytname_[tok]);
 830       if (count < 5)
 831         {
 832           count = 0;
 833           for (int x = yyxbegin; x < yyxend; ++x)
 834             if (yycheck_[x + yyn] == x && x != yyterror_)
 835               {
 836                 res += (!count++) ? ", expecting " : " or ";
 837                 res += yytnamerr_ (yytname_[x]);
 838               }
 839         }
 840     }
 841   else
 842 #endif
 843     res = YY_("syntax error");
 844   return res;
 845 }
 846
 847
 848 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 849    STATE-NUM.  */
 850 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
 851 const ]b4_int_type_for([b4_pact])[
 852 yy::]b4_parser_class_name[::yypact_[] =
 853 {
 854   ]b4_pact[
 855 };
 856
 857 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 858    doesn't specify something else to do.  Zero means the default is an
 859    error.  */
 860 const ]b4_int_type_for([b4_defact])[
 861 yy::]b4_parser_class_name[::yydefact_[] =
 862 {
 863   ]b4_defact[
 864 };
 865
 866 /* YYPGOTO[NTERM-NUM].  */
 867 const ]b4_int_type_for([b4_pgoto])[
 868 yy::]b4_parser_class_name[::yypgoto_[] =
 869 {
 870   ]b4_pgoto[
 871 };
 872
 873 /* YYDEFGOTO[NTERM-NUM].  */
 874 const ]b4_int_type_for([b4_defgoto])[
 875 yy::]b4_parser_class_name[::yydefgoto_[] =
 876 {
 877   ]b4_defgoto[
 878 };
 879
 880 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 881    positive, shift that token.  If negative, reduce the rule which
 882    number is the opposite.  If zero, do what YYDEFACT says.  */
 883 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
 884 const ]b4_int_type_for([b4_table])[
 885 yy::]b4_parser_class_name[::yytable_[] =
 886 {
 887   ]b4_table[
 888 };
 889
 890 /* YYCHECK.  */
 891 const ]b4_int_type_for([b4_check])[
 892 yy::]b4_parser_class_name[::yycheck_[] =
 893 {
 894   ]b4_check[
 895 };
 896
 897 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 898    symbol of state STATE-NUM.  */
 899 const ]b4_int_type_for([b4_stos])[
 900 yy::]b4_parser_class_name[::yystos_[] =
 901 {
 902   ]b4_stos[
 903 };
 904
 905 #if YYDEBUG
 906 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 907    to YYLEX-NUM.  */
 908 const ]b4_int_type_for([b4_toknum])[
 909 yy::]b4_parser_class_name[::yytoken_number_[] =
 910 {
 911   ]b4_toknum[
 912 };
 913 #endif
 914
 915 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 916 const ]b4_int_type_for([b4_r1])[
 917 yy::]b4_parser_class_name[::yyr1_[] =
 918 {
 919   ]b4_r1[
 920 };
 921
 922 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 923 const ]b4_int_type_for([b4_r2])[
 924 yy::]b4_parser_class_name[::yyr2_[] =
 925 {
 926   ]b4_r2[
 927 };
 928
 929 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 930 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 931    First, the terminals, then, starting at \a yyntokens_, nonterminals. */
 932 const char*
 933 const yy::]b4_parser_class_name[::yytname_[] =
 934 {
 935   ]b4_tname[
 936 };
 937 #endif
 938
 939 #if YYDEBUG
 940 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 941 const yy::]b4_parser_class_name[::rhs_number_type
 942 yy::]b4_parser_class_name[::yyrhs_[] =
 943 {
 944   ]b4_rhs[
 945 };
 946
 947 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 948    YYRHS.  */
 949 const ]b4_int_type_for([b4_prhs])[
 950 yy::]b4_parser_class_name[::yyprhs_[] =
 951 {
 952   ]b4_prhs[
 953 };
 954
 955 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 956 const ]b4_int_type_for([b4_rline])[
 957 yy::]b4_parser_class_name[::yyrline_[] =
 958 {
 959   ]b4_rline[
 960 };
 961
 962 // Print the state stack on the debug stream.
 963 void
 964 yy::]b4_parser_class_name[::yystack_print_ ()
 965 {
 966   *yycdebug_ << "Stack now";
 967   for (state_stack_type::const_iterator i = yystate_stack_.begin ();
 968        i != yystate_stack_.end (); ++i)
 969     *yycdebug_ << ' ' << *i;
 970   *yycdebug_ << std::endl;
 971 }
 972
 973 // Report on the debug stream that the rule \a yyrule is going to be reduced.
 974 void
 975 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
 976 {
 977   unsigned int yylno = yyrline_[yyrule];
 978   /* Print the symbols being reduced, and their result.  */
 979   *yycdebug_ << "Reducing stack by rule " << yyrule - 1
 980              << " (line " << yylno << "), ";
 981   for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyrule];
 982        0 <= yyrhs_[i]; ++i)
 983     *yycdebug_ << yytname_[yyrhs_[i]] << ' ';
 984   *yycdebug_ << "-> " << yytname_[yyr1_[yyrule]] << std::endl;
 985 }
 986 #endif // YYDEBUG
 987
 988 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 989 yy::]b4_parser_class_name[::token_number_type
 990 yy::]b4_parser_class_name[::yytranslate_ (int token)
 991 {
 992   static
 993   const token_number_type
 994   translate_table[] =
 995   {
 996     ]b4_translate[
 997   };
 998   if ((unsigned int) token <= yyuser_token_number_max_)
 999     return translate_table[token];
1000   else
1001     return yyundef_token_;
1002 }
1003
1004 const int yy::]b4_parser_class_name[::yyeof_ = 0;
1005 const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
1006 const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1007 const int yy::]b4_parser_class_name[::yyempty_ = -2;
1008 const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1009 const int yy::]b4_parser_class_name[::yyterror_ = 1;
1010 const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
1011 const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1012
1013 const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1014 const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1015
1016 ]b4_epilogue
1017 dnl
1018 @output b4_dir_prefix[]stack.hh
1019 b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1020
1021 #ifndef BISON_STACK_HH
1022 # define BISON_STACK_HH
1023
1024 #include <deque>
1025
1026 namespace yy
1027 {
1028   template <class T, class S = std::deque<T> >
1029   class stack
1030   {
1031   public:
1032
1033     // Hide our reversed order.
1034     typedef typename S::reverse_iterator iterator;
1035     typedef typename S::const_reverse_iterator const_iterator;
1036
1037     stack () : seq_ ()
1038     {
1039     }
1040
1041     stack (unsigned int n) : seq_ (n)
1042     {
1043     }
1044
1045     inline
1046     T&
1047     operator [] (unsigned int i)
1048     {
1049       return seq_[i];
1050     }
1051
1052     inline
1053     const T&
1054     operator [] (unsigned int i) const
1055     {
1056       return seq_[i];
1057     }
1058
1059     inline
1060     void
1061     push (const T& t)
1062     {
1063       seq_.push_front (t);
1064     }
1065
1066     inline
1067     void
1068     pop (unsigned int n = 1)
1069     {
1070       for (; n; --n)
1071         seq_.pop_front ();
1072     }
1073
1074     inline
1075     unsigned int
1076     height () const
1077     {
1078       return seq_.size ();
1079     }
1080
1081     inline const_iterator begin () const { return seq_.rbegin (); }
1082     inline const_iterator end () const { return seq_.rend (); }
1083
1084   private:
1085
1086     S seq_;
1087   };
1088
1089   /// Present a slice of the top of a stack.
1090   template <class T, class S = stack<T> >
1091   class slice
1092   {
1093   public:
1094
1095     slice (const S& stack,
1096            unsigned int range) : stack_ (stack),
1097                                  range_ (range)
1098     {
1099     }
1100
1101     inline
1102     const T&
1103     operator [] (unsigned int i) const
1104     {
1105       return stack_[range_ - i];
1106     }
1107
1108   private:
1109
1110     const S& stack_;
1111     unsigned int range_;
1112   };
1113 }
1114
1115 #endif // not BISON_STACK_HH]
1116 m4_divert(-1)