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 # 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 m4_if(b4_defines_flag, 0, [],
  91 [@output @output_header_name@
  92 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
  93              [2002, 2003])[
  94 /* FIXME: This is wrong, we want computed header guards.
  95    I don't know why the macros are missing now. :( */
  96 #ifndef PARSER_HEADER_H
  97 # define PARSER_HEADER_H
  98
  99 #include "stack.hh"
 100 #include "location.hh"
 101
 102 #include <string>
 103 #include <iostream>
 104
 105 /* Using locations.  */
 106 #define YYLSP_NEEDED ]b4_locations_flag[
 107
 108 ]b4_token_defines(b4_tokens)[
 109
 110 /* Copy the first part of user declarations.  */
 111 ]b4_pre_prologue[
 112
 113 ]/* Line __line__ of lalr1.cc.  */
 114 b4_syncline([@oline@], [@ofile@])[
 115
 116 /* Enabling traces.  */
 117 #ifndef YYDEBUG
 118 # define YYDEBUG ]b4_debug[
 119 #endif
 120
 121 /* Enabling verbose error message.  */
 122 #ifndef YYERROR_VERBOSE
 123 # define YYERROR_VERBOSE ]b4_error_verbose[
 124 #endif
 125
 126 #ifndef YYSTYPE
 127 ]m4_ifdef([b4_stype],
 128 [b4_syncline([b4_stype_line], [b4_filename])
 129 typedef union b4_stype yystype;
 130 /* Line __line__ of lalr1.cc.  */
 131 b4_syncline([@oline@], [@ofile@])],
 132 [typedef int yystype;])[
 133 # define YYSTYPE yystype
 134 #endif
 135
 136 /* Copy the second part of user declarations.  */
 137 ]b4_post_prologue[
 138
 139 ]/* Line __line__ of lalr1.cc.  */
 140 b4_syncline([@oline@], [@ofile@])[
 141 #ifndef YYLLOC_DEFAULT
 142 # define YYLLOC_DEFAULT(Current, Rhs, N) \
 143    Current.end = Rhs[N].end;
 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, 2003])
 289
 290 m4_if(b4_defines_flag, 0, [], [#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 the stacks.  The initial state will be pushed in
 306      yynewstate, since the latter expects the semantical and the
 307      location values to have been already stored, initialize these
 308      stacks with a primary value.  */
 309   state_stack_ = StateStack (0);
 310   semantic_stack_ = SemanticStack (1);
 311   location_stack_ = LocationStack (1);
 312
 313   /* Start.  */
 314   state_ = 0;
 315   looka_ = empty_;
 316 #if YYLSP_NEEDED
 317   location = initlocation_;
 318 #endif
 319   YYCDEBUG << "Starting parse" << std::endl;
 320
 321   /* New state.  */
 322  yynewstate:
 323   state_stack_.push (state_);
 324   YYCDEBUG << "Entering state " << state_ << std::endl;
 325   goto yybackup;
 326
 327   /* Backup.  */
 328  yybackup:
 329
 330   /* Try to take a decision without lookahead.  */
 331   n_ = pact_[state_];
 332   if (n_ == pact_ninf_)
 333     goto yydefault;
 334
 335   /* Read a lookahead token.  */
 336   if (looka_ == empty_)
 337     {
 338       YYCDEBUG << "Reading a token: ";
 339       lex_ ();
 340     }
 341
 342   /* Convert token to internal form.  */
 343   if (looka_ <= 0)
 344     {
 345       looka_ = eof_;
 346       ilooka_ = 0;
 347       YYCDEBUG << "Now at end of input." << std::endl;
 348     }
 349   else
 350     {
 351       ilooka_ = translate_ (looka_);
 352 #if YYDEBUG
 353       if (debug_)
 354         {
 355           YYCDEBUG << "Next token is " << looka_
 356                  << " (" << name_[ilooka_];
 357           print_ ();
 358           YYCDEBUG << ')' << std::endl;
 359         }
 360 #endif
 361     }
 362
 363   n_ += ilooka_;
 364   if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
 365     goto yydefault;
 366
 367   /* Reduce or error.  */
 368   n_ = table_[n_];
 369   if (n_ < 0)
 370     {
 371       if (n_ == table_ninf_)
 372         goto yyerrlab;
 373       else
 374         {
 375           n_ = -n_;
 376           goto yyreduce;
 377         }
 378     }
 379   else if (n_ == 0)
 380     goto yyerrlab;
 381
 382   /* Accept?  */
 383   if (n_ == final_)
 384     goto yyacceptlab;
 385
 386   /* Shift the lookahead token.  */
 387 #if YYDEBUG
 388   YYCDEBUG << "Shifting token " << looka_
 389            << " (" << name_[ilooka_] << "), ";
 390 #endif
 391
 392   /* Discard the token being shifted unless it is eof.  */
 393   if (looka_ != eof_)
 394     looka_ = empty_;
 395
 396   semantic_stack_.push (value);
 397   location_stack_.push (location);
 398
 399   /* Count tokens shifted since error; after three, turn off error
 400      status.  */
 401   if (errstatus)
 402     --errstatus;
 403
 404   state_ = n_;
 405   goto yynewstate;
 406
 407   /* Default action.  */
 408  yydefault:
 409   n_ = defact_[state_];
 410   if (n_ == 0)
 411     goto yyerrlab;
 412   goto yyreduce;
 413
 414   /* Reduce.  */
 415  yyreduce:
 416   len_ = r2_[n_];
 417   if (len_)
 418     {
 419       yyval = semantic_stack_[len_ - 1];
 420       yyloc = location_stack_[len_ - 1];
 421     }
 422   else
 423     {
 424       yyval = semantic_stack_[0];
 425       yyloc = location_stack_[0];
 426     }
 427
 428 #if YYDEBUG
 429   if (debug_)
 430     {
 431       YYCDEBUG << "Reducing via rule " << n_ - 1
 432              << " (line " << rline_[n_] << "), ";
 433       for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
 434            0 <= rhs_[i]; ++i)
 435         YYCDEBUG << name_[rhs_[i]] << ' ';
 436       YYCDEBUG << "-> " << name_[r1_[n_]] << std::endl;
 437     }
 438 #endif
 439
 440   if (len_)
 441     {
 442       Slice< LocationType, LocationStack > slice (location_stack_, len_);
 443       YYLLOC_DEFAULT (yyloc, slice, len_);
 444     }
 445
 446   switch (n_)
 447     {
 448       ]b4_actions[
 449     }
 450
 451 ]/* Line __line__ of lalr1.cc.  */
 452 b4_syncline([@oline@], [@ofile@])[
 453
 454   state_stack_.pop (len_);
 455   semantic_stack_.pop (len_);
 456   location_stack_.pop (len_);
 457
 458 #if YYDEBUG
 459   if (debug_)
 460     {
 461       YYCDEBUG << "state stack now";
 462       for (StateStack::ConstIterator i = state_stack_.begin ();
 463            i != state_stack_.end (); ++i)
 464         YYCDEBUG << ' ' << *i;
 465       YYCDEBUG << std::endl;
 466     }
 467 #endif
 468
 469   semantic_stack_.push (yyval);
 470   location_stack_.push (yyloc);
 471
 472   /* Shift the result of the reduction.  */
 473   n_ = r1_[n_];
 474   state_ = pgoto_[n_ - ntokens_] + state_stack_[0];
 475   if (0 <= state_ && state_ <= last_ && check_[state_] == state_stack_[0])
 476     state_ = table_[state_];
 477   else
 478     state_ = defgoto_[n_ - ntokens_];
 479   goto yynewstate;
 480
 481   /* Report and recover from errors.  This is very incomplete.  */
 482  yyerrlab:
 483   /* If not already recovering from an error, report this error.  */
 484   if (!errstatus)
 485     {
 486       ++nerrs;
 487
 488 #if YYERROR_VERBOSE
 489       n_ = pact_[state_];
 490       if (pact_ninf_ < n_ && n_ < last_)
 491         {
 492           message = "syntax error, unexpected ";
 493           message += name_[ilooka_];
 494           {
 495             int count = 0;
 496             for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 497               if (check_[x + n_] == x && x != terror_)
 498                 ++count;
 499             if (count < 5)
 500               {
 501                 count = 0;
 502                 for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 503                   if (check_[x + n_] == x && x != terror_)
 504                     {
 505                       message += (!count++) ? ", expecting " : " or ";
 506                       message += name_[x];
 507                     }
 508               }
 509           }
 510         }
 511       else
 512 #endif
 513         message = "syntax error";
 514       error_ ();
 515     }
 516   goto yyerrlab1;
 517
 518   /* Error raised explicitly by an action.  */
 519  yyerrlab1:
 520   if (errstatus == 3)
 521     {
 522       /* If just tried and failed to reuse lookahead token after an
 523          error, discard it.  */
 524
 525       /* Return failure if at end of input.  */
 526       if (looka_ == eof_)
 527         goto yyabortlab;
 528 #if YYDEBUG
 529       YYCDEBUG << "Discarding token " << looka_
 530                << " (" << name_[ilooka_] << ")." << std::endl;
 531 #endif
 532       looka_ = empty_;
 533     }
 534
 535   /* Else will try to reuse lookahead token after shifting the error
 536      token.  */
 537
 538   errstatus = 3;
 539
 540   for (;;)
 541     {
 542       n_ = pact_[state_];
 543       if (n_ != pact_ninf_)
 544         {
 545           n_ += terror_;
 546           if (0 <= n_ && n_ <= last_ && check_[n_] == terror_)
 547             {
 548               n_ = table_[n_];
 549               if (0 < n_)
 550                 break;
 551             }
 552         }
 553
 554       /* Pop the current state because it cannot handle the error token.  */
 555       if (state_stack_.height () == 1)
 556         goto yyabortlab;
 557
 558 #if YYDEBUG
 559       if (debug_)
 560         {
 561           if (stos_[state_] < ntokens_)
 562             {
 563               YYCDEBUG << "Error: popping token "
 564                      << token_number_[stos_[state_]]
 565                      << " (" << name_[stos_[state_]];
 566 # ifdef YYPRINT
 567               YYPRINT (stderr, token_number_[stos_[state_]],
 568                        semantic_stack_.top ());
 569 # endif
 570               YYCDEBUG << ')' << std::endl;
 571             }
 572           else
 573             {
 574               YYCDEBUG << "Error: popping nonterminal ("
 575                      << name_[stos_[state_]] << ')' << std::endl;
 576             }
 577         }
 578 #endif
 579
 580       state_ = (state_stack_.pop (), state_stack_[0]);
 581       semantic_stack_.pop ();
 582       location_stack_.pop ();;
 583
 584 #if YYDEBUG
 585       if (debug_)
 586         {
 587           YYCDEBUG << "Error: state stack now";
 588           for (StateStack::ConstIterator i = state_stack_.begin ();
 589                i != state_stack_.end (); ++i)
 590             YYCDEBUG << ' ' << *i;
 591           YYCDEBUG << std::endl;
 592         }
 593 #endif
 594     }
 595
 596   if (n_ == final_)
 597     goto yyacceptlab;
 598
 599   YYCDEBUG << "Shifting error token, ";
 600
 601   semantic_stack_.push (value);
 602   location_stack_.push (location);
 603
 604   state_ = n_;
 605   goto yynewstate;
 606
 607   /* Accept.  */
 608  yyacceptlab:
 609   return 0;
 610
 611   /* Abort.  */
 612  yyabortlab:
 613   return 1;
 614 }
 615
 616 void
 617 yy::]b4_parser_class_name[::lex_ ()
 618 {
 619 #if YYLSP_NEEDED
 620   looka_ = yylex (&value, &location);
 621 #else
 622   looka_ = yylex (&value);
 623 #endif
 624 }
 625
 626 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 627    STATE-NUM.  */
 628 const ]b4_int_type_for([b4_pact]) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
 629 const ]b4_int_type_for([b4_pact])[
 630 yy::]b4_parser_class_name[::pact_[] =
 631 {
 632   ]b4_pact[
 633 };
 634
 635 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 636    doesn't specify something else to do.  Zero means the default is an
 637    error.  */
 638 const ]b4_int_type_for([b4_defact])[
 639 yy::]b4_parser_class_name[::defact_[] =
 640 {
 641   ]b4_defact[
 642 };
 643
 644 /* YYPGOTO[NTERM-NUM].  */
 645 const ]b4_int_type_for([b4_pgoto])[
 646 yy::]b4_parser_class_name[::pgoto_[] =
 647 {
 648   ]b4_pgoto[
 649 };
 650
 651 /* YYDEFGOTO[NTERM-NUM].  */
 652 const ]b4_int_type_for([b4_defgoto])[
 653 yy::]b4_parser_class_name[::defgoto_[] =
 654 {
 655   ]b4_defgoto[
 656 };
 657
 658 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 659    positive, shift that token.  If negative, reduce the rule which
 660    number is the opposite.  If zero, do what YYDEFACT says.  */
 661 const ]b4_int_type_for([b4_table]) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
 662 const ]b4_int_type_for([b4_table])[
 663 yy::]b4_parser_class_name[::table_[] =
 664 {
 665   ]b4_table[
 666 };
 667
 668 /* YYCHECK.  */
 669 const ]b4_int_type_for([b4_check])[
 670 yy::]b4_parser_class_name[::check_[] =
 671 {
 672   ]b4_check[
 673 };
 674
 675 #if YYDEBUG
 676 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
 677    symbol of state STATE-NUM.  */
 678 const ]b4_int_type_for([b4_stos])[
 679 yy::]b4_parser_class_name[::stos_[] =
 680 {
 681   ]b4_stos[
 682 };
 683
 684 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
 685    to YYLEX-NUM.  */
 686 const ]b4_int_type_for([b4_toknum])[
 687 yy::]b4_parser_class_name[::token_number_[] =
 688 {
 689   ]b4_toknum[
 690 };
 691 #endif
 692
 693 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 694 const ]b4_int_type_for([b4_r1])[
 695 yy::]b4_parser_class_name[::r1_[] =
 696 {
 697   ]b4_r1[
 698 };
 699
 700 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 701 const ]b4_int_type_for([b4_r2])[
 702 yy::]b4_parser_class_name[::r2_[] =
 703 {
 704   ]b4_r2[
 705 };
 706
 707 #if YYDEBUG || YYERROR_VERBOSE
 708 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 709    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 710 const char*
 711 const yy::]b4_parser_class_name[::name_[] =
 712 {
 713   ]b4_tname[
 714 };
 715 #endif
 716
 717 #if YYDEBUG
 718 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 719 const yy::]b4_parser_class_name[::RhsNumberType
 720 yy::]b4_parser_class_name[::rhs_[] =
 721 {
 722   ]b4_rhs[
 723 };
 724
 725 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 726    YYRHS.  */
 727 const ]b4_int_type_for([b4_prhs])[
 728 yy::]b4_parser_class_name[::prhs_[] =
 729 {
 730   ]b4_prhs[
 731 };
 732
 733 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 734 const ]b4_int_type_for([b4_rline])[
 735 yy::]b4_parser_class_name[::rline_[] =
 736 {
 737   ]b4_rline[
 738 };
 739 #endif
 740
 741 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 742 yy::]b4_parser_class_name[::TokenNumberType
 743 yy::]b4_parser_class_name[::translate_ (int token)
 744 {
 745   static
 746   const TokenNumberType
 747   translate_[] =
 748   {
 749     ]b4_translate[
 750   };
 751   if ((unsigned) token <= user_token_number_max_)
 752     return translate_[token];
 753   else
 754     return undef_token_;
 755 }
 756
 757 const int yy::]b4_parser_class_name[::eof_ = 0;
 758 const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
 759 const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
 760 const int yy::]b4_parser_class_name[::empty_ = -2;
 761 const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
 762 const int yy::]b4_parser_class_name[::terror_ = 1;
 763 const int yy::]b4_parser_class_name[::errcode_ = 256;
 764 const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
 765 const int yy::]b4_parser_class_name[::initdepth_ = ]b4_stack_depth_init[;
 766
 767 const unsigned yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
 768 const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
 769
 770 ]b4_epilogue
 771 dnl
 772 @output stack.hh
 773 b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003])[
 774
 775 #ifndef BISON_STACK_HH
 776 # define BISON_STACK_HH
 777
 778 #include <deque>
 779
 780 namespace yy
 781 {
 782   template < class T, class S = std::deque< T > >
 783   class Stack
 784   {
 785   public:
 786
 787     typedef typename S::iterator Iterator;
 788     typedef typename S::const_iterator ConstIterator;
 789
 790     Stack () : seq_ ()
 791     {
 792     }
 793
 794     Stack (unsigned n) : seq_ (n)
 795     {
 796     }
 797
 798     inline
 799     T&
 800     operator [] (unsigned index)
 801     {
 802       return seq_[index];
 803     }
 804
 805     inline
 806     const T&
 807     operator [] (unsigned index) const
 808     {
 809       return seq_[index];
 810     }
 811
 812     inline
 813     void
 814     push (const T& t)
 815     {
 816       seq_.push_front (t);
 817     }
 818
 819     inline
 820     void
 821     pop (unsigned n = 1)
 822     {
 823       for (; n; --n)
 824         seq_.pop_front ();
 825     }
 826
 827     inline
 828     unsigned
 829     height () const
 830     {
 831       return seq_.size ();
 832     }
 833
 834     inline ConstIterator begin () const { return seq_.begin (); }
 835     inline ConstIterator end () const { return seq_.end (); }
 836
 837   private:
 838
 839     S seq_;
 840   };
 841
 842   template < class T, class S = Stack< T > >
 843   class Slice
 844   {
 845   public:
 846
 847     Slice (const S& stack,
 848            unsigned range) : stack_ (stack),
 849                              range_ (range)
 850     {
 851     }
 852
 853     inline
 854     const T&
 855     operator [] (unsigned index) const
 856     {
 857       return stack_[range_ - index];
 858     }
 859
 860   private:
 861
 862     const S& stack_;
 863     unsigned range_;
 864   };
 865 }
 866
 867 #endif // not BISON_STACK_HH]
 868 dnl
 869 @output location.hh
 870 b4_copyright([Location class for Bison C++ parsers], [2002, 2003])[
 871
 872 #ifndef BISON_LOCATION_HH
 873 # define BISON_LOCATION_HH
 874
 875 # include <iostream>
 876 # include <string>
 877
 878 namespace yy
 879 {
 880   class Position
 881   {
 882   public:
 883     Position ()
 884       : filename (), line (1), column (0)
 885     {}
 886
 887     std::string filename;
 888     int line;
 889     int column;
 890   };
 891
 892   inline std::ostream&
 893   operator<< (std::ostream& ostr, const Position& pos)
 894   {
 895     if (pos.filename != "")
 896       ostr << pos.filename << ':';
 897     ostr << pos.line << '.' << pos.column;
 898     return ostr;
 899   }
 900
 901   inline Position
 902   operator- (const Position& pos, int col)
 903   {
 904     Position res (pos);
 905     res.column -= col;
 906     return res;
 907   }
 908
 909
 910   class Location
 911   {
 912   public:
 913     Position begin;
 914     Position end;
 915   };
 916
 917   /* Don't issue twice the line number when the location is on a single
 918      line.  */
 919
 920   inline std::ostream&
 921   operator<< (std::ostream& ostr, const Location& pos)
 922   {
 923     ostr << pos.begin;
 924     if (pos.begin.filename != pos.end.filename)
 925       ostr << '-' << pos.end - 1;
 926     else if (pos.begin.line != pos.end.line)
 927       ostr << '-' << pos.end.line  << '.' << pos.end.column - 1;
 928     else if (pos.begin.column != pos.end.column - 1)
 929       ostr << '-' << pos.end.column - 1;
 930     return ostr;
 931   }
 932
 933 }
 934
 935 #endif // not BISON_LOCATION_HH]