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., 59 Temple Place, Suite 330, Boston, MA
  20 # 02111-1307  USA
  21
  22 ## ---------------- ##
  23 ## Default values.  ##
  24 ## ---------------- ##
  25
  26 # Default parser class name.
  27 m4_define_default([b4_parser_class_name], [parser])
  28
  29
  30
  31 ## ----------------- ##
  32 ## Semantic Values.  ##
  33 ## ----------------- ##
  34
  35
  36 # b4_lhs_value([TYPE])
  37 # --------------------
  38 # Expansion of $<TYPE>$.
  39 m4_define([b4_lhs_value],
  40 [(yyval[]m4_ifval([$1], [.$1]))])
  41
  42
  43 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  44 # --------------------------------------
  45 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  46 # symbols on RHS.
  47 m4_define([b4_rhs_value],
  48 [(yysemantic_stack_@{m4_eval([$1 - $2])@}m4_ifval([$3], [.$3]))])
  49
  50 m4_define_default([b4_location_type], [location])
  51 m4_define_default([b4_filename_type], [std::string])
  52
  53 # b4_lhs_location()
  54 # -----------------
  55 # Expansion of @$.
  56 m4_define([b4_lhs_location],
  57 [(yyloc)])
  58
  59
  60 # b4_rhs_location(RULE-LENGTH, NUM)
  61 # ---------------------------------
  62 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  63 # on RHS.
  64 m4_define([b4_rhs_location],
  65 [(yylocation_stack_@{m4_eval([$1 - $2])@})])
  66
  67
  68 # b4_parse_param_decl
  69 # -------------------
  70 # Extra formal arguments of the constructor.
  71 # Change the parameter names from "foo" into "foo_yyarg", so that
  72 # there is no collision bw the user chosen attribute name, and the
  73 # argument name in the constructor.
  74 m4_define([b4_parse_param_decl],
  75 [m4_ifset([b4_parse_param],
  76           [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
  77
  78 m4_define([b4_parse_param_decl_1],
  79 [$1_yyarg])
  80
  81
  82
  83 # b4_parse_param_cons
  84 # -------------------
  85 # Extra initialisations of the constructor.
  86 m4_define([b4_parse_param_cons],
  87           [m4_ifset([b4_parse_param],
  88                     [,
  89       b4_cc_constructor_calls(b4_parse_param)])])
  90 m4_define([b4_cc_constructor_calls],
  91           [m4_map_sep([b4_cc_constructor_call], [,
  92       ], [$@])])
  93 m4_define([b4_cc_constructor_call],
  94           [$2 ($2_yyarg)])
  95
  96 # b4_parse_param_vars
  97 # -------------------
  98 # Extra instance variables.
  99 m4_define([b4_parse_param_vars],
 100           [m4_ifset([b4_parse_param],
 101                     [
 102     /* User arguments.  */
 103 b4_cc_var_decls(b4_parse_param)])])
 104 m4_define([b4_cc_var_decls],
 105           [m4_map_sep([b4_cc_var_decl], [
 106 ], [$@])])
 107 m4_define([b4_cc_var_decl],
 108           [    $1;])
 109
 110
 111
 112 # We do want M4 expansion after # for CPP macros.
 113 m4_changecom()
 114 m4_divert(0)dnl
 115 m4_if(b4_defines_flag, 0, [],
 116 [@output @output_header_name@
 117 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
 118              [2002, 2003, 2004])[
 119 /* FIXME: This is wrong, we want computed header guards.
 120    I don't know why the macros are missing now. :( */
 121 #ifndef PARSER_HEADER_H
 122 # define PARSER_HEADER_H
 123
 124 #include <string>
 125 #include <iostream>
 126
 127 /* Using locations.  */
 128 #define YYLSP_NEEDED ]b4_locations_flag[
 129
 130 namespace yy
 131 {
 132   class position;
 133   class location;
 134 }
 135
 136 ]b4_token_defines(b4_tokens)[
 137
 138 /* Copy the first part of user declarations.  */
 139 ]b4_pre_prologue[
 140
 141 ]/* Line __line__ of lalr1.cc.  */
 142 b4_syncline([@oline@], [@ofile@])[
 143
 144 #include "stack.hh"
 145 #include "location.hh"
 146
 147 /* Enabling traces.  */
 148 #ifndef YYDEBUG
 149 # define YYDEBUG ]b4_debug[
 150 #endif
 151
 152 /* Enabling verbose error message.  */
 153 #ifndef YYERROR_VERBOSE
 154 # define YYERROR_VERBOSE ]b4_error_verbose[
 155 #endif
 156
 157 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 158 ]m4_ifdef([b4_stype],
 159 [b4_syncline([b4_stype_line], [b4_filename])
 160 union YYSTYPE b4_stype;
 161 /* Line __line__ of lalr1.cc.  */
 162 b4_syncline([@oline@], [@ofile@])],
 163 [typedef int YYSTYPE;])[
 164 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 165 # define YYSTYPE_IS_DECLARED 1
 166 # define YYSTYPE_IS_TRIVIAL 1
 167 #endif
 168
 169 /* Copy the second part of user declarations.  */
 170 ]b4_post_prologue[
 171
 172 ]/* Line __line__ of lalr1.cc.  */
 173 b4_syncline([@oline@], [@ofile@])[
 174 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 175    If N is 0, then set CURRENT to the empty location which ends
 176    the previous symbol: RHS[0] (always defined).  */
 177
 178 #ifndef YYLLOC_DEFAULT
 179 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
 180 do {                                                    \
 181   if (N)                                                \
 182     {                                                   \
 183       (Current).begin = (Rhs)[1].begin;                 \
 184       (Current).end   = (Rhs)[N].end;                   \
 185     }                                                   \
 186   else                                                  \
 187     {                                                   \
 188       (Current).begin = (Current).end = (Rhs)[0].end;   \
 189     }                                                   \
 190 } while (0)
 191 #endif
 192
 193 namespace yy
 194 {
 195   class ]b4_parser_class_name[;
 196
 197   template <typename P>
 198   struct traits
 199   {
 200   };
 201
 202   template <>
 203   struct traits<]b4_parser_class_name[>
 204   {
 205     typedef ]b4_int_type_for([b4_translate])[ token_number_type;
 206     typedef ]b4_int_type_for([b4_rhs])[       rhs_number_type;
 207     typedef int state_type;
 208     typedef YYSTYPE semantic_type;
 209     typedef ]b4_location_type[ location_type;
 210   };
 211 }
 212
 213 namespace yy
 214 {
 215   /// A Bison parser.
 216   class ]b4_parser_class_name[
 217   {
 218     /// Symbol semantic values.
 219     typedef traits<]b4_parser_class_name[>::semantic_type semantic_type;
 220     /// Symbol locations.
 221     typedef traits<]b4_parser_class_name[>::location_type location_type;
 222
 223   public:
 224     /// Build a parser object.
 225     ]b4_parser_class_name[ (]b4_parse_param_decl[) :
 226       yydebug_ (false),
 227       yycdebug_ (&std::cerr)]b4_parse_param_cons[
 228     {
 229     }
 230
 231     virtual ~]b4_parser_class_name[ ()
 232     {
 233     }
 234
 235     /// Parse.
 236     /// \returns  0 iff parsing succeeded.
 237     virtual int parse ();
 238
 239     /// The current debugging stream.
 240     std::ostream& debug_stream () const;
 241     /// Set the current debugging stream.
 242     void set_debug_stream (std::ostream &);
 243
 244     /// Type for debugging levels.
 245     typedef int debug_level_type;
 246     /// The current debugging level.
 247     debug_level_type debug_level () const;
 248     /// Set the current debugging level.
 249     void set_debug_level (debug_level_type l);
 250
 251   private:
 252
 253     /// Call the scanner.
 254     virtual void yylex_ ();
 255
 256     /// Report a syntax error.
 257     /// \param loc    where the syntax error is found.
 258     /// \param msg    a description of the syntax error.
 259     virtual void error (const location_type& loc, const std::string& msg);
 260
 261     /// Generate an error message, and invoke error.
 262     virtual void yyreport_syntax_error_ ();
 263
 264 #if YYDEBUG
 265     /// \brief Report a symbol on the debug stream.
 266     /// \param yytype       The token type.
 267     /// \param yyvaluep     Its semantic value.
 268     /// \param yylocationp  Its location.
 269     virtual void yysymprint_ (int yytype,
 270                               const semantic_type* yyvaluep,
 271                               const location_type* yylocationp);
 272 #endif /* ! YYDEBUG */
 273
 274
 275     /// State numbers.
 276     typedef traits<]b4_parser_class_name[>::state_type state_type;
 277     /// State stack type.
 278     typedef stack<state_type>    state_stack_type;
 279     /// Semantic value stack type.
 280     typedef stack<semantic_type> semantic_stack_type;
 281     /// location stack type.
 282     typedef stack<location_type> location_stack_type;
 283
 284     /// The state stack.
 285     state_stack_type yystate_stack_;
 286     /// The semantic value stack.
 287     semantic_stack_type yysemantic_stack_;
 288     /// The location stack.
 289     location_stack_type yylocation_stack_;
 290
 291     /// Internal symbol numbers.
 292     typedef traits<]b4_parser_class_name[>::token_number_type token_number_type;
 293     /* Tables.  */
 294     /// For a state, the index in \a yytable_ of its portion.
 295     static const ]b4_int_type_for([b4_pact])[ yypact_[];
 296     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
 297
 298     /// For a state, default rule to reduce.
 299     /// Unless\a  yytable_ specifies something else to do.
 300     /// Zero means the default is an error.
 301     static const ]b4_int_type_for([b4_defact])[ yydefact_[];
 302
 303     static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
 304     static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
 305
 306     /// What to do in a state.
 307     /// \a yytable_[yypact_[s]]: what to do in state \a s.
 308     /// - if positive, shift that token.
 309     /// - if negative, reduce the rule which number is the opposite.
 310     /// - if zero, do what YYDEFACT says.
 311     static const ]b4_int_type_for([b4_table])[ yytable_[];
 312     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 313
 314     static const ]b4_int_type_for([b4_check])[ yycheck_[];
 315
 316     /// For a state, its accessing symbol.
 317     static const ]b4_int_type_for([b4_stos])[ yystos_[];
 318
 319     /// For a rule, its LHS.
 320     static const ]b4_int_type_for([b4_r1])[ yyr1_[];
 321     /// For a rule, its RHS length.
 322     static const ]b4_int_type_for([b4_r2])[ yyr2_[];
 323
 324 #if YYDEBUG || YYERROR_VERBOSE
 325     /// For a symbol, its name in clear.
 326     static const char* const yyname_[];
 327 #endif
 328
 329 #if YYDEBUG
 330     /// A type to store symbol numbers and -1.
 331     typedef traits<]b4_parser_class_name[>::rhs_number_type rhs_number_type;
 332     /// A `-1'-separated list of the rules' RHS.
 333     static const rhs_number_type yyrhs_[];
 334     /// For each rule, the index of the first RHS symbol in \a yyrhs_.
 335     static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
 336     /// For each rule, its source line number.
 337     static const ]b4_int_type_for([b4_rline])[ yyrline_[];
 338     /// For each scanner token number, its symbol number.
 339     static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
 340     /// Report on the debug stream that the rule \a r is going to be reduced.
 341     virtual void yyreduce_print_ (int r);
 342     /// Print the state stack on the debug stream.
 343     virtual void yystack_print_ ();
 344 #endif
 345
 346     /// Convert a scanner token number to a symbol number.
 347     inline token_number_type yytranslate_ (int token);
 348
 349     /// \brief Reclaim the memory associated to a symbol.
 350     /// \param yymsg        Why this token is reclaimed.
 351     /// \param yytype       The symbol type.
 352     /// \param yyvaluep     Its semantic value.
 353     /// \param yylocationp  Its location.
 354     inline void yydestruct_ (const char* yymsg,
 355                              int yytype,
 356                              semantic_type* yyvaluep,
 357                              location_type* yylocationp);
 358
 359     /// Pop \a n symbols the three stacks.
 360     inline void yypop_ (unsigned int n = 1);
 361
 362     /* Constants.  */
 363     static const int yyeof_;
 364     /* LAST_ -- Last index in TABLE_.  */
 365     static const int yylast_;
 366     static const int yynnts_;
 367     static const int yyempty_;
 368     static const int yyfinal_;
 369     static const int yyterror_;
 370     static const int yyerrcode_;
 371     static const int yyntokens_;
 372     static const unsigned int yyuser_token_number_max_;
 373     static const token_number_type yyundef_token_;
 374
 375     /* State.  */
 376     int yyn_;
 377     int yylen_;
 378     int yystate_;
 379
 380     /* Error handling. */
 381     int yynerrs_;
 382     int yyerrstatus_;
 383
 384     /* Debugging.  */
 385     int yydebug_;
 386     std::ostream* yycdebug_;
 387
 388     /* Look-ahead and look-ahead in internal form.  */
 389     int yylooka_;
 390     int yyilooka_;
 391
 392     /// Semantic value of the look-ahead.
 393     semantic_type yylval;
 394     /// Location of the look-ahead.
 395     location_type yylloc;
 396     /// The locations where the error started and ended.
 397     location yyerror_range_[2];
 398
 399     /// $$.
 400     semantic_type yyval;
 401     /// @@$.
 402     location_type yyloc;
 403 ]b4_parse_param_vars[
 404   };
 405 }
 406
 407 #endif /* ! defined PARSER_HEADER_H */]
 408 ])dnl
 409 @output @output_parser_name@
 410 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
 411              [2002, 2003, 2004])
 412 m4_if(b4_prefix[], [yy], [],
 413 [
 414 // Take the name prefix into account.
 415 #define yylex   b4_prefix[]lex])
 416 m4_if(b4_defines_flag, 0, [],
 417 [
 418 #include @output_header_name@])[
 419
 420 /* A pseudo ostream that takes yydebug_ into account. */
 421 # define YYCDEBUG                                                       \
 422   for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)        \
 423     (*yycdebug_)
 424
 425 /* Enable debugging if requested.  */
 426 #if YYDEBUG
 427
 428 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
 429 do {                                                    \
 430   if (yydebug_)                                         \
 431     {                                                   \
 432       *yycdebug_ << (Title) << ' ';                     \
 433       yysymprint_ ((Type), (Value), (Location));        \
 434       *yycdebug_ << std::endl;                          \
 435     }                                                   \
 436 } while (0)
 437
 438 # define YY_REDUCE_PRINT(Rule)          \
 439 do {                                    \
 440   if (yydebug_)                         \
 441     yyreduce_print_ (Rule);             \
 442 } while (0)
 443
 444 # define YY_STACK_PRINT()               \
 445 do {                                    \
 446   if (yydebug_)                         \
 447     yystack_print_ ();                  \
 448 } while (0)
 449
 450 #else /* !YYDEBUG */
 451
 452 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 453 # define YY_REDUCE_PRINT(Rule)
 454 # define YY_STACK_PRINT()
 455
 456 #endif /* !YYDEBUG */
 457
 458 #define YYACCEPT        goto yyacceptlab
 459 #define YYABORT         goto yyabortlab
 460 #define YYERROR         goto yyerrorlab
 461
 462 #if YYDEBUG
 463 /*--------------------------------.
 464 | Print this symbol on YYOUTPUT.  |
 465 `--------------------------------*/
 466
 467 void
 468 yy::]b4_parser_class_name[::yysymprint_ (int yytype,
 469                          const semantic_type* yyvaluep, const location_type* yylocationp)
 470 {
 471   /* Pacify ``unused variable'' warnings.  */
 472   (void) yyvaluep;
 473   (void) yylocationp;
 474   /* Backward compatibility, but should be removed eventually. */
 475   std::ostream& cdebug_ = *yycdebug_;
 476   (void) cdebug_;
 477
 478   *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
 479              << ' ' << yyname_[yytype] << " ("
 480              << *yylocationp << ": ";
 481   switch (yytype)
 482     {
 483 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 484 [      default:
 485         break;
 486     }
 487   *yycdebug_ << ')';
 488 }
 489 #endif /* ! YYDEBUG */
 490
 491 void
 492 yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
 493                          int yytype, semantic_type* yyvaluep, location_type* yylocationp)
 494 {
 495   /* Pacify ``unused variable'' warnings.  */
 496   (void) yymsg;
 497   (void) yyvaluep;
 498   (void) yylocationp;
 499
 500   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 501
 502   switch (yytype)
 503     {
 504 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 505       default:
 506         break;
 507     }
 508 }
 509
 510 void
 511 yy::]b4_parser_class_name[::yypop_ (unsigned int n)
 512 {
 513   yystate_stack_.pop (n);
 514   yysemantic_stack_.pop (n);
 515   yylocation_stack_.pop (n);
 516 }
 517
 518 std::ostream&
 519 yy::]b4_parser_class_name[::debug_stream () const
 520 {
 521   return *yycdebug_;
 522 }
 523
 524 void
 525 yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
 526 {
 527   yycdebug_ = &o;
 528 }
 529
 530
 531 yy::]b4_parser_class_name[::debug_level_type
 532 yy::]b4_parser_class_name[::debug_level () const
 533 {
 534   return yydebug_;
 535 }
 536
 537 void
 538 yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
 539 {
 540   yydebug_ = l;
 541 }
 542
 543
 544 int
 545 yy::]b4_parser_class_name[::parse ()
 546 {
 547   YYCDEBUG << "Starting parse" << std::endl;
 548
 549   yynerrs_ = 0;
 550   yyerrstatus_ = 0;
 551
 552   /* Start.  */
 553   yystate_ = 0;
 554   yylooka_ = yyempty_;
 555
 556 ]m4_ifdef([b4_initial_action], [
 557 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 558 m4_pushdef([b4_dollar_dollar], [yylval])dnl
 559   /* User initialization code. */
 560   b4_initial_action
 561 m4_popdef([b4_dollar_dollar])dnl
 562 m4_popdef([b4_at_dollar])dnl
 563 /* Line __line__ of yacc.c.  */
 564 b4_syncline([@oline@], [@ofile@])])dnl
 565
 566 [  /* Initialize the stacks.  The initial state will be pushed in
 567      yynewstate, since the latter expects the semantical and the
 568      location values to have been already stored, initialize these
 569      stacks with a primary value.  */
 570   yystate_stack_ = state_stack_type (0);
 571   yysemantic_stack_ = semantic_stack_type (0);
 572   yylocation_stack_ = location_stack_type (0);
 573   yysemantic_stack_.push (yylval);
 574   yylocation_stack_.push (yylloc);
 575
 576   /* New state.  */
 577 yynewstate:
 578   yystate_stack_.push (yystate_);
 579   YYCDEBUG << "Entering state " << yystate_ << std::endl;
 580   goto yybackup;
 581
 582   /* Backup.  */
 583 yybackup:
 584
 585   /* Try to take a decision without look-ahead.  */
 586   yyn_ = yypact_[yystate_];
 587   if (yyn_ == yypact_ninf_)
 588     goto yydefault;
 589
 590   /* Read a look-ahead token.  */
 591   if (yylooka_ == yyempty_)
 592     yylex_ ();
 593
 594   /* Convert token to internal form.  */
 595   if (yylooka_ <= yyeof_)
 596     {
 597       yylooka_ = yyilooka_ = yyeof_;
 598       YYCDEBUG << "Now at end of input." << std::endl;
 599     }
 600   else
 601     {
 602       yyilooka_ = yytranslate_ (yylooka_);
 603       YY_SYMBOL_PRINT ("Next token is", yyilooka_, &yylval, &yylloc);
 604     }
 605
 606   /* If the proper action on seeing token ILOOKA_ is to reduce or to
 607      detect an error, take that action.  */
 608   yyn_ += yyilooka_;
 609   if (yyn_ < 0 || yylast_ < yyn_ || yycheck_[yyn_] != yyilooka_)
 610     goto yydefault;
 611
 612   /* Reduce or error.  */
 613   yyn_ = yytable_[yyn_];
 614   if (yyn_ < 0)
 615     {
 616       if (yyn_ == yytable_ninf_)
 617         goto yyerrlab;
 618       else
 619         {
 620           yyn_ = -yyn_;
 621           goto yyreduce;
 622         }
 623     }
 624   else if (yyn_ == 0)
 625     goto yyerrlab;
 626
 627   /* Accept?  */
 628   if (yyn_ == yyfinal_)
 629     goto yyacceptlab;
 630
 631   /* Shift the look-ahead token.  */
 632   YY_SYMBOL_PRINT ("Shifting", yyilooka_, &yylval, &yylloc);
 633
 634   /* Discard the token being shifted unless it is eof.  */
 635   if (yylooka_ != yyeof_)
 636     yylooka_ = yyempty_;
 637
 638   yysemantic_stack_.push (yylval);
 639   yylocation_stack_.push (yylloc);
 640
 641   /* Count tokens shifted since error; after three, turn off error
 642      status.  */
 643   if (yyerrstatus_)
 644     --yyerrstatus_;
 645
 646   yystate_ = yyn_;
 647   goto yynewstate;
 648
 649 /*-----------------------------------------------------------.
 650 | yydefault -- do the default action for the current state.  |
 651 `-----------------------------------------------------------*/
 652 yydefault:
 653   yyn_ = yydefact_[yystate_];
 654   if (yyn_ == 0)
 655     goto yyerrlab;
 656   goto yyreduce;
 657
 658 /*-----------------------------.
 659 | yyreduce -- Do a reduction.  |
 660 `-----------------------------*/
 661 yyreduce:
 662   yylen_ = yyr2_[yyn_];
 663   /* If LEN_ is nonzero, implement the default value of the action:
 664      `$$ = $1'.  Otherwise, use the top of the stack.
 665
 666      Otherwise, the following line sets YYVAL to garbage.
 667      This behavior is undocumented and Bison
 668      users should not rely upon it.  */
 669   if (yylen_)
 670     yyval = yysemantic_stack_[yylen_ - 1];
 671   else
 672     yyval = yysemantic_stack_[0];
 673
 674   {
 675     slice<location_type, location_stack_type> slice (yylocation_stack_, yylen_);
 676     YYLLOC_DEFAULT (yyloc, slice, yylen_);
 677   }
 678   YY_REDUCE_PRINT (yyn_);
 679   switch (yyn_)
 680     {
 681       ]b4_actions[
 682     }
 683
 684 ]/* Line __line__ of lalr1.cc.  */
 685 b4_syncline([@oline@], [@ofile@])[
 686
 687   yypop_ (yylen_);
 688
 689   YY_STACK_PRINT ();
 690
 691   yysemantic_stack_.push (yyval);
 692   yylocation_stack_.push (yyloc);
 693
 694   /* Shift the result of the reduction.  */
 695   yyn_ = yyr1_[yyn_];
 696   yystate_ = yypgoto_[yyn_ - yyntokens_] + yystate_stack_[0];
 697   if (0 <= yystate_ && yystate_ <= yylast_
 698       && yycheck_[yystate_] == yystate_stack_[0])
 699     yystate_ = yytable_[yystate_];
 700   else
 701     yystate_ = yydefgoto_[yyn_ - yyntokens_];
 702   goto yynewstate;
 703
 704 /*------------------------------------.
 705 | yyerrlab -- here on detecting error |
 706 `------------------------------------*/
 707 yyerrlab:
 708   /* If not already recovering from an error, report this error.  */
 709   yyreport_syntax_error_ ();
 710
 711   yyerror_range_[0] = yylloc;
 712   if (yyerrstatus_ == 3)
 713     {
 714       /* If just tried and failed to reuse look-ahead token after an
 715          error, discard it.  */
 716
 717       /* Return failure if at end of input.  */
 718       if (yylooka_ <= yyeof_)
 719         {
 720           /* If at end of input, pop the error token,
 721              then the rest of the stack, then return failure.  */
 722           if (yylooka_ == yyeof_)
 723              for (;;)
 724                {
 725                  yyerror_range_[0] = yylocation_stack_[0];
 726                  yypop_ ();
 727                  if (yystate_stack_.height () == 1)
 728                    YYABORT;
 729                  yydestruct_ ("Error: popping",
 730                               yystos_[yystate_stack_[0]],
 731                               &yysemantic_stack_[0],
 732                               &yylocation_stack_[0]);
 733                }
 734         }
 735       else
 736         {
 737           yydestruct_ ("Error: discarding", yyilooka_, &yylval, &yylloc);
 738           yylooka_ = yyempty_;
 739         }
 740     }
 741
 742   /* Else will try to reuse look-ahead token after shifting the error
 743      token.  */
 744   goto yyerrlab1;
 745
 746
 747 /*---------------------------------------------------.
 748 | yyerrorlab -- error raised explicitly by YYERROR.  |
 749 `---------------------------------------------------*/
 750 yyerrorlab:
 751
 752   /* Pacify compilers like GCC when the user code never invokes
 753      YYERROR and the label yyerrorlab therefore never appears in user
 754      code.  */
 755   if (false)
 756      goto yyerrorlab;
 757
 758   yyerror_range_[0] = yylocation_stack_[yylen_ - 1];
 759   yypop_ (yylen_);
 760   yystate_ = yystate_stack_[0];
 761   goto yyerrlab1;
 762
 763 /*-------------------------------------------------------------.
 764 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 765 `-------------------------------------------------------------*/
 766 yyerrlab1:
 767   yyerrstatus_ = 3;     /* Each real token shifted decrements this.  */
 768
 769   for (;;)
 770     {
 771       yyn_ = yypact_[yystate_];
 772       if (yyn_ != yypact_ninf_)
 773         {
 774           yyn_ += yyterror_;
 775           if (0 <= yyn_ && yyn_ <= yylast_ && yycheck_[yyn_] == yyterror_)
 776             {
 777               yyn_ = yytable_[yyn_];
 778               if (0 < yyn_)
 779                 break;
 780             }
 781         }
 782
 783       /* Pop the current state because it cannot handle the error token.  */
 784       if (yystate_stack_.height () == 1)
 785         YYABORT;
 786
 787       yyerror_range_[0] = yylocation_stack_[0];
 788       yydestruct_ ("Error: popping",
 789                    yystos_[yystate_],
 790                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 791       yypop_ ();
 792       yystate_ = yystate_stack_[0];
 793       YY_STACK_PRINT ();
 794     }
 795
 796   if (yyn_ == yyfinal_)
 797     goto yyacceptlab;
 798
 799   yyerror_range_[1] = yylloc;
 800   // Using YYLLOC is tempting, but would change the location of
 801   // the look-ahead.  YYLOC is available though.
 802   YYLLOC_DEFAULT (yyloc, yyerror_range_ - 1, 2);
 803   yysemantic_stack_.push (yylval);
 804   yylocation_stack_.push (yyloc);
 805
 806   /* Shift the error token. */
 807   YY_SYMBOL_PRINT ("Shifting", yystos_[yyn_],
 808                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 809
 810   yystate_ = yyn_;
 811   goto yynewstate;
 812
 813   /* Accept.  */
 814 yyacceptlab:
 815   return 0;
 816
 817   /* Abort.  */
 818 yyabortlab:
 819   /* Free the lookahead. */
 820   yydestruct_ ("Error: discarding lookahead", yyilooka_, &yylval, &yylloc);
 821   yylooka_ = yyempty_;
 822   return 1;
 823 }
 824
 825 void
 826 yy::]b4_parser_class_name[::yylex_ ()
 827 {
 828   YYCDEBUG << "Reading a token: ";
 829 #if YYLSP_NEEDED
 830   yylooka_ = yylex (&yylval, &yylloc);
 831 #else
 832   yylooka_ = yylex (&yylval);
 833 #endif
 834 }
 835
 836 // Generate an error message, and invoke error.
 837 void
 838 yy::]b4_parser_class_name[::yyreport_syntax_error_ ()
 839 {
 840   /* If not already recovering from an error, report this error.  */
 841   if (!yyerrstatus_)
 842     {
 843       ++yynerrs_;
 844       std::string message;
 845 #if YYERROR_VERBOSE
 846       yyn_ = yypact_[yystate_];
 847       if (yypact_ninf_ < yyn_ && yyn_ < yylast_)
 848         {
 849           /* Start YYX at -YYN if negative to avoid negative indexes in
 850              YYCHECK.  */
 851           int yyxbegin = yyn_ < 0 ? -yyn_ : 0;
 852
 853           /* Stay within bounds of both yycheck and yytname.  */
 854           int yychecklim = yylast_ - yyn_;
 855           int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 856           int count = 0;
 857           for (int x = yyxbegin; x < yyxend; ++x)
 858             if (yycheck_[x + yyn_] == x && x != yyterror_)
 859               ++count;
 860
 861           message = "syntax error, unexpected ";
 862           message += yyname_[yyilooka_];
 863           if (count < 5)
 864             {
 865               count = 0;
 866               for (int x = yyxbegin; x < yyxend; ++x)
 867                 if (yycheck_[x + yyn_] == x && x != yyterror_)
 868                   {
 869                     message += (!count++) ? ", expecting " : " or ";
 870                     message += yyname_[x];
 871                   }
 872             }
 873         }
 874       else
 875 #endif
 876         message = "syntax error";
 877       error (yylloc, message);
 878     }
 879 }
 880
 881
 882 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 883    STATE-NUM.  */
 884 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
 885 const ]b4_int_type_for([b4_pact])[
 886 yy::]b4_parser_class_name[::yypact_[] =
 887 {
 888   ]b4_pact[
 889 };
 890
 891 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 892    doesn't specify something else to do.  Zero means the default is an
 893    error.  */
 894 const ]b4_int_type_for([b4_defact])[
 895 yy::]b4_parser_class_name[::yydefact_[] =
 896 {
 897   ]b4_defact[
 898 };
 899
 900 /* YYPGOTO[NTERM-NUM].  */
 901 const ]b4_int_type_for([b4_pgoto])[
 902 yy::]b4_parser_class_name[::yypgoto_[] =
 903 {
 904   ]b4_pgoto[
 905 };
 906
 907 /* YYDEFGOTO[NTERM-NUM].  */
 908 const ]b4_int_type_for([b4_defgoto])[
 909 yy::]b4_parser_class_name[::yydefgoto_[] =
 910 {
 911   ]b4_defgoto[
 912 };
 913
 914 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 915    positive, shift that token.  If negative, reduce the rule which
 916    number is the opposite.  If zero, do what YYDEFACT says.  */
 917 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
 918 const ]b4_int_type_for([b4_table])[
 919 yy::]b4_parser_class_name[::yytable_[] =
 920 {
 921   ]b4_table[
 922 };
 923
 924 /* YYCHECK.  */
 925 const ]b4_int_type_for([b4_check])[
 926 yy::]b4_parser_class_name[::yycheck_[] =
 927 {
 928   ]b4_check[
 929 };
 930
 931 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 932    symbol of state STATE-NUM.  */
 933 const ]b4_int_type_for([b4_stos])[
 934 yy::]b4_parser_class_name[::yystos_[] =
 935 {
 936   ]b4_stos[
 937 };
 938
 939 #if YYDEBUG
 940 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 941    to YYLEX-NUM.  */
 942 const ]b4_int_type_for([b4_toknum])[
 943 yy::]b4_parser_class_name[::yytoken_number_[] =
 944 {
 945   ]b4_toknum[
 946 };
 947 #endif
 948
 949 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 950 const ]b4_int_type_for([b4_r1])[
 951 yy::]b4_parser_class_name[::yyr1_[] =
 952 {
 953   ]b4_r1[
 954 };
 955
 956 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 957 const ]b4_int_type_for([b4_r2])[
 958 yy::]b4_parser_class_name[::yyr2_[] =
 959 {
 960   ]b4_r2[
 961 };
 962
 963 #if YYDEBUG || YYERROR_VERBOSE
 964 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 965    First, the terminals, then, starting at \a yyntokens_, nonterminals. */
 966 const char*
 967 const yy::]b4_parser_class_name[::yyname_[] =
 968 {
 969   ]b4_tname[
 970 };
 971 #endif
 972
 973 #if YYDEBUG
 974 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 975 const yy::]b4_parser_class_name[::rhs_number_type
 976 yy::]b4_parser_class_name[::yyrhs_[] =
 977 {
 978   ]b4_rhs[
 979 };
 980
 981 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 982    YYRHS.  */
 983 const ]b4_int_type_for([b4_prhs])[
 984 yy::]b4_parser_class_name[::yyprhs_[] =
 985 {
 986   ]b4_prhs[
 987 };
 988
 989 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 990 const ]b4_int_type_for([b4_rline])[
 991 yy::]b4_parser_class_name[::yyrline_[] =
 992 {
 993   ]b4_rline[
 994 };
 995
 996 // Print the state stack on the debug stream.
 997 void
 998 yy::]b4_parser_class_name[::yystack_print_ ()
 999 {
1000   *yycdebug_ << "Stack now";
1001   for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1002        i != yystate_stack_.end (); ++i)
1003     *yycdebug_ << ' ' << *i;
1004   *yycdebug_ << std::endl;
1005 }
1006
1007 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1008 void
1009 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
1010 {
1011   unsigned int yylno = yyrline_[yyrule];
1012   /* Print the symbols being reduced, and their result.  */
1013     *yycdebug_ << "Reducing stack by rule " << yyn_ - 1
1014                << " (line " << yylno << "), ";
1015   for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyn_];
1016        0 <= yyrhs_[i]; ++i)
1017     *yycdebug_ << yyname_[yyrhs_[i]] << ' ';
1018   *yycdebug_ << "-> " << yyname_[yyr1_[yyn_]] << std::endl;
1019 }
1020 #endif // YYDEBUG
1021
1022 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1023 yy::]b4_parser_class_name[::token_number_type
1024 yy::]b4_parser_class_name[::yytranslate_ (int token)
1025 {
1026   static
1027   const token_number_type
1028   translate_table[] =
1029   {
1030     ]b4_translate[
1031   };
1032   if ((unsigned int) token <= yyuser_token_number_max_)
1033     return translate_table[token];
1034   else
1035     return yyundef_token_;
1036 }
1037
1038 const int yy::]b4_parser_class_name[::yyeof_ = 0;
1039 const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
1040 const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1041 const int yy::]b4_parser_class_name[::yyempty_ = -2;
1042 const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1043 const int yy::]b4_parser_class_name[::yyterror_ = 1;
1044 const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
1045 const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1046
1047 const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1048 const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1049
1050 ]b4_epilogue
1051 dnl
1052 @output stack.hh
1053 b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004])[
1054
1055 #ifndef BISON_STACK_HH
1056 # define BISON_STACK_HH
1057
1058 #include <deque>
1059
1060 namespace yy
1061 {
1062   template <class T, class S = std::deque<T> >
1063   class stack
1064   {
1065   public:
1066
1067     // Hide our reversed order.
1068     typedef typename S::reverse_iterator iterator;
1069     typedef typename S::const_reverse_iterator const_iterator;
1070
1071     stack () : seq_ ()
1072     {
1073     }
1074
1075     stack (unsigned int n) : seq_ (n)
1076     {
1077     }
1078
1079     inline
1080     T&
1081     operator [] (unsigned int i)
1082     {
1083       return seq_[i];
1084     }
1085
1086     inline
1087     const T&
1088     operator [] (unsigned int i) const
1089     {
1090       return seq_[i];
1091     }
1092
1093     inline
1094     void
1095     push (const T& t)
1096     {
1097       seq_.push_front (t);
1098     }
1099
1100     inline
1101     void
1102     pop (unsigned int n = 1)
1103     {
1104       for (; n; --n)
1105         seq_.pop_front ();
1106     }
1107
1108     inline
1109     unsigned int
1110     height () const
1111     {
1112       return seq_.size ();
1113     }
1114
1115     inline const_iterator begin () const { return seq_.rbegin (); }
1116     inline const_iterator end () const { return seq_.rend (); }
1117
1118   private:
1119
1120     S seq_;
1121   };
1122
1123   /// Present a slice of the top of a stack.
1124   template <class T, class S = stack<T> >
1125   class slice
1126   {
1127   public:
1128
1129     slice (const S& stack,
1130            unsigned int range) : stack_ (stack),
1131                                  range_ (range)
1132     {
1133     }
1134
1135     inline
1136     const T&
1137     operator [] (unsigned int i) const
1138     {
1139       return stack_[range_ - i];
1140     }
1141
1142   private:
1143
1144     const S& stack_;
1145     unsigned int range_;
1146   };
1147 }
1148
1149 #endif // not BISON_STACK_HH]
1150 dnl
1151 @output position.hh
1152 b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004])[
1153
1154 /**
1155  ** \file position.hh
1156  ** Define the position class.
1157  */
1158
1159 #ifndef BISON_POSITION_HH
1160 # define BISON_POSITION_HH
1161
1162 # include <iostream>
1163 # include <string>
1164
1165 namespace yy
1166 {
1167   /// Abstract a position.
1168   class position
1169   {
1170   public:
1171     /// Initial column number.
1172     static const unsigned int initial_column = 0;
1173     /// Initial line number.
1174     static const unsigned int initial_line = 1;
1175
1176     /** \name Ctor & dtor.
1177      ** \{ */
1178   public:
1179     /// Construct a position.
1180     position () :
1181       filename (0),
1182       line (initial_line),
1183       column (initial_column)
1184     {
1185     }
1186     /** \} */
1187
1188
1189     /** \name Line and Column related manipulators
1190      ** \{ */
1191   public:
1192     /// (line related) Advance to the COUNT next lines.
1193     inline void lines (int count = 1)
1194     {
1195       column = initial_column;
1196       line += count;
1197     }
1198
1199     /// (column related) Advance to the COUNT next columns.
1200     inline void columns (int count = 1)
1201     {
1202       int leftmost = initial_column;
1203       int current  = column;
1204       if (leftmost <= current + count)
1205         column += count;
1206       else
1207         column = initial_column;
1208     }
1209     /** \} */
1210
1211   public:
1212     /// File name to which this position refers.
1213     ]b4_filename_type[* filename;
1214     /// Current line number.
1215     unsigned int line;
1216     /// Current column number.
1217     unsigned int column;
1218   };
1219
1220   /// Add and assign a position.
1221   inline const position&
1222   operator+= (position& res, const int width)
1223   {
1224     res.columns (width);
1225     return res;
1226   }
1227
1228   /// Add two position objects.
1229   inline const position
1230   operator+ (const position& begin, const int width)
1231   {
1232     position res = begin;
1233     return res += width;
1234   }
1235
1236   /// Add and assign a position.
1237   inline const position&
1238   operator-= (position& res, const int width)
1239   {
1240     return res += -width;
1241   }
1242
1243   /// Add two position objects.
1244   inline const position
1245   operator- (const position& begin, const int width)
1246   {
1247     return begin + -width;
1248   }
1249
1250   /** \brief Intercept output stream redirection.
1251    ** \param ostr the destination output stream
1252    ** \param pos a reference to the position to redirect
1253    */
1254   inline std::ostream&
1255   operator<< (std::ostream& ostr, const position& pos)
1256   {
1257     if (pos.filename)
1258       ostr << *pos.filename << ':';
1259     return ostr << pos.line << '.' << pos.column;
1260   }
1261
1262 }
1263 #endif // not BISON_POSITION_HH]
1264 @output location.hh
1265 b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004])[
1266
1267 /**
1268  ** \file location.hh
1269  ** Define the location class.
1270  */
1271
1272 #ifndef BISON_LOCATION_HH
1273 # define BISON_LOCATION_HH
1274
1275 # include <iostream>
1276 # include <string>
1277 # include "position.hh"
1278
1279 namespace yy
1280 {
1281
1282   /// Abstract a location.
1283   class location
1284   {
1285     /** \name Ctor & dtor.
1286      ** \{ */
1287   public:
1288     /// Construct a location.
1289     location () :
1290       begin (),
1291       end ()
1292     {
1293     }
1294     /** \} */
1295
1296
1297     /** \name Line and Column related manipulators
1298      ** \{ */
1299   public:
1300     /// Reset initial location to final location.
1301     inline void step ()
1302     {
1303       begin = end;
1304     }
1305
1306     /// Extend the current location to the COUNT next columns.
1307     inline void columns (unsigned int count = 1)
1308     {
1309       end += count;
1310     }
1311
1312     /// Extend the current location to the COUNT next lines.
1313     inline void lines (unsigned int count = 1)
1314     {
1315       end.lines (count);
1316     }
1317     /** \} */
1318
1319
1320   public:
1321     /// Beginning of the located region.
1322     position begin;
1323     /// End of the located region.
1324     position end;
1325   };
1326
1327   /// Join two location objects to create a location.
1328   inline const location operator+ (const location& begin, const location& end)
1329   {
1330     location res = begin;
1331     res.end = end.end;
1332     return res;
1333   }
1334
1335   /// Add two location objects.
1336   inline const location operator+ (const location& begin, unsigned int width)
1337   {
1338     location res = begin;
1339     res.columns (width);
1340     return res;
1341   }
1342
1343   /// Add and assign a location.
1344   inline location& operator+= (location& res, unsigned int width)
1345   {
1346     res.columns (width);
1347     return res;
1348   }
1349
1350   /** \brief Intercept output stream redirection.
1351    ** \param ostr the destination output stream
1352    ** \param loc a reference to the location to redirect
1353    **
1354    ** Avoid duplicate information.
1355    */
1356   inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
1357   {
1358     position last = loc.end - 1;
1359     ostr << loc.begin;
1360     if (last.filename
1361         && (!loc.begin.filename
1362             || *loc.begin.filename != *last.filename))
1363       ostr << '-' << last;
1364     else if (loc.begin.line != last.line)
1365       ostr << '-' << last.line  << '.' << last.column;
1366     else if (loc.begin.column != last.column)
1367       ostr << '-' << last.column;
1368     return ostr;
1369   }
1370
1371 }
1372
1373 #endif // not BISON_LOCATION_HH]