]> git.saurik.com Git - bison.git/blob - data/lalr1.cc
projects / bison.git / blob
? search:


646ee904bebaab3720b3d38ade71aa80bd1d03c7
[bison.git] / data / lalr1.cc
1 # C++ skeleton for Bison
2
3 # Copyright (C) 2002-2010 Free Software Foundation, Inc.
4
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
17
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>_" which contents is CONTENT.
24 m4_define([b4_integral_parser_table_declare],
25 [m4_ifval([$3], [b4_c_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>_" which 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_dollar_dollar],
102 [b4_symbol_value_template([yysym.value],
103 b4_symbol_if([$1], [has_type],
104 [b4_symbol([$1], [type])]))])dnl
105 m4_pushdef([b4_at_dollar], [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_at_dollar])dnl
113 m4_popdef([b4_dollar_dollar])dnl
114 ])])
115
116
117 m4_pushdef([b4_copyright_years],
118 [2002-2010])
119
120 m4_define([b4_parser_class_name],
121 [b4_percent_define_get([[parser_class_name]])])
122
123 # The header is mandatory.
124 b4_defines_if([],
125 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
126
127 b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
128 [# Backward compatibility.
129 m4_define([b4_location_constructors])
130 m4_include(b4_pkgdatadir/[location.cc])])])
131 m4_include(b4_pkgdatadir/[stack.hh])
132 b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
133
134 # We do want M4 expansion after # for CPP macros.
135 m4_changecom()
136 m4_divert_push(0)dnl
137 @output(b4_spec_defines_file@)@
138 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
139 dnl FIXME: This is wrong, we want computed header guards.
140 [
141 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
142
143 #ifndef PARSER_HEADER_H
144 # define PARSER_HEADER_H
145
146 ]b4_percent_code_get([[requires]])[
147
148 ]b4_parse_assert_if([#include <cassert>])[
149 #include <stdexcept>
150 #include <string>
151 #include <iostream>
152 #include "stack.hh"
153 ]b4_locations_if([b4_percent_define_ifdef([[location_type]], [],
154 [[#include "location.hh"]])])[
155
156 ]b4_variant_if([b4_namespace_open
157 b4_variant_define
158 b4_namespace_close])[
159
160 /* Enabling traces. */
161 #ifndef YYDEBUG
162 # define YYDEBUG ]b4_parse_trace_if([1], [0])[
163 #endif
164
165 /* Enabling verbose error messages. */
166 #ifdef YYERROR_VERBOSE
167 # undef YYERROR_VERBOSE
168 # define YYERROR_VERBOSE 1
169 #else
170 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
171 #endif
172
173 /* Enabling the token table. */
174 #ifndef YYTOKEN_TABLE
175 # define YYTOKEN_TABLE ]b4_token_table[
176 #endif
177
178 ]b4_namespace_open[
179
180 /// A Bison parser.
181 class ]b4_parser_class_name[
182 {
183 public:
184 ]b4_public_types_declare[
185 /// Build a parser object.
186 ]b4_parser_class_name[ (]b4_parse_param_decl[);
187 virtual ~]b4_parser_class_name[ ();
188
189 /// Parse.
190 /// \returns 0 iff parsing succeeded.
191 virtual int parse ();
192
193 #if YYDEBUG
194 /// The current debugging stream.
195 std::ostream& debug_stream () const;
196 /// Set the current debugging stream.
197 void set_debug_stream (std::ostream &);
198
199 /// Type for debugging levels.
200 typedef int debug_level_type;
201 /// The current debugging level.
202 debug_level_type debug_level () const;
203 /// Set the current debugging level.
204 void set_debug_level (debug_level_type l);
205 #endif
206
207 /// Report a syntax error.]b4_locations_if([
208 /// \param loc where the syntax error is found.])[
209 /// \param msg a description of the syntax error.
210 virtual void error (]b4_locations_if([const location_type& loc, ])[const std::string& msg);
211
212 private:
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 yytoken the lookahead token.
219 virtual std::string yysyntax_error_ (state_type yystate, int yytoken);
220
221 /// Compute post-reduction state.
222 /// \param yystate the current state
223 /// \param yylhs the nonterminal to push on the stack
224 state_type yy_lr_goto_state_ (state_type yystate, int yylhs);
225
226 /// Whether the given \c yypact_ value indicates a defaulted state.
227 /// \param yyvalue the value to check
228 static bool yy_pact_value_is_default_ (int yyvalue);
229
230 /// Whether the given \c yytable_ value indicates a syntax error.
231 /// \param yyvalue the value to check
232 static bool yy_table_value_is_error_ (int yyvalue);
233
234 /// Internal symbol numbers.
235 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
236 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
237 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
238
239 /* Tables. */
240 ]b4_parser_tables_declare[
241
242 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
243 /// For a symbol, its name in clear.
244 static const char* const yytname_[];
245 #endif]b4_error_verbose_if([
246
247 /// Convert the symbol name \a n to a form suitable for a diagnostic.
248 static std::string yytnamerr_ (const char *n);])[
249
250 #if YYDEBUG
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 #endif
262
263 /// Convert a scanner token number \a t to a symbol number.
264 static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
265
266 #if YYDEBUG
267 /// \brief Display a symbol type, value and location.
268 /// \param yyo The output stream.
269 /// \param yysym The symbol.
270 template <typename Exact>
271 void yy_print_ (std::ostream& yyo,
272 const symbol_base_type<Exact>& yysym) const;
273 #endif
274
275 /// \brief Reclaim the memory associated to a symbol.
276 /// \param yymsg Why this token is reclaimed.
277 /// If null, print nothing.
278 /// \param s The symbol.
279 template <typename Exact>
280 inline void yy_destroy_ (const char* yymsg,
281 symbol_base_type<Exact>& yysym) const;
282
283 private:
284 /// Element of the stack: a state and its attributes.
285 struct stack_symbol_type : symbol_base_type<stack_symbol_type>
286 {
287 /// The parent class.
288 typedef symbol_base_type<stack_symbol_type> super_type;
289
290 /// Default constructor.
291 inline stack_symbol_type ();
292
293 /// Constructor.
294 inline stack_symbol_type (]b4_args([state_type s],
295 [const semantic_type& v],
296 b4_locations_if([const location_type& l]))[);
297
298 /// The state.
299 state_type state;
300
301 /// The type (corresponding to \a state).
302 inline int type_get_ () const;
303 };
304
305 /// Stack type.
306 typedef stack<stack_symbol_type> stack_type;
307
308 /// The stack.
309 stack_type yystack_;
310
311 /// Push a new state on the stack.
312 /// \param m a debug message to display
313 /// if null, no trace is output.
314 /// \param s the symbol
315 /// \warning the contents of \a s.value is stolen.
316 inline void yypush_ (const char* m, stack_symbol_type& s);
317
318 /// Push a new look ahead token on the state on the stack.
319 /// \param m a debug message to display
320 /// if null, no trace is output.
321 /// \param s the state
322 /// \param sym the symbol (for its value and location).
323 /// \warning the contents of \a s.value is stolen.
324 inline void yypush_ (const char* m, state_type s, symbol_type& sym);
325
326 /// Pop \a n symbols the three stacks.
327 inline void yypop_ (unsigned int n = 1);
328
329 /* Constants. */
330 enum
331 {
332 yyeof_ = 0,
333 yylast_ = ]b4_last[, //< Last index in yytable_.
334 yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols.
335 yyempty_ = -2,
336 yyfinal_ = ]b4_final_state_number[, //< Termination state number.
337 yyterror_ = 1,
338 yyerrcode_ = 256,
339 yyntokens_ = ]b4_tokens_number[, //< Number of tokens.
340 };
341
342 ]b4_parse_param_vars[
343 };
344
345 ]b4_lex_symbol_if([b4_yytranslate_define
346 b4_public_types_define])[
347 ]b4_namespace_close[
348
349 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
350 [b4_token_defines(b4_tokens)
351
352 #ifndef YYSTYPE
353 /* Redirection for backward compatibility. */
354 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
355 #endif
356 ])
357 b4_percent_code_get([[provides]])[]dnl
358
359 [#endif /* ! defined PARSER_HEADER_H */]
360 @output(b4_parser_file_name@)@
361 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
362 b4_percent_code_get([[top]])[]dnl
363 m4_if(b4_prefix, [yy], [],
364 [
365 // Take the name prefix into account.
366 #define yylex b4_prefix[]lex])[
367
368 /* First part of user declarations. */
369 ]b4_user_pre_prologue[
370
371 #include "@basename(]b4_spec_defines_file[@)"
372
373 /* User implementation prologue. */
374 ]b4_user_post_prologue
375 b4_percent_code_get[]dnl
376
377 [#ifndef YY_
378 # if defined YYENABLE_NLS && YYENABLE_NLS
379 # if ENABLE_NLS
380 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
381 # define YY_(msgid) dgettext ("bison-runtime", msgid)
382 # endif
383 # endif
384 # ifndef YY_
385 # define YY_(msgid) msgid
386 # endif
387 #endif
388
389 ]b4_locations_if([dnl
390 [/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
391 If N is 0, then set CURRENT to the empty location which ends
392 the previous symbol: RHS[0] (always defined). */
393
394 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
395 #ifndef YYLLOC_DEFAULT
396 # define YYLLOC_DEFAULT(Current, Rhs, N) \
397 do \
398 if (N) \
399 { \
400 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
401 (Current).end = YYRHSLOC (Rhs, N).end; \
402 } \
403 else \
404 { \
405 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
406 } \
407 while (false)
408 #endif]])[
409
410 /* Suppress unused-variable warnings by "using" E. */
411 #define YYUSE(e) ((void) (e))
412
413 /* Enable debugging if requested. */
414 #if YYDEBUG
415
416 /* A pseudo ostream that takes yydebug_ into account. */
417 # define YYCDEBUG if (yydebug_) (*yycdebug_)
418
419 # define YY_SYMBOL_PRINT(Title, Symbol) \
420 do { \
421 if (yydebug_) \
422 { \
423 *yycdebug_ << Title << ' '; \
424 yy_print_ (*yycdebug_, Symbol); \
425 *yycdebug_ << std::endl; \
426 } \
427 } while (false)
428
429 # define YY_REDUCE_PRINT(Rule) \
430 do { \
431 if (yydebug_) \
432 yy_reduce_print_ (Rule); \
433 } while (false)
434
435 # define YY_STACK_PRINT() \
436 do { \
437 if (yydebug_) \
438 yystack_print_ (); \
439 } while (false)
440
441 #else /* !YYDEBUG */
442
443 # define YYCDEBUG if (false) std::cerr
444 # define YY_SYMBOL_PRINT(Title, Symbol) static_cast<void>(0)
445 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
446 # define YY_STACK_PRINT() static_cast<void>(0)
447
448 #endif /* !YYDEBUG */
449
450 #define yyerrok (yyerrstatus_ = 0)
451 #define yyclearin (yyempty = true)
452
453 #define YYACCEPT goto yyacceptlab
454 #define YYABORT goto yyabortlab
455 #define YYERROR goto yyerrorlab
456 #define YYRECOVERING() (!!yyerrstatus_)
457
458 ]b4_namespace_open[]b4_error_verbose_if([[
459
460 /* Return YYSTR after stripping away unnecessary quotes and
461 backslashes, so that it's suitable for yyerror. The heuristic is
462 that double-quoting is unnecessary unless the string contains an
463 apostrophe, a comma, or backslash (other than backslash-backslash).
464 YYSTR is taken from yytname. */
465 std::string
466 ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
467 {
468 if (*yystr == '"')
469 {
470 std::string yyr = "";
471 char const *yyp = yystr;
472
473 for (;;)
474 switch (*++yyp)
475 {
476 case '\'':
477 case ',':
478 goto do_not_strip_quotes;
479
480 case '\\':
481 if (*++yyp != '\\')
482 goto do_not_strip_quotes;
483 /* Fall through. */
484 default:
485 yyr += *yyp;
486 break;
487
488 case '"':
489 return yyr;
490 }
491 do_not_strip_quotes: ;
492 }
493
494 return yystr;
495 }
496 ]])[
497
498 /// Build a parser object.
499 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
500 :])[
501 #if YYDEBUG
502 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
503 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
504 #endif]b4_parse_param_cons[
505 {
506 }
507
508 ]b4_parser_class_name::~b4_parser_class_name[ ()
509 {
510 }
511
512
513 /*---------------.
514 | Symbol types. |
515 `---------------*/
516
517 ]b4_lex_symbol_if([], [b4_public_types_define])[
518
519 // stack_symbol_type.
520 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
521 : super_type ()
522 , state ()
523 {
524 }
525
526 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_args(
527 [state_type s],
528 [const semantic_type& v],
529 b4_locations_if([const location_type& l]))[)
530 : super_type (v]b4_locations_if([, l])[)
531 , state (s)
532 {
533 }
534
535 int
536 ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
537 {
538 return yystos_[state];
539 }
540
541
542 template <typename Exact>
543 void
544 ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
545 symbol_base_type<Exact>& yysym) const
546 {
547 int yytype = yysym.type_get ();
548 YYUSE (yymsg);
549 if (yymsg)
550 YY_SYMBOL_PRINT (yymsg, yysym);
551
552 // User destructor.
553 switch (yytype)
554 {
555 ]b4_symbol_foreach([b4_symbol_destructor])dnl
556 [ default:
557 break;
558 }]b4_variant_if([
559
560 // Type destructor.
561 b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
562 }
563
564 #if YYDEBUG
565 template <typename Exact>
566 void
567 ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
568 const symbol_base_type<Exact>& yysym) const
569 {
570 int yytype = yysym.type_get ();
571 yyo << (yytype < yyntokens_ ? "token" : "nterm")
572 << ' ' << yytname_[yytype] << " ("]b4_locations_if([
573 << yysym.location << ": "])[;
574 switch (yytype)
575 {
576 ]b4_symbol_foreach([b4_symbol_printer])dnl
577 [ default:
578 break;
579 }
580 yyo << ')';
581 }
582 #endif
583
584 void
585 ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
586 symbol_type& sym)
587 {
588 if (m)
589 YY_SYMBOL_PRINT (m, sym);
590 ]b4_variant_if(
591 [[ yystack_.push (stack_symbol_type (]b4_args(
592 [s],
593 [semantic_type()],
594 b4_locations_if([sym.location]))[));
595 ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
596 [build], [sym.value])],
597 [[ yystack_.push (stack_symbol_type (]b4_args(
598 [s],
599 [sym.value],
600 b4_locations_if([sym.location]))[));]])[
601 }
602
603 void
604 ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
605 {
606 if (m)
607 YY_SYMBOL_PRINT (m, s);
608 ]b4_variant_if(
609 [[ yystack_.push (stack_symbol_type (]b4_args(
610 [s.state],
611 [semantic_type()],
612 b4_locations_if([s.location]))[));
613 ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
614 [build], [s.value])],
615 [ yystack_.push (s);])[
616 }
617
618 void
619 ]b4_parser_class_name[::yypop_ (unsigned int n)
620 {
621 yystack_.pop (n);
622 }
623
624 #if YYDEBUG
625 std::ostream&
626 ]b4_parser_class_name[::debug_stream () const
627 {
628 return *yycdebug_;
629 }
630
631 void
632 ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
633 {
634 yycdebug_ = &o;
635 }
636
637
638 ]b4_parser_class_name[::debug_level_type
639 ]b4_parser_class_name[::debug_level () const
640 {
641 return yydebug_;
642 }
643
644 void
645 ]b4_parser_class_name[::set_debug_level (debug_level_type l)
646 {
647 yydebug_ = l;
648 }
649 #endif
650
651 inline ]b4_parser_class_name[::state_type
652 ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
653 {
654 int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
655 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
656 return yytable_[yyr];
657 else
658 return yydefgoto_[yylhs - yyntokens_];
659 }
660
661 inline bool
662 ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue)
663 {
664 return yyvalue == yypact_ninf_;
665 }
666
667 inline bool
668 ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue)
669 {
670 return yyvalue == yytable_ninf_;
671 }
672
673 int
674 ]b4_parser_class_name[::parse ()
675 {
676 /// Whether yyla contains a lookahead.
677 bool yyempty = true;
678
679 /* State. */
680 int yyn;
681 int yylen = 0;
682
683 /* Error handling. */
684 int yynerrs_ = 0;
685 int yyerrstatus_ = 0;
686
687 /// The lookahead symbol.
688 symbol_type yyla;]b4_locations_if([[
689
690 /// The locations where the error started and ended.
691 stack_symbol_type yyerror_range[3];]])[
692
693 /// $$ and @@$.
694 stack_symbol_type yylhs;
695
696 /// The return value of parse().
697 int yyresult;
698
699 YYCDEBUG << "Starting parse" << std::endl;
700
701 ]m4_ifdef([b4_initial_action], [
702 m4_pushdef([b4_at_dollar], [yyla.location])dnl
703 m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
704 /* User initialization code. */
705 b4_user_initial_action
706 m4_popdef([b4_dollar_dollar])dnl
707 m4_popdef([b4_at_dollar])])dnl
708
709 [ /* Initialize the stack. The initial state will be set in
710 yynewstate, since the latter expects the semantical and the
711 location values to have been already stored, initialize these
712 stacks with a primary value. */
713 yystack_ = stack_type (0);
714 yypush_ (0, 0, yyla);
715
716 // A new symbol was pushed on the stack.
717 yynewstate:
718 YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
719
720 /* Accept? */
721 if (yystack_[0].state == yyfinal_)
722 goto yyacceptlab;
723
724 goto yybackup;
725
726 /* Backup. */
727 yybackup:
728
729 /* Try to take a decision without lookahead. */
730 yyn = yypact_[yystack_[0].state];
731 if (yy_pact_value_is_default_ (yyn))
732 goto yydefault;
733
734 /* Read a lookahead token. */
735 if (yyempty)
736 {
737 YYCDEBUG << "Reading a token: ";
738 ]b4_lex_symbol_if(
739 [ yyla = b4_c_function_call([yylex], [symbol_type],
740 m4_ifdef([b4_lex_param], b4_lex_param));],
741 [ yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
742 [[YYSTYPE*], [&yyla.value]][]dnl
743 b4_locations_if([, [[location*], [&yyla.location]]])dnl
744 m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
745 yyempty = false;
746 }
747 YY_SYMBOL_PRINT ("Next token is", yyla);
748
749 /* If the proper action on seeing token YYLA.TYPE is to reduce or
750 to detect an error, take that action. */
751 yyn += yyla.type;
752 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
753 goto yydefault;
754
755 /* Reduce or error. */
756 yyn = yytable_[yyn];
757 if (yyn <= 0)
758 {
759 if (yy_table_value_is_error_ (yyn))
760 goto yyerrlab;
761 yyn = -yyn;
762 goto yyreduce;
763 }
764
765 /* Discard the token being shifted. */
766 yyempty = true;
767
768 /* Count tokens shifted since error; after three, turn off error
769 status. */
770 if (yyerrstatus_)
771 --yyerrstatus_;
772
773 /* Shift the lookahead token. */
774 yypush_ ("Shifting", yyn, yyla);
775 goto yynewstate;
776
777 /*-----------------------------------------------------------.
778 | yydefault -- do the default action for the current state. |
779 `-----------------------------------------------------------*/
780 yydefault:
781 yyn = yydefact_[yystack_[0].state];
782 if (yyn == 0)
783 goto yyerrlab;
784 goto yyreduce;
785
786 /*-----------------------------.
787 | yyreduce -- Do a reduction. |
788 `-----------------------------*/
789 yyreduce:
790 yylen = yyr2_[yyn];
791 yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([
792 /* Variants are always initialized to an empty instance of the
793 correct type. The default $$=$1 action is NOT applied when using
794 variants. */
795 b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[
796 /* If YYLEN is nonzero, implement the default value of the action:
797 `$$ = $1'. Otherwise, use the top of the stack.
798
799 Otherwise, the following line sets YYLHS.VALUE to garbage.
800 This behavior is undocumented and Bison
801 users should not rely upon it. */
802 if (yylen)
803 yylhs.value = yystack_@{yylen - 1@}.value;
804 else
805 yylhs.value = yystack_@{0@}.value;])[
806 ]b4_locations_if([dnl
807 [
808 // Compute the default @@$.
809 {
810 slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
811 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
812 }]])[
813
814 // Perform the reduction.
815 YY_REDUCE_PRINT (yyn);
816 try
817 {
818 switch (yyn)
819 {
820 ]b4_user_actions[
821 default:
822 break;
823 }
824 }
825 catch (const syntax_error& yyexc)
826 {
827 error (]b4_args(b4_locations_if([yyexc.location]),
828 [[yyexc.what()]])[);
829 YYERROR;
830 }
831 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
832 ]b4_variant_if([[
833 // Destroy the rhs symbols.
834 for (int i = 0; i < yylen; ++i)
835 // Destroy a variant which value may have been swapped with
836 // yylhs.value (for instance if the action was "std::swap($$,
837 // $1)"). The value of yylhs.value (hence possibly one of these
838 // rhs symbols) depends on the default contruction for this
839 // type. In the case of pointers for instance, no
840 // initialization is done, so the value is junk. Therefore do
841 // not try to report the value of symbols about to be destroyed
842 // in the debug trace, it's possibly junk. Hence yymsg = 0.
843 // Besides, that keeps exactly the same traces as with the other
844 // Bison skeletons.
845 yy_destroy_ (0, yystack_[i]);]])[
846
847 yypop_ (yylen);
848 yylen = 0;
849 YY_STACK_PRINT ();
850
851 /* Shift the result of the reduction. */
852 yypush_ (0, yylhs);
853 goto yynewstate;
854
855 /*--------------------------------------.
856 | yyerrlab -- here on detecting error. |
857 `--------------------------------------*/
858 yyerrlab:
859 /* If not already recovering from an error, report this error. */
860 if (!yyerrstatus_)
861 {
862 ++yynerrs_;
863 error (]b4_args(b4_locations_if([yyla.location]),
864 [[yysyntax_error_ (yystack_[0].state, yyla.type)]])[);
865 }
866
867 ]b4_locations_if([[
868 yyerror_range[1].location = yyla.location;]])[
869 if (yyerrstatus_ == 3)
870 {
871 /* If just tried and failed to reuse lookahead token after an
872 error, discard it. */
873
874 /* Return failure if at end of input. */
875 if (yyla.type == yyeof_)
876 YYABORT;
877 else if (!yyempty)
878 {
879 yy_destroy_ ("Error: discarding", yyla);
880 yyempty = true;
881 }
882 }
883
884 /* Else will try to reuse lookahead token after shifting the error
885 token. */
886 goto yyerrlab1;
887
888
889 /*---------------------------------------------------.
890 | yyerrorlab -- error raised explicitly by YYERROR. |
891 `---------------------------------------------------*/
892 yyerrorlab:
893
894 /* Pacify compilers like GCC when the user code never invokes
895 YYERROR and the label yyerrorlab therefore never appears in user
896 code. */
897 if (false)
898 goto yyerrorlab;]b4_locations_if([[
899 yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[
900 /* $$ was initialized before running the user action. */
901 yy_destroy_ ("Error: discarding", yylhs);]])[
902 /* Do not reclaim the symbols of the rule which action triggered
903 this YYERROR. */
904 yypop_ (yylen);
905 yylen = 0;
906 goto yyerrlab1;
907
908 /*-------------------------------------------------------------.
909 | yyerrlab1 -- common code for both syntax error and YYERROR. |
910 `-------------------------------------------------------------*/
911 yyerrlab1:
912 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
913 {
914 stack_symbol_type error_token;
915 for (;;)
916 {
917 yyn = yypact_[yystack_[0].state];
918 if (!yy_pact_value_is_default_ (yyn))
919 {
920 yyn += yyterror_;
921 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
922 {
923 yyn = yytable_[yyn];
924 if (0 < yyn)
925 break;
926 }
927 }
928
929 // Pop the current state because it cannot handle the error token.
930 if (yystack_.size () == 1)
931 YYABORT;
932 ]b4_locations_if([[
933 yyerror_range[1].location = yystack_[0].location;]])[
934 yy_destroy_ ("Error: popping", yystack_[0]);
935 yypop_ ();
936 YY_STACK_PRINT ();
937 }
938 ]b4_locations_if([[
939 yyerror_range[2].location = yyla.location;
940 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[
941
942 /* Shift the error token. */
943 error_token.state = yyn;
944 yypush_ ("Shifting", error_token);
945 }
946 goto yynewstate;
947
948 /* Accept. */
949 yyacceptlab:
950 yyresult = 0;
951 goto yyreturn;
952
953 /* Abort. */
954 yyabortlab:
955 yyresult = 1;
956 goto yyreturn;
957
958 yyreturn:
959 if (!yyempty)
960 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
961
962 /* Do not reclaim the symbols of the rule which action triggered
963 this YYABORT or YYACCEPT. */
964 yypop_ (yylen);
965 while (yystack_.size () != 1)
966 {
967 yy_destroy_ ("Cleanup: popping", yystack_[0]);
968 yypop_ ();
969 }
970
971 return yyresult;
972 }
973
974 // Generate an error message.
975 std::string
976 ]b4_parser_class_name[::yysyntax_error_ (]dnl
977 b4_error_verbose_if([state_type yystate, int yytoken],
978 [int, int])[)
979 {
980 std::string yyres;]b4_error_verbose_if([[
981 int yyn = yypact_[yystate];
982 if (yypact_ninf_ < yyn && yyn <= yylast_)
983 {
984 /* Start YYX at -YYN if negative to avoid negative indexes in
985 YYCHECK. In other words, skip the first -YYN actions for this
986 state because they are default actions. */
987 int yyxbegin = yyn < 0 ? -yyn : 0;
988
989 /* Stay within bounds of both yycheck and yytname. */
990 int yychecklim = yylast_ - yyn + 1;
991 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
992
993 // Number of reported tokens (one for the "unexpected", one per
994 // "expected").
995 size_t yycount = 0;
996 // Its maximum.
997 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
998 // Arguments of yyformat.
999 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1000 yyarg[yycount++] = yytname_[yytoken];
1001 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1002 if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1003 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1004 {
1005 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1006 {
1007 yycount = 1;
1008 break;
1009 }
1010 else
1011 yyarg[yycount++] = yytname_[yyx];
1012 }
1013
1014 char const* yyformat = 0;
1015 switch (yycount)
1016 {
1017 #define YYCASE_(N, S) \
1018 case N: \
1019 yyformat = S; \
1020 break
1021 YYCASE_(1, YY_("syntax error, unexpected %s"));
1022 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1023 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1024 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1025 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1026 #undef YYCASE_
1027 }
1028 // Argument number.
1029 size_t yyi = 0;
1030 for (char const* yyp = yyformat; *yyp; ++yyp)
1031 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1032 {
1033 yyres += yytnamerr_ (yyarg[yyi++]);
1034 ++yyp;
1035 }
1036 else
1037 yyres += *yyp;
1038 }
1039 else
1040 ]])dnl
1041 [ yyres = YY_("syntax error");
1042 return yyres;
1043 }
1044
1045
1046 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1047
1048 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1049
1050 ]b4_parser_tables_define[
1051
1052 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1053 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1054 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1055 const char*
1056 const ]b4_parser_class_name[::yytname_[] =
1057 {
1058 ]b4_tname[
1059 };
1060 #endif
1061
1062 #if YYDEBUG
1063 ]b4_integral_parser_table_define([rline], [b4_rline])[
1064
1065 // Print the state stack on the debug stream.
1066 void
1067 ]b4_parser_class_name[::yystack_print_ ()
1068 {
1069 *yycdebug_ << "Stack now";
1070 for (stack_type::const_iterator
1071 i = yystack_.begin (),
1072 i_end = yystack_.end ();
1073 i != i_end; ++i)
1074 *yycdebug_ << ' ' << i->state;
1075 *yycdebug_ << std::endl;
1076 }
1077
1078 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1079 void
1080 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1081 {
1082 unsigned int yylno = yyrline_[yyrule];
1083 int yynrhs = yyr2_[yyrule];
1084 /* Print the symbols being reduced, and their result. */
1085 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1086 << " (line " << yylno << "):" << std::endl;
1087 /* The symbols being reduced. */
1088 for (int yyi = 0; yyi < yynrhs; yyi++)
1089 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1090 ]b4_rhs_data(yynrhs, yyi + 1)[);
1091 }
1092 #endif // YYDEBUG
1093
1094 ]b4_lex_symbol_if([], [b4_yytranslate_define])[
1095 ]b4_namespace_close[
1096 ]b4_epilogue[]dnl
1097 m4_divert_pop(0)
1098 m4_popdef([b4_copyright_years])dnl
bison