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