source: trunk/contrib/bison-2.4.2/share/bison/lalr1.cc @ 1935

Last change on this file since 1935 was 1933, checked in by sam, 10 years ago

contrib: add Bison and Flex executables for Windows.

File size: 29.9 KB
Line 
1# C++ skeleton for Bison
2
3# Copyright (C) 2002-2010 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 3 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, see <http://www.gnu.org/licenses/>.
17
18m4_include(b4_pkgdatadir/[c++.m4])
19
20m4_define([b4_parser_class_name],
21          [b4_percent_define_get([[parser_class_name]])])
22
23# The header is mandatory.
24b4_defines_if([],
25              [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
26
27# Backward compatibility.
28m4_define([b4_location_constructors])
29m4_include(b4_pkgdatadir/[location.cc])
30
31# We do want M4 expansion after # for CPP macros.
32m4_changecom()
33m4_divert_push(0)dnl
34b4_defines_if(
35[@output(b4_spec_defines_file@)@
36b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++],
37             [2002-2010])
38dnl FIXME: This is wrong, we want computed header guards.
39[
40/* C++ LALR(1) parser skeleton written by Akim Demaille.  */
41
42#ifndef PARSER_HEADER_H
43# define PARSER_HEADER_H
44
45]b4_percent_code_get([[requires]])[
46
47#include <string>
48#include <iostream>
49#include "stack.hh"
50
51]b4_namespace_open[
52  class position;
53  class location;
54]b4_namespace_close[
55
56#include "location.hh"
57
58/* Enabling traces.  */
59#ifndef YYDEBUG
60# define YYDEBUG ]b4_debug_flag[
61#endif
62
63/* Enabling verbose error messages.  */
64#ifdef YYERROR_VERBOSE
65# undef YYERROR_VERBOSE
66# define YYERROR_VERBOSE 1
67#else
68# define YYERROR_VERBOSE ]b4_error_verbose_flag[
69#endif
70
71/* Enabling the token table.  */
72#ifndef YYTOKEN_TABLE
73# define YYTOKEN_TABLE ]b4_token_table[
74#endif
75
76/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
77   If N is 0, then set CURRENT to the empty location which ends
78   the previous symbol: RHS[0] (always defined).  */
79
80#ifndef YYLLOC_DEFAULT
81# define YYLLOC_DEFAULT(Current, Rhs, N)                \
82do {                                                    \
83  if (N)                                                \
84    {                                                   \
85      (Current).begin = (Rhs)[1].begin;                 \
86      (Current).end   = (Rhs)[N].end;                   \
87    }                                                   \
88  else                                                  \
89    {                                                   \
90      (Current).begin = (Current).end = (Rhs)[0].end;   \
91    }                                                   \
92} while (false)
93#endif
94
95]b4_namespace_open[
96
97  /// A Bison parser.
98  class ]b4_parser_class_name[
99  {
100  public:
101    /// Symbol semantic values.
102#ifndef YYSTYPE
103]m4_ifdef([b4_stype],
104[    union semantic_type
105    {
106b4_user_stype
107    };],
108[m4_if(b4_tag_seen_flag, 0,
109[[    typedef int semantic_type;]],
110[[    typedef YYSTYPE semantic_type;]])])[
111#else
112    typedef YYSTYPE semantic_type;
113#endif
114    /// Symbol locations.
115    typedef ]b4_percent_define_get([[location_type]])[ location_type;
116    /// Tokens.
117    struct token
118    {
119      ]b4_token_enums(b4_tokens)[
120    };
121    /// Token type.
122    typedef token::yytokentype token_type;
123
124    /// Build a parser object.
125    ]b4_parser_class_name[ (]b4_parse_param_decl[);
126    virtual ~]b4_parser_class_name[ ();
127
128    /// Parse.
129    /// \returns  0 iff parsing succeeded.
130    virtual int parse ();
131
132#if YYDEBUG
133    /// The current debugging stream.
134    std::ostream& debug_stream () const;
135    /// Set the current debugging stream.
136    void set_debug_stream (std::ostream &);
137
138    /// Type for debugging levels.
139    typedef int debug_level_type;
140    /// The current debugging level.
141    debug_level_type debug_level () const;
142    /// Set the current debugging level.
143    void set_debug_level (debug_level_type l);
144#endif
145
146  private:
147    /// Report a syntax error.
148    /// \param loc    where the syntax error is found.
149    /// \param msg    a description of the syntax error.
150    virtual void error (const location_type& loc, const std::string& msg);
151
152    /// Generate an error message.
153    /// \param state   the state where the error occurred.
154    /// \param tok     the lookahead token.
155    virtual std::string yysyntax_error_ (int yystate]dnl
156b4_error_verbose_if([, int tok])[);
157
158#if YYDEBUG
159    /// \brief Report a symbol value on the debug stream.
160    /// \param yytype       The token type.
161    /// \param yyvaluep     Its semantic value.
162    /// \param yylocationp  Its location.
163    virtual void yy_symbol_value_print_ (int yytype,
164                                         const semantic_type* yyvaluep,
165                                         const location_type* yylocationp);
166    /// \brief Report a symbol on the debug stream.
167    /// \param yytype       The token type.
168    /// \param yyvaluep     Its semantic value.
169    /// \param yylocationp  Its location.
170    virtual void yy_symbol_print_ (int yytype,
171                                   const semantic_type* yyvaluep,
172                                   const location_type* yylocationp);
173#endif
174
175
176    /// State numbers.
177    typedef int state_type;
178    /// State stack type.
179    typedef stack<state_type>    state_stack_type;
180    /// Semantic value stack type.
181    typedef stack<semantic_type> semantic_stack_type;
182    /// location stack type.
183    typedef stack<location_type> location_stack_type;
184
185    /// The state stack.
186    state_stack_type yystate_stack_;
187    /// The semantic value stack.
188    semantic_stack_type yysemantic_stack_;
189    /// The location stack.
190    location_stack_type yylocation_stack_;
191
192    /// Internal symbol numbers.
193    typedef ]b4_int_type_for([b4_translate])[ token_number_type;
194    /* Tables.  */
195    /// For a state, the index in \a yytable_ of its portion.
196    static const ]b4_int_type_for([b4_pact])[ yypact_[];
197    static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
198
199    /// For a state, default rule to reduce.
200    /// Unless\a  yytable_ specifies something else to do.
201    /// Zero means the default is an error.
202    static const ]b4_int_type_for([b4_defact])[ yydefact_[];
203
204    static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
205    static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
206
207    /// What to do in a state.
208    /// \a yytable_[yypact_[s]]: what to do in state \a s.
209    /// - if positive, shift that token.
210    /// - if negative, reduce the rule which number is the opposite.
211    /// - if zero, do what YYDEFACT says.
212    static const ]b4_int_type_for([b4_table])[ yytable_[];
213    static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
214
215    static const ]b4_int_type_for([b4_check])[ yycheck_[];
216
217    /// For a state, its accessing symbol.
218    static const ]b4_int_type_for([b4_stos])[ yystos_[];
219
220    /// For a rule, its LHS.
221    static const ]b4_int_type_for([b4_r1])[ yyr1_[];
222    /// For a rule, its RHS length.
223    static const ]b4_int_type_for([b4_r2])[ yyr2_[];
224
225#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
226    /// For a symbol, its name in clear.
227    static const char* const yytname_[];
228#endif
229
230#if YYERROR_VERBOSE
231    /// Convert the symbol name \a n to a form suitable for a diagnostic.
232    virtual std::string yytnamerr_ (const char *n);
233#endif
234
235#if YYDEBUG
236    /// A type to store symbol numbers and -1.
237    typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type;
238    /// A `-1'-separated list of the rules' RHS.
239    static const rhs_number_type yyrhs_[];
240    /// For each rule, the index of the first RHS symbol in \a yyrhs_.
241    static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
242    /// For each rule, its source line number.
243    static const ]b4_int_type_for([b4_rline])[ yyrline_[];
244    /// For each scanner token number, its symbol number.
245    static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
246    /// Report on the debug stream that the rule \a r is going to be reduced.
247    virtual void yy_reduce_print_ (int r);
248    /// Print the state stack on the debug stream.
249    virtual void yystack_print_ ();
250
251    /* Debugging.  */
252    int yydebug_;
253    std::ostream* yycdebug_;
254#endif
255
256    /// Convert a scanner token number \a t to a symbol number.
257    token_number_type yytranslate_ (int t);
258
259    /// \brief Reclaim the memory associated to a symbol.
260    /// \param yymsg        Why this token is reclaimed.
261    /// \param yytype       The symbol type.
262    /// \param yyvaluep     Its semantic value.
263    /// \param yylocationp  Its location.
264    inline void yydestruct_ (const char* yymsg,
265                             int yytype,
266                             semantic_type* yyvaluep,
267                             location_type* yylocationp);
268
269    /// Pop \a n symbols the three stacks.
270    inline void yypop_ (unsigned int n = 1);
271
272    /* Constants.  */
273    static const int yyeof_;
274    /* LAST_ -- Last index in TABLE_.  */
275    static const int yylast_;
276    static const int yynnts_;
277    static const int yyempty_;
278    static const int yyfinal_;
279    static const int yyterror_;
280    static const int yyerrcode_;
281    static const int yyntokens_;
282    static const unsigned int yyuser_token_number_max_;
283    static const token_number_type yyundef_token_;
284]b4_parse_param_vars[
285  };
286]b4_namespace_close[
287
288]b4_percent_define_flag_if([[global_tokens_and_yystype]],
289[b4_token_defines(b4_tokens)
290
291#ifndef YYSTYPE
292 /* Redirection for backward compatibility.  */
293# define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
294#endif
295])
296b4_percent_code_get([[provides]])[]dnl
297
298[#endif /* ! defined PARSER_HEADER_H */]
299])dnl
300@output(b4_parser_file_name@)@
301b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++],
302             [2002-2010])
303b4_percent_code_get([[top]])[]dnl
304m4_if(b4_prefix, [yy], [],
305[
306// Take the name prefix into account.
307#define yylex   b4_prefix[]lex])[
308
309/* First part of user declarations.  */
310]b4_user_pre_prologue
311
312b4_defines_if([[
313#include "@basename(]b4_spec_defines_file[@)"]])[
314
315/* User implementation prologue.  */
316]b4_user_post_prologue
317b4_percent_code_get[]dnl
318
319[#ifndef YY_
320# if defined YYENABLE_NLS && YYENABLE_NLS
321#  if ENABLE_NLS
322#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
323#   define YY_(msgid) dgettext ("bison-runtime", msgid)
324#  endif
325# endif
326# ifndef YY_
327#  define YY_(msgid) msgid
328# endif
329#endif
330
331/* Suppress unused-variable warnings by "using" E.  */
332#define YYUSE(e) ((void) (e))
333
334/* Enable debugging if requested.  */
335#if YYDEBUG
336
337/* A pseudo ostream that takes yydebug_ into account.  */
338# define YYCDEBUG if (yydebug_) (*yycdebug_)
339
340# define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
341do {                                                    \
342  if (yydebug_)                                         \
343    {                                                   \
344      *yycdebug_ << Title << ' ';                       \
345      yy_symbol_print_ ((Type), (Value), (Location));   \
346      *yycdebug_ << std::endl;                          \
347    }                                                   \
348} while (false)
349
350# define YY_REDUCE_PRINT(Rule)          \
351do {                                    \
352  if (yydebug_)                         \
353    yy_reduce_print_ (Rule);            \
354} while (false)
355
356# define YY_STACK_PRINT()               \
357do {                                    \
358  if (yydebug_)                         \
359    yystack_print_ ();                  \
360} while (false)
361
362#else /* !YYDEBUG */
363
364# define YYCDEBUG if (false) std::cerr
365# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
366# define YY_REDUCE_PRINT(Rule)
367# define YY_STACK_PRINT()
368
369#endif /* !YYDEBUG */
370
371#define yyerrok         (yyerrstatus_ = 0)
372#define yyclearin       (yychar = yyempty_)
373
374#define YYACCEPT        goto yyacceptlab
375#define YYABORT         goto yyabortlab
376#define YYERROR         goto yyerrorlab
377#define YYRECOVERING()  (!!yyerrstatus_)
378
379]b4_namespace_open[
380#if YYERROR_VERBOSE
381
382  /* Return YYSTR after stripping away unnecessary quotes and
383     backslashes, so that it's suitable for yyerror.  The heuristic is
384     that double-quoting is unnecessary unless the string contains an
385     apostrophe, a comma, or backslash (other than backslash-backslash).
386     YYSTR is taken from yytname.  */
387  std::string
388  ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
389  {
390    if (*yystr == '"')
391      {
392        std::string yyr = "";
393        char const *yyp = yystr;
394
395        for (;;)
396          switch (*++yyp)
397            {
398            case '\'':
399            case ',':
400              goto do_not_strip_quotes;
401
402            case '\\':
403              if (*++yyp != '\\')
404                goto do_not_strip_quotes;
405              /* Fall through.  */
406            default:
407              yyr += *yyp;
408              break;
409
410            case '"':
411              return yyr;
412            }
413      do_not_strip_quotes: ;
414      }
415
416    return yystr;
417  }
418
419#endif
420
421  /// Build a parser object.
422  ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
423    :])[
424#if YYDEBUG
425    ]m4_ifset([b4_parse_param], [  ], [ :])[yydebug_ (false),
426      yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
427#endif]b4_parse_param_cons[
428  {
429  }
430
431  ]b4_parser_class_name::~b4_parser_class_name[ ()
432  {
433  }
434
435#if YYDEBUG
436  /*--------------------------------.
437  | Print this symbol on YYOUTPUT.  |
438  `--------------------------------*/
439
440  inline void
441  ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
442                           const semantic_type* yyvaluep, const location_type* yylocationp)
443  {
444    YYUSE (yylocationp);
445    YYUSE (yyvaluep);
446    switch (yytype)
447      {
448  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
449[       default:
450          break;
451      }
452  }
453
454
455  void
456  ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
457                           const semantic_type* yyvaluep, const location_type* yylocationp)
458  {
459    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
460               << ' ' << yytname_[yytype] << " ("
461               << *yylocationp << ": ";
462    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
463    *yycdebug_ << ')';
464  }
465#endif
466
467  void
468  ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
469                           int yytype, semantic_type* yyvaluep, location_type* yylocationp)
470  {
471    YYUSE (yylocationp);
472    YYUSE (yymsg);
473    YYUSE (yyvaluep);
474
475    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
476
477    switch (yytype)
478      {
479  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
480        default:
481          break;
482      }
483  }
484
485  void
486  ]b4_parser_class_name[::yypop_ (unsigned int n)
487  {
488    yystate_stack_.pop (n);
489    yysemantic_stack_.pop (n);
490    yylocation_stack_.pop (n);
491  }
492
493#if YYDEBUG
494  std::ostream&
495  ]b4_parser_class_name[::debug_stream () const
496  {
497    return *yycdebug_;
498  }
499
500  void
501  ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
502  {
503    yycdebug_ = &o;
504  }
505
506
507  ]b4_parser_class_name[::debug_level_type
508  ]b4_parser_class_name[::debug_level () const
509  {
510    return yydebug_;
511  }
512
513  void
514  ]b4_parser_class_name[::set_debug_level (debug_level_type l)
515  {
516    yydebug_ = l;
517  }
518#endif
519
520  int
521  ]b4_parser_class_name[::parse ()
522  {
523    /// Lookahead and lookahead in internal form.
524    int yychar = yyempty_;
525    int yytoken = 0;
526
527    /* State.  */
528    int yyn;
529    int yylen = 0;
530    int yystate = 0;
531
532    /* Error handling.  */
533    int yynerrs_ = 0;
534    int yyerrstatus_ = 0;
535
536    /// Semantic value of the lookahead.
537    semantic_type yylval;
538    /// Location of the lookahead.
539    location_type yylloc;
540    /// The locations where the error started and ended.
541    location_type yyerror_range[2];
542
543    /// $$.
544    semantic_type yyval;
545    /// @@$.
546    location_type yyloc;
547
548    int yyresult;
549
550    YYCDEBUG << "Starting parse" << std::endl;
551
552]m4_ifdef([b4_initial_action], [
553m4_pushdef([b4_at_dollar],     [yylloc])dnl
554m4_pushdef([b4_dollar_dollar], [yylval])dnl
555    /* User initialization code.  */
556    b4_user_initial_action
557m4_popdef([b4_dollar_dollar])dnl
558m4_popdef([b4_at_dollar])])dnl
559
560  [  /* Initialize the stacks.  The initial state will be pushed in
561       yynewstate, since the latter expects the semantical and the
562       location values to have been already stored, initialize these
563       stacks with a primary value.  */
564    yystate_stack_ = state_stack_type (0);
565    yysemantic_stack_ = semantic_stack_type (0);
566    yylocation_stack_ = location_stack_type (0);
567    yysemantic_stack_.push (yylval);
568    yylocation_stack_.push (yylloc);
569
570    /* New state.  */
571  yynewstate:
572    yystate_stack_.push (yystate);
573    YYCDEBUG << "Entering state " << yystate << std::endl;
574
575    /* Accept?  */
576    if (yystate == yyfinal_)
577      goto yyacceptlab;
578
579    goto yybackup;
580
581    /* Backup.  */
582  yybackup:
583
584    /* Try to take a decision without lookahead.  */
585    yyn = yypact_[yystate];
586    if (yyn == yypact_ninf_)
587      goto yydefault;
588
589    /* Read a lookahead token.  */
590    if (yychar == yyempty_)
591      {
592        YYCDEBUG << "Reading a token: ";
593        yychar = ]b4_c_function_call([yylex], [int],
594                                     [[YYSTYPE*], [&yylval]][]dnl
595b4_locations_if([, [[location*], [&yylloc]]])dnl
596m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
597      }
598
599
600    /* Convert token to internal form.  */
601    if (yychar <= yyeof_)
602      {
603        yychar = yytoken = yyeof_;
604        YYCDEBUG << "Now at end of input." << std::endl;
605      }
606    else
607      {
608        yytoken = yytranslate_ (yychar);
609        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
610      }
611
612    /* If the proper action on seeing token YYTOKEN is to reduce or to
613       detect an error, take that action.  */
614    yyn += yytoken;
615    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
616      goto yydefault;
617
618    /* Reduce or error.  */
619    yyn = yytable_[yyn];
620    if (yyn <= 0)
621      {
622        if (yyn == 0 || yyn == yytable_ninf_)
623        goto yyerrlab;
624        yyn = -yyn;
625        goto yyreduce;
626      }
627
628    /* Shift the lookahead token.  */
629    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
630
631    /* Discard the token being shifted.  */
632    yychar = yyempty_;
633
634    yysemantic_stack_.push (yylval);
635    yylocation_stack_.push (yylloc);
636
637    /* Count tokens shifted since error; after three, turn off error
638       status.  */
639    if (yyerrstatus_)
640      --yyerrstatus_;
641
642    yystate = yyn;
643    goto yynewstate;
644
645  /*-----------------------------------------------------------.
646  | yydefault -- do the default action for the current state.  |
647  `-----------------------------------------------------------*/
648  yydefault:
649    yyn = yydefact_[yystate];
650    if (yyn == 0)
651      goto yyerrlab;
652    goto yyreduce;
653
654  /*-----------------------------.
655  | yyreduce -- Do a reduction.  |
656  `-----------------------------*/
657  yyreduce:
658    yylen = yyr2_[yyn];
659    /* If YYLEN is nonzero, implement the default value of the action:
660       `$$ = $1'.  Otherwise, use the top of the stack.
661
662       Otherwise, the following line sets YYVAL to garbage.
663       This behavior is undocumented and Bison
664       users should not rely upon it.  */
665    if (yylen)
666      yyval = yysemantic_stack_[yylen - 1];
667    else
668      yyval = yysemantic_stack_[0];
669
670    {
671      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
672      YYLLOC_DEFAULT (yyloc, slice, yylen);
673    }
674    YY_REDUCE_PRINT (yyn);
675    switch (yyn)
676      {
677        ]b4_user_actions[
678        default:
679          break;
680      }
681    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
682
683    yypop_ (yylen);
684    yylen = 0;
685    YY_STACK_PRINT ();
686
687    yysemantic_stack_.push (yyval);
688    yylocation_stack_.push (yyloc);
689
690    /* Shift the result of the reduction.  */
691    yyn = yyr1_[yyn];
692    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
693    if (0 <= yystate && yystate <= yylast_
694        && yycheck_[yystate] == yystate_stack_[0])
695      yystate = yytable_[yystate];
696    else
697      yystate = yydefgoto_[yyn - yyntokens_];
698    goto yynewstate;
699
700  /*------------------------------------.
701  | yyerrlab -- here on detecting error |
702  `------------------------------------*/
703  yyerrlab:
704    /* If not already recovering from an error, report this error.  */
705    if (!yyerrstatus_)
706      {
707        ++yynerrs_;
708        error (yylloc, yysyntax_error_ (yystate]dnl
709b4_error_verbose_if([, yytoken])[));
710      }
711
712    yyerror_range[0] = yylloc;
713    if (yyerrstatus_ == 3)
714      {
715        /* If just tried and failed to reuse lookahead token after an
716         error, discard it.  */
717
718        if (yychar <= yyeof_)
719          {
720          /* Return failure if at end of input.  */
721          if (yychar == yyeof_)
722            YYABORT;
723          }
724        else
725          {
726            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
727            yychar = yyempty_;
728          }
729      }
730
731    /* Else will try to reuse lookahead token after shifting the error
732       token.  */
733    goto yyerrlab1;
734
735
736  /*---------------------------------------------------.
737  | yyerrorlab -- error raised explicitly by YYERROR.  |
738  `---------------------------------------------------*/
739  yyerrorlab:
740
741    /* Pacify compilers like GCC when the user code never invokes
742       YYERROR and the label yyerrorlab therefore never appears in user
743       code.  */
744    if (false)
745      goto yyerrorlab;
746
747    yyerror_range[0] = yylocation_stack_[yylen - 1];
748    /* Do not reclaim the symbols of the rule which action triggered
749       this YYERROR.  */
750    yypop_ (yylen);
751    yylen = 0;
752    yystate = yystate_stack_[0];
753    goto yyerrlab1;
754
755  /*-------------------------------------------------------------.
756  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
757  `-------------------------------------------------------------*/
758  yyerrlab1:
759    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
760
761    for (;;)
762      {
763        yyn = yypact_[yystate];
764        if (yyn != yypact_ninf_)
765        {
766          yyn += yyterror_;
767          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
768            {
769              yyn = yytable_[yyn];
770              if (0 < yyn)
771                break;
772            }
773        }
774
775        /* Pop the current state because it cannot handle the error token.  */
776        if (yystate_stack_.height () == 1)
777        YYABORT;
778
779        yyerror_range[0] = yylocation_stack_[0];
780        yydestruct_ ("Error: popping",
781                     yystos_[yystate],
782                     &yysemantic_stack_[0], &yylocation_stack_[0]);
783        yypop_ ();
784        yystate = yystate_stack_[0];
785        YY_STACK_PRINT ();
786      }
787
788    yyerror_range[1] = yylloc;
789    // Using YYLLOC is tempting, but would change the location of
790    // the lookahead.  YYLOC is available though.
791    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
792    yysemantic_stack_.push (yylval);
793    yylocation_stack_.push (yyloc);
794
795    /* Shift the error token.  */
796    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
797                     &yysemantic_stack_[0], &yylocation_stack_[0]);
798
799    yystate = yyn;
800    goto yynewstate;
801
802    /* Accept.  */
803  yyacceptlab:
804    yyresult = 0;
805    goto yyreturn;
806
807    /* Abort.  */
808  yyabortlab:
809    yyresult = 1;
810    goto yyreturn;
811
812  yyreturn:
813    if (yychar != yyempty_)
814      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
815
816    /* Do not reclaim the symbols of the rule which action triggered
817       this YYABORT or YYACCEPT.  */
818    yypop_ (yylen);
819    while (yystate_stack_.height () != 1)
820      {
821        yydestruct_ ("Cleanup: popping",
822                   yystos_[yystate_stack_[0]],
823                   &yysemantic_stack_[0],
824                   &yylocation_stack_[0]);
825        yypop_ ();
826      }
827
828    return yyresult;
829  }
830
831  // Generate an error message.
832  std::string
833  ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
834b4_error_verbose_if([, int tok])[)
835  {
836    std::string res;
837    YYUSE (yystate);
838#if YYERROR_VERBOSE
839    int yyn = yypact_[yystate];
840    if (yypact_ninf_ < yyn && yyn <= yylast_)
841      {
842        /* Start YYX at -YYN if negative to avoid negative indexes in
843           YYCHECK.  */
844        int yyxbegin = yyn < 0 ? -yyn : 0;
845
846        /* Stay within bounds of both yycheck and yytname.  */
847        int yychecklim = yylast_ - yyn + 1;
848        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
849        int count = 0;
850        for (int x = yyxbegin; x < yyxend; ++x)
851          if (yycheck_[x + yyn] == x && x != yyterror_)
852            ++count;
853
854        // FIXME: This method of building the message is not compatible
855        // with internationalization.  It should work like yacc.c does it.
856        // That is, first build a string that looks like this:
857        // "syntax error, unexpected %s or %s or %s"
858        // Then, invoke YY_ on this string.
859        // Finally, use the string as a format to output
860        // yytname_[tok], etc.
861        // Until this gets fixed, this message appears in English only.
862        res = "syntax error, unexpected ";
863        res += yytnamerr_ (yytname_[tok]);
864        if (count < 5)
865          {
866            count = 0;
867            for (int x = yyxbegin; x < yyxend; ++x)
868              if (yycheck_[x + yyn] == x && x != yyterror_)
869                {
870                  res += (!count++) ? ", expecting " : " or ";
871                  res += yytnamerr_ (yytname_[x]);
872                }
873          }
874      }
875    else
876#endif
877      res = YY_("syntax error");
878    return res;
879  }
880
881
882  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
883     STATE-NUM.  */
884  const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
885  const ]b4_int_type_for([b4_pact])[
886  ]b4_parser_class_name[::yypact_[] =
887  {
888    ]b4_pact[
889  };
890
891  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
892     doesn't specify something else to do.  Zero means the default is an
893     error.  */
894  const ]b4_int_type_for([b4_defact])[
895  ]b4_parser_class_name[::yydefact_[] =
896  {
897    ]b4_defact[
898  };
899
900  /* YYPGOTO[NTERM-NUM].  */
901  const ]b4_int_type_for([b4_pgoto])[
902  ]b4_parser_class_name[::yypgoto_[] =
903  {
904    ]b4_pgoto[
905  };
906
907  /* YYDEFGOTO[NTERM-NUM].  */
908  const ]b4_int_type_for([b4_defgoto])[
909  ]b4_parser_class_name[::yydefgoto_[] =
910  {
911    ]b4_defgoto[
912  };
913
914  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
915     positive, shift that token.  If negative, reduce the rule which
916     number is the opposite.  If zero, do what YYDEFACT says.  */
917  const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
918  const ]b4_int_type_for([b4_table])[
919  ]b4_parser_class_name[::yytable_[] =
920  {
921    ]b4_table[
922  };
923
924  /* YYCHECK.  */
925  const ]b4_int_type_for([b4_check])[
926  ]b4_parser_class_name[::yycheck_[] =
927  {
928    ]b4_check[
929  };
930
931  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
932     symbol of state STATE-NUM.  */
933  const ]b4_int_type_for([b4_stos])[
934  ]b4_parser_class_name[::yystos_[] =
935  {
936    ]b4_stos[
937  };
938
939#if YYDEBUG
940  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
941     to YYLEX-NUM.  */
942  const ]b4_int_type_for([b4_toknum])[
943  ]b4_parser_class_name[::yytoken_number_[] =
944  {
945    ]b4_toknum[
946  };
947#endif
948
949  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
950  const ]b4_int_type_for([b4_r1])[
951  ]b4_parser_class_name[::yyr1_[] =
952  {
953    ]b4_r1[
954  };
955
956  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
957  const ]b4_int_type_for([b4_r2])[
958  ]b4_parser_class_name[::yyr2_[] =
959  {
960    ]b4_r2[
961  };
962
963#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
964  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
965     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
966  const char*
967  const ]b4_parser_class_name[::yytname_[] =
968  {
969    ]b4_tname[
970  };
971#endif
972
973#if YYDEBUG
974  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
975  const ]b4_parser_class_name[::rhs_number_type
976  ]b4_parser_class_name[::yyrhs_[] =
977  {
978    ]b4_rhs[
979  };
980
981  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
982     YYRHS.  */
983  const ]b4_int_type_for([b4_prhs])[
984  ]b4_parser_class_name[::yyprhs_[] =
985  {
986    ]b4_prhs[
987  };
988
989  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
990  const ]b4_int_type_for([b4_rline])[
991  ]b4_parser_class_name[::yyrline_[] =
992  {
993    ]b4_rline[
994  };
995
996  // Print the state stack on the debug stream.
997  void
998  ]b4_parser_class_name[::yystack_print_ ()
999  {
1000    *yycdebug_ << "Stack now";
1001    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1002         i != yystate_stack_.end (); ++i)
1003      *yycdebug_ << ' ' << *i;
1004    *yycdebug_ << std::endl;
1005  }
1006
1007  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1008  void
1009  ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1010  {
1011    unsigned int yylno = yyrline_[yyrule];
1012    int yynrhs = yyr2_[yyrule];
1013    /* Print the symbols being reduced, and their result.  */
1014    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1015               << " (line " << yylno << "):" << std::endl;
1016    /* The symbols being reduced.  */
1017    for (int yyi = 0; yyi < yynrhs; yyi++)
1018      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1019                       yyrhs_[yyprhs_[yyrule] + yyi],
1020                       &]b4_rhs_value(yynrhs, yyi + 1)[,
1021                       &]b4_rhs_location(yynrhs, yyi + 1)[);
1022  }
1023#endif // YYDEBUG
1024
1025  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1026  ]b4_parser_class_name[::token_number_type
1027  ]b4_parser_class_name[::yytranslate_ (int t)
1028  {
1029    static
1030    const token_number_type
1031    translate_table[] =
1032    {
1033      ]b4_translate[
1034    };
1035    if ((unsigned int) t <= yyuser_token_number_max_)
1036      return translate_table[t];
1037    else
1038      return yyundef_token_;
1039  }
1040
1041  const int ]b4_parser_class_name[::yyeof_ = 0;
1042  const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
1043  const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1044  const int ]b4_parser_class_name[::yyempty_ = -2;
1045  const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1046  const int ]b4_parser_class_name[::yyterror_ = 1;
1047  const int ]b4_parser_class_name[::yyerrcode_ = 256;
1048  const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1049
1050  const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1051  const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1052
1053]b4_namespace_close[
1054
1055]b4_epilogue
1056dnl
1057@output(b4_dir_prefix[]stack.hh@)@
1058b4_copyright([Stack handling for Bison parsers in C++],
1059             [2002-2010])[
1060
1061#ifndef BISON_STACK_HH
1062# define BISON_STACK_HH
1063
1064#include <deque>
1065
1066]b4_namespace_open[
1067  template <class T, class S = std::deque<T> >
1068  class stack
1069  {
1070  public:
1071
1072    // Hide our reversed order.
1073    typedef typename S::reverse_iterator iterator;
1074    typedef typename S::const_reverse_iterator const_iterator;
1075
1076    stack () : seq_ ()
1077    {
1078    }
1079
1080    stack (unsigned int n) : seq_ (n)
1081    {
1082    }
1083
1084    inline
1085    T&
1086    operator [] (unsigned int i)
1087    {
1088      return seq_[i];
1089    }
1090
1091    inline
1092    const T&
1093    operator [] (unsigned int i) const
1094    {
1095      return seq_[i];
1096    }
1097
1098    inline
1099    void
1100    push (const T& t)
1101    {
1102      seq_.push_front (t);
1103    }
1104
1105    inline
1106    void
1107    pop (unsigned int n = 1)
1108    {
1109      for (; n; --n)
1110        seq_.pop_front ();
1111    }
1112
1113    inline
1114    unsigned int
1115    height () const
1116    {
1117      return seq_.size ();
1118    }
1119
1120    inline const_iterator begin () const { return seq_.rbegin (); }
1121    inline const_iterator end () const { return seq_.rend (); }
1122
1123  private:
1124
1125    S seq_;
1126  };
1127
1128  /// Present a slice of the top of a stack.
1129  template <class T, class S = stack<T> >
1130  class slice
1131  {
1132  public:
1133
1134    slice (const S& stack,
1135           unsigned int range) : stack_ (stack),
1136                                 range_ (range)
1137    {
1138    }
1139
1140    inline
1141    const T&
1142    operator [] (unsigned int i) const
1143    {
1144      return stack_[range_ - i];
1145    }
1146
1147  private:
1148
1149    const S& stack_;
1150    unsigned int range_;
1151  };
1152]b4_namespace_close[
1153
1154#endif // not BISON_STACK_HH[]dnl
1155]
1156m4_divert_pop(0)
Note: See TracBrowser for help on using the repository browser.