data/lalr1.cc

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