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 ## ---------------- ##
  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, 2005])[
 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, 2005])
 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       default: break;
 683     }
 684
 685 ]/* Line __line__ of lalr1.cc.  */
 686 b4_syncline([@oline@], [@ofile@])[
 687
 688   yypop_ (yylen_);
 689
 690   YY_STACK_PRINT ();
 691
 692   yysemantic_stack_.push (yyval);
 693   yylocation_stack_.push (yyloc);
 694
 695   /* Shift the result of the reduction.  */
 696   yyn_ = yyr1_[yyn_];
 697   yystate_ = yypgoto_[yyn_ - yyntokens_] + yystate_stack_[0];
 698   if (0 <= yystate_ && yystate_ <= yylast_
 699       && yycheck_[yystate_] == yystate_stack_[0])
 700     yystate_ = yytable_[yystate_];
 701   else
 702     yystate_ = yydefgoto_[yyn_ - yyntokens_];
 703   goto yynewstate;
 704
 705 /*------------------------------------.
 706 | yyerrlab -- here on detecting error |
 707 `------------------------------------*/
 708 yyerrlab:
 709   /* If not already recovering from an error, report this error.  */
 710   yyreport_syntax_error_ ();
 711
 712   yyerror_range_[0] = yylloc;
 713   if (yyerrstatus_ == 3)
 714     {
 715       /* If just tried and failed to reuse look-ahead token after an
 716          error, discard it.  */
 717
 718       /* Return failure if at end of input.  */
 719       if (yylooka_ <= yyeof_)
 720         {
 721           /* If at end of input, pop the error token,
 722              then the rest of the stack, then return failure.  */
 723           if (yylooka_ == yyeof_)
 724              for (;;)
 725                {
 726                  yyerror_range_[0] = yylocation_stack_[0];
 727                  yypop_ ();
 728                  if (yystate_stack_.height () == 1)
 729                    YYABORT;
 730                  yydestruct_ ("Error: popping",
 731                               yystos_[yystate_stack_[0]],
 732                               &yysemantic_stack_[0],
 733                               &yylocation_stack_[0]);
 734                }
 735         }
 736       else
 737         {
 738           yydestruct_ ("Error: discarding", yyilooka_, &yylval, &yylloc);
 739           yylooka_ = yyempty_;
 740         }
 741     }
 742
 743   /* Else will try to reuse look-ahead token after shifting the error
 744      token.  */
 745   goto yyerrlab1;
 746
 747
 748 /*---------------------------------------------------.
 749 | yyerrorlab -- error raised explicitly by YYERROR.  |
 750 `---------------------------------------------------*/
 751 yyerrorlab:
 752
 753   /* Pacify compilers like GCC when the user code never invokes
 754      YYERROR and the label yyerrorlab therefore never appears in user
 755      code.  */
 756   if (false)
 757      goto yyerrorlab;
 758
 759   yyerror_range_[0] = yylocation_stack_[yylen_ - 1];
 760   yypop_ (yylen_);
 761   yystate_ = yystate_stack_[0];
 762   goto yyerrlab1;
 763
 764 /*-------------------------------------------------------------.
 765 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 766 `-------------------------------------------------------------*/
 767 yyerrlab1:
 768   yyerrstatus_ = 3;     /* Each real token shifted decrements this.  */
 769
 770   for (;;)
 771     {
 772       yyn_ = yypact_[yystate_];
 773       if (yyn_ != yypact_ninf_)
 774         {
 775           yyn_ += yyterror_;
 776           if (0 <= yyn_ && yyn_ <= yylast_ && yycheck_[yyn_] == yyterror_)
 777             {
 778               yyn_ = yytable_[yyn_];
 779               if (0 < yyn_)
 780                 break;
 781             }
 782         }
 783
 784       /* Pop the current state because it cannot handle the error token.  */
 785       if (yystate_stack_.height () == 1)
 786         YYABORT;
 787
 788       yyerror_range_[0] = yylocation_stack_[0];
 789       yydestruct_ ("Error: popping",
 790                    yystos_[yystate_],
 791                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 792       yypop_ ();
 793       yystate_ = yystate_stack_[0];
 794       YY_STACK_PRINT ();
 795     }
 796
 797   if (yyn_ == yyfinal_)
 798     goto yyacceptlab;
 799
 800   yyerror_range_[1] = yylloc;
 801   // Using YYLLOC is tempting, but would change the location of
 802   // the look-ahead.  YYLOC is available though.
 803   YYLLOC_DEFAULT (yyloc, yyerror_range_ - 1, 2);
 804   yysemantic_stack_.push (yylval);
 805   yylocation_stack_.push (yyloc);
 806
 807   /* Shift the error token. */
 808   YY_SYMBOL_PRINT ("Shifting", yystos_[yyn_],
 809                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 810
 811   yystate_ = yyn_;
 812   goto yynewstate;
 813
 814   /* Accept.  */
 815 yyacceptlab:
 816   return 0;
 817
 818   /* Abort.  */
 819 yyabortlab:
 820   /* Free the lookahead. */
 821   yydestruct_ ("Error: discarding lookahead", yyilooka_, &yylval, &yylloc);
 822   yylooka_ = yyempty_;
 823   return 1;
 824 }
 825
 826 void
 827 yy::]b4_parser_class_name[::yylex_ ()
 828 {
 829   YYCDEBUG << "Reading a token: ";
 830 #if YYLSP_NEEDED
 831   yylooka_ = yylex (&yylval, &yylloc);
 832 #else
 833   yylooka_ = yylex (&yylval);
 834 #endif
 835 }
 836
 837 // Generate an error message, and invoke error.
 838 void
 839 yy::]b4_parser_class_name[::yyreport_syntax_error_ ()
 840 {
 841   /* If not already recovering from an error, report this error.  */
 842   if (!yyerrstatus_)
 843     {
 844       ++yynerrs_;
 845       std::string message;
 846 #if YYERROR_VERBOSE
 847       yyn_ = yypact_[yystate_];
 848       if (yypact_ninf_ < yyn_ && yyn_ < yylast_)
 849         {
 850           /* Start YYX at -YYN if negative to avoid negative indexes in
 851              YYCHECK.  */
 852           int yyxbegin = yyn_ < 0 ? -yyn_ : 0;
 853
 854           /* Stay within bounds of both yycheck and yytname.  */
 855           int yychecklim = yylast_ - yyn_;
 856           int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 857           int count = 0;
 858           for (int x = yyxbegin; x < yyxend; ++x)
 859             if (yycheck_[x + yyn_] == x && x != yyterror_)
 860               ++count;
 861
 862           message = "syntax error, unexpected ";
 863           message += yyname_[yyilooka_];
 864           if (count < 5)
 865             {
 866               count = 0;
 867               for (int x = yyxbegin; x < yyxend; ++x)
 868                 if (yycheck_[x + yyn_] == x && x != yyterror_)
 869                   {
 870                     message += (!count++) ? ", expecting " : " or ";
 871                     message += yyname_[x];
 872                   }
 873             }
 874         }
 875       else
 876 #endif
 877         message = "syntax error";
 878       error (yylloc, message);
 879     }
 880 }
 881
 882
 883 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 884    STATE-NUM.  */
 885 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
 886 const ]b4_int_type_for([b4_pact])[
 887 yy::]b4_parser_class_name[::yypact_[] =
 888 {
 889   ]b4_pact[
 890 };
 891
 892 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 893    doesn't specify something else to do.  Zero means the default is an
 894    error.  */
 895 const ]b4_int_type_for([b4_defact])[
 896 yy::]b4_parser_class_name[::yydefact_[] =
 897 {
 898   ]b4_defact[
 899 };
 900
 901 /* YYPGOTO[NTERM-NUM].  */
 902 const ]b4_int_type_for([b4_pgoto])[
 903 yy::]b4_parser_class_name[::yypgoto_[] =
 904 {
 905   ]b4_pgoto[
 906 };
 907
 908 /* YYDEFGOTO[NTERM-NUM].  */
 909 const ]b4_int_type_for([b4_defgoto])[
 910 yy::]b4_parser_class_name[::yydefgoto_[] =
 911 {
 912   ]b4_defgoto[
 913 };
 914
 915 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 916    positive, shift that token.  If negative, reduce the rule which
 917    number is the opposite.  If zero, do what YYDEFACT says.  */
 918 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
 919 const ]b4_int_type_for([b4_table])[
 920 yy::]b4_parser_class_name[::yytable_[] =
 921 {
 922   ]b4_table[
 923 };
 924
 925 /* YYCHECK.  */
 926 const ]b4_int_type_for([b4_check])[
 927 yy::]b4_parser_class_name[::yycheck_[] =
 928 {
 929   ]b4_check[
 930 };
 931
 932 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 933    symbol of state STATE-NUM.  */
 934 const ]b4_int_type_for([b4_stos])[
 935 yy::]b4_parser_class_name[::yystos_[] =
 936 {
 937   ]b4_stos[
 938 };
 939
 940 #if YYDEBUG
 941 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 942    to YYLEX-NUM.  */
 943 const ]b4_int_type_for([b4_toknum])[
 944 yy::]b4_parser_class_name[::yytoken_number_[] =
 945 {
 946   ]b4_toknum[
 947 };
 948 #endif
 949
 950 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 951 const ]b4_int_type_for([b4_r1])[
 952 yy::]b4_parser_class_name[::yyr1_[] =
 953 {
 954   ]b4_r1[
 955 };
 956
 957 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 958 const ]b4_int_type_for([b4_r2])[
 959 yy::]b4_parser_class_name[::yyr2_[] =
 960 {
 961   ]b4_r2[
 962 };
 963
 964 #if YYDEBUG || YYERROR_VERBOSE
 965 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 966    First, the terminals, then, starting at \a yyntokens_, nonterminals. */
 967 const char*
 968 const yy::]b4_parser_class_name[::yyname_[] =
 969 {
 970   ]b4_tname[
 971 };
 972 #endif
 973
 974 #if YYDEBUG
 975 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 976 const yy::]b4_parser_class_name[::rhs_number_type
 977 yy::]b4_parser_class_name[::yyrhs_[] =
 978 {
 979   ]b4_rhs[
 980 };
 981
 982 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 983    YYRHS.  */
 984 const ]b4_int_type_for([b4_prhs])[
 985 yy::]b4_parser_class_name[::yyprhs_[] =
 986 {
 987   ]b4_prhs[
 988 };
 989
 990 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 991 const ]b4_int_type_for([b4_rline])[
 992 yy::]b4_parser_class_name[::yyrline_[] =
 993 {
 994   ]b4_rline[
 995 };
 996
 997 // Print the state stack on the debug stream.
 998 void
 999 yy::]b4_parser_class_name[::yystack_print_ ()
1000 {
1001   *yycdebug_ << "Stack now";
1002   for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1003        i != yystate_stack_.end (); ++i)
1004     *yycdebug_ << ' ' << *i;
1005   *yycdebug_ << std::endl;
1006 }
1007
1008 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1009 void
1010 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
1011 {
1012   unsigned int yylno = yyrline_[yyrule];
1013   /* Print the symbols being reduced, and their result.  */
1014     *yycdebug_ << "Reducing stack by rule " << yyn_ - 1
1015                << " (line " << yylno << "), ";
1016   for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyn_];
1017        0 <= yyrhs_[i]; ++i)
1018     *yycdebug_ << yyname_[yyrhs_[i]] << ' ';
1019   *yycdebug_ << "-> " << yyname_[yyr1_[yyn_]] << std::endl;
1020 }
1021 #endif // YYDEBUG
1022
1023 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1024 yy::]b4_parser_class_name[::token_number_type
1025 yy::]b4_parser_class_name[::yytranslate_ (int token)
1026 {
1027   static
1028   const token_number_type
1029   translate_table[] =
1030   {
1031     ]b4_translate[
1032   };
1033   if ((unsigned int) token <= yyuser_token_number_max_)
1034     return translate_table[token];
1035   else
1036     return yyundef_token_;
1037 }
1038
1039 const int yy::]b4_parser_class_name[::yyeof_ = 0;
1040 const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
1041 const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1042 const int yy::]b4_parser_class_name[::yyempty_ = -2;
1043 const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1044 const int yy::]b4_parser_class_name[::yyterror_ = 1;
1045 const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
1046 const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1047
1048 const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1049 const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1050
1051 ]b4_epilogue
1052 dnl
1053 @output stack.hh
1054 b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1055
1056 #ifndef BISON_STACK_HH
1057 # define BISON_STACK_HH
1058
1059 #include <deque>
1060
1061 namespace yy
1062 {
1063   template <class T, class S = std::deque<T> >
1064   class stack
1065   {
1066   public:
1067
1068     // Hide our reversed order.
1069     typedef typename S::reverse_iterator iterator;
1070     typedef typename S::const_reverse_iterator const_iterator;
1071
1072     stack () : seq_ ()
1073     {
1074     }
1075
1076     stack (unsigned int n) : seq_ (n)
1077     {
1078     }
1079
1080     inline
1081     T&
1082     operator [] (unsigned int i)
1083     {
1084       return seq_[i];
1085     }
1086
1087     inline
1088     const T&
1089     operator [] (unsigned int i) const
1090     {
1091       return seq_[i];
1092     }
1093
1094     inline
1095     void
1096     push (const T& t)
1097     {
1098       seq_.push_front (t);
1099     }
1100
1101     inline
1102     void
1103     pop (unsigned int n = 1)
1104     {
1105       for (; n; --n)
1106         seq_.pop_front ();
1107     }
1108
1109     inline
1110     unsigned int
1111     height () const
1112     {
1113       return seq_.size ();
1114     }
1115
1116     inline const_iterator begin () const { return seq_.rbegin (); }
1117     inline const_iterator end () const { return seq_.rend (); }
1118
1119   private:
1120
1121     S seq_;
1122   };
1123
1124   /// Present a slice of the top of a stack.
1125   template <class T, class S = stack<T> >
1126   class slice
1127   {
1128   public:
1129
1130     slice (const S& stack,
1131            unsigned int range) : stack_ (stack),
1132                                  range_ (range)
1133     {
1134     }
1135
1136     inline
1137     const T&
1138     operator [] (unsigned int i) const
1139     {
1140       return stack_[range_ - i];
1141     }
1142
1143   private:
1144
1145     const S& stack_;
1146     unsigned int range_;
1147   };
1148 }
1149
1150 #endif // not BISON_STACK_HH]
1151 dnl
1152 @output position.hh
1153 b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1154
1155 /**
1156  ** \file position.hh
1157  ** Define the position class.
1158  */
1159
1160 #ifndef BISON_POSITION_HH
1161 # define BISON_POSITION_HH
1162
1163 # include <iostream>
1164 # include <string>
1165
1166 namespace yy
1167 {
1168   /// Abstract a position.
1169   class position
1170   {
1171   public:
1172     /// Initial column number.
1173     static const unsigned int initial_column = 0;
1174     /// Initial line number.
1175     static const unsigned int initial_line = 1;
1176
1177     /** \name Ctor & dtor.
1178      ** \{ */
1179   public:
1180     /// Construct a position.
1181     position () :
1182       filename (0),
1183       line (initial_line),
1184       column (initial_column)
1185     {
1186     }
1187     /** \} */
1188
1189
1190     /** \name Line and Column related manipulators
1191      ** \{ */
1192   public:
1193     /// (line related) Advance to the COUNT next lines.
1194     inline void lines (int count = 1)
1195     {
1196       column = initial_column;
1197       line += count;
1198     }
1199
1200     /// (column related) Advance to the COUNT next columns.
1201     inline void columns (int count = 1)
1202     {
1203       int leftmost = initial_column;
1204       int current  = column;
1205       if (leftmost <= current + count)
1206         column += count;
1207       else
1208         column = initial_column;
1209     }
1210     /** \} */
1211
1212   public:
1213     /// File name to which this position refers.
1214     ]b4_filename_type[* filename;
1215     /// Current line number.
1216     unsigned int line;
1217     /// Current column number.
1218     unsigned int column;
1219   };
1220
1221   /// Add and assign a position.
1222   inline const position&
1223   operator+= (position& res, const int width)
1224   {
1225     res.columns (width);
1226     return res;
1227   }
1228
1229   /// Add two position objects.
1230   inline const position
1231   operator+ (const position& begin, const int width)
1232   {
1233     position res = begin;
1234     return res += width;
1235   }
1236
1237   /// Add and assign a position.
1238   inline const position&
1239   operator-= (position& res, const int width)
1240   {
1241     return res += -width;
1242   }
1243
1244   /// Add two position objects.
1245   inline const position
1246   operator- (const position& begin, const int width)
1247   {
1248     return begin + -width;
1249   }
1250
1251   /** \brief Intercept output stream redirection.
1252    ** \param ostr the destination output stream
1253    ** \param pos a reference to the position to redirect
1254    */
1255   inline std::ostream&
1256   operator<< (std::ostream& ostr, const position& pos)
1257   {
1258     if (pos.filename)
1259       ostr << *pos.filename << ':';
1260     return ostr << pos.line << '.' << pos.column;
1261   }
1262
1263 }
1264 #endif // not BISON_POSITION_HH]
1265 @output location.hh
1266 b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1267
1268 /**
1269  ** \file location.hh
1270  ** Define the location class.
1271  */
1272
1273 #ifndef BISON_LOCATION_HH
1274 # define BISON_LOCATION_HH
1275
1276 # include <iostream>
1277 # include <string>
1278 # include "position.hh"
1279
1280 namespace yy
1281 {
1282
1283   /// Abstract a location.
1284   class location
1285   {
1286     /** \name Ctor & dtor.
1287      ** \{ */
1288   public:
1289     /// Construct a location.
1290     location () :
1291       begin (),
1292       end ()
1293     {
1294     }
1295     /** \} */
1296
1297
1298     /** \name Line and Column related manipulators
1299      ** \{ */
1300   public:
1301     /// Reset initial location to final location.
1302     inline void step ()
1303     {
1304       begin = end;
1305     }
1306
1307     /// Extend the current location to the COUNT next columns.
1308     inline void columns (unsigned int count = 1)
1309     {
1310       end += count;
1311     }
1312
1313     /// Extend the current location to the COUNT next lines.
1314     inline void lines (unsigned int count = 1)
1315     {
1316       end.lines (count);
1317     }
1318     /** \} */
1319
1320
1321   public:
1322     /// Beginning of the located region.
1323     position begin;
1324     /// End of the located region.
1325     position end;
1326   };
1327
1328   /// Join two location objects to create a location.
1329   inline const location operator+ (const location& begin, const location& end)
1330   {
1331     location res = begin;
1332     res.end = end.end;
1333     return res;
1334   }
1335
1336   /// Add two location objects.
1337   inline const location operator+ (const location& begin, unsigned int width)
1338   {
1339     location res = begin;
1340     res.columns (width);
1341     return res;
1342   }
1343
1344   /// Add and assign a location.
1345   inline location& operator+= (location& res, unsigned int width)
1346   {
1347     res.columns (width);
1348     return res;
1349   }
1350
1351   /** \brief Intercept output stream redirection.
1352    ** \param ostr the destination output stream
1353    ** \param loc a reference to the location to redirect
1354    **
1355    ** Avoid duplicate information.
1356    */
1357   inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
1358   {
1359     position last = loc.end - 1;
1360     ostr << loc.begin;
1361     if (last.filename
1362         && (!loc.begin.filename
1363             || *loc.begin.filename != *last.filename))
1364       ostr << '-' << last;
1365     else if (loc.begin.line != last.line)
1366       ostr << '-' << last.line  << '.' << last.column;
1367     else if (loc.begin.column != last.column)
1368       ostr << '-' << last.column;
1369     return ostr;
1370   }
1371
1372 }
1373
1374 #endif // not BISON_LOCATION_HH]