data/bison.c++

   1 #output "b4_output_prefix[]b4_output_infix[]-class.hh"
   2 /* -*- C++ -*- */
   3
   4 /* A Bison parser, made from %%filename,
   5    by GNU bison %%version.  */
   6
   7 /* Skeleton output parser for bison,
   8    Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* As a special exception, when this file is copied by Bison into a
  26    Bison output file, you may use that output file without restriction.
  27    This special exception was added by the Free Software Foundation
  28    in version 1.24 of Bison.  */
  29
  30 #include "stack.hh"
  31 #include "location.hh"
  32
  33 b4_prologue
  34
  35 // FIXME: This should be defined in traits, not here.
  36 typedef b4_stype yystype;
  37
  38 namespace yy
  39 {
  40   class b4_name;
  41
  42   template < typename P >
  43   struct Traits
  44   {
  45   };
  46
  47   template < >
  48   struct Traits< b4_name >
  49   {
  50     typedef int      StateType;
  51     typedef yystype  SemanticType;
  52     typedef b4_ltype LocationType;
  53   };
  54 }
  55
  56 namespace yy
  57 {
  58   class b4_name
  59   {
  60   public:
  61
  62     typedef Traits< b4_name >::StateType    StateType;
  63     typedef Traits< b4_name >::SemanticType SemanticType;
  64     typedef Traits< b4_name >::LocationType LocationType;
  65
  66     typedef Stack< StateType >    StateStack;
  67     typedef Stack< SemanticType > SemanticStack;
  68     typedef Stack< LocationType > LocationStack;
  69
  70     b4_name (bool debug) : debug_ (debug)
  71     {
  72       looka = empty_;
  73     }
  74
  75     virtual ~b4_name ()
  76     {
  77     }
  78
  79     virtual int parse ();
  80
  81   private:
  82
  83     /* Call to lexical analyser.  */
  84     virtual
  85     void
  86     lex ()
  87     {
  88       looka = yylex (&value, &location);
  89     }
  90
  91     /* Stacks.  */
  92     StateStack    state_stack;
  93     SemanticStack semantic_stack;
  94     LocationStack location_stack;
  95
  96     /* Tables.  */
  97     static const short pact_[[]];
  98     static const short defact_[[]];
  99     static const short pgoto_[[]];
 100     static const short defgoto_[[]];
 101     static const short table_[[]];
 102     static const short check_[[]];
 103     static const short r1_[[]];
 104     static const short r2_[[]];
 105     static const char* const name_[[]];
 106
 107     /* More tables, for debugging.  */
 108     /* FIXME: These tables should not be printed when not in debug
 109        mode.  %%ifdef?  */
 110     static const short rhs_[[]];
 111     static const short prhs_[[]];
 112     static const short rline_[[]];
 113
 114     /* Even more tables.  */
 115     static inline char translate (int token);
 116
 117     /* Eof and empty.  */
 118     static const int eof_;
 119     static const int empty_;
 120     static const int ntokens_;
 121
 122     /* State.  */
 123     int n;
 124     int len;
 125     int debug_;
 126     int state;
 127
 128     /* Lookahead.  */
 129     int looka;
 130     int ilooka;
 131
 132     /* @$ and $$.  */
 133     SemanticType value;
 134     LocationType location;
 135   };
 136 }
 137
 138 #output "b4_output_prefix[]b4_output_infix[].cc"
 139 #include "b4_output_prefix[]b4_output_infix-class.hh"
 140
 141 /* Enabling traces.  */
 142 #ifndef YYDEBUG
 143 # define YYDEBUG b4_debug
 144 #endif
 145
 146 /* Enable debugging if requested.  */
 147 #if YYDEBUG
 148
 149 # include <cstdio>
 150 # define YYFPRINTF std::fprintf
 151
 152 # define YYDPRINTF(Args)                        \
 153 do {                                            \
 154   if (debug_)                                   \
 155     YYFPRINTF Args;                             \
 156 } while (0)
 157 /* Nonzero means print parse trace. [The following comment makes no
 158    sense to me.  Could someone clarify it?  --akim] Since this is
 159    uninitialized, it does not stop multiple parsers from coexisting.
 160    */
 161 int yydebug;
 162 #else /* !YYDEBUG */
 163 # define YYDPRINTF(Args)
 164 #endif /* !YYDEBUG */
 165
 166 /* Tokens.  */
 167 b4_tokendef
 168
 169 int
 170 yy::b4_name::parse ()
 171 {
 172   /* Initialize stack.  */
 173   state_stack = StateStack (0);
 174   semantic_stack = SemanticStack (1);
 175   location_stack = LocationStack (1);
 176
 177   /* Reserve initial space.  The C parser needed that, but is it really
 178      useful here?  */
 179   state_stack.reserve (b4_initdepth);
 180   semantic_stack.reserve (b4_initdepth);
 181   location_stack.reserve (b4_initdepth);
 182
 183   /* Start.  */
 184   state = 0;
 185   YYDPRINTF ((stderr, "Starting parse\n"));
 186
 187   /* New state.  */
 188  yynewstate:
 189   state_stack.push (state);
 190   YYDPRINTF ((stderr, "Entering state %d\n", state));
 191   goto yybackup;
 192
 193   /* Backup.  */
 194  yybackup:
 195
 196   /* Try to take a decision without lookahead.  */
 197   n = pact_[[state]];
 198   if (n == b4_flag)
 199     goto yydefault;
 200
 201   /* Read a lookahead token.  */
 202   if (looka == empty_)
 203     {
 204       YYDPRINTF ((stderr, "Reading a token: "));
 205       lex ();
 206     }
 207
 208   /* Convert token to internal form.  */
 209   if (looka <= 0)
 210     {
 211       looka = eof_;
 212       ilooka = 0;
 213       YYDPRINTF ((stderr, "Now at end of input.\n"));
 214     }
 215   else
 216     {
 217       ilooka = translate (looka);
 218 #if YYDEBUG
 219       if (debug_)
 220         {
 221           YYFPRINTF (stderr, "Next token is %d (%s", looka, name_[[ilooka]]);
 222           YYFPRINTF (stderr, ")\n");
 223         }
 224 #endif
 225     }
 226
 227   n += ilooka;
 228   if (n < 0 || n > b4_last || check_[[n]] != ilooka)
 229     goto yydefault;
 230
 231   /* Reduce or error.  */
 232   n = table_[[n]];
 233   if (n < 0)
 234     {
 235       if (n == b4_flag)
 236         goto yyerrlab;
 237       else
 238         {
 239           n = -n;
 240           goto yyreduce;
 241         }
 242     }
 243   else if (n == 0)
 244     goto yyerrlab;
 245
 246   /* Accept?  */
 247   if (n == b4_final)
 248     goto yyacceptlab;
 249
 250   /* Shift the lookahead token.  */
 251   YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka, name_[[ilooka]]));
 252
 253   /* Discard the token being shifted unless it is eof.  */
 254   if (looka != eof_)
 255     looka = empty_;
 256
 257   semantic_stack.push (value);
 258   location_stack.push (location);
 259   state = n;
 260   goto yynewstate;
 261
 262   /* Default action.  */
 263  yydefault:
 264   n = defact_[[state]];
 265   if (n == 0)
 266     goto yyerrlab;
 267   goto yyreduce;
 268
 269   /* Reduce.  */
 270  yyreduce:
 271   len = r2_[[n]];
 272   if (len)
 273     {
 274       value = semantic_stack[[1 - len]];
 275       location = location_stack[[1 - len]];
 276     }
 277   else
 278     {
 279       // FIXME: This is truly ugly.
 280       value = semantic_stack[[0]];
 281       location = location_stack[[0]];
 282     }
 283
 284 #if YYDEBUG
 285   if (debug_)
 286     {
 287       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n - 1, rline_[[n]]);
 288       for (unsigned i = prhs_[[n]];
 289            rhs_[[i]] >= 0; ++i)
 290         YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]);
 291       YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n]]]);
 292     }
 293 #endif
 294
 295   {
 296     SemanticType& yyval (value);
 297     LocationType& yyloc (location);
 298     SemanticStack& yyvsp (semantic_stack);
 299     LocationStack& yylsp (location_stack);
 300
 301     switch (n)
 302       {
 303         b4_actions
 304       }
 305   }
 306
 307   state_stack.pop (len);
 308   semantic_stack.pop (len);
 309   location_stack.pop (len);
 310
 311 #if YYDEBUG
 312   if (debug_)
 313     {
 314       YYFPRINTF (stderr, "state stack now");
 315       for (StateStack::ConstIterator i = state_stack.begin ();
 316            i != state_stack.end (); ++i)
 317         YYFPRINTF (stderr, " %d", *i);
 318       YYFPRINTF (stderr, "\n");
 319     }
 320 #endif
 321
 322   semantic_stack.push (value);
 323   location_stack.push (location);
 324
 325   /* Shift the result of the reduction.  */
 326   n = r1_[[n]];
 327   state = pgoto_[[n - ntokens_]] + state_stack[[0]];
 328   if (state >= 0 && state <= b4_last && check_[[state]] == state_stack[[0]])
 329     state = table_[[state]];
 330   else
 331     state = defgoto_[[n - ntokens_]];
 332   goto yynewstate;
 333
 334   /* Report and recover from errors.  This is very incomplete.  */
 335  yyerrlab:
 336   std::cerr << "Parse error." << std::endl; // FIXME: Need something like yyerror?
 337   return 1;
 338
 339   /* Accept.  */
 340  yyacceptlab:
 341   return 0;
 342 }
 343
 344 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 345    STATE-NUM.  */
 346 const short
 347 yy::b4_name::pact_[[]] =
 348 {
 349   b4_pact
 350 };
 351
 352 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 353    doesn't specify something else to do.  Zero means the default is an
 354    error.  */
 355 const short
 356 yy::b4_name::defact_[[]] =
 357 {
 358   b4_defact
 359 };
 360
 361 /* YYPGOTO[NTERM-NUM].  */
 362 const short
 363 yy::b4_name::pgoto_[[]] =
 364 {
 365   b4_pgoto
 366 };
 367
 368 /* YYDEFGOTO[NTERM-NUM].  */
 369 const short
 370 yy::b4_name::defgoto_[[]] =
 371 {
 372   b4_defgoto
 373 };
 374
 375 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 376    positive, shift that token.  If negative, reduce the rule which
 377    number is the opposite.  If zero, do what YYDEFACT says.  */
 378 const short
 379 yy::b4_name::table_[[]] =
 380 {
 381   b4_table
 382 };
 383
 384 /* YYCHECK.  */
 385 const short
 386 yy::b4_name::check_[[]] =
 387 {
 388   b4_check
 389 };
 390
 391 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 392 const short
 393 yy::b4_name::rline_[[]] =
 394 {
 395   b4_rline
 396 };
 397
 398 /*YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 399 const short
 400 yy::b4_name::r1_[[]] =
 401 {
 402   b4_r1
 403 };
 404
 405 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 406 const short
 407 yy::b4_name::r2_[[]] =
 408 {
 409   b4_r2
 410 };
 411
 412 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 413    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 414 const char*
 415 const yy::b4_name::name_[[]] =
 416 {
 417   b4_tname
 418 };
 419
 420 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 421 const short
 422 yy::b4_name::rhs_[[]] =
 423 {
 424   b4_rhs
 425 };
 426
 427 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 428    YYRHS.  */
 429 const short
 430 yy::b4_name::prhs_[[]] =
 431 {
 432   b4_prhs
 433 };
 434
 435 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 436 char
 437 yy::b4_name::translate (int token)
 438 {
 439   static
 440   const char
 441   translate_[[]] =
 442   {
 443     b4_translate
 444   };
 445   return ((unsigned)(token) <= b4_maxtok ? translate_[[token]] : b4_nsym);
 446 }
 447
 448 const int yy::b4_name::eof_ = 0;
 449 const int yy::b4_name::empty_ = -2;
 450 const int yy::b4_name::ntokens_ = b4_ntokens;
 451
 452 b4_epilogue
 453
 454 #output "stack.hh"
 455 #ifndef BISON_STACK_HH
 456 # define BISON_STACK_HH
 457
 458 #include <vector>
 459
 460 namespace yy
 461 {
 462   template < class T, class S = std::vector< T > >
 463   class Stack
 464   {
 465   public:
 466
 467     typedef typename S::iterator Iterator;
 468     typedef typename S::const_iterator ConstIterator;
 469
 470     Stack () : seq_ ()
 471     {
 472     }
 473
 474     Stack (unsigned n) : seq_ (n)
 475     {
 476     }
 477
 478     inline
 479     T&
 480     operator [[]] (int index)
 481     {
 482       return seq_[[seq_.size () - 1 + index]];
 483     }
 484
 485     inline
 486     const T&
 487     operator [[]] (int index) const
 488     {
 489       return seq_[[seq_.size () - 1 + index]];
 490     }
 491
 492     inline
 493     void
 494     push (const T& t)
 495     {
 496       seq_.push_back (t);
 497     }
 498
 499     inline
 500     void
 501     pop (unsigned n = 1)
 502     {
 503       for (; n; --n)
 504         seq_.pop_back ();
 505     }
 506
 507     inline
 508     void
 509     reserve (unsigned n)
 510     {
 511       seq_.reserve (n);
 512     }
 513
 514     inline ConstIterator begin () const { return seq_.begin (); }
 515     inline ConstIterator end () const { return seq_.end (); }
 516
 517   private:
 518
 519     S seq_;
 520   };
 521 }
 522
 523 #endif // not BISON_STACK_HH
 524
 525 #output "location.hh"
 526 #ifndef BISON_LOCATION_HH
 527 # define BISON_LOCATION_HH
 528
 529 namespace yy
 530 {
 531   struct Position
 532   {
 533     int line;
 534     int column;
 535   };
 536
 537   struct Location
 538   {
 539     Position first;
 540     Position last;
 541   };
 542 }
 543
 544 #endif // not BISON_LOCATION_HH
 545
 546 m4_if(b4_defines_flag, 0, [],
 547 [#output "b4_output_header_name"
 548 #ifndef b4_header_guard
 549 # define b4_header_guard
 550
 551 b4_tokendef
 552
 553 #ifndef YYSTYPE
 554 typedef b4_stype
 555 yystype;
 556 # define YYSTYPE yystype
 557 #endif
 558
 559 m4_if(b4_pure, [0],
 560 [extern YYSTYPE b4_prefix[]lval;])
 561
 562 m4_if(b4_locations_flag, [0], [],
 563 [#ifndef YYLTYPE
 564 typedef struct yyltype
 565 {
 566   int first_line;
 567   int first_column;
 568   int last_line;
 569   int last_column;
 570 } yyltype;
 571 # define YYLTYPE yyltype
 572 #endif
 573
 574 m4_if(b4_pure, [0],
 575 [extern YYLTYPE b4_prefix[]lloc;])
 576 ])
 577 #endif /* not b4_header_guard */
 578 ])