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