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   unsigned int yylno = rline_[yyrule];
 830   /* Print the symbols being reduced, and their result.  */
 831   cdebug_ << "Reducing via rule " << n_ - 1 << " (line " << yylno << "), ";
 832   for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
 833        0 <= rhs_[i]; ++i)
 834     cdebug_ << name_[rhs_[i]] << ' ';
 835   cdebug_ << "-> " << name_[r1_[n_]] << std::endl;
 836 }
 837 #endif // YYDEBUG
 838
 839 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 840 yy::]b4_parser_class_name[::TokenNumberType
 841 yy::]b4_parser_class_name[::translate_ (int token)
 842 {
 843   static
 844   const TokenNumberType
 845   translate_table[] =
 846   {
 847     ]b4_translate[
 848   };
 849   if ((unsigned) token <= user_token_number_max_)
 850     return translate_table[token];
 851   else
 852     return undef_token_;
 853 }
 854
 855 const int yy::]b4_parser_class_name[::eof_ = 0;
 856 const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
 857 const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
 858 const int yy::]b4_parser_class_name[::empty_ = -2;
 859 const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
 860 const int yy::]b4_parser_class_name[::terror_ = 1;
 861 const int yy::]b4_parser_class_name[::errcode_ = 256;
 862 const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
 863
 864 const unsigned yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
 865 const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
 866
 867 ]b4_epilogue
 868 dnl
 869 @output stack.hh
 870 b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003])[
 871
 872 #ifndef BISON_STACK_HH
 873 # define BISON_STACK_HH
 874
 875 #include <deque>
 876
 877 namespace yy
 878 {
 879   template < class T, class S = std::deque< T > >
 880   class Stack
 881   {
 882   public:
 883
 884     typedef typename S::iterator Iterator;
 885     typedef typename S::const_iterator ConstIterator;
 886
 887     Stack () : seq_ ()
 888     {
 889     }
 890
 891     Stack (unsigned n) : seq_ (n)
 892     {
 893     }
 894
 895     inline
 896     T&
 897     operator [] (unsigned i)
 898     {
 899       return seq_[i];
 900     }
 901
 902     inline
 903     const T&
 904     operator [] (unsigned i) const
 905     {
 906       return seq_[i];
 907     }
 908
 909     inline
 910     void
 911     push (const T& t)
 912     {
 913       seq_.push_front (t);
 914     }
 915
 916     inline
 917     void
 918     pop (unsigned n = 1)
 919     {
 920       for (; n; --n)
 921         seq_.pop_front ();
 922     }
 923
 924     inline
 925     unsigned
 926     height () const
 927     {
 928       return seq_.size ();
 929     }
 930
 931     inline ConstIterator begin () const { return seq_.begin (); }
 932     inline ConstIterator end () const { return seq_.end (); }
 933
 934   private:
 935
 936     S seq_;
 937   };
 938
 939   template < class T, class S = Stack< T > >
 940   class Slice
 941   {
 942   public:
 943
 944     Slice (const S& stack,
 945            unsigned range) : stack_ (stack),
 946                              range_ (range)
 947     {
 948     }
 949
 950     inline
 951     const T&
 952     operator [] (unsigned i) const
 953     {
 954       return stack_[range_ - i];
 955     }
 956
 957   private:
 958
 959     const S& stack_;
 960     unsigned range_;
 961   };
 962 }
 963
 964 #endif // not BISON_STACK_HH]
 965 dnl
 966 @output position.hh
 967 b4_copyright([Position class for Bison C++ parsers], [2002, 2003])[
 968
 969 /**
 970  ** \file position.hh
 971  ** Define the Location class.
 972  */
 973
 974 #ifndef BISON_POSITION_HH
 975 # define BISON_POSITION_HH
 976
 977 # include <iostream>
 978 # include <string>
 979
 980 namespace yy
 981 {
 982   /** \brief Abstract a Position. */
 983   class Position
 984   {
 985   public:
 986     /** \brief Initial column number. */
 987     static const unsigned int initial_column = 0;
 988     /** \brief Initial line number. */
 989     static const unsigned int initial_line = 1;
 990
 991     /** \name Ctor & dtor.
 992      ** \{ */
 993   public:
 994     /** \brief Construct a Position. */
 995     Position () :
 996       filename (),
 997       line (initial_line),
 998       column (initial_column)
 999     {
1000     }
1001     /** \} */
1002
1003
1004     /** \name Line and Column related manipulators
1005      ** \{ */
1006   public:
1007     /** \brief (line related) Advance to the COUNT next lines. */
1008     inline void lines (int count = 1)
1009     {
1010       column = initial_column;
1011       line += count;
1012     }
1013
1014     /** \brief (column related) Advance to the COUNT next columns. */
1015     inline void columns (int count = 1)
1016     {
1017       int leftmost = initial_column;
1018       int current  = column;
1019       if (leftmost <= current + count)
1020         column += count;
1021       else
1022         column = initial_column;
1023     }
1024     /** \} */
1025
1026   public:
1027     /** \brief File name to which this position refers. */
1028     std::string filename;
1029     /** \brief Current line number. */
1030     unsigned int line;
1031     /** \brief Current column number. */
1032     unsigned int column;
1033   };
1034
1035   /** \brief Add and assign a Position. */
1036   inline const Position&
1037   operator+= (Position& res, const int width)
1038   {
1039     res.columns (width);
1040     return res;
1041   }
1042
1043   /** \brief Add two Position objects. */
1044   inline const Position
1045   operator+ (const Position& begin, const int width)
1046   {
1047     Position res = begin;
1048     return res += width;
1049   }
1050
1051   /** \brief Add and assign a Position. */
1052   inline const Position&
1053   operator-= (Position& res, const int width)
1054   {
1055     return res += -width;
1056   }
1057
1058   /** \brief Add two Position objects. */
1059   inline const Position
1060   operator- (const Position& begin, const int width)
1061   {
1062     return begin + -width;
1063   }
1064
1065   /** \brief Intercept output stream redirection.
1066    ** \param ostr the destination output stream
1067    ** \param pos a reference to the Position to redirect
1068    */
1069   inline std::ostream&
1070   operator<< (std::ostream& ostr, const Position& pos)
1071   {
1072     if (!pos.filename.empty ())
1073       ostr << pos.filename << ':';
1074     return ostr << pos.line << '.' << pos.column;
1075   }
1076
1077 }
1078 #endif // not BISON_POSITION_HH]
1079 @output location.hh
1080 b4_copyright([Location class for Bison C++ parsers], [2002, 2003])[
1081
1082 /**
1083  ** \file location.hh
1084  ** Define the Location class.
1085  */
1086
1087 #ifndef BISON_LOCATION_HH
1088 # define BISON_LOCATION_HH
1089
1090 # include <iostream>
1091 # include <string>
1092 # include "position.hh"
1093
1094 namespace yy
1095 {
1096
1097   /** \brief Abstract a Location. */
1098   class Location
1099   {
1100     /** \name Ctor & dtor.
1101      ** \{ */
1102   public:
1103     /** \brief Construct a Location. */
1104     Location (void) :
1105       begin (),
1106       end ()
1107     {
1108     }
1109     /** \} */
1110
1111
1112     /** \name Line and Column related manipulators
1113      ** \{ */
1114   public:
1115     /** \brief Reset initial location to final location. */
1116     inline void step (void)
1117     {
1118       begin = end;
1119     }
1120
1121     /** \brief Extend the current location to the COUNT next columns. */
1122     inline void columns (unsigned int count = 1)
1123     {
1124       end += count;
1125     }
1126
1127     /** \brief Extend the current location to the COUNT next lines. */
1128     inline void lines (unsigned int count = 1)
1129     {
1130       end.lines (count);
1131     }
1132     /** \} */
1133
1134
1135   public:
1136     /** \brief Beginning of the located region. */
1137     Position begin;
1138     /** \brief End of the located region. */
1139     Position end;
1140   };
1141
1142   /** \brief Join two Location objects to create a Location. */
1143   inline const Location operator+ (const Location& begin, const Location& end)
1144   {
1145     Location res = begin;
1146     res.end = end.end;
1147     return res;
1148   }
1149
1150   /** \brief Add two Location objects */
1151   inline const Location operator+ (const Location& begin, unsigned width)
1152   {
1153     Location res = begin;
1154     res.columns (width);
1155     return res;
1156   }
1157
1158   /** \brief Add and assign a Location */
1159   inline Location &operator+= (Location& res, unsigned width)
1160   {
1161     res.columns (width);
1162     return res;
1163   }
1164
1165   /** \brief Intercept output stream redirection.
1166    ** \param ostr the destination output stream
1167    ** \param loc a reference to the Location to redirect
1168    **
1169    ** Avoid duplicate information.
1170    */
1171   inline std::ostream& operator<< (std::ostream& ostr, const Location& loc)
1172   {
1173     Position last = loc.end - 1;
1174     ostr << loc.begin;
1175     if (loc.begin.filename != last.filename)
1176       ostr << '-' << last;
1177     else if (loc.begin.line != last.line)
1178       ostr << '-' << last.line  << '.' << last.column;
1179     else if (loc.begin.column != last.column)
1180       ostr << '-' << last.column;
1181     return ostr;
1182   }
1183
1184 }
1185
1186 #endif // not BISON_LOCATION_HH]