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