]> git.saurik.com Git - bison.git/blob - data/lalr1.cc
tests: don't require locations uselessly.
[bison.git] / data / lalr1.cc
1 # C++ skeleton for Bison
2
3 # Copyright (C) 2002-2012 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-2012])
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) YYUSE(Symbol)
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 if (yymsg)
549 YY_SYMBOL_PRINT (yymsg, yysym);
550
551 // User destructor.
552 switch (yytype)
553 {
554 ]b4_symbol_foreach([b4_symbol_destructor])dnl
555 [ default:
556 break;
557 }]b4_variant_if([
558
559 // Type destructor.
560 b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
561 }
562
563 #if YYDEBUG
564 template <typename Exact>
565 void
566 ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
567 const symbol_base_type<Exact>& yysym) const
568 {
569 int yytype = yysym.type_get ();
570 yyo << (yytype < yyntokens_ ? "token" : "nterm")
571 << ' ' << yytname_[yytype] << " ("]b4_locations_if([
572 << yysym.location << ": "])[;
573 switch (yytype)
574 {
575 ]b4_symbol_foreach([b4_symbol_printer])dnl
576 [ default:
577 break;
578 }
579 yyo << ')';
580 }
581 #endif
582
583 void
584 ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
585 symbol_type& sym)
586 {
587 if (m)
588 YY_SYMBOL_PRINT (m, sym);
589 ]b4_variant_if(
590 [[ yystack_.push (stack_symbol_type (]b4_args(
591 [s],
592 [semantic_type()],
593 b4_locations_if([sym.location]))[));
594 ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
595 [build], [sym.value])],
596 [[ yystack_.push (stack_symbol_type (]b4_args(
597 [s],
598 [sym.value],
599 b4_locations_if([sym.location]))[));]])[
600 }
601
602 void
603 ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
604 {
605 if (m)
606 YY_SYMBOL_PRINT (m, s);
607 ]b4_variant_if(
608 [[ yystack_.push (stack_symbol_type (]b4_args(
609 [s.state],
610 [semantic_type()],
611 b4_locations_if([s.location]))[));
612 ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
613 [build], [s.value])],
614 [ yystack_.push (s);])[
615 }
616
617 void
618 ]b4_parser_class_name[::yypop_ (unsigned int n)
619 {
620 yystack_.pop (n);
621 }
622
623 #if YYDEBUG
624 std::ostream&
625 ]b4_parser_class_name[::debug_stream () const
626 {
627 return *yycdebug_;
628 }
629
630 void
631 ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
632 {
633 yycdebug_ = &o;
634 }
635
636
637 ]b4_parser_class_name[::debug_level_type
638 ]b4_parser_class_name[::debug_level () const
639 {
640 return yydebug_;
641 }
642
643 void
644 ]b4_parser_class_name[::set_debug_level (debug_level_type l)
645 {
646 yydebug_ = l;
647 }
648 #endif
649
650 inline ]b4_parser_class_name[::state_type
651 ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
652 {
653 int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
654 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
655 return yytable_[yyr];
656 else
657 return yydefgoto_[yylhs - yyntokens_];
658 }
659
660 inline bool
661 ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue)
662 {
663 return yyvalue == yypact_ninf_;
664 }
665
666 inline bool
667 ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue)
668 {
669 return yyvalue == yytable_ninf_;
670 }
671
672 int
673 ]b4_parser_class_name[::parse ()
674 {
675 /// Whether yyla contains a lookahead.
676 bool yyempty = true;
677
678 /* State. */
679 int yyn;
680 int yylen = 0;
681
682 /* Error handling. */
683 int yynerrs_ = 0;
684 int yyerrstatus_ = 0;
685
686 /// The lookahead symbol.
687 symbol_type yyla;]b4_locations_if([[
688
689 /// The locations where the error started and ended.
690 stack_symbol_type yyerror_range[3];]])[
691
692 /// $$ and @@$.
693 stack_symbol_type yylhs;
694
695 /// The return value of parse().
696 int yyresult;
697
698 YYCDEBUG << "Starting parse" << std::endl;
699
700 ]m4_ifdef([b4_initial_action], [
701 m4_pushdef([b4_at_dollar], [yyla.location])dnl
702 m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
703 /* User initialization code. */
704 b4_user_initial_action
705 m4_popdef([b4_dollar_dollar])dnl
706 m4_popdef([b4_at_dollar])])dnl
707
708 [ /* Initialize the stack. The initial state will be set in
709 yynewstate, since the latter expects the semantical and the
710 location values to have been already stored, initialize these
711 stacks with a primary value. */
712 yystack_ = stack_type (0);
713 yypush_ (0, 0, yyla);
714
715 // A new symbol was pushed on the stack.
716 yynewstate:
717 YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
718
719 /* Accept? */
720 if (yystack_[0].state == yyfinal_)
721 goto yyacceptlab;
722
723 goto yybackup;
724
725 /* Backup. */
726 yybackup:
727
728 /* Try to take a decision without lookahead. */
729 yyn = yypact_[yystack_[0].state];
730 if (yy_pact_value_is_default_ (yyn))
731 goto yydefault;
732
733 /* Read a lookahead token. */
734 if (yyempty)
735 {
736 YYCDEBUG << "Reading a token: ";
737 ]b4_lex_symbol_if(
738 [ yyla = b4_c_function_call([yylex], [symbol_type],
739 m4_ifdef([b4_lex_param], b4_lex_param));],
740 [ yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
741 [[YYSTYPE*], [&yyla.value]][]dnl
742 b4_locations_if([, [[location*], [&yyla.location]]])dnl
743 m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
744 yyempty = false;
745 }
746 YY_SYMBOL_PRINT ("Next token is", yyla);
747
748 /* If the proper action on seeing token YYLA.TYPE is to reduce or
749 to detect an error, take that action. */
750 yyn += yyla.type;
751 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
752 goto yydefault;
753
754 /* Reduce or error. */
755 yyn = yytable_[yyn];
756 if (yyn <= 0)
757 {
758 if (yy_table_value_is_error_ (yyn))
759 goto yyerrlab;
760 yyn = -yyn;
761 goto yyreduce;
762 }
763
764 /* Discard the token being shifted. */
765 yyempty = true;
766
767 /* Count tokens shifted since error; after three, turn off error
768 status. */
769 if (yyerrstatus_)
770 --yyerrstatus_;
771
772 /* Shift the lookahead token. */
773 yypush_ ("Shifting", yyn, yyla);
774 goto yynewstate;
775
776 /*-----------------------------------------------------------.
777 | yydefault -- do the default action for the current state. |
778 `-----------------------------------------------------------*/
779 yydefault:
780 yyn = yydefact_[yystack_[0].state];
781 if (yyn == 0)
782 goto yyerrlab;
783 goto yyreduce;
784
785 /*-----------------------------.
786 | yyreduce -- Do a reduction. |
787 `-----------------------------*/
788 yyreduce:
789 yylen = yyr2_[yyn];
790 yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([
791 /* Variants are always initialized to an empty instance of the
792 correct type. The default $$=$1 action is NOT applied when using
793 variants. */
794 b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[
795 /* If YYLEN is nonzero, implement the default value of the action:
796 `$$ = $1'. Otherwise, use the top of the stack.
797
798 Otherwise, the following line sets YYLHS.VALUE to garbage.
799 This behavior is undocumented and Bison
800 users should not rely upon it. */
801 if (yylen)
802 yylhs.value = yystack_@{yylen - 1@}.value;
803 else
804 yylhs.value = yystack_@{0@}.value;])[
805 ]b4_locations_if([dnl
806 [
807 // Compute the default @@$.
808 {
809 slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
810 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
811 }]])[
812
813 // Perform the reduction.
814 YY_REDUCE_PRINT (yyn);
815 try
816 {
817 switch (yyn)
818 {
819 ]b4_user_actions[
820 default:
821 break;
822 }
823 }
824 catch (const syntax_error& yyexc)
825 {
826 error (]b4_args(b4_locations_if([yyexc.location]),
827 [[yyexc.what()]])[);
828 YYERROR;
829 }
830 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
831 ]b4_variant_if([[
832 // Destroy the rhs symbols.
833 for (int i = 0; i < yylen; ++i)
834 // Destroy a variant which value may have been swapped with
835 // yylhs.value (for instance if the action was "std::swap($$,
836 // $1)"). The value of yylhs.value (hence possibly one of these
837 // rhs symbols) depends on the default contruction for this
838 // type. In the case of pointers for instance, no
839 // initialization is done, so the value is junk. Therefore do
840 // not try to report the value of symbols about to be destroyed
841 // in the debug trace, it's possibly junk. Hence yymsg = 0.
842 // Besides, that keeps exactly the same traces as with the other
843 // Bison skeletons.
844 yy_destroy_ (0, yystack_[i]);]])[
845
846 yypop_ (yylen);
847 yylen = 0;
848 YY_STACK_PRINT ();
849
850 /* Shift the result of the reduction. */
851 yypush_ (0, yylhs);
852 goto yynewstate;
853
854 /*--------------------------------------.
855 | yyerrlab -- here on detecting error. |
856 `--------------------------------------*/
857 yyerrlab:
858 /* If not already recovering from an error, report this error. */
859 if (!yyerrstatus_)
860 {
861 ++yynerrs_;
862 error (]b4_args(b4_locations_if([yyla.location]),
863 [[yysyntax_error_ (yystack_[0].state,
864 yyempty ? yyempty_ : 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 {]b4_error_verbose_if([[
980 std::string yyres;
981 // Number of reported tokens (one for the "unexpected", one per
982 // "expected").
983 size_t yycount = 0;
984 // Its maximum.
985 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
986 // Arguments of yyformat.
987 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
988
989 /* There are many possibilities here to consider:
990 - If this state is a consistent state with a default action, then
991 the only way this function was invoked is if the default action
992 is an error action. In that case, don't check for expected
993 tokens because there are none.
994 - The only way there can be no lookahead present (in yytoken) is
995 if this state is a consistent state with a default action.
996 Thus, detecting the absence of a lookahead is sufficient to
997 determine that there is no unexpected or expected token to
998 report. In that case, just report a simple "syntax error".
999 - Don't assume there isn't a lookahead just because this state is
1000 a consistent state with a default action. There might have
1001 been a previous inconsistent state, consistent state with a
1002 non-default action, or user semantic action that manipulated
1003 yyla. (However, yyla is currently not documented for users.)
1004 - Of course, the expected token list depends on states to have
1005 correct lookahead information, and it depends on the parser not
1006 to perform extra reductions after fetching a lookahead from the
1007 scanner and before detecting a syntax error. Thus, state
1008 merging (from LALR or IELR) and default reductions corrupt the
1009 expected token list. However, the list is correct for
1010 canonical LR with one exception: it will still contain any
1011 token that will not be accepted due to an error action in a
1012 later state.
1013 */
1014 if (yytoken != yyempty_)
1015 {
1016 yyarg[yycount++] = yytname_[yytoken];
1017 int yyn = yypact_[yystate];
1018 if (!yy_pact_value_is_default_ (yyn))
1019 {
1020 /* Start YYX at -YYN if negative to avoid negative indexes in
1021 YYCHECK. In other words, skip the first -YYN actions for
1022 this state because they are default actions. */
1023 int yyxbegin = yyn < 0 ? -yyn : 0;
1024 /* Stay within bounds of both yycheck and yytname. */
1025 int yychecklim = yylast_ - yyn + 1;
1026 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1027 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1028 if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1029 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1030 {
1031 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1032 {
1033 yycount = 1;
1034 break;
1035 }
1036 else
1037 yyarg[yycount++] = yytname_[yyx];
1038 }
1039 }
1040 }
1041
1042 char const* yyformat = 0;
1043 switch (yycount)
1044 {
1045 #define YYCASE_(N, S) \
1046 case N: \
1047 yyformat = S; \
1048 break
1049 YYCASE_(0, YY_("syntax error"));
1050 YYCASE_(1, YY_("syntax error, unexpected %s"));
1051 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1052 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1053 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1054 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1055 #undef YYCASE_
1056 }
1057
1058 // Argument number.
1059 size_t yyi = 0;
1060 for (char const* yyp = yyformat; *yyp; ++yyp)
1061 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1062 {
1063 yyres += yytnamerr_ (yyarg[yyi++]);
1064 ++yyp;
1065 }
1066 else
1067 yyres += *yyp;
1068 return yyres;]], [[
1069 return YY_("syntax error");]])[
1070 }
1071
1072
1073 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1074
1075 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1076
1077 ]b4_parser_tables_define[
1078
1079 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1080 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1081 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1082 const char*
1083 const ]b4_parser_class_name[::yytname_[] =
1084 {
1085 ]b4_tname[
1086 };
1087 #endif
1088
1089 #if YYDEBUG
1090 ]b4_integral_parser_table_define([rline], [b4_rline])[
1091
1092 // Print the state stack on the debug stream.
1093 void
1094 ]b4_parser_class_name[::yystack_print_ ()
1095 {
1096 *yycdebug_ << "Stack now";
1097 for (stack_type::const_iterator
1098 i = yystack_.begin (),
1099 i_end = yystack_.end ();
1100 i != i_end; ++i)
1101 *yycdebug_ << ' ' << i->state;
1102 *yycdebug_ << std::endl;
1103 }
1104
1105 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1106 void
1107 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1108 {
1109 unsigned int yylno = yyrline_[yyrule];
1110 int yynrhs = yyr2_[yyrule];
1111 /* Print the symbols being reduced, and their result. */
1112 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1113 << " (line " << yylno << "):" << std::endl;
1114 /* The symbols being reduced. */
1115 for (int yyi = 0; yyi < yynrhs; yyi++)
1116 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1117 ]b4_rhs_data(yynrhs, yyi + 1)[);
1118 }
1119 #endif // YYDEBUG
1120
1121 ]b4_lex_symbol_if([], [b4_yytranslate_define])[
1122 ]b4_namespace_close[
1123 ]b4_epilogue[]dnl
1124 m4_divert_pop(0)
1125 m4_popdef([b4_copyright_years])dnl