Upgrade win_flex/win_bison to 2.5.5 (bison 3.0)
[mirror/qt/qt5.git] / gnuwin32 / bin / data / lalr1.cc
1 # C++ skeleton for Bison
2
3 # Copyright (C) 2002-2013 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
18 m4_include(b4_pkgdatadir/[c++.m4])
19
20 # api.value.type=variant is valid.
21 m4_define([b4_value_type_setup_variant])
22
23 # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
24 # --------------------------------------------------------------
25 # Declare "parser::yy<TABLE-NAME>_" whose contents is CONTENT.
26 m4_define([b4_integral_parser_table_declare],
27 [m4_ifval([$3], [b4_comment([$3], [  ])
28 ])dnl
29   static const b4_int_type_for([$2]) yy$1_[[]];dnl
30 ])
31
32 # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
33 # -------------------------------------------------------------
34 # Define "parser::yy<TABLE-NAME>_" whose contents is CONTENT.
35 m4_define([b4_integral_parser_table_define],
36 [  const b4_int_type_for([$2])
37   b4_parser_class_name::yy$1_[[]] =
38   {
39   $2
40   };dnl
41 ])
42
43 # b4_symbol_value_template(VAL, [TYPE])
44 # -------------------------------------
45 # Same as b4_symbol_value, but used in a template method.  It makes
46 # a difference when using variants.  Note that b4_value_type_setup_union
47 # overrides b4_symbol_value, so we must override it again.
48 m4_copy([b4_symbol_value], [b4_symbol_value_template])
49 m4_append([b4_value_type_setup_union],
50           [m4_copy_force([b4_symbol_value_union], [b4_symbol_value_template])])
51
52 # b4_lhs_value([TYPE])
53 # --------------------
54 # Expansion of $<TYPE>$.
55 m4_define([b4_lhs_value],
56           [b4_symbol_value([yylhs.value], [$1])])
57
58
59 # b4_lhs_location()
60 # -----------------
61 # Expansion of @$.
62 m4_define([b4_lhs_location],
63           [yylhs.location])
64
65
66 # b4_rhs_data(RULE-LENGTH, NUM)
67 # -----------------------------
68 # Return the data corresponding to the symbol #NUM, where the current
69 # rule has RULE-LENGTH symbols on RHS.
70 m4_define([b4_rhs_data],
71           [yystack_@{b4_subtract($@)@}])
72
73
74 # b4_rhs_state(RULE-LENGTH, NUM)
75 # ------------------------------
76 # The state corresponding to the symbol #NUM, where the current
77 # rule has RULE-LENGTH symbols on RHS.
78 m4_define([b4_rhs_state],
79           [b4_rhs_data([$1], [$2]).state])
80
81
82 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
83 # --------------------------------------
84 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
85 # symbols on RHS.
86 m4_define([b4_rhs_value],
87           [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
88
89
90 # b4_rhs_location(RULE-LENGTH, NUM)
91 # ---------------------------------
92 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
93 # on RHS.
94 m4_define([b4_rhs_location],
95           [b4_rhs_data([$1], [$2]).location])
96
97
98 # b4_symbol_action(SYMBOL-NUM, KIND)
99 # ----------------------------------
100 # Run the action KIND (destructor or printer) for SYMBOL-NUM.
101 # Same as in C, but using references instead of pointers.
102 m4_define([b4_symbol_action],
103 [b4_symbol_if([$1], [has_$2],
104 [m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl
105 b4_dollar_pushdef([yysym.value],
106                    b4_symbol_if([$1], [has_type],
107                                 [m4_dquote(b4_symbol([$1], [type]))]),
108                    [yysym.location])dnl
109       b4_symbol_case_([$1])
110 b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
111         b4_symbol([$1], [$2])
112 b4_syncline([@oline@], [@ofile@])
113         break;
114
115 m4_popdef([b4_symbol_value])[]dnl
116 b4_dollar_popdef[]dnl
117 ])])
118
119
120 # b4_lex
121 # ------
122 # Call yylex.
123 m4_define([b4_lex],
124 [b4_token_ctor_if(
125 [b4_function_call([yylex],
126                   [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))],
127 [b4_function_call([yylex], [int],
128                   [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
129 b4_locations_if([, [[location*], [&yyla.location]]])dnl
130 m4_ifdef([b4_lex_param], [, ]b4_lex_param))])])
131
132
133 m4_pushdef([b4_copyright_years],
134            [2002-2013])
135
136 m4_define([b4_parser_class_name],
137           [b4_percent_define_get([[parser_class_name]])])
138
139 b4_bison_locations_if([# Backward compatibility.
140    m4_define([b4_location_constructors])
141    m4_include(b4_pkgdatadir/[location.cc])])
142 m4_include(b4_pkgdatadir/[stack.hh])
143 b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
144
145 # b4_shared_declarations
146 # ----------------------
147 # Declaration that might either go into the header (if --defines)
148 # or open coded in the parser body.
149 m4_define([b4_shared_declarations],
150 [b4_percent_code_get([[requires]])[
151 ]b4_parse_assert_if([# include <cassert>])[
152 # include <vector>
153 # include <iostream>
154 # include <stdexcept>
155 # include <string>]b4_defines_if([[
156 # include "stack.hh"
157 ]b4_bison_locations_if([[# include "location.hh"]])])[
158 ]b4_variant_if([b4_variant_includes])[
159
160 ]b4_YYDEBUG_define[
161
162 ]b4_namespace_open[
163
164 ]b4_defines_if([],
165 [b4_stack_define
166 b4_bison_locations_if([b4_position_define
167 b4_location_define])])[
168
169 ]b4_variant_if([b4_variant_define])[
170
171   /// A Bison parser.
172   class ]b4_parser_class_name[
173   {
174   public:
175 ]b4_public_types_declare[
176     /// Build a parser object.
177     ]b4_parser_class_name[ (]b4_parse_param_decl[);
178     virtual ~]b4_parser_class_name[ ();
179
180     /// Parse.
181     /// \returns  0 iff parsing succeeded.
182     virtual int parse ();
183
184 #if ]b4_api_PREFIX[DEBUG
185     /// The current debugging stream.
186     std::ostream& debug_stream () const;
187     /// Set the current debugging stream.
188     void set_debug_stream (std::ostream &);
189
190     /// Type for debugging levels.
191     typedef int debug_level_type;
192     /// The current debugging level.
193     debug_level_type debug_level () const;
194     /// Set the current debugging level.
195     void set_debug_level (debug_level_type l);
196 #endif
197
198     /// Report a syntax error.]b4_locations_if([[
199     /// \param loc    where the syntax error is found.]])[
200     /// \param msg    a description of the syntax error.
201     virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);
202
203     /// Report a syntax error.
204     void error (const syntax_error& err);
205
206   private:
207     /// This class is not copyable.
208     ]b4_parser_class_name[ (const ]b4_parser_class_name[&);
209     ]b4_parser_class_name[& operator= (const ]b4_parser_class_name[&);
210
211     /// State numbers.
212     typedef int state_type;
213
214     /// Generate an error message.
215     /// \param yystate   the state where the error occurred.
216     /// \param yytoken   the lookahead token type, or yyempty_.
217     virtual std::string yysyntax_error_ (state_type yystate,
218                                          symbol_number_type yytoken) const;
219
220     /// Compute post-reduction state.
221     /// \param yystate   the current state
222     /// \param yylhs     the nonterminal to push on the stack
223     state_type yy_lr_goto_state_ (state_type yystate, int yylhs);
224
225     /// Whether the given \c yypact_ value indicates a defaulted state.
226     /// \param yyvalue   the value to check
227     static bool yy_pact_value_is_default_ (int yyvalue);
228
229     /// Whether the given \c yytable_ value indicates a syntax error.
230     /// \param yyvalue   the value to check
231     static bool yy_table_value_is_error_ (int yyvalue);
232
233     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
234     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
235
236     /// Convert a scanner token number \a t to a symbol number.
237     static token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t);
238
239     // Tables.
240 ]b4_parser_tables_declare[]b4_error_verbose_if([
241
242     /// Convert the symbol name \a n to a form suitable for a diagnostic.
243     static std::string yytnamerr_ (const char *n);])[
244
245 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
246     /// For a symbol, its name in clear.
247     static const char* const yytname_[];
248 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
249 ]b4_integral_parser_table_declare([rline], [b4_rline],
250      [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[
251     /// Report on the debug stream that the rule \a r is going to be reduced.
252     virtual void yy_reduce_print_ (int r);
253     /// Print the state stack on the debug stream.
254     virtual void yystack_print_ ();
255
256     // Debugging.
257     int yydebug_;
258     std::ostream* yycdebug_;
259
260     /// \brief Display a symbol type, value and location.
261     /// \param yyo    The output stream.
262     /// \param yysym  The symbol.
263     template <typename Base>
264     void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
265 #endif
266
267     /// \brief Reclaim the memory associated to a symbol.
268     /// \param yymsg     Why this token is reclaimed.
269     ///                  If null, print nothing.
270     /// \param s         The symbol.
271     template <typename Base>
272     void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
273
274   private:
275     /// Type access provider for state based symbols.
276     struct by_state
277     {
278       /// Default constructor.
279       by_state ();
280
281       /// The symbol type as needed by the constructor.
282       typedef state_type kind_type;
283
284       /// Constructor.
285       by_state (kind_type s);
286
287       /// Copy constructor.
288       by_state (const by_state& other);
289
290       /// Steal the symbol type from \a that.
291       void move (by_state& that);
292
293       /// The (internal) type number (corresponding to \a state).
294       /// "empty" when empty.
295       symbol_number_type type_get () const;
296
297       enum { empty = 0 };
298
299       /// The state.
300       state_type state;
301     };
302
303     /// "Internal" symbol: element of the stack.
304     struct stack_symbol_type : basic_symbol<by_state>
305     {
306       /// Superclass.
307       typedef basic_symbol<by_state> super_type;
308       /// Construct an empty symbol.
309       stack_symbol_type ();
310       /// Steal the contents from \a sym to build this.
311       stack_symbol_type (state_type s, symbol_type& sym);
312       /// Assignment, needed by push_back.
313       stack_symbol_type& operator= (const stack_symbol_type& that);
314     };
315
316     /// Stack type.
317     typedef stack<stack_symbol_type> stack_type;
318
319     /// The stack.
320     stack_type yystack_;
321
322     /// Push a new state on the stack.
323     /// \param m    a debug message to display
324     ///             if null, no trace is output.
325     /// \param s    the symbol
326     /// \warning the contents of \a s.value is stolen.
327     void yypush_ (const char* m, stack_symbol_type& s);
328
329     /// Push a new look ahead token on the state on the stack.
330     /// \param m    a debug message to display
331     ///             if null, no trace is output.
332     /// \param s    the state
333     /// \param sym  the symbol (for its value and location).
334     /// \warning the contents of \a s.value is stolen.
335     void yypush_ (const char* m, state_type s, symbol_type& sym);
336
337     /// Pop \a n symbols the three stacks.
338     void yypop_ (unsigned int n = 1);
339
340     // Constants.
341     enum
342     {
343       yyeof_ = 0,
344       yylast_ = ]b4_last[,           //< Last index in yytable_.
345       yynnts_ = ]b4_nterms_number[,  //< Number of nonterminal symbols.
346       yyempty_ = -2,
347       yyfinal_ = ]b4_final_state_number[, //< Termination state number.
348       yyterror_ = 1,
349       yyerrcode_ = 256,
350       yyntokens_ = ]b4_tokens_number[    //< Number of tokens.
351     };
352
353 ]b4_parse_param_vars[
354   };
355
356 ]b4_token_ctor_if([b4_yytranslate_define
357 b4_public_types_define])[
358 ]b4_namespace_close[
359
360 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
361 [b4_token_defines
362
363 #ifndef ]b4_api_PREFIX[STYPE
364  // Redirection for backward compatibility.
365 # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type
366 #endif
367 ])[
368 ]b4_percent_code_get([[provides]])[
369 ]])
370
371 b4_defines_if(
372 [b4_output_begin([b4_spec_defines_file])
373 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
374 [
375 /**
376  ** \file ]b4_spec_defines_file[
377  ** Define the ]b4_namespace_ref[::parser class.
378  */
379
380 // C++ LALR(1) parser skeleton written by Akim Demaille.
381
382 ]b4_cpp_guard_open([b4_spec_defines_file])[
383 ]b4_shared_declarations[
384 ]b4_cpp_guard_close([b4_spec_defines_file])
385 b4_output_end()
386 ])
387
388
389 b4_output_begin([b4_parser_file_name])
390 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
391 b4_percent_code_get([[top]])[]dnl
392 m4_if(b4_prefix, [yy], [],
393 [
394 // Take the name prefix into account.
395 #define yylex   b4_prefix[]lex])[
396
397 // First part of user declarations.
398 ]b4_user_pre_prologue[
399
400 ]b4_null_define[
401
402 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
403                [b4_shared_declarations])[
404
405 // User implementation prologue.
406 ]b4_user_post_prologue[
407 ]b4_percent_code_get[
408
409 #ifndef YY_
410 # if defined YYENABLE_NLS && YYENABLE_NLS
411 #  if ENABLE_NLS
412 #   include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
413 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
414 #  endif
415 # endif
416 # ifndef YY_
417 #  define YY_(msgid) msgid
418 # endif
419 #endif
420
421 ]b4_locations_if([dnl
422 [#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
423 ]b4_yylloc_default_define])[
424
425 // Suppress unused-variable warnings by "using" E.
426 #define YYUSE(E) ((void) (E))
427
428 // Enable debugging if requested.
429 #if ]b4_api_PREFIX[DEBUG
430
431 // A pseudo ostream that takes yydebug_ into account.
432 # define YYCDEBUG if (yydebug_) (*yycdebug_)
433
434 # define YY_SYMBOL_PRINT(Title, Symbol)         \
435   do {                                          \
436     if (yydebug_)                               \
437     {                                           \
438       *yycdebug_ << Title << ' ';               \
439       yy_print_ (*yycdebug_, Symbol);           \
440       *yycdebug_ << std::endl;                  \
441     }                                           \
442   } while (false)
443
444 # define YY_REDUCE_PRINT(Rule)          \
445   do {                                  \
446     if (yydebug_)                       \
447       yy_reduce_print_ (Rule);          \
448   } while (false)
449
450 # define YY_STACK_PRINT()               \
451   do {                                  \
452     if (yydebug_)                       \
453       yystack_print_ ();                \
454   } while (false)
455
456 #else // !]b4_api_PREFIX[DEBUG
457
458 # define YYCDEBUG if (false) std::cerr
459 # define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)
460 # define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
461 # define YY_STACK_PRINT()                static_cast<void>(0)
462
463 #endif // !]b4_api_PREFIX[DEBUG
464
465 #define yyerrok         (yyerrstatus_ = 0)
466 #define yyclearin       (yyempty = true)
467
468 #define YYACCEPT        goto yyacceptlab
469 #define YYABORT         goto yyabortlab
470 #define YYERROR         goto yyerrorlab
471 #define YYRECOVERING()  (!!yyerrstatus_)
472
473 ]b4_namespace_open[]b4_error_verbose_if([[
474
475   /* Return YYSTR after stripping away unnecessary quotes and
476      backslashes, so that it's suitable for yyerror.  The heuristic is
477      that double-quoting is unnecessary unless the string contains an
478      apostrophe, a comma, or backslash (other than backslash-backslash).
479      YYSTR is taken from yytname.  */
480   std::string
481   ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
482   {
483     if (*yystr == '"')
484       {
485         std::string yyr = "";
486         char const *yyp = yystr;
487
488         for (;;)
489           switch (*++yyp)
490             {
491             case '\'':
492             case ',':
493               goto do_not_strip_quotes;
494
495             case '\\':
496               if (*++yyp != '\\')
497                 goto do_not_strip_quotes;
498               // Fall through.
499             default:
500               yyr += *yyp;
501               break;
502
503             case '"':
504               return yyr;
505             }
506       do_not_strip_quotes: ;
507       }
508
509     return yystr;
510   }
511 ]])[
512
513   /// Build a parser object.
514   ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
515     :])[
516 #if ]b4_api_PREFIX[DEBUG
517     ]m4_ifset([b4_parse_param], [  ], [ :])[yydebug_ (false),
518       yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
519 #endif]b4_parse_param_cons[
520   {}
521
522   ]b4_parser_class_name::~b4_parser_class_name[ ()
523   {}
524
525
526   /*---------------.
527   | Symbol types.  |
528   `---------------*/
529
530 ]b4_token_ctor_if([], [b4_public_types_define])[
531
532   // by_state.
533   inline
534   ]b4_parser_class_name[::by_state::by_state ()
535     : state (empty)
536   {}
537
538   inline
539   ]b4_parser_class_name[::by_state::by_state (const by_state& other)
540     : state (other.state)
541   {}
542
543   inline
544   void
545   ]b4_parser_class_name[::by_state::move (by_state& that)
546   {
547     state = that.state;
548     that.state = empty;
549   }
550
551   inline
552   ]b4_parser_class_name[::by_state::by_state (state_type s)
553     : state (s)
554   {}
555
556   inline
557   ]b4_parser_class_name[::symbol_number_type
558   ]b4_parser_class_name[::by_state::type_get () const
559   {
560     return state == empty ? 0 : yystos_[state];
561   }
562
563   inline
564   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
565   {}
566
567
568   inline
569   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that)
570     : super_type (s]b4_locations_if([, that.location])[)
571   {
572     ]b4_variant_if([b4_symbol_variant([that.type_get ()],
573                                       [value], [move], [that.value])],
574                    [[value = that.value;]])[
575     // that is emptied.
576     that.type = empty;
577   }
578
579   inline
580   ]b4_parser_class_name[::stack_symbol_type&
581   ]b4_parser_class_name[::stack_symbol_type::operator= (const stack_symbol_type& that)
582   {
583     state = that.state;
584     ]b4_variant_if([b4_symbol_variant([that.type_get ()],
585                                       [value], [copy], [that.value])],
586                    [[value = that.value;]])[]b4_locations_if([
587     location = that.location;])[
588     return *this;
589   }
590
591
592   template <typename Base>
593   inline
594   void
595   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
596   {
597     if (yymsg)
598       YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [
599
600     // User destructor.
601     b4_symbol_actions([destructor], [yysym.type_get ()])])[
602   }
603
604 #if ]b4_api_PREFIX[DEBUG
605   template <typename Base>
606   void
607   ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
608                                      const basic_symbol<Base>& yysym) const
609   {
610     std::ostream& yyoutput = yyo;
611     YYUSE (yyoutput);
612     symbol_number_type yytype = yysym.type_get ();
613     yyo << (yytype < yyntokens_ ? "token" : "nterm")
614         << ' ' << yytname_[yytype] << " ("]b4_locations_if([
615         << yysym.location << ": "])[;
616     ]b4_symbol_actions([printer])[
617     yyo << ')';
618   }
619 #endif
620
621   inline
622   void
623   ]b4_parser_class_name[::yypush_ (const char* m, state_type s, symbol_type& sym)
624   {
625     stack_symbol_type t (s, sym);
626     yypush_ (m, t);
627   }
628
629   inline
630   void
631   ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
632   {
633     if (m)
634       YY_SYMBOL_PRINT (m, s);
635     yystack_.push (s);
636   }
637
638   inline
639   void
640   ]b4_parser_class_name[::yypop_ (unsigned int n)
641   {
642     yystack_.pop (n);
643   }
644
645 #if ]b4_api_PREFIX[DEBUG
646   std::ostream&
647   ]b4_parser_class_name[::debug_stream () const
648   {
649     return *yycdebug_;
650   }
651
652   void
653   ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
654   {
655     yycdebug_ = &o;
656   }
657
658
659   ]b4_parser_class_name[::debug_level_type
660   ]b4_parser_class_name[::debug_level () const
661   {
662     return yydebug_;
663   }
664
665   void
666   ]b4_parser_class_name[::set_debug_level (debug_level_type l)
667   {
668     yydebug_ = l;
669   }
670 #endif // ]b4_api_PREFIX[DEBUG
671
672   inline ]b4_parser_class_name[::state_type
673   ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
674   {
675     int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
676     if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
677       return yytable_[yyr];
678     else
679       return yydefgoto_[yylhs - yyntokens_];
680   }
681
682   inline bool
683   ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue)
684   {
685     return yyvalue == yypact_ninf_;
686   }
687
688   inline bool
689   ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue)
690   {
691     return yyvalue == yytable_ninf_;
692   }
693
694   int
695   ]b4_parser_class_name[::parse ()
696   {
697     /// Whether yyla contains a lookahead.
698     bool yyempty = true;
699
700     // State.
701     int yyn;
702     int yylen = 0;
703
704     // Error handling.
705     int yynerrs_ = 0;
706     int yyerrstatus_ = 0;
707
708     /// The lookahead symbol.
709     symbol_type yyla;]b4_locations_if([[
710
711     /// The locations where the error started and ended.
712     stack_symbol_type yyerror_range[3];]])[
713
714     /// $$ and @@$.
715     stack_symbol_type yylhs;
716
717     /// The return value of parse ().
718     int yyresult;
719
720     // FIXME: This shoud be completely indented.  It is not yet to
721     // avoid gratuitous conflicts when merging into the master branch.
722     try
723       {
724     YYCDEBUG << "Starting parse" << std::endl;
725
726 ]m4_ifdef([b4_initial_action], [
727 b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl
728     // User initialization code.
729     b4_user_initial_action
730 b4_dollar_popdef])[]dnl
731
732   [  /* Initialize the stack.  The initial state will be set in
733        yynewstate, since the latter expects the semantical and the
734        location values to have been already stored, initialize these
735        stacks with a primary value.  */
736     yystack_.clear ();
737     yypush_ (YY_NULL, 0, yyla);
738
739     // A new symbol was pushed on the stack.
740   yynewstate:
741     YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
742
743     // Accept?
744     if (yystack_[0].state == yyfinal_)
745       goto yyacceptlab;
746
747     goto yybackup;
748
749     // Backup.
750   yybackup:
751
752     // Try to take a decision without lookahead.
753     yyn = yypact_[yystack_[0].state];
754     if (yy_pact_value_is_default_ (yyn))
755       goto yydefault;
756
757     // Read a lookahead token.
758     if (yyempty)
759       {
760         YYCDEBUG << "Reading a token: ";
761         try
762           {]b4_token_ctor_if([[
763             symbol_type yylookahead (]b4_lex[);
764             yyla.move (yylookahead);]], [[
765             yyla.type = yytranslate_ (]b4_lex[);]])[
766           }
767         catch (const syntax_error& yyexc)
768           {
769             error (yyexc);
770             goto yyerrlab1;
771           }
772         yyempty = false;
773       }
774     YY_SYMBOL_PRINT ("Next token is", yyla);
775
776     /* If the proper action on seeing token YYLA.TYPE is to reduce or
777        to detect an error, take that action.  */
778     yyn += yyla.type_get ();
779     if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ())
780       goto yydefault;
781
782     // Reduce or error.
783     yyn = yytable_[yyn];
784     if (yyn <= 0)
785       {
786         if (yy_table_value_is_error_ (yyn))
787           goto yyerrlab;
788         yyn = -yyn;
789         goto yyreduce;
790       }
791
792     // Discard the token being shifted.
793     yyempty = true;
794
795     // Count tokens shifted since error; after three, turn off error status.
796     if (yyerrstatus_)
797       --yyerrstatus_;
798
799     // Shift the lookahead token.
800     yypush_ ("Shifting", yyn, yyla);
801     goto yynewstate;
802
803   /*-----------------------------------------------------------.
804   | yydefault -- do the default action for the current state.  |
805   `-----------------------------------------------------------*/
806   yydefault:
807     yyn = yydefact_[yystack_[0].state];
808     if (yyn == 0)
809       goto yyerrlab;
810     goto yyreduce;
811
812   /*-----------------------------.
813   | yyreduce -- Do a reduction.  |
814   `-----------------------------*/
815   yyreduce:
816     yylen = yyr2_[yyn];
817     yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([
818     /* Variants are always initialized to an empty instance of the
819        correct type. The default $$=$1 action is NOT applied when using
820        variants.  */
821     b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[
822     /* If YYLEN is nonzero, implement the default value of the action:
823        '$$ = $1'.  Otherwise, use the top of the stack.
824
825        Otherwise, the following line sets YYLHS.VALUE to garbage.
826        This behavior is undocumented and Bison
827        users should not rely upon it.  */
828     if (yylen)
829       yylhs.value = yystack_@{yylen - 1@}.value;
830     else
831       yylhs.value = yystack_@{0@}.value;])[
832 ]b4_locations_if([dnl
833 [
834     // Compute the default @@$.
835     {
836       slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
837       YYLLOC_DEFAULT (yylhs.location, slice, yylen);
838     }]])[
839
840     // Perform the reduction.
841     YY_REDUCE_PRINT (yyn);
842     try
843       {
844         switch (yyn)
845           {
846 ]b4_user_actions[
847           default:
848             break;
849           }
850       }
851     catch (const syntax_error& yyexc)
852       {
853         error (yyexc);
854         YYERROR;
855       }
856     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
857     yypop_ (yylen);
858     yylen = 0;
859     YY_STACK_PRINT ();
860
861     // Shift the result of the reduction.
862     yypush_ (YY_NULL, yylhs);
863     goto yynewstate;
864
865   /*--------------------------------------.
866   | yyerrlab -- here on detecting error.  |
867   `--------------------------------------*/
868   yyerrlab:
869     // If not already recovering from an error, report this error.
870     if (!yyerrstatus_)
871       {
872         ++yynerrs_;
873         error (]b4_join(b4_locations_if([yyla.location]),
874                         [[yysyntax_error_ (yystack_[0].state,
875                                            yyempty ? yyempty_ : yyla.type_get ())]])[);
876       }
877
878 ]b4_locations_if([[
879     yyerror_range[1].location = yyla.location;]])[
880     if (yyerrstatus_ == 3)
881       {
882         /* If just tried and failed to reuse lookahead token after an
883            error, discard it.  */
884
885         // Return failure if at end of input.
886         if (yyla.type_get () == yyeof_)
887           YYABORT;
888         else if (!yyempty)
889           {
890             yy_destroy_ ("Error: discarding", yyla);
891             yyempty = true;
892           }
893       }
894
895     // Else will try to reuse lookahead token after shifting the error token.
896     goto yyerrlab1;
897
898
899   /*---------------------------------------------------.
900   | yyerrorlab -- error raised explicitly by YYERROR.  |
901   `---------------------------------------------------*/
902   yyerrorlab:
903
904     /* Pacify compilers like GCC when the user code never invokes
905        YYERROR and the label yyerrorlab therefore never appears in user
906        code.  */
907     if (false)
908       goto yyerrorlab;]b4_locations_if([[
909     yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[
910     /* $$ was initialized before running the user action.  */
911     YY_SYMBOL_PRINT ("Error: discarding", yylhs);
912     yylhs.~stack_symbol_type();]])[
913     /* Do not reclaim the symbols of the rule whose action triggered
914        this YYERROR.  */
915     yypop_ (yylen);
916     yylen = 0;
917     goto yyerrlab1;
918
919   /*-------------------------------------------------------------.
920   | yyerrlab1 -- common code for both syntax error and YYERROR.  |
921   `-------------------------------------------------------------*/
922   yyerrlab1:
923     yyerrstatus_ = 3;   // Each real token shifted decrements this.
924     {
925       stack_symbol_type error_token;
926       for (;;)
927         {
928           yyn = yypact_[yystack_[0].state];
929           if (!yy_pact_value_is_default_ (yyn))
930             {
931               yyn += yyterror_;
932               if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
933                 {
934                   yyn = yytable_[yyn];
935                   if (0 < yyn)
936                     break;
937                 }
938             }
939
940           // Pop the current state because it cannot handle the error token.
941           if (yystack_.size () == 1)
942             YYABORT;
943 ]b4_locations_if([[
944           yyerror_range[1].location = yystack_[0].location;]])[
945           yy_destroy_ ("Error: popping", yystack_[0]);
946           yypop_ ();
947           YY_STACK_PRINT ();
948         }
949 ]b4_locations_if([[
950       yyerror_range[2].location = yyla.location;
951       YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
952
953       // Shift the error token.
954       error_token.state = yyn;
955       yypush_ ("Shifting", error_token);
956     }
957     goto yynewstate;
958
959     // Accept.
960   yyacceptlab:
961     yyresult = 0;
962     goto yyreturn;
963
964     // Abort.
965   yyabortlab:
966     yyresult = 1;
967     goto yyreturn;
968
969   yyreturn:
970     if (!yyempty)
971       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
972
973     /* Do not reclaim the symbols of the rule whose action triggered
974        this YYABORT or YYACCEPT.  */
975     yypop_ (yylen);
976     while (1 < yystack_.size ())
977       {
978         yy_destroy_ ("Cleanup: popping", yystack_[0]);
979         yypop_ ();
980       }
981
982     return yyresult;
983   }
984     catch (...)
985       {
986         YYCDEBUG << "Exception caught: cleaning lookahead and stack"
987                  << std::endl;
988         // Do not try to display the values of the reclaimed symbols,
989         // as their printer might throw an exception.
990         if (!yyempty)
991           yy_destroy_ (YY_NULL, yyla);
992
993         while (1 < yystack_.size ())
994           {
995             yy_destroy_ (YY_NULL, yystack_[0]);
996             yypop_ ();
997           }
998         throw;
999       }
1000   }
1001
1002   void
1003   ]b4_parser_class_name[::error (const syntax_error& yyexc)
1004   {
1005     error (]b4_join(b4_locations_if([yyexc.location]),
1006                     [[yyexc.what()]])[);
1007   }
1008
1009   // Generate an error message.
1010   std::string
1011   ]b4_parser_class_name[::yysyntax_error_ (]dnl
1012 b4_error_verbose_if([state_type yystate, symbol_number_type yytoken],
1013                     [state_type, symbol_number_type])[) const
1014   {]b4_error_verbose_if([[
1015     std::string yyres;
1016     // Number of reported tokens (one for the "unexpected", one per
1017     // "expected").
1018     size_t yycount = 0;
1019     // Its maximum.
1020     enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1021     // Arguments of yyformat.
1022     char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1023
1024     /* There are many possibilities here to consider:
1025        - If this state is a consistent state with a default action, then
1026          the only way this function was invoked is if the default action
1027          is an error action.  In that case, don't check for expected
1028          tokens because there are none.
1029        - The only way there can be no lookahead present (in yytoken) is
1030          if this state is a consistent state with a default action.
1031          Thus, detecting the absence of a lookahead is sufficient to
1032          determine that there is no unexpected or expected token to
1033          report.  In that case, just report a simple "syntax error".
1034        - Don't assume there isn't a lookahead just because this state is
1035          a consistent state with a default action.  There might have
1036          been a previous inconsistent state, consistent state with a
1037          non-default action, or user semantic action that manipulated
1038          yyla.  (However, yyla is currently not documented for users.)
1039        - Of course, the expected token list depends on states to have
1040          correct lookahead information, and it depends on the parser not
1041          to perform extra reductions after fetching a lookahead from the
1042          scanner and before detecting a syntax error.  Thus, state
1043          merging (from LALR or IELR) and default reductions corrupt the
1044          expected token list.  However, the list is correct for
1045          canonical LR with one exception: it will still contain any
1046          token that will not be accepted due to an error action in a
1047          later state.
1048     */
1049     if (yytoken != yyempty_)
1050       {
1051         yyarg[yycount++] = yytname_[yytoken];
1052         int yyn = yypact_[yystate];
1053         if (!yy_pact_value_is_default_ (yyn))
1054           {
1055             /* Start YYX at -YYN if negative to avoid negative indexes in
1056                YYCHECK.  In other words, skip the first -YYN actions for
1057                this state because they are default actions.  */
1058             int yyxbegin = yyn < 0 ? -yyn : 0;
1059             // Stay within bounds of both yycheck and yytname.
1060             int yychecklim = yylast_ - yyn + 1;
1061             int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1062             for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1063               if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1064                   && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1065                 {
1066                   if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1067                     {
1068                       yycount = 1;
1069                       break;
1070                     }
1071                   else
1072                     yyarg[yycount++] = yytname_[yyx];
1073                 }
1074           }
1075       }
1076
1077     char const* yyformat = YY_NULL;
1078     switch (yycount)
1079       {
1080 #define YYCASE_(N, S)                         \
1081         case N:                               \
1082           yyformat = S;                       \
1083         break
1084         YYCASE_(0, YY_("syntax error"));
1085         YYCASE_(1, YY_("syntax error, unexpected %s"));
1086         YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1087         YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1088         YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1089         YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1090 #undef YYCASE_
1091       }
1092
1093     // Argument number.
1094     size_t yyi = 0;
1095     for (char const* yyp = yyformat; *yyp; ++yyp)
1096       if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1097         {
1098           yyres += yytnamerr_ (yyarg[yyi++]);
1099           ++yyp;
1100         }
1101       else
1102         yyres += *yyp;
1103     return yyres;]], [[
1104     return YY_("syntax error");]])[
1105   }
1106
1107
1108   const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1109
1110   const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1111
1112 ]b4_parser_tables_define[
1113
1114 ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[
1115   // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1116   // First, the terminals, then, starting at \a yyntokens_, nonterminals.
1117   const char*
1118   const ]b4_parser_class_name[::yytname_[] =
1119   {
1120   ]b4_tname[
1121   };
1122
1123 ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[
1124 ]b4_integral_parser_table_define([rline], [b4_rline])[
1125
1126   // Print the state stack on the debug stream.
1127   void
1128   ]b4_parser_class_name[::yystack_print_ ()
1129   {
1130     *yycdebug_ << "Stack now";
1131     for (stack_type::const_iterator
1132            i = yystack_.begin (),
1133            i_end = yystack_.end ();
1134          i != i_end; ++i)
1135       *yycdebug_ << ' ' << i->state;
1136     *yycdebug_ << std::endl;
1137   }
1138
1139   // Report on the debug stream that the rule \a yyrule is going to be reduced.
1140   void
1141   ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1142   {
1143     unsigned int yylno = yyrline_[yyrule];
1144     int yynrhs = yyr2_[yyrule];
1145     // Print the symbols being reduced, and their result.
1146     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1147                << " (line " << yylno << "):" << std::endl;
1148     // The symbols being reduced.
1149     for (int yyi = 0; yyi < yynrhs; yyi++)
1150       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1151                        ]b4_rhs_data(yynrhs, yyi + 1)[);
1152   }
1153 #endif // ]b4_api_PREFIX[DEBUG
1154
1155 ]b4_token_ctor_if([], [b4_yytranslate_define])[
1156 ]b4_namespace_close[
1157 ]b4_epilogue[]dnl
1158 b4_output_end()
1159
1160
1161 m4_popdef([b4_copyright_years])dnl