data/lalr1.cc

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