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 #ifndef YY_
 421 # if YYENABLE_NLS
 422 #  if ENABLE_NLS
 423 #   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
 424 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 425 #  endif
 426 # endif
 427 # ifndef YY_
 428 #  define YY_(msgid) msgid
 429 # endif
 430 #endif
 431
 432 /* A pseudo ostream that takes yydebug_ into account. */
 433 # define YYCDEBUG                                                       \
 434   for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)        \
 435     (*yycdebug_)
 436
 437 /* Enable debugging if requested.  */
 438 #if YYDEBUG
 439
 440 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
 441 do {                                                    \
 442   if (yydebug_)                                         \
 443     {                                                   \
 444       *yycdebug_ << (Title) << ' ';                     \
 445       yysymprint_ ((Type), (Value), (Location));        \
 446       *yycdebug_ << std::endl;                          \
 447     }                                                   \
 448 } while (0)
 449
 450 # define YY_REDUCE_PRINT(Rule)          \
 451 do {                                    \
 452   if (yydebug_)                         \
 453     yyreduce_print_ (Rule);             \
 454 } while (0)
 455
 456 # define YY_STACK_PRINT()               \
 457 do {                                    \
 458   if (yydebug_)                         \
 459     yystack_print_ ();                  \
 460 } while (0)
 461
 462 #else /* !YYDEBUG */
 463
 464 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 465 # define YY_REDUCE_PRINT(Rule)
 466 # define YY_STACK_PRINT()
 467
 468 #endif /* !YYDEBUG */
 469
 470 #define YYACCEPT        goto yyacceptlab
 471 #define YYABORT         goto yyabortlab
 472 #define YYERROR         goto yyerrorlab
 473
 474 #if YYDEBUG
 475 /*--------------------------------.
 476 | Print this symbol on YYOUTPUT.  |
 477 `--------------------------------*/
 478
 479 void
 480 yy::]b4_parser_class_name[::yysymprint_ (int yytype,
 481                          const semantic_type* yyvaluep, const location_type* yylocationp)
 482 {
 483   /* Pacify ``unused variable'' warnings.  */
 484   (void) yyvaluep;
 485   (void) yylocationp;
 486   /* Backward compatibility, but should be removed eventually. */
 487   std::ostream& cdebug_ = *yycdebug_;
 488   (void) cdebug_;
 489
 490   *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
 491              << ' ' << yyname_[yytype] << " ("
 492              << *yylocationp << ": ";
 493   switch (yytype)
 494     {
 495 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 496 [      default:
 497         break;
 498     }
 499   *yycdebug_ << ')';
 500 }
 501 #endif /* ! YYDEBUG */
 502
 503 void
 504 yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
 505                          int yytype, semantic_type* yyvaluep, location_type* yylocationp)
 506 {
 507   /* Pacify ``unused variable'' warnings.  */
 508   (void) yymsg;
 509   (void) yyvaluep;
 510   (void) yylocationp;
 511
 512   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 513
 514   switch (yytype)
 515     {
 516 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 517       default:
 518         break;
 519     }
 520 }
 521
 522 void
 523 yy::]b4_parser_class_name[::yypop_ (unsigned int n)
 524 {
 525   yystate_stack_.pop (n);
 526   yysemantic_stack_.pop (n);
 527   yylocation_stack_.pop (n);
 528 }
 529
 530 std::ostream&
 531 yy::]b4_parser_class_name[::debug_stream () const
 532 {
 533   return *yycdebug_;
 534 }
 535
 536 void
 537 yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
 538 {
 539   yycdebug_ = &o;
 540 }
 541
 542
 543 yy::]b4_parser_class_name[::debug_level_type
 544 yy::]b4_parser_class_name[::debug_level () const
 545 {
 546   return yydebug_;
 547 }
 548
 549 void
 550 yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
 551 {
 552   yydebug_ = l;
 553 }
 554
 555
 556 int
 557 yy::]b4_parser_class_name[::parse ()
 558 {
 559   int yyresult_;
 560
 561   YYCDEBUG << "Starting parse" << std::endl;
 562
 563   yynerrs_ = 0;
 564   yyerrstatus_ = 0;
 565
 566   /* Start.  */
 567   yystate_ = 0;
 568   yylooka_ = yyempty_;
 569
 570 ]m4_ifdef([b4_initial_action], [
 571 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 572 m4_pushdef([b4_dollar_dollar], [yylval])dnl
 573   /* User initialization code. */
 574   b4_initial_action
 575 m4_popdef([b4_dollar_dollar])dnl
 576 m4_popdef([b4_at_dollar])dnl
 577 /* Line __line__ of yacc.c.  */
 578 b4_syncline([@oline@], [@ofile@])])dnl
 579
 580 [  /* Initialize the stacks.  The initial state will be pushed in
 581      yynewstate, since the latter expects the semantical and the
 582      location values to have been already stored, initialize these
 583      stacks with a primary value.  */
 584   yystate_stack_ = state_stack_type (0);
 585   yysemantic_stack_ = semantic_stack_type (0);
 586   yylocation_stack_ = location_stack_type (0);
 587   yysemantic_stack_.push (yylval);
 588   yylocation_stack_.push (yylloc);
 589
 590   /* New state.  */
 591 yynewstate:
 592   yystate_stack_.push (yystate_);
 593   YYCDEBUG << "Entering state " << yystate_ << std::endl;
 594   goto yybackup;
 595
 596   /* Backup.  */
 597 yybackup:
 598
 599   /* Try to take a decision without look-ahead.  */
 600   yyn_ = yypact_[yystate_];
 601   if (yyn_ == yypact_ninf_)
 602     goto yydefault;
 603
 604   /* Read a look-ahead token.  */
 605   if (yylooka_ == yyempty_)
 606     yylex_ ();
 607
 608   /* Convert token to internal form.  */
 609   if (yylooka_ <= yyeof_)
 610     {
 611       yylooka_ = yyilooka_ = yyeof_;
 612       YYCDEBUG << "Now at end of input." << std::endl;
 613     }
 614   else
 615     {
 616       yyilooka_ = yytranslate_ (yylooka_);
 617       YY_SYMBOL_PRINT ("Next token is", yyilooka_, &yylval, &yylloc);
 618     }
 619
 620   /* If the proper action on seeing token ILOOKA_ is to reduce or to
 621      detect an error, take that action.  */
 622   yyn_ += yyilooka_;
 623   if (yyn_ < 0 || yylast_ < yyn_ || yycheck_[yyn_] != yyilooka_)
 624     goto yydefault;
 625
 626   /* Reduce or error.  */
 627   yyn_ = yytable_[yyn_];
 628   if (yyn_ < 0)
 629     {
 630       if (yyn_ == yytable_ninf_)
 631         goto yyerrlab;
 632       else
 633         {
 634           yyn_ = -yyn_;
 635           goto yyreduce;
 636         }
 637     }
 638   else if (yyn_ == 0)
 639     goto yyerrlab;
 640
 641   /* Accept?  */
 642   if (yyn_ == yyfinal_)
 643     goto yyacceptlab;
 644
 645   /* Shift the look-ahead token.  */
 646   YY_SYMBOL_PRINT ("Shifting", yyilooka_, &yylval, &yylloc);
 647
 648   /* Discard the token being shifted unless it is eof.  */
 649   if (yylooka_ != yyeof_)
 650     yylooka_ = yyempty_;
 651
 652   yysemantic_stack_.push (yylval);
 653   yylocation_stack_.push (yylloc);
 654
 655   /* Count tokens shifted since error; after three, turn off error
 656      status.  */
 657   if (yyerrstatus_)
 658     --yyerrstatus_;
 659
 660   yystate_ = yyn_;
 661   goto yynewstate;
 662
 663 /*-----------------------------------------------------------.
 664 | yydefault -- do the default action for the current state.  |
 665 `-----------------------------------------------------------*/
 666 yydefault:
 667   yyn_ = yydefact_[yystate_];
 668   if (yyn_ == 0)
 669     goto yyerrlab;
 670   goto yyreduce;
 671
 672 /*-----------------------------.
 673 | yyreduce -- Do a reduction.  |
 674 `-----------------------------*/
 675 yyreduce:
 676   yylen_ = yyr2_[yyn_];
 677   /* If LEN_ is nonzero, implement the default value of the action:
 678      `$$ = $1'.  Otherwise, use the top of the stack.
 679
 680      Otherwise, the following line sets YYVAL to garbage.
 681      This behavior is undocumented and Bison
 682      users should not rely upon it.  */
 683   if (yylen_)
 684     yyval = yysemantic_stack_[yylen_ - 1];
 685   else
 686     yyval = yysemantic_stack_[0];
 687
 688   {
 689     slice<location_type, location_stack_type> slice (yylocation_stack_, yylen_);
 690     YYLLOC_DEFAULT (yyloc, slice, yylen_);
 691   }
 692   YY_REDUCE_PRINT (yyn_);
 693   switch (yyn_)
 694     {
 695       ]b4_actions[
 696       default: break;
 697     }
 698
 699 ]/* Line __line__ of lalr1.cc.  */
 700 b4_syncline([@oline@], [@ofile@])[
 701
 702   yypop_ (yylen_);
 703
 704   YY_STACK_PRINT ();
 705
 706   yysemantic_stack_.push (yyval);
 707   yylocation_stack_.push (yyloc);
 708
 709   /* Shift the result of the reduction.  */
 710   yyn_ = yyr1_[yyn_];
 711   yystate_ = yypgoto_[yyn_ - yyntokens_] + yystate_stack_[0];
 712   if (0 <= yystate_ && yystate_ <= yylast_
 713       && yycheck_[yystate_] == yystate_stack_[0])
 714     yystate_ = yytable_[yystate_];
 715   else
 716     yystate_ = yydefgoto_[yyn_ - yyntokens_];
 717   goto yynewstate;
 718
 719 /*------------------------------------.
 720 | yyerrlab -- here on detecting error |
 721 `------------------------------------*/
 722 yyerrlab:
 723   /* If not already recovering from an error, report this error.  */
 724   yyreport_syntax_error_ ();
 725
 726   yyerror_range_[0] = yylloc;
 727   if (yyerrstatus_ == 3)
 728     {
 729       /* If just tried and failed to reuse look-ahead token after an
 730          error, discard it.  */
 731
 732       if (yylooka_ <= yyeof_)
 733         {
 734           /* Return failure if at end of input.  */
 735           if (yylooka_ == yyeof_)
 736             YYABORT;
 737         }
 738       else
 739         {
 740           yydestruct_ ("Error: discarding", yyilooka_, &yylval, &yylloc);
 741           yylooka_ = yyempty_;
 742         }
 743     }
 744
 745   /* Else will try to reuse look-ahead token after shifting the error
 746      token.  */
 747   goto yyerrlab1;
 748
 749
 750 /*---------------------------------------------------.
 751 | yyerrorlab -- error raised explicitly by YYERROR.  |
 752 `---------------------------------------------------*/
 753 yyerrorlab:
 754
 755   /* Pacify compilers like GCC when the user code never invokes
 756      YYERROR and the label yyerrorlab therefore never appears in user
 757      code.  */
 758   if (false)
 759     goto yyerrorlab;
 760
 761   yyerror_range_[0] = yylocation_stack_[yylen_ - 1];
 762   yypop_ (yylen_);
 763   yystate_ = yystate_stack_[0];
 764   goto yyerrlab1;
 765
 766 /*-------------------------------------------------------------.
 767 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 768 `-------------------------------------------------------------*/
 769 yyerrlab1:
 770   yyerrstatus_ = 3;     /* Each real token shifted decrements this.  */
 771
 772   for (;;)
 773     {
 774       yyn_ = yypact_[yystate_];
 775       if (yyn_ != yypact_ninf_)
 776         {
 777           yyn_ += yyterror_;
 778           if (0 <= yyn_ && yyn_ <= yylast_ && yycheck_[yyn_] == yyterror_)
 779             {
 780               yyn_ = yytable_[yyn_];
 781               if (0 < yyn_)
 782                 break;
 783             }
 784         }
 785
 786       /* Pop the current state because it cannot handle the error token.  */
 787       if (yystate_stack_.height () == 1)
 788         YYABORT;
 789
 790       yyerror_range_[0] = yylocation_stack_[0];
 791       yydestruct_ ("Error: popping",
 792                    yystos_[yystate_],
 793                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 794       yypop_ ();
 795       yystate_ = yystate_stack_[0];
 796       YY_STACK_PRINT ();
 797     }
 798
 799   if (yyn_ == yyfinal_)
 800     goto yyacceptlab;
 801
 802   yyerror_range_[1] = yylloc;
 803   // Using YYLLOC is tempting, but would change the location of
 804   // the look-ahead.  YYLOC is available though.
 805   YYLLOC_DEFAULT (yyloc, yyerror_range_ - 1, 2);
 806   yysemantic_stack_.push (yylval);
 807   yylocation_stack_.push (yyloc);
 808
 809   /* Shift the error token. */
 810   YY_SYMBOL_PRINT ("Shifting", yystos_[yyn_],
 811                    &yysemantic_stack_[0], &yylocation_stack_[0]);
 812
 813   yystate_ = yyn_;
 814   goto yynewstate;
 815
 816   /* Accept.  */
 817 yyacceptlab:
 818   yyresult_ = 0;
 819   goto yyreturn;
 820
 821   /* Abort.  */
 822 yyabortlab:
 823   yyresult_ = 1;
 824   goto yyreturn;
 825
 826 yyreturn:
 827   if (yylooka_ != yyeof_ && yylooka_ != yyempty_)
 828     yydestruct_ ("Error: discarding lookahead", yyilooka_, &yylval, &yylloc);
 829
 830   while (yystate_stack_.height () != 1)
 831     {
 832       yydestruct_ ("Error: popping",
 833                    yystos_[yystate_stack_[0]],
 834                    &yysemantic_stack_[0],
 835                    &yylocation_stack_[0]);
 836       yypop_ ();
 837     }
 838
 839   return yyresult_;
 840 }
 841
 842 void
 843 yy::]b4_parser_class_name[::yylex_ ()
 844 {
 845   YYCDEBUG << "Reading a token: ";
 846   yylooka_ = ]b4_c_function_call([yylex], [int],
 847 [[YYSTYPE*], [&yylval]][]dnl
 848 b4_location_if([, [[location*], [&yylloc]]])dnl
 849 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 850 }
 851
 852 // Generate an error message, and invoke error.
 853 void
 854 yy::]b4_parser_class_name[::yyreport_syntax_error_ ()
 855 {
 856   /* If not already recovering from an error, report this error.  */
 857   if (!yyerrstatus_)
 858     {
 859       ++yynerrs_;
 860       std::string message;
 861 #if YYERROR_VERBOSE
 862       yyn_ = yypact_[yystate_];
 863       if (yypact_ninf_ < yyn_ && yyn_ < yylast_)
 864         {
 865           /* Start YYX at -YYN if negative to avoid negative indexes in
 866              YYCHECK.  */
 867           int yyxbegin = yyn_ < 0 ? -yyn_ : 0;
 868
 869           /* Stay within bounds of both yycheck and yytname.  */
 870           int yychecklim = yylast_ - yyn_;
 871           int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 872           int count = 0;
 873           for (int x = yyxbegin; x < yyxend; ++x)
 874             if (yycheck_[x + yyn_] == x && x != yyterror_)
 875               ++count;
 876
 877           // FIXME: This method of building the message is not compatible
 878           // with internationalization.  It should work like yacc.c does it.
 879           // That is, first build a string that looks like this:
 880           // "syntax error, unexpected %s or %s or %s"
 881           // Then, invoke YY_ on this string.
 882           // Finally, use the string as a format to output
 883           // yyname_[yyilooka_], etc.
 884           // Until this gets fixed, this message appears in English only.
 885           message = "syntax error, unexpected ";
 886           message += yyname_[yyilooka_];
 887           if (count < 5)
 888             {
 889               count = 0;
 890               for (int x = yyxbegin; x < yyxend; ++x)
 891                 if (yycheck_[x + yyn_] == x && x != yyterror_)
 892                   {
 893                     message += (!count++) ? ", expecting " : " or ";
 894                     message += yyname_[x];
 895                   }
 896             }
 897         }
 898       else
 899 #endif
 900         message = YY_("syntax error");
 901       error (yylloc, message);
 902     }
 903 }
 904
 905
 906 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 907    STATE-NUM.  */
 908 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
 909 const ]b4_int_type_for([b4_pact])[
 910 yy::]b4_parser_class_name[::yypact_[] =
 911 {
 912   ]b4_pact[
 913 };
 914
 915 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 916    doesn't specify something else to do.  Zero means the default is an
 917    error.  */
 918 const ]b4_int_type_for([b4_defact])[
 919 yy::]b4_parser_class_name[::yydefact_[] =
 920 {
 921   ]b4_defact[
 922 };
 923
 924 /* YYPGOTO[NTERM-NUM].  */
 925 const ]b4_int_type_for([b4_pgoto])[
 926 yy::]b4_parser_class_name[::yypgoto_[] =
 927 {
 928   ]b4_pgoto[
 929 };
 930
 931 /* YYDEFGOTO[NTERM-NUM].  */
 932 const ]b4_int_type_for([b4_defgoto])[
 933 yy::]b4_parser_class_name[::yydefgoto_[] =
 934 {
 935   ]b4_defgoto[
 936 };
 937
 938 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 939    positive, shift that token.  If negative, reduce the rule which
 940    number is the opposite.  If zero, do what YYDEFACT says.  */
 941 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
 942 const ]b4_int_type_for([b4_table])[
 943 yy::]b4_parser_class_name[::yytable_[] =
 944 {
 945   ]b4_table[
 946 };
 947
 948 /* YYCHECK.  */
 949 const ]b4_int_type_for([b4_check])[
 950 yy::]b4_parser_class_name[::yycheck_[] =
 951 {
 952   ]b4_check[
 953 };
 954
 955 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 956    symbol of state STATE-NUM.  */
 957 const ]b4_int_type_for([b4_stos])[
 958 yy::]b4_parser_class_name[::yystos_[] =
 959 {
 960   ]b4_stos[
 961 };
 962
 963 #if YYDEBUG
 964 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 965    to YYLEX-NUM.  */
 966 const ]b4_int_type_for([b4_toknum])[
 967 yy::]b4_parser_class_name[::yytoken_number_[] =
 968 {
 969   ]b4_toknum[
 970 };
 971 #endif
 972
 973 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 974 const ]b4_int_type_for([b4_r1])[
 975 yy::]b4_parser_class_name[::yyr1_[] =
 976 {
 977   ]b4_r1[
 978 };
 979
 980 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 981 const ]b4_int_type_for([b4_r2])[
 982 yy::]b4_parser_class_name[::yyr2_[] =
 983 {
 984   ]b4_r2[
 985 };
 986
 987 #if YYDEBUG || YYERROR_VERBOSE
 988 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 989    First, the terminals, then, starting at \a yyntokens_, nonterminals. */
 990 const char*
 991 const yy::]b4_parser_class_name[::yyname_[] =
 992 {
 993   ]b4_tname[
 994 };
 995 #endif
 996
 997 #if YYDEBUG
 998 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 999 const yy::]b4_parser_class_name[::rhs_number_type
1000 yy::]b4_parser_class_name[::yyrhs_[] =
1001 {
1002   ]b4_rhs[
1003 };
1004
1005 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1006    YYRHS.  */
1007 const ]b4_int_type_for([b4_prhs])[
1008 yy::]b4_parser_class_name[::yyprhs_[] =
1009 {
1010   ]b4_prhs[
1011 };
1012
1013 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1014 const ]b4_int_type_for([b4_rline])[
1015 yy::]b4_parser_class_name[::yyrline_[] =
1016 {
1017   ]b4_rline[
1018 };
1019
1020 // Print the state stack on the debug stream.
1021 void
1022 yy::]b4_parser_class_name[::yystack_print_ ()
1023 {
1024   *yycdebug_ << "Stack now";
1025   for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1026        i != yystate_stack_.end (); ++i)
1027     *yycdebug_ << ' ' << *i;
1028   *yycdebug_ << std::endl;
1029 }
1030
1031 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1032 void
1033 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
1034 {
1035   unsigned int yylno = yyrline_[yyrule];
1036   /* Print the symbols being reduced, and their result.  */
1037   *yycdebug_ << "Reducing stack by rule " << yyn_ - 1
1038              << " (line " << yylno << "), ";
1039   for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyn_];
1040        0 <= yyrhs_[i]; ++i)
1041     *yycdebug_ << yyname_[yyrhs_[i]] << ' ';
1042   *yycdebug_ << "-> " << yyname_[yyr1_[yyn_]] << std::endl;
1043 }
1044 #endif // YYDEBUG
1045
1046 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1047 yy::]b4_parser_class_name[::token_number_type
1048 yy::]b4_parser_class_name[::yytranslate_ (int token)
1049 {
1050   static
1051   const token_number_type
1052   translate_table[] =
1053   {
1054     ]b4_translate[
1055   };
1056   if ((unsigned int) token <= yyuser_token_number_max_)
1057     return translate_table[token];
1058   else
1059     return yyundef_token_;
1060 }
1061
1062 const int yy::]b4_parser_class_name[::yyeof_ = 0;
1063 const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
1064 const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1065 const int yy::]b4_parser_class_name[::yyempty_ = -2;
1066 const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1067 const int yy::]b4_parser_class_name[::yyterror_ = 1;
1068 const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
1069 const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1070
1071 const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1072 const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1073
1074 ]b4_epilogue
1075 dnl
1076 @output stack.hh
1077 b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1078
1079 #ifndef BISON_STACK_HH
1080 # define BISON_STACK_HH
1081
1082 #include <deque>
1083
1084 namespace yy
1085 {
1086   template <class T, class S = std::deque<T> >
1087   class stack
1088   {
1089   public:
1090
1091     // Hide our reversed order.
1092     typedef typename S::reverse_iterator iterator;
1093     typedef typename S::const_reverse_iterator const_iterator;
1094
1095     stack () : seq_ ()
1096     {
1097     }
1098
1099     stack (unsigned int n) : seq_ (n)
1100     {
1101     }
1102
1103     inline
1104     T&
1105     operator [] (unsigned int i)
1106     {
1107       return seq_[i];
1108     }
1109
1110     inline
1111     const T&
1112     operator [] (unsigned int i) const
1113     {
1114       return seq_[i];
1115     }
1116
1117     inline
1118     void
1119     push (const T& t)
1120     {
1121       seq_.push_front (t);
1122     }
1123
1124     inline
1125     void
1126     pop (unsigned int n = 1)
1127     {
1128       for (; n; --n)
1129         seq_.pop_front ();
1130     }
1131
1132     inline
1133     unsigned int
1134     height () const
1135     {
1136       return seq_.size ();
1137     }
1138
1139     inline const_iterator begin () const { return seq_.rbegin (); }
1140     inline const_iterator end () const { return seq_.rend (); }
1141
1142   private:
1143
1144     S seq_;
1145   };
1146
1147   /// Present a slice of the top of a stack.
1148   template <class T, class S = stack<T> >
1149   class slice
1150   {
1151   public:
1152
1153     slice (const S& stack,
1154            unsigned int range) : stack_ (stack),
1155                                  range_ (range)
1156     {
1157     }
1158
1159     inline
1160     const T&
1161     operator [] (unsigned int i) const
1162     {
1163       return stack_[range_ - i];
1164     }
1165
1166   private:
1167
1168     const S& stack_;
1169     unsigned int range_;
1170   };
1171 }
1172
1173 #endif // not BISON_STACK_HH]
1174 dnl
1175 @output position.hh
1176 b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1177
1178 /**
1179  ** \file position.hh
1180  ** Define the position class.
1181  */
1182
1183 #ifndef BISON_POSITION_HH
1184 # define BISON_POSITION_HH
1185
1186 # include <iostream>
1187 # include <string>
1188
1189 namespace yy
1190 {
1191   /// Abstract a position.
1192   class position
1193   {
1194   public:
1195     /// Initial column number.
1196     static const unsigned int initial_column = 0;
1197     /// Initial line number.
1198     static const unsigned int initial_line = 1;
1199
1200     /** \name Ctor & dtor.
1201      ** \{ */
1202   public:
1203     /// Construct a position.
1204     position () :
1205       filename (0),
1206       line (initial_line),
1207       column (initial_column)
1208     {
1209     }
1210     /** \} */
1211
1212
1213     /** \name Line and Column related manipulators
1214      ** \{ */
1215   public:
1216     /// (line related) Advance to the COUNT next lines.
1217     inline void lines (int count = 1)
1218     {
1219       column = initial_column;
1220       line += count;
1221     }
1222
1223     /// (column related) Advance to the COUNT next columns.
1224     inline void columns (int count = 1)
1225     {
1226       int leftmost = initial_column;
1227       int current  = column;
1228       if (leftmost <= current + count)
1229         column += count;
1230       else
1231         column = initial_column;
1232     }
1233     /** \} */
1234
1235   public:
1236     /// File name to which this position refers.
1237     ]b4_filename_type[* filename;
1238     /// Current line number.
1239     unsigned int line;
1240     /// Current column number.
1241     unsigned int column;
1242   };
1243
1244   /// Add and assign a position.
1245   inline const position&
1246   operator+= (position& res, const int width)
1247   {
1248     res.columns (width);
1249     return res;
1250   }
1251
1252   /// Add two position objects.
1253   inline const position
1254   operator+ (const position& begin, const int width)
1255   {
1256     position res = begin;
1257     return res += width;
1258   }
1259
1260   /// Add and assign a position.
1261   inline const position&
1262   operator-= (position& res, const int width)
1263   {
1264     return res += -width;
1265   }
1266
1267   /// Add two position objects.
1268   inline const position
1269   operator- (const position& begin, const int width)
1270   {
1271     return begin + -width;
1272   }
1273
1274   /** \brief Intercept output stream redirection.
1275    ** \param ostr the destination output stream
1276    ** \param pos a reference to the position to redirect
1277    */
1278   inline std::ostream&
1279   operator<< (std::ostream& ostr, const position& pos)
1280   {
1281     if (pos.filename)
1282       ostr << *pos.filename << ':';
1283     return ostr << pos.line << '.' << pos.column;
1284   }
1285
1286 }
1287 #endif // not BISON_POSITION_HH]
1288 @output location.hh
1289 b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1290
1291 /**
1292  ** \file location.hh
1293  ** Define the location class.
1294  */
1295
1296 #ifndef BISON_LOCATION_HH
1297 # define BISON_LOCATION_HH
1298
1299 # include <iostream>
1300 # include <string>
1301 # include "position.hh"
1302
1303 namespace yy
1304 {
1305
1306   /// Abstract a location.
1307   class location
1308   {
1309     /** \name Ctor & dtor.
1310      ** \{ */
1311   public:
1312     /// Construct a location.
1313     location () :
1314       begin (),
1315       end ()
1316     {
1317     }
1318     /** \} */
1319
1320
1321     /** \name Line and Column related manipulators
1322      ** \{ */
1323   public:
1324     /// Reset initial location to final location.
1325     inline void step ()
1326     {
1327       begin = end;
1328     }
1329
1330     /// Extend the current location to the COUNT next columns.
1331     inline void columns (unsigned int count = 1)
1332     {
1333       end += count;
1334     }
1335
1336     /// Extend the current location to the COUNT next lines.
1337     inline void lines (unsigned int count = 1)
1338     {
1339       end.lines (count);
1340     }
1341     /** \} */
1342
1343
1344   public:
1345     /// Beginning of the located region.
1346     position begin;
1347     /// End of the located region.
1348     position end;
1349   };
1350
1351   /// Join two location objects to create a location.
1352   inline const location operator+ (const location& begin, const location& end)
1353   {
1354     location res = begin;
1355     res.end = end.end;
1356     return res;
1357   }
1358
1359   /// Add two location objects.
1360   inline const location operator+ (const location& begin, unsigned int width)
1361   {
1362     location res = begin;
1363     res.columns (width);
1364     return res;
1365   }
1366
1367   /// Add and assign a location.
1368   inline location& operator+= (location& res, unsigned int width)
1369   {
1370     res.columns (width);
1371     return res;
1372   }
1373
1374   /** \brief Intercept output stream redirection.
1375    ** \param ostr the destination output stream
1376    ** \param loc a reference to the location to redirect
1377    **
1378    ** Avoid duplicate information.
1379    */
1380   inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
1381   {
1382     position last = loc.end - 1;
1383     ostr << loc.begin;
1384     if (last.filename
1385         && (!loc.begin.filename
1386             || *loc.begin.filename != *last.filename))
1387       ostr << '-' << last;
1388     else if (loc.begin.line != last.line)
1389       ostr << '-' << last.line  << '.' << last.column;
1390     else if (loc.begin.column != last.column)
1391       ostr << '-' << last.column;
1392     return ostr;
1393   }
1394
1395 }
1396
1397 #endif // not BISON_LOCATION_HH]