/[bison]/bison/data/bison.c++
ViewVC logotype

Diff of /bison/data/bison.c++

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.7 by ra, Thu Feb 7 14:41:46 2002 UTC revision 1.8 by ra, Thu Feb 7 16:41:23 2002 UTC
# Line 1  Line 1 
1  #output "b4_output_prefix[]b4_output_infix[]-class.hh"  #output "b4_output_prefix[]b4_output_infix[]-class.hh"
2  /* -*- C++ -*- */  /* -*- C++ -*- */
3    
4  /* A Bison parser, made from %%filename,  /* A Bison parser, made from b4_filename,
5     by GNU bison %%version.  */     by GNU bison b4_version.  */
6    
7  /* Skeleton output parser for bison,  /* Skeleton output parser for bison,
8     Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.     Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
# Line 32  Line 32 
32    
33  b4_prologue  b4_prologue
34    
35    /* Enabling traces.  */
36    #ifndef YYDEBUG
37    # define YYDEBUG b4_debug
38    #endif
39    
40    /* Enabling verbose error message.  */
41    #ifndef YYERROR_VERBOSE
42    # define YYERROR_VERBOSE b4_error_verbose
43    #endif
44    
45    /* Using locations.  */
46    #define YYLSP_NEEDED b4_locations_flag
47    
48  // FIXME: This should be defined in traits, not here.  // FIXME: This should be defined in traits, not here.
49  typedef b4_stype yystype;  typedef b4_stype yystype;
50    
# Line 69  namespace yy Line 82  namespace yy
82    
83      b4_name (bool debug) : debug_ (debug)      b4_name (bool debug) : debug_ (debug)
84      {      {
       looka = empty_;  
85      }      }
86    
87      virtual ~b4_name ()      virtual ~b4_name ()
# Line 80  namespace yy Line 92  namespace yy
92    
93    private:    private:
94    
95        virtual void lex_ ();
96      virtual void error_ ();      virtual void error_ ();
97      virtual void print_ ();      virtual void print_ ();
98    
     /* Call to lexical analyser.  */  
     virtual  
     void  
     lex ()  
     {  
       looka = yylex (&value, &location);  
     }  
   
99      /* Stacks.  */      /* Stacks.  */
100      StateStack    state_stack;      StateStack    state_stack_;
101      SemanticStack semantic_stack;      SemanticStack semantic_stack_;
102      LocationStack location_stack;      LocationStack location_stack_;
103    
104      /* Tables.  */      /* Tables.  */
105      static const short pact_[[]];      static const short pact_[[]];
# Line 105  namespace yy Line 110  namespace yy
110      static const short check_[[]];      static const short check_[[]];
111      static const short r1_[[]];      static const short r1_[[]];
112      static const short r2_[[]];      static const short r2_[[]];
113    
114    #if YYDEBUG || YYERROR_VERBOSE
115      static const char* const name_[[]];      static const char* const name_[[]];
116    #endif
117    
118      /* More tables, for debugging.  */      /* More tables, for debugging.  */
119      /* FIXME: These tables should not be printed when not in debug  #if YYDEBUG
        mode.  %%ifdef?  */  
120      static const short rhs_[[]];      static const short rhs_[[]];
121      static const short prhs_[[]];      static const short prhs_[[]];
122      static const short rline_[[]];      static const short rline_[[]];
123    #endif
124    
125      /* Even more tables.  */      /* Even more tables.  */
126      static inline char translate (int token);      static inline char translate_ (int token);
127    
128      /* Constants.  */      /* Constants.  */
129      static const int eof_;      static const int eof_;
130        static const int last_;
131        static const int flag_;
132        static const int nnts_;
133        static const int nsym_;
134      static const int empty_;      static const int empty_;
135        static const int final_;
136      static const int terror_;      static const int terror_;
137      static const int errcode_;      static const int errcode_;
138      static const int ntokens_;      static const int ntokens_;
139        static const int initdepth_;
140        static const unsigned maxtok_;
141    
142      /* State.  */      /* State.  */
143      int n;      int n_;
144      int len;      int len_;
145      int debug_;      int debug_;
146      int state;      int state_;
147    
148      /* Lookahead.  */      /* Lookahead and lookahead in internal form.  */
149      int looka;      int looka_;
150      int ilooka;      int ilooka_;
151    
152      /* Message.  */      /* Message.  */
153      std::string message;      std::string message;
# Line 146  namespace yy Line 161  namespace yy
161  #output "b4_output_prefix[]b4_output_infix[].cc"  #output "b4_output_prefix[]b4_output_infix[].cc"
162  #include "b4_output_prefix[]b4_output_infix-class.hh"  #include "b4_output_prefix[]b4_output_infix-class.hh"
163    
 /* Enabling traces.  */  
 #ifndef YYDEBUG  
 # define YYDEBUG b4_debug  
 #endif  
   
164  /* Enable debugging if requested.  */  /* Enable debugging if requested.  */
165  #if YYDEBUG  #if YYDEBUG
   
166  # include <cstdio>  # include <cstdio>
167  # define YYFPRINTF std::fprintf  # define YYFPRINTF std::fprintf
   
168  # define YYDPRINTF(Args)                        \  # define YYDPRINTF(Args)                        \
169  do {                                            \  do {                                            \
170    if (debug_)                                   \    if (debug_)                                   \
171      YYFPRINTF Args;                             \      YYFPRINTF Args;                             \
172  } while (0)  } while (0)
 /* Nonzero means print parse trace. [The following comment makes no  
    sense to me.  Could someone clarify it?  --akim] Since this is  
    uninitialized, it does not stop multiple parsers from coexisting.  
    */  
 int yydebug;  
173  #else /* !YYDEBUG */  #else /* !YYDEBUG */
174  # define YYDPRINTF(Args)  # define YYDPRINTF(Args)
175  #endif /* !YYDEBUG */  #endif /* !YYDEBUG */
# Line 181  yy::b4_name::parse () Line 184  yy::b4_name::parse ()
184    int errstatus = 0;    int errstatus = 0;
185    
186    /* Initialize stack.  */    /* Initialize stack.  */
187    state_stack = StateStack (0);    state_stack_ = StateStack (0);
188    semantic_stack = SemanticStack (1);    semantic_stack_ = SemanticStack (1);
189    location_stack = LocationStack (1);    location_stack_ = LocationStack (1);
190    
191    /* Reserve initial space.  The C parser needed that, but is it really    /* Reserve initial space.  The C parser needed that, but is it really
192       useful here?  */       useful here?  */
193    state_stack.reserve (b4_initdepth);    state_stack_.reserve (initdepth_);
194    semantic_stack.reserve (b4_initdepth);    semantic_stack_.reserve (initdepth_);
195    location_stack.reserve (b4_initdepth);    location_stack_.reserve (initdepth_);
196    
197    /* Start.  */    /* Start.  */
198    state = 0;    state_ = 0;
199      looka_ = empty_;
200    YYDPRINTF ((stderr, "Starting parse\n"));    YYDPRINTF ((stderr, "Starting parse\n"));
201    
202    /* New state.  */    /* New state.  */
203   yynewstate:   yynewstate:
204    state_stack.push (state);    state_stack_.push (state_);
205    YYDPRINTF ((stderr, "Entering state %d\n", state));    YYDPRINTF ((stderr, "Entering state %d\n", state_));
206    goto yybackup;    goto yybackup;
207    
208    /* Backup.  */    /* Backup.  */
209   yybackup:   yybackup:
210    
211    /* Try to take a decision without lookahead.  */    /* Try to take a decision without lookahead.  */
212    n = pact_[[state]];    n_ = pact_[[state_]];
213    if (n == b4_flag)    if (n_ == flag_)
214      goto yydefault;      goto yydefault;
215    
216    /* Read a lookahead token.  */    /* Read a lookahead token.  */
217    if (looka == empty_)    if (looka_ == empty_)
218      {      {
219        YYDPRINTF ((stderr, "Reading a token: "));        YYDPRINTF ((stderr, "Reading a token: "));
220        lex ();        lex_ ();
221      }      }
222    
223    /* Convert token to internal form.  */    /* Convert token to internal form.  */
224    if (looka <= 0)    if (looka_ <= 0)
225      {      {
226        looka = eof_;        looka_ = eof_;
227        ilooka = 0;        ilooka_ = 0;
228        YYDPRINTF ((stderr, "Now at end of input.\n"));        YYDPRINTF ((stderr, "Now at end of input.\n"));
229      }      }
230    else    else
231      {      {
232        ilooka = translate (looka);        ilooka_ = translate_ (looka_);
233  #if YYDEBUG  #if YYDEBUG
234        if (debug_)        if (debug_)
235          {          {
236            YYFPRINTF (stderr, "Next token is %d (%s", looka, name_[[ilooka]]);            YYFPRINTF (stderr, "Next token is %d (%s", looka_, name_[[ilooka_]]);
237            print_ ();            print_ ();
238            YYFPRINTF (stderr, ")\n");            YYFPRINTF (stderr, ")\n");
239          }          }
240  #endif  #endif
241      }      }
242    
243    n += ilooka;    n_ += ilooka_;
244    if (n < 0 || n > b4_last || check_[[n]] != ilooka)    if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_)
245      goto yydefault;      goto yydefault;
246    
247    /* Reduce or error.  */    /* Reduce or error.  */
248    n = table_[[n]];    n_ = table_[[n_]];
249    if (n < 0)    if (n_ < 0)
250      {      {
251        if (n == b4_flag)        if (n_ == flag_)
252          goto yyerrlab;          goto yyerrlab;
253        else        else
254          {          {
255            n = -n;            n_ = -n_;
256            goto yyreduce;            goto yyreduce;
257          }          }
258      }      }
259    else if (n == 0)    else if (n_ == 0)
260      goto yyerrlab;      goto yyerrlab;
261        
262    /* Accept?  */    /* Accept?  */
263    if (n == b4_final)    if (n_ == final_)
264      goto yyacceptlab;      goto yyacceptlab;
265    
266    /* Shift the lookahead token.  */    /* Shift the lookahead token.  */
267    YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka, name_[[ilooka]]));    YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka_, name_[[ilooka_]]));
268    
269    /* Discard the token being shifted unless it is eof.  */    /* Discard the token being shifted unless it is eof.  */
270    if (looka != eof_)    if (looka_ != eof_)
271      looka = empty_;      looka_ = empty_;
272    
273    semantic_stack.push (value);    semantic_stack_.push (value);
274    location_stack.push (location);    location_stack_.push (location);
275    state = n;    state_ = n_;
276    goto yynewstate;    goto yynewstate;
277    
278    /* Default action.  */    /* Default action.  */
279   yydefault:   yydefault:
280    n = defact_[[state]];    n_ = defact_[[state_]];
281    if (n == 0)    if (n_ == 0)
282      goto yyerrlab;      goto yyerrlab;
283    goto yyreduce;    goto yyreduce;
284    
285    /* Reduce.  */    /* Reduce.  */
286   yyreduce:   yyreduce:
287    len = r2_[[n]];    len_ = r2_[[n_]];
288    if (len)    if (len_)
289      {      {
290        value = semantic_stack[[1 - len]];        value = semantic_stack_[[1 - len_]];
291        location = location_stack[[1 - len]];        location = location_stack_[[1 - len_]];
292      }      }
293    else    else
294      {      {
295        // FIXME: This is truly ugly.        value = semantic_stack_[[0]];
296        value = semantic_stack[[0]];        location = location_stack_[[0]];
       location = location_stack[[0]];  
297      }      }
298    
299  #if YYDEBUG  #if YYDEBUG
300    if (debug_)    if (debug_)
301      {      {
302        YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n - 1, rline_[[n]]);        YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n_ - 1, rline_[[n_]]);
303        for (unsigned i = prhs_[[n]];        for (unsigned i = prhs_[[n_]];
304             rhs_[[i]] >= 0; ++i)             rhs_[[i]] >= 0; ++i)
305          YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]);          YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]);
306        YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n]]]);        YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n_]]]);
307      }      }
308  #endif  #endif
309        
310    {    {
311      SemanticType& yyval (value);      SemanticType& yyval (value);
312      LocationType& yyloc (location);      LocationType& yyloc (location);
313      SemanticStack& yyvsp (semantic_stack);      SemanticStack& yyvsp (semantic_stack_);
314      LocationStack& yylsp (location_stack);      LocationStack& yylsp (location_stack_);
315    
316      switch (n)      switch (n_)
317        {        {
318          b4_actions          b4_actions
319        }        }
320    }    }
321        
322    state_stack.pop (len);    state_stack_.pop (len_);
323    semantic_stack.pop (len);    semantic_stack_.pop (len_);
324    location_stack.pop (len);    location_stack_.pop (len_);
325    
326  #if YYDEBUG  #if YYDEBUG
327    if (debug_)    if (debug_)
328      {      {
329        YYFPRINTF (stderr, "state stack now");        YYFPRINTF (stderr, "state stack now");
330        for (StateStack::ConstIterator i = state_stack.begin ();        for (StateStack::ConstIterator i = state_stack_.begin ();
331             i != state_stack.end (); ++i)             i != state_stack_.end (); ++i)
332          YYFPRINTF (stderr, " %d", *i);          YYFPRINTF (stderr, " %d", *i);
333        YYFPRINTF (stderr, "\n");        YYFPRINTF (stderr, "\n");
334      }      }
335  #endif  #endif
336        
337    semantic_stack.push (value);    semantic_stack_.push (value);
338    location_stack.push (location);    location_stack_.push (location);
339    
340    /* Shift the result of the reduction.  */    /* Shift the result of the reduction.  */
341    n = r1_[[n]];    n_ = r1_[[n_]];
342    state = pgoto_[[n - ntokens_]] + state_stack[[0]];    state_ = pgoto_[[n_ - ntokens_]] + state_stack_[[0]];
343    if (state >= 0 && state <= b4_last && check_[[state]] == state_stack[[0]])    if (state_ >= 0 && state_ <= last_ && check_[[state_]] == state_stack_[[0]])
344      state = table_[[state]];      state_ = table_[[state_]];
345    else    else
346      state = defgoto_[[n - ntokens_]];      state_ = defgoto_[[n_ - ntokens_]];
347    goto yynewstate;    goto yynewstate;
348    
349    /* Report and recover from errors.  This is very incomplete.  */    /* Report and recover from errors.  This is very incomplete.  */
# Line 350  yy::b4_name::parse () Line 353  yy::b4_name::parse ()
353      {      {
354        ++nerrs;        ++nerrs;
355                
356        // FIXME: Should be #if YYERROR_VERBOSE from here...  #if YYERROR_VERBOSE
357        n = pact_[[state]];        n_ = pact_[[state_]];
358        if (n > b4_flag && n < b4_last)        if (n_ > flag_ && n_ < last_)
359          {          {
360            message = "parse error, unexpected ";            message = "parse error, unexpected ";
361            message += name_[[ilooka]];            message += name_[[ilooka_]];
362            {            {
363              int count = 0;              int count = 0;
364              for (int x = (n < 0 ? -n : 0); x < b4_ntokens + b4_nnts; ++x)              for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
365                if (check_[[x + n]] == x)                if (check_[[x + n_]] == x)
366                  ++count;                  ++count;
367              if (count < 5)              if (count < 5)
368                {                {
369                  count = 0;                  count = 0;
370                  for (int x = (n < 0 ? -n : 0); x < b4_ntokens + b4_nnts; ++x)                  for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
371                    if (check_[[x + n]] == x)                    if (check_[[x + n_]] == x)
372                      {                      {
373                        message += (!count++) ? ", expecting " : " or ";                        message += (!count++) ? ", expecting " : " or ";
374                        message += name_[[x]];                        message += name_[[x]];
# Line 374  yy::b4_name::parse () Line 377  yy::b4_name::parse ()
377            }            }
378          }          }
379        else        else
380        // FIXME: to there...  #endif
381          message = "parse error";          message = "parse error";
382      }      }
383    error_ ();    error_ ();
# Line 388  yy::b4_name::parse () Line 391  yy::b4_name::parse ()
391           error, discard it.  */           error, discard it.  */
392    
393        /* Return failure if at end of input.  */        /* Return failure if at end of input.  */
394        if (looka == eof_)        if (looka_ == eof_)
395          goto yyabortlab;          goto yyabortlab;
396        YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka, name_[[ilooka]]));        YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka_, name_[[ilooka_]]));
397        looka = empty_;        looka_ = empty_;
398      }      }
399    
400    /* Else will try to reuse lookahead token after shifting the error    /* Else will try to reuse lookahead token after shifting the error
# Line 403  yy::b4_name::parse () Line 406  yy::b4_name::parse ()
406    /* Pop the current state because it cannot handle the error token.  */    /* Pop the current state because it cannot handle the error token.  */
407   yyerrdefault:   yyerrdefault:
408   yyerrpop:   yyerrpop:
409    if (!state_stack.height ())    if (!state_stack_.height ())
410      goto yyabortlab;      goto yyabortlab;
411    state = (state_stack.pop (), state_stack[[0]]);    state_ = (state_stack_.pop (), state_stack_[[0]]);
412    semantic_stack.pop ();    semantic_stack_.pop ();
413    location_stack.pop ();;    location_stack_.pop ();;
414    
415  #if YYDEBUG  #if YYDEBUG
416    if (debug_)    if (debug_)
417      {      {
418        YYFPRINTF (stderr, "Error: state stack now");        YYFPRINTF (stderr, "Error: state stack now");
419        for (StateStack::ConstIterator i = state_stack.begin ();        for (StateStack::ConstIterator i = state_stack_.begin ();
420             i != state_stack.end (); ++i)             i != state_stack_.end (); ++i)
421          YYFPRINTF (stderr, " %d", *i);          YYFPRINTF (stderr, " %d", *i);
422        YYFPRINTF (stderr, "\n");        YYFPRINTF (stderr, "\n");
423      }      }
424  #endif  #endif
425    
426   yyerrhandle:   yyerrhandle:
427    n = pact_[[state]];    n_ = pact_[[state_]];
428    if (n == b4_flag)    if (n_ == flag_)
429      goto yyerrdefault;      goto yyerrdefault;
430    
431    n += terror_;    n_ += terror_;
432    if (n < 0 || n > b4_last || check_[[n]] != terror_)    if (n_ < 0 || n_ > last_ || check_[[n_]] != terror_)
433      goto yyerrdefault;      goto yyerrdefault;
434    
435    n = table_[[n]];    n_ = table_[[n_]];
436    if (n < 0)    if (n_ < 0)
437      {      {
438        if (n == b4_flag)        if (n_ == flag_)
439          goto yyerrpop;          goto yyerrpop;
440        n = -n;        n_ = -n_;
441        goto yyreduce;        goto yyreduce;
442      }      }
443    else if (!n)    else if (!n_)
444      goto yyerrpop;      goto yyerrpop;
445    
446    if (n == b4_final)    if (n_ == final_)
447      goto yyacceptlab;      goto yyacceptlab;
448    
449    YYDPRINTF ((stderr, "Shifting error token, "));    YYDPRINTF ((stderr, "Shifting error token, "));
450    
451    semantic_stack.push (value);    semantic_stack_.push (value);
452    location_stack.push (location);    location_stack_.push (location);
453    
454    state = n;    state_ = n_;
455    goto yynewstate;    goto yynewstate;
456    
457    /* Accept.  */    /* Accept.  */
# Line 460  yy::b4_name::parse () Line 463  yy::b4_name::parse ()
463    return 1;    return 1;
464  }  }
465    
466    void
467    yy::b4_name::lex_ ()
468    {
469    #if YYLSP_NEEDED
470      looka_ = yylex (&value, &location);
471    #else
472      looka_ = yylex (&value);
473    #endif
474    }
475    
476  /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing  /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
477     STATE-NUM.  */     STATE-NUM.  */
478  const short  const short
479  yy::b4_name::pact_[[]] =  yy::b4_name::pact_[[]] =
480  {  {
481    b4_pact    b4_pact
# Line 471  yy::b4_name::pact_[[]] = Line 484  yy::b4_name::pact_[[]] =
484  /* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE  /* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE
485     doesn't specify something else to do.  Zero means the default is an     doesn't specify something else to do.  Zero means the default is an
486     error.  */     error.  */
487  const short  const short
488  yy::b4_name::defact_[[]] =  yy::b4_name::defact_[[]] =
489  {  {
490    b4_defact    b4_defact
491  };  };
492    
493  /* YYPGOTO[[NTERM-NUM]].  */  /* YYPGOTO[[NTERM-NUM]].  */
494  const short  const short
495  yy::b4_name::pgoto_[[]] =  yy::b4_name::pgoto_[[]] =
496  {  {
497    b4_pgoto    b4_pgoto
498  };  };
499    
500  /* YYDEFGOTO[[NTERM-NUM]].  */  /* YYDEFGOTO[[NTERM-NUM]].  */
501  const short  const short
502  yy::b4_name::defgoto_[[]] =  yy::b4_name::defgoto_[[]] =
503  {  {
504    b4_defgoto    b4_defgoto
# Line 494  yy::b4_name::defgoto_[[]] = Line 507  yy::b4_name::defgoto_[[]] =
507  /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If  /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
508     positive, shift that token.  If negative, reduce the rule which     positive, shift that token.  If negative, reduce the rule which
509     number is the opposite.  If zero, do what YYDEFACT says.  */     number is the opposite.  If zero, do what YYDEFACT says.  */
510  const short  const short
511  yy::b4_name::table_[[]] =  yy::b4_name::table_[[]] =
512  {  {
513    b4_table    b4_table
514  };  };
515    
516  /* YYCHECK.  */  /* YYCHECK.  */
517  const short  const short
518  yy::b4_name::check_[[]] =  yy::b4_name::check_[[]] =
519  {  {
520    b4_check    b4_check
521  };  };
522    
 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */  
 const short  
 yy::b4_name::rline_[[]] =  
 {  
   b4_rline  
 };  
   
523  /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */  /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
524  const short  const short
525  yy::b4_name::r1_[[]] =  yy::b4_name::r1_[[]] =
# Line 528  yy::b4_name::r2_[[]] = Line 534  yy::b4_name::r2_[[]] =
534    b4_r2    b4_r2
535  };  };
536    
537    #if YYDEBUG || YYERROR_VERBOSE
538  /* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.  /* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
539     First, the terminals, then, starting at YYNTOKENS, nonterminals. */     First, the terminals, then, starting at YYNTOKENS, nonterminals. */
540  const char*  const char*
# Line 535  const yy::b4_name::name_[[]] = Line 542  const yy::b4_name::name_[[]] =
542  {  {
543    b4_tname    b4_tname
544  };  };
545    #endif
546    
547    #if YYDEBUG
548  /* YYRHS -- A `-1'-separated list of the rules' RHS. */  /* YYRHS -- A `-1'-separated list of the rules' RHS. */
549  const short  const short
550  yy::b4_name::rhs_[[]] =  yy::b4_name::rhs_[[]] =
# Line 545  yy::b4_name::rhs_[[]] = Line 554  yy::b4_name::rhs_[[]] =
554    
555  /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in  /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
556     YYRHS.  */     YYRHS.  */
557  const short  const short
558  yy::b4_name::prhs_[[]] =  yy::b4_name::prhs_[[]] =
559  {  {
560    b4_prhs    b4_prhs
561  };  };
562    
563    /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
564    const short
565    yy::b4_name::rline_[[]] =
566    {
567      b4_rline
568    };
569    #endif
570    
571  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
572  char  char
573  yy::b4_name::translate (int token)  yy::b4_name::translate_ (int token)
574  {  {
575    static    static
576    const char    const char
# Line 561  yy::b4_name::translate (int token) Line 578  yy::b4_name::translate (int token)
578    {    {
579      b4_translate      b4_translate
580    };    };
581    return ((unsigned)(token) <= b4_maxtok ? translate_[[token]] : b4_nsym);    return ((unsigned)(token) <= maxtok_ ? translate_[[token]] : nsym_);
582  }  }
583    
584  const int yy::b4_name::eof_ = 0;  const int yy::b4_name::eof_ = 0;
585    const int yy::b4_name::last_ = b4_last;
586    const int yy::b4_name::flag_ = b4_flag;
587    const int yy::b4_name::nnts_ = b4_nnts;
588    const int yy::b4_name::nsym_ = b4_nsym;
589  const int yy::b4_name::empty_ = -2;  const int yy::b4_name::empty_ = -2;
590    const int yy::b4_name::final_ = b4_final;
591  const int yy::b4_name::terror_ = 1;  const int yy::b4_name::terror_ = 1;
592  const int yy::b4_name::errcode_ = 256;  const int yy::b4_name::errcode_ = 256;
593  const int yy::b4_name::ntokens_ = b4_ntokens;  const int yy::b4_name::ntokens_ = b4_ntokens;
594    const int yy::b4_name::initdepth_ = b4_initdepth;
595    
596    const unsigned yy::b4_name::maxtok_ = b4_maxtok;
597    
598  b4_epilogue  b4_epilogue
599    

Legend:
Removed from v.1.7  
changed lines
  Added in v.1.8

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26