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