data/lalr1.cc

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