data/lalr1.cc

   1 m4_divert(-1)
   2 # C++ skeleton for Bison
   3 # Copyright (C) 2002 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 # Stack parameters.
  25 m4_define_default([b4_stack_depth_init],  [200])
  26
  27 # Default Parser class name.
  28 m4_define_default([b4_parser_class_name], [Parser])
  29
  30
  31
  32 ## ----------------- ##
  33 ## Semantic Values.  ##
  34 ## ----------------- ##
  35
  36
  37 # b4_lhs_value([TYPE])
  38 # --------------------
  39 # Expansion of $<TYPE>$.
  40 m4_define([b4_lhs_value],
  41 [yyval[]m4_ifval([$1], [.$1])])
  42
  43
  44 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  45 # --------------------------------------
  46 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  47 # symbols on RHS.
  48 m4_define([b4_rhs_value],
  49 [semantic_stack_@{m4_eval([$1 - $2])@}m4_ifval([$3], [.$3])])
  50
  51 m4_define_default([b4_location_type], [Location])
  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 [location_stack_@{m4_eval([$1 - $2])@}])
  66
  67
  68 m4_define([b4_inherit],
  69           [m4_ifdef([b4_root],
  70                     [: public b4_root
  71 ],
  72                     [])])
  73
  74 m4_define([b4_param],
  75           [m4_ifdef([b4_root],
  76                     [,
  77             const Param& param],
  78                     [])])
  79
  80 m4_define([b4_constructor],
  81           [m4_ifdef([b4_root],
  82                     [b4_root (param),
  83       ],
  84                     [])])
  85
  86
  87 # We do want M4 expansion after # for CPP macros.
  88 m4_changecom()
  89 m4_divert(0)dnl
  90 @output @output_header_name@
  91 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
  92              [2002])[
  93 /* FIXME: This is wrong, we want computed header guards.
  94    I don't know why the macros are missing now. :( */
  95 #ifndef PARSER_HEADER_H
  96 # define PARSER_HEADER_H
  97
  98 #include "stack.hh"
  99 #include "location.hh"
 100
 101 #include <string>
 102 #include <iostream>
 103
 104 /* Using locations.  */
 105 #define YYLSP_NEEDED ]b4_locations_flag[
 106
 107 ]b4_token_defines(b4_tokens)[
 108
 109 /* Copy the first part of user declarations.  */
 110 ]b4_pre_prologue[
 111
 112 ]/* Line __line__ of lalr1.cc.  */
 113 b4_syncline([@oline@], [@ofile@])[
 114
 115 /* Enabling traces.  */
 116 #ifndef YYDEBUG
 117 # define YYDEBUG ]b4_debug[
 118 #endif
 119
 120 /* Enabling verbose error message.  */
 121 #ifndef YYERROR_VERBOSE
 122 # define YYERROR_VERBOSE ]b4_error_verbose[
 123 #endif
 124
 125 #ifndef YYSTYPE
 126 ]m4_ifdef([b4_stype],
 127 [b4_syncline([b4_stype_line], [b4_filename])
 128 typedef union b4_stype yystype;
 129 /* Line __line__ of lalr1.cc.  */
 130 b4_syncline([@oline@], [@ofile@])],
 131 [typedef int yystype;])[
 132 # define YYSTYPE yystype
 133 #endif
 134
 135 /* Copy the second part of user declarations.  */
 136 ]b4_post_prologue[
 137
 138 ]/* Line __line__ of lalr1.cc.  */
 139 b4_syncline([@oline@], [@ofile@])[
 140 #ifndef YYLLOC_DEFAULT
 141 # define YYLLOC_DEFAULT(Current, Rhs, N) \
 142    Current.last_line = Rhs[N].last_line; \
 143    Current.last_column = Rhs[N].last_column;
 144 #endif
 145
 146 namespace yy
 147 {
 148   class ]b4_parser_class_name[;
 149
 150   template < typename P >
 151   struct Traits
 152   {
 153   };
 154
 155   template < >
 156   struct Traits< ]b4_parser_class_name[ >
 157   {
 158     typedef ]b4_int_type_for([b4_translate])[ TokenNumberType;
 159     typedef ]b4_int_type_for([b4_rhs])[       RhsNumberType;
 160     typedef int      StateType;
 161     typedef yystype  SemanticType;
 162     typedef ]b4_location_type[ LocationType;
 163   };
 164 }
 165
 166 namespace yy
 167 {
 168   class ]b4_parser_class_name b4_inherit[
 169   {
 170   public:
 171
 172     typedef Traits< ]b4_parser_class_name[ >::TokenNumberType TokenNumberType;
 173     typedef Traits< ]b4_parser_class_name[ >::RhsNumberType   RhsNumberType;
 174     typedef Traits< ]b4_parser_class_name[ >::StateType       StateType;
 175     typedef Traits< ]b4_parser_class_name[ >::SemanticType    SemanticType;
 176     typedef Traits< ]b4_parser_class_name[ >::LocationType    LocationType;
 177
 178     typedef Stack< StateType >    StateStack;
 179     typedef Stack< SemanticType > SemanticStack;
 180     typedef Stack< LocationType > LocationStack;
 181
 182 #if YYLSP_NEEDED
 183     ]b4_parser_class_name[ (bool debug,
 184             LocationType initlocation][]b4_param[) :
 185       ]b4_constructor[][debug_ (debug),
 186       cdebug_ (std::cerr),
 187       initlocation_ (initlocation)
 188 #else
 189     ]b4_parser_class_name[ (bool debug][]b4_param[) :
 190       ]b4_constructor[][debug_ (debug),
 191       cdebug_ (std::cerr)
 192 #endif
 193     {
 194     }
 195
 196     virtual ~]b4_parser_class_name[ ()
 197     {
 198     }
 199
 200     virtual int parse ();
 201
 202   private:
 203
 204     virtual void lex_ ();
 205     virtual void error_ ();
 206     virtual void print_ ();
 207
 208     /* Stacks.  */
 209     StateStack    state_stack_;
 210     SemanticStack semantic_stack_;
 211     LocationStack location_stack_;
 212
 213     /* Tables.  */
 214     static const ]b4_int_type_for([b4_pact])[ pact_[];
 215     static const ]b4_int_type_for([b4_pact])[ pact_ninf_;
 216     static const ]b4_int_type_for([b4_defact])[ defact_[];
 217     static const ]b4_int_type_for([b4_pgoto])[ pgoto_[];
 218     static const ]b4_int_type_for([b4_defgoto])[ defgoto_[];
 219     static const ]b4_int_type_for([b4_table])[ table_[];
 220     static const ]b4_int_type_for([b4_table])[ table_ninf_;
 221     static const ]b4_int_type_for([b4_check])[ check_[];
 222     static const ]b4_int_type_for([b4_r1])[ r1_[];
 223     static const ]b4_int_type_for([b4_r2])[ r2_[];
 224
 225 #if YYDEBUG || YYERROR_VERBOSE
 226     static const char* const name_[];
 227 #endif
 228
 229     /* More tables, for debugging.  */
 230 #if YYDEBUG
 231     static const RhsNumberType rhs_[];
 232     static const ]b4_int_type_for([b4_prhs])[ prhs_[];
 233     static const ]b4_int_type_for([b4_rline])[ rline_[];
 234     static const ]b4_int_type_for([b4_stos])[ stos_[];
 235     static const ]b4_int_type_for([b4_toknum])[ token_number_[];
 236 #endif
 237
 238     /* Even more tables.  */
 239     static inline TokenNumberType translate_ (int token);
 240
 241     /* Constants.  */
 242     static const int eof_;
 243     /* LAST_ -- Last index in TABLE_.  */
 244     static const int last_;
 245     static const int nnts_;
 246     static const int empty_;
 247     static const int final_;
 248     static const int terror_;
 249     static const int errcode_;
 250     static const int ntokens_;
 251     static const int initdepth_;
 252     static const unsigned user_token_number_max_;
 253     static const TokenNumberType undef_token_;
 254
 255     /* State.  */
 256     int n_;
 257     int len_;
 258     int state_;
 259
 260     /* Debugging.  */
 261     int debug_;
 262     std::ostream &cdebug_;
 263
 264     /* Lookahead and lookahead in internal form.  */
 265     int looka_;
 266     int ilooka_;
 267
 268     /* Message.  */
 269     std::string message;
 270
 271     /* Semantic value and location of lookahead token.  */
 272     SemanticType value;
 273     LocationType location;
 274
 275     /* @@$ and $$.  */
 276     SemanticType yyval;
 277     LocationType yyloc;
 278
 279     /* Initial location.  */
 280     LocationType initlocation_;
 281   };
 282 }
 283
 284 #endif /* ! defined PARSER_HEADER_H */]
 285 dnl
 286 @output @output_parser_name@
 287 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
 288              [2002])[
 289
 290 #include @output_header_name@
 291
 292 /* Enable debugging if requested.  */
 293 #if YYDEBUG
 294 # define YYCDEBUG    if (debug_) cdebug_
 295 #else /* !YYDEBUG */
 296 # define YYCDEBUG    if (0) cdebug_
 297 #endif /* !YYDEBUG */
 298
 299 int
 300 yy::]b4_parser_class_name[::parse ()
 301 {
 302   int nerrs = 0;
 303   int errstatus = 0;
 304
 305   /* Initialize stack.  */
 306   state_stack_ = StateStack (0);
 307   semantic_stack_ = SemanticStack (1);
 308   location_stack_ = LocationStack (1);
 309
 310   /* Start.  */
 311   state_ = 0;
 312   looka_ = empty_;
 313 #if YYLSP_NEEDED
 314   location = initlocation_;
 315 #endif
 316   YYCDEBUG << "Starting parse" << std::endl;
 317
 318   /* New state.  */
 319  yynewstate:
 320   state_stack_.push (state_);
 321   YYCDEBUG << "Entering state " << state_ << std::endl;
 322   goto yybackup;
 323
 324   /* Backup.  */
 325  yybackup:
 326
 327   /* Try to take a decision without lookahead.  */
 328   n_ = pact_[state_];
 329   if (n_ == pact_ninf_)
 330     goto yydefault;
 331
 332   /* Read a lookahead token.  */
 333   if (looka_ == empty_)
 334     {
 335       YYCDEBUG << "Reading a token: ";
 336       lex_ ();
 337     }
 338
 339   /* Convert token to internal form.  */
 340   if (looka_ <= 0)
 341     {
 342       looka_ = eof_;
 343       ilooka_ = 0;
 344       YYCDEBUG << "Now at end of input." << std::endl;
 345     }
 346   else
 347     {
 348       ilooka_ = translate_ (looka_);
 349 #if YYDEBUG
 350       if (debug_)
 351         {
 352           YYCDEBUG << "Next token is " << looka_
 353                  << " (" << name_[ilooka_];
 354           print_ ();
 355           YYCDEBUG << ')' << std::endl;
 356         }
 357 #endif
 358     }
 359
 360   n_ += ilooka_;
 361   if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
 362     goto yydefault;
 363
 364   /* Reduce or error.  */
 365   n_ = table_[n_];
 366   if (n_ < 0)
 367     {
 368       if (n_ == table_ninf_)
 369         goto yyerrlab;
 370       else
 371         {
 372           n_ = -n_;
 373           goto yyreduce;
 374         }
 375     }
 376   else if (n_ == 0)
 377     goto yyerrlab;
 378
 379   /* Accept?  */
 380   if (n_ == final_)
 381     goto yyacceptlab;
 382
 383   /* Shift the lookahead token.  */
 384   YYCDEBUG << "Shifting token " << looka_
 385          << " (" << name_[ilooka_] << "), ";
 386
 387   /* Discard the token being shifted unless it is eof.  */
 388   if (looka_ != eof_)
 389     looka_ = empty_;
 390
 391   semantic_stack_.push (value);
 392   location_stack_.push (location);
 393
 394   /* Count tokens shifted since error; after three, turn off error
 395      status.  */
 396   if (errstatus)
 397     --errstatus;
 398
 399   state_ = n_;
 400   goto yynewstate;
 401
 402   /* Default action.  */
 403  yydefault:
 404   n_ = defact_[state_];
 405   if (n_ == 0)
 406     goto yyerrlab;
 407   goto yyreduce;
 408
 409   /* Reduce.  */
 410  yyreduce:
 411   len_ = r2_[n_];
 412   if (len_)
 413     {
 414       yyval = semantic_stack_[len_ - 1];
 415       yyloc = location_stack_[len_ - 1];
 416     }
 417   else
 418     {
 419       yyval = semantic_stack_[0];
 420       yyloc = location_stack_[0];
 421     }
 422
 423 #if YYDEBUG
 424   if (debug_)
 425     {
 426       YYCDEBUG << "Reducing via rule " << n_ - 1
 427              << " (line " << rline_[n_] << "), ";
 428       for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
 429            0 <= rhs_[i]; ++i)
 430         YYCDEBUG << name_[rhs_[i]] << ' ';
 431       YYCDEBUG << "-> " << name_[r1_[n_]] << std::endl;
 432     }
 433 #endif
 434
 435   if (len_)
 436     {
 437       Slice< LocationType, LocationStack > slice (location_stack_, len_);
 438       YYLLOC_DEFAULT (yyloc, slice, len_);
 439     }
 440
 441   switch (n_)
 442     {
 443       ]b4_actions[
 444     }
 445
 446 ]/* Line __line__ of lalr1.cc.  */
 447 b4_syncline([@oline@], [@ofile@])[
 448
 449   state_stack_.pop (len_);
 450   semantic_stack_.pop (len_);
 451   location_stack_.pop (len_);
 452
 453 #if YYDEBUG
 454   if (debug_)
 455     {
 456       YYCDEBUG << "state stack now";
 457       for (StateStack::ConstIterator i = state_stack_.begin ();
 458            i != state_stack_.end (); ++i)
 459         YYCDEBUG << ' ' << *i;
 460       YYCDEBUG << std::endl;
 461     }
 462 #endif
 463
 464   semantic_stack_.push (yyval);
 465   location_stack_.push (yyloc);
 466
 467   /* Shift the result of the reduction.  */
 468   n_ = r1_[n_];
 469   state_ = pgoto_[n_ - ntokens_] + state_stack_[0];
 470   if (0 <= state_ && state_ <= last_ && check_[state_] == state_stack_[0])
 471     state_ = table_[state_];
 472   else
 473     state_ = defgoto_[n_ - ntokens_];
 474   goto yynewstate;
 475
 476   /* Report and recover from errors.  This is very incomplete.  */
 477  yyerrlab:
 478   /* If not already recovering from an error, report this error.  */
 479   if (!errstatus)
 480     {
 481       ++nerrs;
 482
 483 #if YYERROR_VERBOSE
 484       n_ = pact_[state_];
 485       if (pact_ninf_ < n_ && n_ < last_)
 486         {
 487           message = "syntax error, unexpected ";
 488           message += name_[ilooka_];
 489           {
 490             int count = 0;
 491             for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 492               if (check_[x + n_] == x && x != terror_)
 493                 ++count;
 494             if (count < 5)
 495               {
 496                 count = 0;
 497                 for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 498                   if (check_[x + n_] == x && x != terror_)
 499                     {
 500                       message += (!count++) ? ", expecting " : " or ";
 501                       message += name_[x];
 502                     }
 503               }
 504           }
 505         }
 506       else
 507 #endif
 508         message = "syntax error";
 509       error_ ();
 510     }
 511   goto yyerrlab1;
 512
 513   /* Error raised explicitly by an action.  */
 514  yyerrlab1:
 515   if (errstatus == 3)
 516     {
 517       /* If just tried and failed to reuse lookahead token after an
 518          error, discard it.  */
 519
 520       /* Return failure if at end of input.  */
 521       if (looka_ == eof_)
 522         goto yyabortlab;
 523       YYCDEBUG << "Discarding token " << looka_
 524              << " (" << name_[ilooka_] << ")." << std::endl;
 525       looka_ = empty_;
 526     }
 527
 528   /* Else will try to reuse lookahead token after shifting the error
 529      token.  */
 530
 531   errstatus = 3;
 532
 533   for (;;)
 534     {
 535       n_ = pact_[state_];
 536       if (n_ != pact_ninf_)
 537         {
 538           n_ += terror_;
 539           if (0 <= n_ && n_ <= last_ && check_[n_] == terror_)
 540             {
 541               n_ = table_[n_];
 542               if (0 < n_)
 543                 break;
 544             }
 545         }
 546
 547       /* Pop the current state because it cannot handle the error token.  */
 548       if (!state_stack_.height ())
 549         goto yyabortlab;
 550
 551 #if YYDEBUG
 552       if (debug_)
 553         {
 554           if (stos_[state_] < ntokens_)
 555             {
 556               YYCDEBUG << "Error: popping token "
 557                      << token_number_[stos_[state_]]
 558                      << " (" << name_[stos_[state_]];
 559 # ifdef YYPRINT
 560               YYPRINT (stderr, token_number_[stos_[state_]],
 561                        semantic_stack_.top ());
 562 # endif
 563               YYCDEBUG << ')' << std::endl;
 564             }
 565           else
 566             {
 567               YYCDEBUG << "Error: popping nonterminal ("
 568                      << name_[stos_[state_]] << ')' << std::endl;
 569             }
 570         }
 571 #endif
 572
 573       state_ = (state_stack_.pop (), state_stack_[0]);
 574       semantic_stack_.pop ();
 575       location_stack_.pop ();;
 576
 577 #if YYDEBUG
 578       if (debug_)
 579         {
 580           YYCDEBUG << "Error: state stack now";
 581           for (StateStack::ConstIterator i = state_stack_.begin ();
 582                i != state_stack_.end (); ++i)
 583             YYCDEBUG << ' ' << *i;
 584           YYCDEBUG << std::endl;
 585         }
 586 #endif
 587     }
 588
 589   if (n_ == final_)
 590     goto yyacceptlab;
 591
 592   YYCDEBUG << "Shifting error token, ";
 593
 594   semantic_stack_.push (value);
 595   location_stack_.push (location);
 596
 597   state_ = n_;
 598   goto yynewstate;
 599
 600   /* Accept.  */
 601  yyacceptlab:
 602   return 0;
 603
 604   /* Abort.  */
 605  yyabortlab:
 606   return 1;
 607 }
 608
 609 void
 610 yy::]b4_parser_class_name[::lex_ ()
 611 {
 612 #if YYLSP_NEEDED
 613   looka_ = yylex (&value, &location);
 614 #else
 615   looka_ = yylex (&value);
 616 #endif
 617 }
 618
 619 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 620    STATE-NUM.  */
 621 const ]b4_int_type_for([b4_pact]) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
 622 const ]b4_int_type_for([b4_pact])[
 623 yy::]b4_parser_class_name[::pact_[] =
 624 {
 625   ]b4_pact[
 626 };
 627
 628 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 629    doesn't specify something else to do.  Zero means the default is an
 630    error.  */
 631 const ]b4_int_type_for([b4_defact])[
 632 yy::]b4_parser_class_name[::defact_[] =
 633 {
 634   ]b4_defact[
 635 };
 636
 637 /* YYPGOTO[NTERM-NUM].  */
 638 const ]b4_int_type_for([b4_pgoto])[
 639 yy::]b4_parser_class_name[::pgoto_[] =
 640 {
 641   ]b4_pgoto[
 642 };
 643
 644 /* YYDEFGOTO[NTERM-NUM].  */
 645 const ]b4_int_type_for([b4_defgoto])[
 646 yy::]b4_parser_class_name[::defgoto_[] =
 647 {
 648   ]b4_defgoto[
 649 };
 650
 651 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 652    positive, shift that token.  If negative, reduce the rule which
 653    number is the opposite.  If zero, do what YYDEFACT says.  */
 654 const ]b4_int_type_for([b4_table]) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
 655 const ]b4_int_type_for([b4_table])[
 656 yy::]b4_parser_class_name[::table_[] =
 657 {
 658   ]b4_table[
 659 };
 660
 661 /* YYCHECK.  */
 662 const ]b4_int_type_for([b4_check])[
 663 yy::]b4_parser_class_name[::check_[] =
 664 {
 665   ]b4_check[
 666 };
 667
 668 #if YYDEBUG
 669 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 670    symbol of state STATE-NUM.  */
 671 const ]b4_int_type_for([b4_stos])[
 672 yy::]b4_parser_class_name[::stos_[] =
 673 {
 674   ]b4_stos[
 675 };
 676
 677 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
 678    to YYLEX-NUM.  */
 679 const ]b4_int_type_for([b4_toknum])[
 680 yy::]b4_parser_class_name[::token_number_[] =
 681 {
 682   ]b4_toknum[
 683 };
 684 #endif
 685
 686 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 687 const ]b4_int_type_for([b4_r1])[
 688 yy::]b4_parser_class_name[::r1_[] =
 689 {
 690   ]b4_r1[
 691 };
 692
 693 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 694 const ]b4_int_type_for([b4_r2])[
 695 yy::]b4_parser_class_name[::r2_[] =
 696 {
 697   ]b4_r2[
 698 };
 699
 700 #if YYDEBUG || YYERROR_VERBOSE
 701 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 702    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 703 const char*
 704 const yy::]b4_parser_class_name[::name_[] =
 705 {
 706   ]b4_tname[
 707 };
 708 #endif
 709
 710 #if YYDEBUG
 711 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 712 const yy::]b4_parser_class_name[::RhsNumberType
 713 yy::]b4_parser_class_name[::rhs_[] =
 714 {
 715   ]b4_rhs[
 716 };
 717
 718 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 719    YYRHS.  */
 720 const ]b4_int_type_for([b4_prhs])[
 721 yy::]b4_parser_class_name[::prhs_[] =
 722 {
 723   ]b4_prhs[
 724 };
 725
 726 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 727 const ]b4_int_type_for([b4_rline])[
 728 yy::]b4_parser_class_name[::rline_[] =
 729 {
 730   ]b4_rline[
 731 };
 732 #endif
 733
 734 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 735 yy::]b4_parser_class_name[::TokenNumberType
 736 yy::]b4_parser_class_name[::translate_ (int token)
 737 {
 738   static
 739   const TokenNumberType
 740   translate_[] =
 741   {
 742     ]b4_translate[
 743   };
 744   if ((unsigned) token <= user_token_number_max_)
 745     return translate_[token];
 746   else
 747     return undef_token_;
 748 }
 749
 750 const int yy::]b4_parser_class_name[::eof_ = 0;
 751 const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
 752 const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
 753 const int yy::]b4_parser_class_name[::empty_ = -2;
 754 const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
 755 const int yy::]b4_parser_class_name[::terror_ = 1;
 756 const int yy::]b4_parser_class_name[::errcode_ = 256;
 757 const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
 758 const int yy::]b4_parser_class_name[::initdepth_ = ]b4_stack_depth_init[;
 759
 760 const unsigned yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
 761 const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
 762
 763 ]b4_epilogue
 764 dnl
 765 @output stack.hh
 766 b4_copyright([2002])[
 767
 768 #ifndef BISON_STACK_HH
 769 # define BISON_STACK_HH
 770
 771 #include <deque>
 772
 773 namespace yy
 774 {
 775   template < class T, class S = std::deque< T > >
 776   class Stack
 777   {
 778   public:
 779
 780     typedef typename S::iterator Iterator;
 781     typedef typename S::const_iterator ConstIterator;
 782
 783     Stack () : seq_ ()
 784     {
 785     }
 786
 787     Stack (unsigned n) : seq_ (n)
 788     {
 789     }
 790
 791     inline
 792     T&
 793     operator [] (unsigned index)
 794     {
 795       return seq_[index];
 796     }
 797
 798     inline
 799     const T&
 800     operator [] (unsigned index) const
 801     {
 802       return seq_[index];
 803     }
 804
 805     inline
 806     void
 807     push (const T& t)
 808     {
 809       seq_.push_front (t);
 810     }
 811
 812     inline
 813     void
 814     pop (unsigned n = 1)
 815     {
 816       for (; n; --n)
 817         seq_.pop_front ();
 818     }
 819
 820     inline
 821     unsigned
 822     height () const
 823     {
 824       return seq_.size ();
 825     }
 826
 827     inline ConstIterator begin () const { return seq_.begin (); }
 828     inline ConstIterator end () const { return seq_.end (); }
 829
 830   private:
 831
 832     S seq_;
 833   };
 834
 835   template < class T, class S = Stack< T > >
 836   class Slice
 837   {
 838   public:
 839
 840     Slice (const S& stack,
 841            unsigned range) : stack_ (stack),
 842                              range_ (range)
 843     {
 844     }
 845
 846     inline
 847     const T&
 848     operator [] (unsigned index) const
 849     {
 850       return stack_[range_ - index];
 851     }
 852
 853   private:
 854
 855     const S& stack_;
 856     unsigned range_;
 857   };
 858 }
 859
 860 #endif // not BISON_STACK_HH]
 861 dnl
 862 @output location.hh
 863 b4_copyright([2002])[
 864
 865 #ifndef BISON_LOCATION_HH
 866 # define BISON_LOCATION_HH
 867
 868 namespace yy
 869 {
 870   struct Position
 871   {
 872     int line;
 873     int column;
 874   };
 875
 876   struct Location
 877   {
 878     Position first;
 879     Position last;
 880   };
 881 }
 882
 883 #endif // not BISON_LOCATION_HH]