data/bison.c++

   1 m4_divert(-1)
   2
   3 # b4_sint_type(MAX)
   4 # -----------------
   5 # Return the smallest signed int type able to handle the number MAX.
   6 m4_define([b4_sint_type],
   7 [m4_if(m4_eval([$1 <= 127]),        [1], [signed char],
   8        m4_eval([$1 <= 32767]),      [1], [signed short],
   9        [signed int])])
  10
  11
  12 # b4_uint_type(MAX)
  13 # -----------------
  14 # Return the smallest unsigned int type able to handle the number MAX.
  15 m4_define([b4_uint_type],
  16 [m4_if(m4_eval([$1 <= 255]),        [1], [unsigned char],
  17        m4_eval([$1 <= 65535]),      [1], [unsigned short],
  18        [unsigned int])])
  19
  20
  21 # b4_lhs_value([TYPE])
  22 # --------------------
  23 # Expansion of $<TYPE>$.
  24 m4_define([b4_lhs_value],
  25 [yyval[]m4_ifval([$1], [.$1])])
  26
  27
  28 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  29 # --------------------------------------
  30 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  31 # symbols on RHS.
  32 m4_define([b4_rhs_value],
  33 [semantic_stack_@<:@m4_eval([$1 - $2])@:>@m4_ifval([$3], [.$3])])
  34
  35
  36 # b4_lhs_location()
  37 # -----------------
  38 # Expansion of @$.
  39 m4_define([b4_lhs_location],
  40 [yyloc])
  41
  42
  43 # b4_rhs_location(RULE-LENGTH, NUM)
  44 # ---------------------------------
  45 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  46 # on RHS.
  47 m4_define([b4_rhs_location],
  48 [location_stack_@<:@m4_eval([$1 - $2])@:>@])
  49
  50
  51 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
  52 # -----------------------------------------
  53 # Output the definition of this token as #define.
  54 m4_define([b4_token_define],
  55 [#define $1 $2
  56 ])
  57
  58
  59 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
  60 # -------------------------------------------------------
  61 # Output the definition of the tokens as #define.
  62 m4_define([b4_token_defines],
  63 [m4_map([b4_token_define], [$@])])
  64
  65 m4_define_default([b4_input_suffix], [.y])
  66
  67 m4_define_default([b4_output_parser_suffix],
  68 [m4_translit(b4_input_suffix, [yY], [cC])])
  69
  70 m4_define_default([b4_output_parser_name],
  71 [b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
  72
  73
  74 m4_define_default([b4_output_header_suffix],
  75 [m4_translit(b4_input_suffix, [yY], [hH])])
  76
  77 m4_define_default([b4_output_header_name],
  78 [b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
  79
  80 m4_define_default([b4_header_guard],
  81                   [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
  82                                 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
  83
  84 m4_define([b4_inherit],
  85           [m4_ifdef([b4_root],
  86                     [: public b4_root
  87 ],
  88                     [])])
  89
  90 m4_define([b4_param],
  91           [m4_ifdef([b4_root],
  92                     [,
  93             const Param& param],
  94                     [])])
  95
  96 m4_define([b4_constructor],
  97           [m4_ifdef([b4_root],
  98                     [b4_root (param),
  99       ],
 100                     [])])
 101
 102 m4_define([b4_copyright],
 103           [/* -*- C++ -*- */
 104 /* A Bison parser, made from b4_filename,
 105    by GNU bison b4_version.  */
 106
 107 /* Skeleton output parser for bison,
 108    Copyright 2002 Free Software Foundation, Inc.
 109
 110    This program is free software; you can redistribute it and/or modify
 111    it under the terms of the GNU General Public License as published by
 112    the Free Software Foundation; either version 2, or (at your option)
 113    any later version.
 114
 115    This program is distributed in the hope that it will be useful,
 116    but WITHOUT ANY WARRANTY; without even the implied warranty of
 117    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 118    GNU General Public License for more details.
 119
 120    You should have received a copy of the GNU General Public License
 121    along with this program; if not, write to the Free Software
 122    Foundation, Inc., 59 Temple Place - Suite 330,
 123    Boston, MA 02111-1307, USA.  */
 124
 125 /* As a special exception, when this file is copied by Bison into a
 126    Bison output file, you may use that output file without restriction.
 127    This special exception was added by the Free Software Foundation
 128    in version 1.24 of Bison.  */])
 129
 130 m4_divert(0)dnl
 131 #output "b4_output_header_name"
 132 b4_copyright
 133 #ifndef b4_header_guard
 134 # define b4_header_guard
 135
 136 #include "stack.hh"
 137 #include "location.hh"
 138
 139 #include <string>
 140
 141 /* Using locations.  */
 142 #define YYLSP_NEEDED b4_locations_flag
 143
 144 /* Copy the first part of user declarations.  */
 145 b4_pre_prologue
 146
 147 /* Tokens.  */
 148 b4_token_defines(b4_tokens)
 149
 150 /* Enabling traces.  */
 151 #ifndef YYDEBUG
 152 # define YYDEBUG b4_debug
 153 #endif
 154
 155 /* Enabling verbose error message.  */
 156 #ifndef YYERROR_VERBOSE
 157 # define YYERROR_VERBOSE b4_error_verbose
 158 #endif
 159
 160 #ifndef YYSTYPE
 161 m4_ifdef([b4_stype_line],
 162 [#line b4_stype_line "b4_filename"
 163 ])dnl
 164 typedef b4_stype
 165 yystype;
 166 # define YYSTYPE yystype
 167 #endif
 168
 169 /* Copy the second part of user declarations.  */
 170 b4_post_prologue
 171
 172 #line __oline__  "__ofile__"
 173 #ifndef YYLLOC_DEFAULT
 174 # define YYLLOC_DEFAULT(Current, Rhs, N) \
 175    Current.last_line = Rhs[[N]].last_line; \
 176    Current.last_column = Rhs[[N]].last_column;
 177 #endif
 178
 179 m4_if(b4_locations_flag, [0], [],
 180 [#ifndef YYLTYPE
 181 typedef struct yyltype
 182 {
 183   int first_line;
 184   int first_column;
 185   int last_line;
 186   int last_column;
 187 } yyltype;
 188 # define YYLTYPE yyltype
 189 #endif])
 190
 191 namespace yy
 192 {
 193   class b4_name;
 194
 195   template < typename P >
 196   struct Traits
 197   {
 198   };
 199
 200   template < >
 201   struct Traits< b4_name >
 202   {
 203     typedef b4_uint_type(b4_translate_max) TokenNumberType;
 204     typedef b4_sint_type(b4_rhs_max)       RhsNumberType;
 205     typedef int      StateType;
 206     typedef yystype  SemanticType;
 207     typedef b4_ltype LocationType;
 208   };
 209 }
 210
 211 namespace yy
 212 {
 213   class b4_name b4_inherit
 214   {
 215   public:
 216
 217     typedef Traits< b4_name >::TokenNumberType TokenNumberType;
 218     typedef Traits< b4_name >::RhsNumberType   RhsNumberType;
 219     typedef Traits< b4_name >::StateType       StateType;
 220     typedef Traits< b4_name >::SemanticType    SemanticType;
 221     typedef Traits< b4_name >::LocationType    LocationType;
 222
 223     typedef Stack< StateType >    StateStack;
 224     typedef Stack< SemanticType > SemanticStack;
 225     typedef Stack< LocationType > LocationStack;
 226
 227 #if YYLSP_NEEDED
 228     b4_name (bool debug,
 229             LocationType initlocation[]b4_param) :
 230       b4_constructor[]debug_ (debug),
 231       initlocation_ (initlocation)
 232 #else
 233     b4_name (bool debug[]b4_param) :
 234       b4_constructor[]debug_ (debug)
 235 #endif
 236     {
 237     }
 238
 239     virtual ~b4_name ()
 240     {
 241     }
 242
 243     virtual int parse ();
 244
 245   private:
 246
 247     virtual void lex_ ();
 248     virtual void error_ ();
 249     virtual void print_ ();
 250
 251     /* Stacks.  */
 252     StateStack    state_stack_;
 253     SemanticStack semantic_stack_;
 254     LocationStack location_stack_;
 255
 256     /* Tables.  */
 257     static const short pact_[[]];
 258     static const short defact_[[]];
 259     static const short pgoto_[[]];
 260     static const short defgoto_[[]];
 261     static const short table_[[]];
 262     static const short check_[[]];
 263     static const b4_uint_type(b4_r1_max) r1_[[]];
 264     static const b4_uint_type(b4_r2_max) r2_[[]];
 265
 266 #if YYDEBUG || YYERROR_VERBOSE
 267     static const char* const name_[[]];
 268 #endif
 269
 270     /* More tables, for debugging.  */
 271 #if YYDEBUG
 272     static const RhsNumberType rhs_[[]];
 273     static const b4_uint_type(b4_prhs_max) prhs_[[]];
 274     static const b4_uint_type(b4_rline_max) rline_[[]];
 275     static const b4_uint_type(b4_stos_max) stos_[[]];
 276     static const short token_number_[[]];
 277 #endif
 278
 279     /* Even more tables.  */
 280     static inline TokenNumberType translate_ (int token);
 281
 282     /* Constants.  */
 283     static const int eof_;
 284     static const int last_;
 285     static const int flag_;
 286     static const int nnts_;
 287     static const int nsym_;
 288     static const int empty_;
 289     static const int final_;
 290     static const int terror_;
 291     static const int errcode_;
 292     static const int ntokens_;
 293     static const int initdepth_;
 294     static const unsigned user_token_number_max_;
 295     static const TokenNumberType undef_token_;
 296
 297     /* State.  */
 298     int n_;
 299     int len_;
 300     int debug_;
 301     int state_;
 302
 303     /* Lookahead and lookahead in internal form.  */
 304     int looka_;
 305     int ilooka_;
 306
 307     /* Message.  */
 308     std::string message;
 309
 310     /* Semantic value and location of lookahead token.  */
 311     SemanticType value;
 312     LocationType location;
 313
 314     /* @$ and $$.  */
 315     SemanticType yyval;
 316     LocationType yyloc;
 317
 318     /* Initial location.  */
 319     LocationType initlocation_;
 320   };
 321 }
 322
 323 #endif /* not b4_header_guard */
 324
 325 #output "b4_output_prefix[]b4_output_infix[].cc"
 326 b4_copyright
 327
 328 #include "b4_output_header_name"
 329
 330 /* Enable debugging if requested.  */
 331 #if YYDEBUG
 332 # include <cstdio>
 333 # define YYFPRINTF std::fprintf
 334 # define YYDPRINTF(Args)                        \
 335 do {                                            \
 336   if (debug_)                                   \
 337     YYFPRINTF Args;                             \
 338 } while (0)
 339 #else /* !YYDEBUG */
 340 # define YYDPRINTF(Args)
 341 #endif /* !YYDEBUG */
 342
 343 int
 344 yy::b4_name::parse ()
 345 {
 346   int nerrs = 0;
 347   int errstatus = 0;
 348
 349   /* Initialize stack.  */
 350   state_stack_ = StateStack (0);
 351   semantic_stack_ = SemanticStack (1);
 352   location_stack_ = LocationStack (1);
 353
 354   /* Start.  */
 355   state_ = 0;
 356   looka_ = empty_;
 357 #if YYLSP_NEEDED
 358   location = initlocation_;
 359 #endif
 360   YYDPRINTF ((stderr, "Starting parse\n"));
 361
 362   /* New state.  */
 363  yynewstate:
 364   state_stack_.push (state_);
 365   YYDPRINTF ((stderr, "Entering state %d\n", state_));
 366   goto yybackup;
 367
 368   /* Backup.  */
 369  yybackup:
 370
 371   /* Try to take a decision without lookahead.  */
 372   n_ = pact_[[state_]];
 373   if (n_ == flag_)
 374     goto yydefault;
 375
 376   /* Read a lookahead token.  */
 377   if (looka_ == empty_)
 378     {
 379       YYDPRINTF ((stderr, "Reading a token: "));
 380       lex_ ();
 381     }
 382
 383   /* Convert token to internal form.  */
 384   if (looka_ <= 0)
 385     {
 386       looka_ = eof_;
 387       ilooka_ = 0;
 388       YYDPRINTF ((stderr, "Now at end of input.\n"));
 389     }
 390   else
 391     {
 392       ilooka_ = translate_ (looka_);
 393 #if YYDEBUG
 394       if (debug_)
 395         {
 396           YYFPRINTF (stderr, "Next token is %d (%s", looka_, name_[[ilooka_]]);
 397           print_ ();
 398           YYFPRINTF (stderr, ")\n");
 399         }
 400 #endif
 401     }
 402
 403   n_ += ilooka_;
 404   if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_)
 405     goto yydefault;
 406
 407   /* Reduce or error.  */
 408   n_ = table_[[n_]];
 409   if (n_ < 0)
 410     {
 411       if (n_ == flag_)
 412         goto yyerrlab;
 413       else
 414         {
 415           n_ = -n_;
 416           goto yyreduce;
 417         }
 418     }
 419   else if (n_ == 0)
 420     goto yyerrlab;
 421
 422   /* Accept?  */
 423   if (n_ == final_)
 424     goto yyacceptlab;
 425
 426   /* Shift the lookahead token.  */
 427   YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka_, name_[[ilooka_]]));
 428
 429   /* Discard the token being shifted unless it is eof.  */
 430   if (looka_ != eof_)
 431     looka_ = empty_;
 432
 433   semantic_stack_.push (value);
 434   location_stack_.push (location);
 435
 436   /* Count tokens shifted since error; after three, turn off error
 437      status.  */
 438   if (errstatus)
 439     --errstatus;
 440
 441   state_ = n_;
 442   goto yynewstate;
 443
 444   /* Default action.  */
 445  yydefault:
 446   n_ = defact_[[state_]];
 447   if (n_ == 0)
 448     goto yyerrlab;
 449   goto yyreduce;
 450
 451   /* Reduce.  */
 452  yyreduce:
 453   len_ = r2_[[n_]];
 454   if (len_)
 455     {
 456       yyval = semantic_stack_[[len_ - 1]];
 457       yyloc = location_stack_[[len_ - 1]];
 458     }
 459   else
 460     {
 461       yyval = semantic_stack_[[0]];
 462       yyloc = location_stack_[[0]];
 463     }
 464
 465 #if YYDEBUG
 466   if (debug_)
 467     {
 468       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n_ - 1, rline_[[n_]]);
 469       for (b4_uint_type(b4_prhs_max) i = prhs_[[n_]];
 470            rhs_[[i]] >= 0; ++i)
 471         YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]);
 472       YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n_]]]);
 473     }
 474 #endif
 475
 476   if (len_)
 477     {
 478       Slice< LocationType, LocationStack > slice (location_stack_, len_);
 479       YYLLOC_DEFAULT (yyloc, slice, len_);
 480     }
 481
 482   switch (n_)
 483     {
 484       b4_actions
 485     }
 486
 487 /* Line __line__ of __file__.  */
 488 #line __oline__ "__ofile__"
 489
 490   state_stack_.pop (len_);
 491   semantic_stack_.pop (len_);
 492   location_stack_.pop (len_);
 493
 494 #if YYDEBUG
 495   if (debug_)
 496     {
 497       YYFPRINTF (stderr, "state stack now");
 498       for (StateStack::ConstIterator i = state_stack_.begin ();
 499            i != state_stack_.end (); ++i)
 500         YYFPRINTF (stderr, " %d", *i);
 501       YYFPRINTF (stderr, "\n");
 502     }
 503 #endif
 504
 505   semantic_stack_.push (yyval);
 506   location_stack_.push (yyloc);
 507
 508   /* Shift the result of the reduction.  */
 509   n_ = r1_[[n_]];
 510   state_ = pgoto_[[n_ - ntokens_]] + state_stack_[[0]];
 511   if (state_ >= 0 && state_ <= last_ && check_[[state_]] == state_stack_[[0]])
 512     state_ = table_[[state_]];
 513   else
 514     state_ = defgoto_[[n_ - ntokens_]];
 515   goto yynewstate;
 516
 517   /* Report and recover from errors.  This is very incomplete.  */
 518  yyerrlab:
 519   /* If not already recovering from an error, report this error.  */
 520   if (!errstatus)
 521     {
 522       ++nerrs;
 523
 524 #if YYERROR_VERBOSE
 525       n_ = pact_[[state_]];
 526       if (n_ > flag_ && n_ < last_)
 527         {
 528           message = "parse error, unexpected ";
 529           message += name_[[ilooka_]];
 530           {
 531             int count = 0;
 532             for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 533               if (check_[[x + n_]] == x)
 534                 ++count;
 535             if (count < 5)
 536               {
 537                 count = 0;
 538                 for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
 539                   if (check_[[x + n_]] == x)
 540                     {
 541                       message += (!count++) ? ", expecting " : " or ";
 542                       message += name_[[x]];
 543                     }
 544               }
 545           }
 546         }
 547       else
 548 #endif
 549         message = "parse error";
 550       error_ ();
 551     }
 552   goto yyerrlab1;
 553
 554   /* Error raised explicitly by an action.  */
 555  yyerrlab1:
 556   if (errstatus == 3)
 557     {
 558       /* If just tried and failed to reuse lookahead token after an
 559          error, discard it.  */
 560
 561       /* Return failure if at end of input.  */
 562       if (looka_ == eof_)
 563         goto yyabortlab;
 564       YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka_, name_[[ilooka_]]));
 565       looka_ = empty_;
 566     }
 567
 568   /* Else will try to reuse lookahead token after shifting the error
 569      token.  */
 570
 571   errstatus = 3;
 572
 573   for (;;)
 574     {
 575       n_ = pact_[[state_]];
 576       if (n_ != flag_)
 577         {
 578           n_ += terror_;
 579           if (0 <= n_ && n_ <= last_ && check_[[n_]] == terror_)
 580             {
 581               n_ = table_[[n_]];
 582               if (0 < n_)
 583                 break;
 584             }
 585         }
 586
 587       /* Pop the current state because it cannot handle the error token.  */
 588       if (!state_stack_.height ())
 589         goto yyabortlab;
 590
 591 #if YYDEBUG
 592       if (debug_)
 593         {
 594           if (stos_[[state_]] < ntokens_)
 595             {
 596               YYFPRINTF (stderr, "Error: popping token %d (%s",
 597                          token_number_[[stos_[state_]]],
 598                          name_[[stos_[state_]]]);
 599 # ifdef YYPRINT
 600               YYPRINT (stderr, token_number_[[stos_[state_]]],
 601                        semantic_stack_.top ());
 602 # endif
 603               YYFPRINTF (stderr, ")\n");
 604             }
 605           else
 606             {
 607               YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",
 608                          name_[[stos_[state_]]]);
 609             }
 610         }
 611 #endif
 612
 613       state_ = (state_stack_.pop (), state_stack_[[0]]);
 614       semantic_stack_.pop ();
 615       location_stack_.pop ();;
 616
 617 #if YYDEBUG
 618       if (debug_)
 619         {
 620           YYFPRINTF (stderr, "Error: state stack now");
 621           for (StateStack::ConstIterator i = state_stack_.begin ();
 622                i != state_stack_.end (); ++i)
 623             YYFPRINTF (stderr, " %d", *i);
 624           YYFPRINTF (stderr, "\n");
 625         }
 626 #endif
 627     }
 628
 629   if (n_ == final_)
 630     goto yyacceptlab;
 631
 632   YYDPRINTF ((stderr, "Shifting error token, "));
 633
 634   semantic_stack_.push (value);
 635   location_stack_.push (location);
 636
 637   state_ = n_;
 638   goto yynewstate;
 639
 640   /* Accept.  */
 641  yyacceptlab:
 642   return 0;
 643
 644   /* Abort.  */
 645  yyabortlab:
 646   return 1;
 647 }
 648
 649 void
 650 yy::b4_name::lex_ ()
 651 {
 652 #if YYLSP_NEEDED
 653   looka_ = yylex (&value, &location);
 654 #else
 655   looka_ = yylex (&value);
 656 #endif
 657 }
 658
 659 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
 660    STATE-NUM.  */
 661 const short
 662 yy::b4_name::pact_[[]] =
 663 {
 664   b4_pact
 665 };
 666
 667 /* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE
 668    doesn't specify something else to do.  Zero means the default is an
 669    error.  */
 670 const short
 671 yy::b4_name::defact_[[]] =
 672 {
 673   b4_defact
 674 };
 675
 676 /* YYPGOTO[[NTERM-NUM]].  */
 677 const short
 678 yy::b4_name::pgoto_[[]] =
 679 {
 680   b4_pgoto
 681 };
 682
 683 /* YYDEFGOTO[[NTERM-NUM]].  */
 684 const short
 685 yy::b4_name::defgoto_[[]] =
 686 {
 687   b4_defgoto
 688 };
 689
 690 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
 691    positive, shift that token.  If negative, reduce the rule which
 692    number is the opposite.  If zero, do what YYDEFACT says.  */
 693 const short
 694 yy::b4_name::table_[[]] =
 695 {
 696   b4_table
 697 };
 698
 699 /* YYCHECK.  */
 700 const short
 701 yy::b4_name::check_[[]] =
 702 {
 703   b4_check
 704 };
 705
 706 #if YYDEBUG
 707 /* STOS_[[STATE-NUM]] -- The (internal number of the) accessing
 708    symbol of state STATE-NUM.  */
 709 const b4_uint_type(b4_stos_max)
 710 yy::b4_name::stos_[[]] =
 711 {
 712   b4_stos
 713 };
 714
 715 /* TOKEN_NUMBER_[[YYLEX-NUM]] -- Internal token number corresponding
 716    to YYLEX-NUM.  */
 717 const short
 718 yy::b4_name::token_number_[[]] =
 719 {
 720   b4_toknum
 721 };
 722 #endif
 723
 724 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 725 const b4_uint_type(b4_r1_max)
 726 yy::b4_name::r1_[[]] =
 727 {
 728   b4_r1
 729 };
 730
 731 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
 732 const b4_uint_type(b4_r2_max)
 733 yy::b4_name::r2_[[]] =
 734 {
 735   b4_r2
 736 };
 737
 738 #if YYDEBUG || YYERROR_VERBOSE
 739 /* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
 740    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 741 const char*
 742 const yy::b4_name::name_[[]] =
 743 {
 744   b4_tname
 745 };
 746 #endif
 747
 748 #if YYDEBUG
 749 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 750 const yy::b4_name::RhsNumberType
 751 yy::b4_name::rhs_[[]] =
 752 {
 753   b4_rhs
 754 };
 755
 756 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
 757    YYRHS.  */
 758 const b4_uint_type(b4_prhs_max)
 759 yy::b4_name::prhs_[[]] =
 760 {
 761   b4_prhs
 762 };
 763
 764 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
 765 const b4_uint_type(b4_rline_max)
 766 yy::b4_name::rline_[[]] =
 767 {
 768   b4_rline
 769 };
 770 #endif
 771
 772 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 773 yy::b4_name::TokenNumberType
 774 yy::b4_name::translate_ (int token)
 775 {
 776   static
 777   const TokenNumberType
 778   translate_[[]] =
 779   {
 780     b4_translate
 781   };
 782   if ((unsigned) token <= user_token_number_max_)
 783     return translate_[[token]];
 784   else
 785     return undef_token_;
 786 }
 787
 788 const int yy::b4_name::eof_ = 0;
 789 const int yy::b4_name::last_ = b4_last;
 790 const int yy::b4_name::flag_ = b4_flag;
 791 const int yy::b4_name::nnts_ = b4_nnts;
 792 const int yy::b4_name::nsym_ = b4_nsym;
 793 const int yy::b4_name::empty_ = -2;
 794 const int yy::b4_name::final_ = b4_final;
 795 const int yy::b4_name::terror_ = 1;
 796 const int yy::b4_name::errcode_ = 256;
 797 const int yy::b4_name::ntokens_ = b4_ntokens;
 798 const int yy::b4_name::initdepth_ = b4_initdepth;
 799
 800 const unsigned yy::b4_name::user_token_number_max_ = b4_user_token_number_max;
 801 const yy::b4_name::TokenNumberType yy::b4_name::undef_token_ = b4_undef_token_number;
 802
 803 b4_epilogue
 804
 805 #output "stack.hh"
 806 b4_copyright
 807
 808 #ifndef BISON_STACK_HH
 809 # define BISON_STACK_HH
 810
 811 #include <deque>
 812
 813 namespace yy
 814 {
 815   template < class T, class S = std::deque< T > >
 816   class Stack
 817   {
 818   public:
 819
 820     typedef typename S::iterator Iterator;
 821     typedef typename S::const_iterator ConstIterator;
 822
 823     Stack () : seq_ ()
 824     {
 825     }
 826
 827     Stack (unsigned n) : seq_ (n)
 828     {
 829     }
 830
 831     inline
 832     T&
 833     operator [[]] (unsigned index)
 834     {
 835       return seq_[[index]];
 836     }
 837
 838     inline
 839     const T&
 840     operator [[]] (unsigned index) const
 841     {
 842       return seq_[[index]];
 843     }
 844
 845     inline
 846     void
 847     push (const T& t)
 848     {
 849       seq_.push_front (t);
 850     }
 851
 852     inline
 853     void
 854     pop (unsigned n = 1)
 855     {
 856       for (; n; --n)
 857         seq_.pop_front ();
 858     }
 859
 860     inline
 861     unsigned
 862     height () const
 863     {
 864       return seq_.size ();
 865     }
 866
 867     inline ConstIterator begin () const { return seq_.begin (); }
 868     inline ConstIterator end () const { return seq_.end (); }
 869
 870   private:
 871
 872     S seq_;
 873   };
 874
 875   template < class T, class S = Stack< T > >
 876   class Slice
 877   {
 878   public:
 879
 880     Slice (const S& stack,
 881            unsigned range) : stack_ (stack),
 882                              range_ (range)
 883     {
 884     }
 885
 886     inline
 887     const T&
 888     operator [[]] (unsigned index) const
 889     {
 890       return stack_[[range_ - index]];
 891     }
 892
 893   private:
 894
 895     const S& stack_;
 896     unsigned range_;
 897   };
 898 }
 899
 900 #endif // not BISON_STACK_HH
 901
 902 #output "location.hh"
 903 b4_copyright
 904
 905 #ifndef BISON_LOCATION_HH
 906 # define BISON_LOCATION_HH
 907
 908 namespace yy
 909 {
 910   struct Position
 911   {
 912     int line;
 913     int column;
 914   };
 915
 916   struct Location
 917   {
 918     Position first;
 919     Position last;
 920   };
 921 }
 922
 923 #endif // not BISON_LOCATION_HH