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