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


bacdf37ce42c2743e6d5810677c4f8ce3261189c
[bison.git] / data / lalr1.cc
1 # C++ skeleton for Bison
2
3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 # Free Software Foundation, Inc.
5
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19 m4_include(b4_pkgdatadir/[c++.m4])
20
21 # b4_table_define(TABLE-NAME, CONTENT)
22 # ------------------------------------
23 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
24 m4_define([b4_table_define],
25 [const b4_int_type_for([$2])
26 b4_parser_class_name::yy$1_[[]] =
27 {
28 $2
29 }dnl
30 ])
31
32 # b4_symbol_value_template(VAL, [TYPE])
33 # -------------------------------------
34 # Same as b4_symbol_value, but used in a template method.
35 m4_copy([b4_symbol_value], [b4_symbol_value_template])
36
37 # How the semantic value is extracted when using variants.
38 b4_variant_if([
39 # b4_symbol_value(VAL, [TYPE])
40 # ----------------------------
41 m4_define([b4_symbol_value],
42 [m4_ifval([$2],
43 [$1.as<$2>()],
44 [$1])])
45
46 # b4_symbol_value_template(VAL, [TYPE])
47 # -------------------------------------
48 # Same as b4_symbol_value, but used in a template method.
49 m4_define([b4_symbol_value_template],
50 [m4_ifval([$2],
51 [$1.template as<$2>()],
52 [$1])])
53 ]) # b4_variant_if
54
55
56 # b4_lex_symbol_if([IF-YYLEX-RETURNS-A-COMPLETE-SYMBOL], [IF-NOT])
57 # ----------------------------------------------------------------
58 m4_define([b4_lex_symbol_if],
59 [b4_percent_define_ifdef([[lex_symbol]], [$1], [$2])])
60
61
62 # b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
63 # ------------------------------------------------
64 m4_define([b4_assert_if],
65 [b4_percent_define_ifdef([[assert]], [$1], [$2])])
66
67
68 # b4_lhs_value([TYPE])
69 # --------------------
70 # Expansion of $<TYPE>$.
71 m4_define([b4_lhs_value],
72 [b4_symbol_value([yylhs.value], [$1])])
73
74
75 # b4_lhs_location()
76 # -----------------
77 # Expansion of @$.
78 m4_define([b4_lhs_location],
79 [yylhs.location])
80
81
82 # b4_rhs_data(RULE-LENGTH, NUM)
83 # -----------------------------
84 # Return the data corresponding to the symbol #NUM, where the current
85 # rule has RULE-LENGTH symbols on RHS.
86 m4_define([b4_rhs_data],
87 [yystack_@{($1) - ($2)@}])
88
89
90 # b4_rhs_state(RULE-LENGTH, NUM)
91 # -----------------------------
92 # The state corresponding to the symbol #NUM, where the current
93 # rule has RULE-LENGTH symbols on RHS.
94 m4_define([b4_rhs_state],
95 [b4_rhs_data([$1], [$2]).state])
96
97
98 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
99 # --------------------------------------
100 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
101 # symbols on RHS.
102 m4_define([b4_rhs_value],
103 [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
104
105
106 # b4_rhs_location(RULE-LENGTH, NUM)
107 # ---------------------------------
108 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
109 # on RHS.
110 m4_define([b4_rhs_location],
111 [b4_rhs_data([$1], [$2]).location])
112
113
114 # b4_symbol(NUM, FIELD)
115 # ---------------------
116 # Recover a FIELD about symbol #NUM. Thanks to m4_indir, fails if
117 # undefined.
118 m4_define([b4_symbol],
119 [m4_indir([b4_symbol($1, $2)])])
120
121
122 # b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE)
123 # -------------------------------------------
124 # If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE.
125 # Otherwise an error.
126 m4_define([b4_symbol_if],
127 [m4_case(b4_symbol([$1], [$2]),
128 [1], [$3],
129 [0], [$4],
130 [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])])
131
132
133 # b4_symbol_actions(FILENAME, LINENO,
134 # SYMBOL-TAG, SYMBOL-NUM,
135 # SYMBOL-ACTION, SYMBOL-TYPENAME)
136 # -------------------------------------------------
137 # Same as in C, but using references instead of pointers.
138 m4_define([b4_symbol_actions],
139 [m4_pushdef([b4_dollar_dollar],
140 [b4_symbol_value_template([yysym.value], [$6])])dnl
141 m4_pushdef([b4_at_dollar], [yysym.location])dnl
142 case $4: // $3
143 b4_syncline([$2], [$1])
144 $5;
145 b4_syncline([@oline@], [@ofile@])
146 break;
147 m4_popdef([b4_at_dollar])dnl
148 m4_popdef([b4_dollar_dollar])dnl
149 ])
150
151
152 # b4_symbol_case_(SYMBOL-NUM)
153 # ---------------------------
154 # Issue a "case NUM" for SYMBOL-NUM.
155 m4_define([b4_symbol_case_],
156 [ case b4_symbol([$1], [number]): // b4_symbol([$1], [tag])
157 ])
158
159
160 # b4_type_action_(NUMS)
161 # ---------------------
162 # Run actions for the symbol NUMS that all have the same type-name.
163 # Skip NUMS that have no type-name.
164 m4_define([b4_type_action_],
165 [b4_symbol_if([$1], [has_type_name],
166 [m4_map([b4_symbol_case_], [$@])[]dnl
167 b4_dollar_dollar([b4_symbol([$1], [number])],
168 [b4_symbol([$1], [tag])],
169 [b4_symbol([$1], [type_name])]);
170 break;
171
172 ])])
173
174
175 # b4_symbol_constructor_declaration_(SYMBOL-NUMBERS)
176 # ----------------------------------------------------
177 # Declare the overloaded version of make_symbol for the (common) type of
178 # these SYMBOL-NUMBERS. Use at class-level.
179 m4_define([b4_symbol_constructor_declaration_],
180 [ template <token_type>
181 static inline symbol_type
182 make_symbol (b4_symbol_if([$1], [has_type_name],
183 [const b4_symbol([$1], [type_name])& v, ])dnl
184 const location_type& l);
185
186 ])
187
188 # b4_symbol_constructor_declarations
189 # ----------------------------------
190 # Declare the overloaded versions of make_symbol for all the value types.
191 # Use at class-level.
192 m4_define([b4_symbol_constructor_declarations],
193 [b4_variant_if([
194 // Declaration of make_symbol for each value type.
195 m4_map([b4_symbol_constructor_declaration_], m4_defn([b4_type_names]))])])
196
197
198
199 # b4_symbol_constructor_specialization_(SYMBOL-NUMBER)
200 # ----------------------------------------------------
201 # Declare the specialization of make_symbol for this each SYMBOL-NUMBER.
202 # Specializations cannot be declared at class-level, this must be done
203 # at namespace-level.
204 m4_define([b4_symbol_constructor_specialization_],
205 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [tag_is_id],
206 [ template <>
207 inline
208 b4_parser_class_name::symbol_type
209 b4_parser_class_name::make_symbol <b4_parser_class_name::token::b4_symbol([$1], [tag])> (dnl
210 b4_symbol_if([$1], [has_type_name],
211 [const b4_symbol([$1], [type_name])& v, ])dnl
212 const b4_parser_class_name::location_type& l);
213 ])])])
214
215 # b4_symbol_constructor_specializations
216 # -------------------------------------
217 # Declare specializations of make_symbol.
218 m4_define([b4_symbol_constructor_specializations],
219 [b4_variant_if([
220 // Specializations of make_symbol for each symbol type.
221 m4_map([b4_symbol_constructor_specialization_],
222 m4_defn([b4_symbol_numbers]))])dnl
223 ])
224
225
226
227 # b4_symbol_constructor_definition_(SYMBOL-NUMBER)
228 # ------------------------------------------------
229 # Define make_symbol for this SYMBOL-NUMBER.
230 m4_define([b4_symbol_constructor_definition_],
231 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [tag_is_id],
232 [ template <>
233 b4_parser_class_name::symbol_type
234 b4_parser_class_name::make_symbol <b4_parser_class_name::token::b4_symbol([$1], [tag])> (dnl
235 b4_symbol_if([$1], [has_type_name],
236 [const b4_symbol([$1], [type_name])& v, ])dnl
237 const location_type& l)
238 {
239 return symbol_type (yytranslate_ (token::b4_symbol([$1], [tag])),dnl
240 b4_symbol_if([$1], [has_type_name], [v, ])l);
241 }
242
243 ])])])
244
245
246 # b4_symbol_constructor_declarations
247 # ----------------------------------
248 # Define the overloaded versions of make_symbol for all the value types.
249 m4_define([b4_symbol_constructor_definitions],
250 [b4_variant_if(
251 [ // Implementation of make_symbol for each symbol type.
252 m4_map([b4_symbol_constructor_definition_], m4_defn([b4_symbol_numbers]))])])
253
254
255 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
256 # ------------------------------------------------
257 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
258 # YYTYPE.
259 m4_define([b4_symbol_variant],
260 [m4_pushdef([b4_dollar_dollar],
261 [$2.$3<$][3>(m4_shift3($@))])dnl
262 switch ($1)
263 {
264 m4_map([b4_type_action_], m4_defn([b4_type_names]))[]dnl
265 default:
266 break;
267 }
268 m4_popdef([b4_dollar_dollar])dnl
269 ])
270
271
272 # _b4_char_sizeof_counter
273 # -----------------------
274 # A counter used by _b4_char_sizeof_dummy to create fresh symbols.
275 m4_define([_b4_char_sizeof_counter],
276 [0])
277
278 # _b4_char_sizeof_dummy
279 # ---------------------
280 # At each call return a new C++ identifier.
281 m4_define([_b4_char_sizeof_dummy],
282 [m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
283 dummy[]_b4_char_sizeof_counter])
284
285
286 # b4_char_sizeof(SYMBOL-NUM)
287 # --------------------------
288 # To be mapped on the list of type names to produce:
289 #
290 # char dummy1[sizeof(type_name_1)];
291 # char dummy2[sizeof(type_name_2)];
292 #
293 # for defined type names.
294 # $3 is doubly-quoted, do not quote it again.
295 m4_define([b4_char_sizeof],
296 [m4_ifval(b4_symbol([$1], [type_name]),
297 [
298 char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type_name])])@}; // b4_symbol([$1], [tag])])dnl
299 ])
300
301
302 m4_pushdef([b4_copyright_years],
303 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
304
305 m4_define([b4_parser_class_name],
306 [b4_percent_define_get([[parser_class_name]])])
307
308 # The header is mandatory.
309 b4_defines_if([],
310 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
311
312 # Backward compatibility.
313 m4_define([b4_location_constructors])
314 m4_include(b4_pkgdatadir/[location.cc])
315
316 # We do want M4 expansion after # for CPP macros.
317 m4_changecom()
318 m4_divert_push(0)dnl
319 b4_defines_if(
320 [@output(b4_spec_defines_file@)@
321 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
322 dnl FIXME: This is wrong, we want computed header guards.
323 [
324 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
325
326 #ifndef PARSER_HEADER_H
327 # define PARSER_HEADER_H
328
329 ]b4_percent_code_get([[requires]])[
330
331 ]b4_assert_if([#include <cassert>])[
332 #include <string>
333 #include <iostream>
334 #include "stack.hh"
335
336 ]b4_namespace_open[
337 class position;
338 class location;
339 ]b4_variant_if(
340 [[
341 /// A char[S] buffer to store and retrieve objects.
342 ///
343 /// Sort of a variant, but does not keep track of the nature
344 /// of the stored data, since that knowledge is available
345 /// via the current state.
346 template <size_t S>
347 struct variant
348 {]b4_assert_if([
349 /// Whether something is contained.
350 bool built;
351 ])[
352 /// Empty construction.
353 inline
354 variant ()]b4_assert_if([
355 : built(false)])[
356 {}
357
358 /// Instantiate a \a T in here.
359 template <typename T>
360 inline T&
361 build()
362 {]b4_assert_if([
363 assert(!built);
364 built = true;])[
365 return *new (buffer) T;
366 }
367
368 /// Instantiate a \a T in here from \a t.
369 template <typename T>
370 inline T&
371 build(const T& t)
372 {]b4_assert_if([
373 assert(!built);
374 built = true;])[
375 return *new (buffer) T(t);
376 }
377
378 /// Construct and fill.
379 template <typename T>
380 inline
381 variant (const T& t)]b4_assert_if([
382 : built(true)])[
383 {
384 new (buffer) T(t);
385 }
386
387 /// Accessor to a built \a T.
388 template <typename T>
389 inline T&
390 as()
391 {]b4_assert_if([
392 assert(built);])[
393 return reinterpret_cast<T&>(buffer);
394 }
395
396 /// Const accessor to a built \a T (for %printer).
397 template <typename T>
398 inline const T&
399 as() const
400 {]b4_assert_if([
401 assert(built);])[
402 return reinterpret_cast<const T&>(buffer);
403 }
404
405 /// Swap the content with \a other.
406 template <typename T>
407 inline void
408 swap(variant<S>& other)
409 {
410 std::swap(as<T>(), other.as<T>());
411 }
412
413 /// Assign the content of \a other to this.
414 /// Destroys \a other.
415 template <typename T>
416 inline void
417 build(variant<S>& other)
418 {
419 build<T>();
420 swap<T>(other);
421 other.destroy<T>();
422 }
423
424 /// Destroy the stored \a T.
425 template <typename T>
426 inline void
427 destroy()
428 {
429 as<T>().~T();]b4_assert_if([
430 built = false;])[
431 }
432
433 /// A buffer large enough to store any of the semantic values.
434 char buffer[S];
435 };
436 ]])[
437 ]b4_namespace_close[
438
439 #include "location.hh"
440
441 /* Enabling traces. */
442 #ifndef YYDEBUG
443 # define YYDEBUG ]b4_debug_flag[
444 #endif
445
446 /* Enabling verbose error messages. */
447 #ifdef YYERROR_VERBOSE
448 # undef YYERROR_VERBOSE
449 # define YYERROR_VERBOSE 1
450 #else
451 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
452 #endif
453
454 /* Enabling the token table. */
455 #ifndef YYTOKEN_TABLE
456 # define YYTOKEN_TABLE ]b4_token_table[
457 #endif
458
459 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
460 If N is 0, then set CURRENT to the empty location which ends
461 the previous symbol: RHS[0] (always defined). */
462
463 #ifndef YYLLOC_DEFAULT
464 # define YYLLOC_DEFAULT(Current, Rhs, N) \
465 do { \
466 if (N) \
467 { \
468 (Current).begin = (Rhs)[1].location.begin; \
469 (Current).end = (Rhs)[N].location.end; \
470 } \
471 else \
472 { \
473 (Current).begin = (Current).end = (Rhs)[0].location.end; \
474 } \
475 } while (false)
476 #endif
477
478 ]b4_namespace_open[
479
480 /// A Bison parser.
481 class ]b4_parser_class_name[
482 {
483 public:
484 #ifndef YYSTYPE
485 ]b4_variant_if(
486 [ /// An auxiliary type to compute the largest semantic type.
487 union union_type
488 {]m4_map([b4_char_sizeof], m4_defn([b4_symbol_numbers]))[
489 };
490
491 /// Symbol semantic values.
492 typedef variant<sizeof(union_type)> semantic_type;],
493 [ /// Symbol semantic values.
494 m4_ifdef([b4_stype],
495 [ union semantic_type
496 {b4_user_stype
497 };],
498 [m4_if(b4_tag_seen_flag, 0,
499 [[ typedef int semantic_type;]],
500 [[ typedef YYSTYPE semantic_type;]])])])[
501 #else
502 typedef YYSTYPE semantic_type;
503 #endif
504 /// Symbol locations.
505 typedef ]b4_percent_define_get([[location_type]])[ location_type;
506 /// Tokens.
507 struct token
508 {
509 ]b4_token_enums(b4_tokens)[
510 };
511 /// Token type.
512 typedef token::yytokentype token_type;
513
514 /// Build a parser object.
515 ]b4_parser_class_name[ (]b4_parse_param_decl[);
516 virtual ~]b4_parser_class_name[ ();
517
518 /// Parse.
519 /// \returns 0 iff parsing succeeded.
520 virtual int parse ();
521
522 #if YYDEBUG
523 /// The current debugging stream.
524 std::ostream& debug_stream () const;
525 /// Set the current debugging stream.
526 void set_debug_stream (std::ostream &);
527
528 /// Type for debugging levels.
529 typedef int debug_level_type;
530 /// The current debugging level.
531 debug_level_type debug_level () const;
532 /// Set the current debugging level.
533 void set_debug_level (debug_level_type l);
534 #endif
535
536 private:
537 /// Report a syntax error.
538 /// \param loc where the syntax error is found.
539 /// \param msg a description of the syntax error.
540 virtual void error (const location_type& loc, const std::string& msg);
541
542 /// Generate an error message.
543 /// \param state the state where the error occurred.
544 /// \param tok the lookahead token.
545 virtual std::string yysyntax_error_ (int yystate, int tok);
546
547 /// State numbers.
548 typedef int state_type;
549
550 /// Internal symbol numbers.
551 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
552 /* Tables. */
553 /// For a state, the index in \a yytable_ of its portion.
554 static const ]b4_int_type_for([b4_pact])[ yypact_[];
555 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
556
557 /// For a state, default rule to reduce.
558 /// Unless\a yytable_ specifies something else to do.
559 /// Zero means the default is an error.
560 static const ]b4_int_type_for([b4_defact])[ yydefact_[];
561
562 static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
563 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
564
565 /// What to do in a state.
566 /// \a yytable_[yypact_[s]]: what to do in state \a s.
567 /// - if positive, shift that token.
568 /// - if negative, reduce the rule which number is the opposite.
569 /// - if zero, do what YYDEFACT says.
570 static const ]b4_int_type_for([b4_table])[ yytable_[];
571 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
572
573 static const ]b4_int_type_for([b4_check])[ yycheck_[];
574
575 /// For a state, its accessing symbol.
576 static const ]b4_int_type_for([b4_stos])[ yystos_[];
577
578 /// For a rule, its LHS.
579 static const ]b4_int_type_for([b4_r1])[ yyr1_[];
580 /// For a rule, its RHS length.
581 static const ]b4_int_type_for([b4_r2])[ yyr2_[];
582
583 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
584 /// For a symbol, its name in clear.
585 static const char* const yytname_[];
586 #endif
587
588 #if YYERROR_VERBOSE
589 /// Convert the symbol name \a n to a form suitable for a diagnostic.
590 virtual std::string yytnamerr_ (const char *n);
591 #endif
592
593 #if YYDEBUG
594 /// For each rule, its source line number.
595 static const ]b4_int_type_for([b4_rline])[ yyrline_[];
596 /// For each scanner token number, its symbol number.
597 static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
598 /// Report on the debug stream that the rule \a r is going to be reduced.
599 virtual void yy_reduce_print_ (int r);
600 /// Print the state stack on the debug stream.
601 virtual void yystack_print_ ();
602
603 /* Debugging. */
604 int yydebug_;
605 std::ostream* yycdebug_;
606 #endif
607
608 /// Convert a scanner token number \a t to a symbol number.
609 static inline token_number_type yytranslate_ (int t);
610
611 /// A complete symbol, with its type.
612 template <typename Exact>
613 struct symbol_base_type
614 {
615 /// Default constructor.
616 inline symbol_base_type ();
617
618 /// Constructor.
619 inline symbol_base_type (const location_type& l);
620 inline symbol_base_type (const semantic_type& v, const location_type& l);
621
622 /// Return this with its exact type.
623 const Exact& self () const;
624 Exact& self ();
625
626 /// Return the type of this symbol.
627 int type_get () const;
628
629 /// The semantic value.
630 semantic_type value;
631
632 /// The location.
633 location_type location;
634 };
635
636 #if YYDEBUG
637 /// \brief Display a symbol type, value and location.
638 /// \param yyo The output stream.
639 /// \param yysym The symbol.
640 template <typename Exact>
641 void yy_print_ (std::ostream& yyo,
642 const symbol_base_type<Exact>& yysym) const;
643 #endif
644
645 /// \brief Reclaim the memory associated to a symbol.
646 /// \param yymsg Why this token is reclaimed.
647 /// If null, print nothing.
648 /// \param s The symbol.
649 template <typename Exact>
650 inline void yy_destroy_ (const char* yymsg,
651 symbol_base_type<Exact>& yysym) const;
652
653 public:
654 /// Element of the stack: a state and its attributes.
655 struct symbol_type : symbol_base_type<symbol_type>
656 {
657 /// The parent class.
658 typedef symbol_base_type<symbol_type> super_type;
659
660 /// Default constructor.
661 inline symbol_type ();
662
663 /// Constructor.
664 inline symbol_type (int t,
665 const semantic_type& v, const location_type& l);
666
667 inline symbol_type (int t,
668 const location_type& l);
669
670 /// The symbol type.
671 int type;
672
673 /// Return the type corresponding to this state.
674 inline int type_get_ () const;
675 };
676
677 ]b4_symbol_constructor_declarations[
678
679 private:
680 /// Element of the stack: a state and its attributes.
681 struct stack_symbol_type : symbol_base_type<stack_symbol_type>
682 {
683 /// The parent class.
684 typedef symbol_base_type<stack_symbol_type> super_type;
685
686 /// Default constructor.
687 inline stack_symbol_type ();
688
689 /// Constructor.
690 inline stack_symbol_type (state_type s,
691 const semantic_type& v, const location_type& l);
692
693 /// The state.
694 state_type state;
695
696 /// Return the type corresponding to this state.
697 inline int type_get_ () const;
698 };
699
700 /// Stack type.
701 typedef stack<stack_symbol_type> stack_type;
702
703 /// The stack.
704 stack_type yystack_;
705
706 /// Push a new state on the stack.
707 /// \param m a debug message to display
708 /// if null, no trace is output.
709 /// \param s the symbol
710 /// \warning the contents of \a s.value is stolen.
711 inline void yypush_ (const char* m, stack_symbol_type& s);
712
713 /// Push a new look ahead token on the state on the stack.
714 /// \param m a debug message to display
715 /// if null, no trace is output.
716 /// \param s the state
717 /// \param sym the symbol (for its value and location).
718 /// \warning the contents of \a s.value is stolen.
719 inline void yypush_ (const char* m, state_type s, symbol_type& sym);
720
721 /// Pop \a n symbols the three stacks.
722 inline void yypop_ (unsigned int n = 1);
723
724 /* Constants. */
725 enum
726 {
727 yyeof_ = 0,
728 yylast_ = ]b4_last[, //< Last index in yytable_.
729 yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols.
730 yyempty_ = -2,
731 yyfinal_ = ]b4_final_state_number[, //< Termination state number.
732 yyterror_ = 1,
733 yyerrcode_ = 256,
734 yyntokens_ = ]b4_tokens_number[, //< Number of tokens.
735 };
736
737 ]b4_parse_param_vars[
738 };
739 ]b4_symbol_constructor_specializations[
740 ]b4_namespace_close[
741
742 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
743 [b4_token_defines(b4_tokens)
744
745 #ifndef YYSTYPE
746 /* Redirection for backward compatibility. */
747 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
748 #endif
749 ])
750 b4_percent_code_get([[provides]])[]dnl
751
752 [#endif /* ! defined PARSER_HEADER_H */]
753 ])dnl
754 @output(b4_parser_file_name@)@
755 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
756 b4_percent_code_get([[top]])[]dnl
757 m4_if(b4_prefix, [yy], [],
758 [
759 // Take the name prefix into account.
760 #define yylex b4_prefix[]lex])[
761
762 /* First part of user declarations. */
763 ]b4_user_pre_prologue
764
765 b4_defines_if([[
766 #include "@basename(]b4_spec_defines_file[@)"]])[
767
768 /* User implementation prologue. */
769 ]b4_user_post_prologue
770 b4_percent_code_get[]dnl
771
772 [#ifndef YY_
773 # if YYENABLE_NLS
774 # if ENABLE_NLS
775 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
776 # define YY_(msgid) dgettext ("bison-runtime", msgid)
777 # endif
778 # endif
779 # ifndef YY_
780 # define YY_(msgid) msgid
781 # endif
782 #endif
783
784 /* Suppress unused-variable warnings by "using" E. */
785 #define YYUSE(e) ((void) (e))
786
787 /* Enable debugging if requested. */
788 #if YYDEBUG
789
790 /* A pseudo ostream that takes yydebug_ into account. */
791 # define YYCDEBUG if (yydebug_) (*yycdebug_)
792
793 # define YY_SYMBOL_PRINT(Title, Symbol) \
794 do { \
795 if (yydebug_) \
796 { \
797 *yycdebug_ << Title << ' '; \
798 yy_print_ (*yycdebug_, Symbol); \
799 *yycdebug_ << std::endl; \
800 } \
801 } while (false)
802
803 # define YY_REDUCE_PRINT(Rule) \
804 do { \
805 if (yydebug_) \
806 yy_reduce_print_ (Rule); \
807 } while (false)
808
809 # define YY_STACK_PRINT() \
810 do { \
811 if (yydebug_) \
812 yystack_print_ (); \
813 } while (false)
814
815 #else /* !YYDEBUG */
816
817 # define YYCDEBUG if (false) std::cerr
818 # define YY_SYMBOL_PRINT(Title, Symbol) static_cast<void>(0)
819 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
820 # define YY_STACK_PRINT() static_cast<void>(0)
821
822 #endif /* !YYDEBUG */
823
824 #define yyerrok (yyerrstatus_ = 0)
825 #define yyclearin (yyempty = true)
826
827 #define YYACCEPT goto yyacceptlab
828 #define YYABORT goto yyabortlab
829 #define YYERROR goto yyerrorlab
830 #define YYRECOVERING() (!!yyerrstatus_)
831
832 ]b4_namespace_open[
833 #if YYERROR_VERBOSE
834
835 /* Return YYSTR after stripping away unnecessary quotes and
836 backslashes, so that it's suitable for yyerror. The heuristic is
837 that double-quoting is unnecessary unless the string contains an
838 apostrophe, a comma, or backslash (other than backslash-backslash).
839 YYSTR is taken from yytname. */
840 std::string
841 ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
842 {
843 if (*yystr == '"')
844 {
845 std::string yyr = "";
846 char const *yyp = yystr;
847
848 for (;;)
849 switch (*++yyp)
850 {
851 case '\'':
852 case ',':
853 goto do_not_strip_quotes;
854
855 case '\\':
856 if (*++yyp != '\\')
857 goto do_not_strip_quotes;
858 /* Fall through. */
859 default:
860 yyr += *yyp;
861 break;
862
863 case '"':
864 return yyr;
865 }
866 do_not_strip_quotes: ;
867 }
868
869 return yystr;
870 }
871
872 #endif
873
874 /// Build a parser object.
875 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
876 :])[
877 #if YYDEBUG
878 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
879 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
880 #endif]b4_parse_param_cons[
881 {
882 }
883
884 ]b4_parser_class_name::~b4_parser_class_name[ ()
885 {
886 }
887
888
889 /*---------------.
890 | Symbol types. |
891 `---------------*/
892
893 // symbol_base_type.
894 template <typename Exact>
895 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
896 : value()
897 , location()
898 {
899 }
900
901 template <typename Exact>
902 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
903 : value()
904 , location(l)
905 {
906 }
907
908 template <typename Exact>
909 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const semantic_type& v, const location_type& l)
910 : value(v)
911 , location(l)
912 {
913 }
914
915 template <typename Exact>
916 const Exact&
917 ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
918 {
919 return static_cast<const Exact&>(*this);
920 }
921
922 template <typename Exact>
923 Exact&
924 ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
925 {
926 return static_cast<Exact&>(*this);
927 }
928
929 template <typename Exact>
930 int
931 ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
932 {
933 return self ().type_get_ ();
934 }
935
936 // symbol_type.
937 ]b4_parser_class_name[::symbol_type::symbol_type ()
938 : super_type ()
939 , type ()
940 {
941 }
942
943 ]b4_parser_class_name[::symbol_type::symbol_type (int t,
944 const location_type& l)
945 : super_type (l)
946 , type (t)
947 {
948 }
949
950 ]b4_parser_class_name[::symbol_type::symbol_type (int t,
951 const semantic_type& v, const location_type& l)
952 : super_type (v, l)
953 , type (t)
954 {
955 }
956
957 int
958 ]b4_parser_class_name[::symbol_type::type_get_ () const
959 {
960 return type;
961 }
962
963 ]b4_symbol_constructor_definitions[
964
965 // stack_symbol_type.
966 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
967 : super_type ()
968 , state ()
969 {
970 }
971
972 ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s,
973 const semantic_type& v, const location_type& l)
974 : super_type (v, l)
975 , state (s)
976 {
977 }
978
979 int
980 ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
981 {
982 return yystos_[state];
983 }
984
985
986 template <typename Exact>
987 void
988 ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
989 symbol_base_type<Exact>& yysym) const
990 {
991 int yytype = yysym.type_get ();
992 YYUSE (yymsg);
993 if (yymsg)
994 YY_SYMBOL_PRINT (yymsg, yysym);
995
996 // User destructor.
997 switch (yytype)
998 {
999 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
1000 default:
1001 break;
1002 }]b4_variant_if([
1003
1004 // Type destructor.
1005 b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
1006 }
1007
1008 #if YYDEBUG
1009 template <typename Exact>
1010 void
1011 ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
1012 const symbol_base_type<Exact>& yysym) const
1013 {
1014 int yytype = yysym.type_get ();
1015 yyo << (yytype < yyntokens_ ? "token" : "nterm")
1016 << ' ' << yytname_[yytype] << " ("
1017 << yysym.location << ": ";
1018 switch (yytype)
1019 {
1020 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))[
1021 default:
1022 break;
1023 }
1024 yyo << ')';
1025 }
1026 #endif
1027
1028 void
1029 ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
1030 symbol_type& sym)
1031 {
1032 if (m)
1033 YY_SYMBOL_PRINT (m, sym);
1034 ]b4_variant_if(
1035 [[ yystack_.push (stack_symbol_type (s, semantic_type(), sym.location));
1036 ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
1037 [build], [sym.value])],
1038 [ yystack_.push (stack_symbol_type (s, sym.value, sym.location));])[
1039 }
1040
1041 void
1042 ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
1043 {
1044 if (m)
1045 YY_SYMBOL_PRINT (m, s);
1046 ]b4_variant_if(
1047 [[ yystack_.push (stack_symbol_type (s.state, semantic_type(), s.location));
1048 ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
1049 [build], [s.value])],
1050 [ yystack_.push (s);])[
1051 }
1052
1053 void
1054 ]b4_parser_class_name[::yypop_ (unsigned int n)
1055 {
1056 yystack_.pop (n);
1057 }
1058
1059 #if YYDEBUG
1060 std::ostream&
1061 ]b4_parser_class_name[::debug_stream () const
1062 {
1063 return *yycdebug_;
1064 }
1065
1066 void
1067 ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
1068 {
1069 yycdebug_ = &o;
1070 }
1071
1072
1073 ]b4_parser_class_name[::debug_level_type
1074 ]b4_parser_class_name[::debug_level () const
1075 {
1076 return yydebug_;
1077 }
1078
1079 void
1080 ]b4_parser_class_name[::set_debug_level (debug_level_type l)
1081 {
1082 yydebug_ = l;
1083 }
1084 #endif
1085
1086 int
1087 ]b4_parser_class_name[::parse ()
1088 {
1089 /// Whether yyla contains a lookahead.
1090 bool yyempty = true;
1091
1092 /* State. */
1093 int yyn;
1094 int yylen = 0;
1095 int yystate = 0;
1096
1097 /* Error handling. */
1098 int yynerrs_ = 0;
1099 int yyerrstatus_ = 0;
1100
1101 /// The lookahead symbol.
1102 symbol_type yyla;
1103
1104 /// The locations where the error started and ended.
1105 stack_symbol_type yyerror_range[2];
1106
1107 /// $$ and @@$.
1108 stack_symbol_type yylhs;
1109
1110 /// The return value of parse().
1111 int yyresult;
1112
1113 YYCDEBUG << "Starting parse" << std::endl;
1114
1115 ]m4_ifdef([b4_initial_action], [
1116 m4_pushdef([b4_at_dollar], [yyla.location])dnl
1117 m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
1118 /* User initialization code. */
1119 b4_user_initial_action
1120 m4_popdef([b4_dollar_dollar])dnl
1121 m4_popdef([b4_at_dollar])])dnl
1122
1123 [ /* Initialize the stack. The initial state will be set in
1124 yynewstate, since the latter expects the semantical and the
1125 location values to have been already stored, initialize these
1126 stacks with a primary value. */
1127 yystack_ = stack_type (0);
1128 yypush_ (0, 0, yyla);
1129
1130 // A new state was pushed on the stack.
1131 // Invariant: yystate == yystack_[0].state, i.e.,
1132 // yystate was just pushed onto the state stack.
1133 yynewstate:
1134 YYCDEBUG << "Entering state " << yystate << std::endl;
1135
1136 /* Accept? */
1137 if (yystate == yyfinal_)
1138 goto yyacceptlab;
1139
1140 goto yybackup;
1141
1142 /* Backup. */
1143 yybackup:
1144
1145 /* Try to take a decision without lookahead. */
1146 yyn = yypact_[yystate];
1147 if (yyn == yypact_ninf_)
1148 goto yydefault;
1149
1150 /* Read a lookahead token. */
1151 if (yyempty)
1152 {
1153 YYCDEBUG << "Reading a token: ";
1154 ]b4_lex_symbol_if(
1155 [ yyla = yylex();],
1156 [ yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
1157 [[YYSTYPE*], [&yyla.value]][]dnl
1158 b4_locations_if([, [[location*], [&yyla.location]]])dnl
1159 m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
1160 yyempty = false;
1161 }
1162 YY_SYMBOL_PRINT ("Next token is", yyla);
1163
1164 /* If the proper action on seeing token YYLA.TYPE is to reduce or
1165 to detect an error, take that action. */
1166 yyn += yyla.type;
1167 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
1168 goto yydefault;
1169
1170 /* Reduce or error. */
1171 yyn = yytable_[yyn];
1172 if (yyn <= 0)
1173 {
1174 if (yyn == 0 || yyn == yytable_ninf_)
1175 goto yyerrlab;
1176 yyn = -yyn;
1177 goto yyreduce;
1178 }
1179
1180 /* Discard the token being shifted. */
1181 yyempty = true;
1182
1183 /* Count tokens shifted since error; after three, turn off error
1184 status. */
1185 if (yyerrstatus_)
1186 --yyerrstatus_;
1187
1188 /* Shift the lookahead token. */
1189 yystate = yyn;
1190 yypush_ ("Shifting", yystate, yyla);
1191 goto yynewstate;
1192
1193 /*-----------------------------------------------------------.
1194 | yydefault -- do the default action for the current state. |
1195 `-----------------------------------------------------------*/
1196 yydefault:
1197 yyn = yydefact_[yystate];
1198 if (yyn == 0)
1199 goto yyerrlab;
1200 goto yyreduce;
1201
1202 /*-----------------------------.
1203 | yyreduce -- Do a reduction. |
1204 `-----------------------------*/
1205 yyreduce:
1206 yylen = yyr2_[yyn];]b4_variant_if([
1207 /* Variants are always initialized to an empty instance of the
1208 correct type. The default $$=$1 rule is NOT applied when using
1209 variants */
1210 ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])[],[
1211 /* If YYLEN is nonzero, implement the default value of the action:
1212 `$$ = $1'. Otherwise, use the top of the stack.
1213
1214 Otherwise, the following line sets YYLHS.VALUE to garbage.
1215 This behavior is undocumented and Bison
1216 users should not rely upon it. */
1217 if (yylen)
1218 yylhs.value = yystack_@{yylen - 1@}.value;
1219 else
1220 yylhs.value = yystack_@{0@}.value;])[
1221
1222 // Compute the default @@$.
1223 {
1224 slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
1225 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
1226 }
1227
1228 // Perform the reduction.
1229 YY_REDUCE_PRINT (yyn);
1230 switch (yyn)
1231 {
1232 ]b4_user_actions[
1233 default:
1234 break;
1235 }
1236 // Compute post-reduction state.
1237 yyn = yyr1_[yyn];
1238 yystate = yypgoto_[yyn - yyntokens_] + yystack_[yylen].state;
1239 if (0 <= yystate && yystate <= yylast_
1240 && yycheck_[yystate] == yystack_[yylen].state)
1241 yystate = yytable_[yystate];
1242 else
1243 yystate = yydefgoto_[yyn - yyntokens_];
1244 yylhs.state = yystate;
1245 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
1246 ]b4_variant_if([[
1247 // Destroy the lhs symbols.
1248 for (int i = 0; i < yylen; ++i)
1249 // Destroy a variant which value may have be swapped with
1250 // yylhs.value. The value of yylhs.value (hence maybe one of
1251 // these lhs symbols) depends on what does the default
1252 // contruction for this type. In the case of pointers for
1253 // instance, nothing is done, so the value is junk. Therefore
1254 // do not try to report the content in the debug trace, it's
1255 // junk. Hence yymsg = 0. Besides, that keeps exactly the same
1256 // traces as with the other Bison skeletons.
1257 yy_destroy_ (0, yystack_[i]);]])[
1258
1259 yypop_ (yylen);
1260 yylen = 0;
1261 YY_STACK_PRINT ();
1262
1263 /* Shift the result of the reduction. */
1264 yypush_ (0, yylhs);
1265 goto yynewstate;
1266
1267 /*------------------------------------.
1268 | yyerrlab -- here on detecting error |
1269 `------------------------------------*/
1270 yyerrlab:
1271 /* If not already recovering from an error, report this error. */
1272 if (!yyerrstatus_)
1273 {
1274 ++yynerrs_;
1275 error (yyla.location, yysyntax_error_ (yystate, yyla.type));
1276 }
1277
1278 yyerror_range[0].location = yyla.location;
1279 if (yyerrstatus_ == 3)
1280 {
1281 /* If just tried and failed to reuse lookahead token after an
1282 error, discard it. */
1283
1284 /* Return failure if at end of input. */
1285 if (yyla.type == yyeof_)
1286 YYABORT;
1287 else
1288 {
1289 yy_destroy_ ("Error: discarding", yyla);
1290 yyempty = true;
1291 }
1292 }
1293
1294 /* Else will try to reuse lookahead token after shifting the error
1295 token. */
1296 goto yyerrlab1;
1297
1298
1299 /*---------------------------------------------------.
1300 | yyerrorlab -- error raised explicitly by YYERROR. |
1301 `---------------------------------------------------*/
1302 yyerrorlab:
1303
1304 /* Pacify compilers like GCC when the user code never invokes
1305 YYERROR and the label yyerrorlab therefore never appears in user
1306 code. */
1307 if (false)
1308 goto yyerrorlab;
1309
1310 yyerror_range[0].location = yystack_[yylen - 1].location;
1311 /* Do not reclaim the symbols of the rule which action triggered
1312 this YYERROR. */
1313 yypop_ (yylen);
1314 yylen = 0;
1315 yystate = yystack_[0].state;
1316 goto yyerrlab1;
1317
1318 /*-------------------------------------------------------------.
1319 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1320 `-------------------------------------------------------------*/
1321 yyerrlab1:
1322 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
1323 {
1324 stack_symbol_type error_token;
1325 for (;;)
1326 {
1327 yyn = yypact_[yystate];
1328 if (yyn != yypact_ninf_)
1329 {
1330 yyn += yyterror_;
1331 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
1332 {
1333 yyn = yytable_[yyn];
1334 if (0 < yyn)
1335 break;
1336 }
1337 }
1338
1339 // Pop the current state because it cannot handle the error token.
1340 if (yystack_.size () == 1)
1341 YYABORT;
1342
1343 yyerror_range[0].location = yystack_[0].location;
1344 yy_destroy_ ("Error: popping", yystack_[0]);
1345 yypop_ ();
1346 yystate = yystack_[0].state;
1347 YY_STACK_PRINT ();
1348 }
1349
1350 yyerror_range[1].location = yyla.location;
1351 YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);
1352
1353 /* Shift the error token. */
1354 error_token.state = yystate = yyn;
1355 yypush_ ("Shifting", error_token);
1356 }
1357 goto yynewstate;
1358
1359 /* Accept. */
1360 yyacceptlab:
1361 yyresult = 0;
1362 goto yyreturn;
1363
1364 /* Abort. */
1365 yyabortlab:
1366 yyresult = 1;
1367 goto yyreturn;
1368
1369 yyreturn:
1370 if (!yyempty)
1371 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
1372
1373 /* Do not reclaim the symbols of the rule which action triggered
1374 this YYABORT or YYACCEPT. */
1375 yypop_ (yylen);
1376 while (yystack_.size () != 1)
1377 {
1378 yy_destroy_ ("Cleanup: popping", yystack_[0]);
1379 yypop_ ();
1380 }
1381
1382 return yyresult;
1383 }
1384
1385 // Generate an error message.
1386 std::string
1387 ]b4_parser_class_name[::yysyntax_error_ (int yystate, int]dnl
1388 b4_error_verbose_if([ yytoken])[)
1389 {
1390 std::string yyres;
1391 YYUSE (yystate);
1392 #if YYERROR_VERBOSE
1393 int yyn = yypact_[yystate];
1394 if (yypact_ninf_ < yyn && yyn <= yylast_)
1395 {
1396 /* Start YYX at -YYN if negative to avoid negative indexes in
1397 YYCHECK. */
1398 int yyxbegin = yyn < 0 ? -yyn : 0;
1399
1400 /* Stay within bounds of both yycheck and yytname. */
1401 int yychecklim = yylast_ - yyn + 1;
1402 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1403
1404 // Number of "expected" tokens.
1405 size_t yycount = 0;
1406 // Its maximum.
1407 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1408 // Arguments of yyformat.
1409 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1410 yyarg[yycount++] = yytname_[yytoken];
1411 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1412 if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_)
1413 {
1414 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1415 {
1416 yycount = 1;
1417 break;
1418 }
1419 else
1420 yyarg[yycount++] = yytname_[yyx];
1421 }
1422
1423 char const* yyformat = 0;
1424 switch (yycount)
1425 {
1426 #define YYCASE_(N, S) \
1427 case N: \
1428 yyformat = S; \
1429 break
1430 YYCASE_(1, YY_("syntax error, unexpected %s"));
1431 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1432 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1433 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1434 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1435 #undef YYCASE_
1436 }
1437 // Argument number.
1438 size_t yyi = 0;
1439 for (char const* yyp = yyformat; *yyp; ++yyp)
1440 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1441 {
1442 yyres += yytnamerr_ (yyarg[yyi++]);
1443 ++yyp;
1444 }
1445 else
1446 yyres += *yyp;
1447 }
1448 else
1449 #endif
1450 yyres = YY_("syntax error");
1451 return yyres;
1452 }
1453
1454
1455 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1456 STATE-NUM. */
1457 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1458 ]b4_table_define([pact], [b4_pact])[;
1459
1460 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1461 doesn't specify something else to do. Zero means the default is an
1462 error. */
1463 ]b4_table_define([defact], [b4_defact])[;
1464
1465 /* YYPGOTO[NTERM-NUM]. */
1466 ]b4_table_define([pgoto], [b4_pgoto])[;
1467
1468 /* YYDEFGOTO[NTERM-NUM]. */
1469 ]b4_table_define([defgoto], [b4_defgoto])[;
1470
1471 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1472 positive, shift that token. If negative, reduce the rule which
1473 number is the opposite. If zero, do what YYDEFACT says. */
1474 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1475 ]b4_table_define([table], [b4_table])[;
1476
1477 /* YYCHECK. */
1478 ]b4_table_define([check], [b4_check])[;
1479
1480 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1481 symbol of state STATE-NUM. */
1482 ]b4_table_define([stos], [b4_stos])[;
1483
1484 #if YYDEBUG
1485 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1486 to YYLEX-NUM. */
1487 ]b4_table_define([token_number], [b4_toknum])[;
1488 #endif
1489
1490 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1491 ]b4_table_define([r1], [b4_r1])[;
1492
1493 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1494 ]b4_table_define([r2], [b4_r2])[;
1495
1496 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1497 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1498 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1499 const char*
1500 const ]b4_parser_class_name[::yytname_[] =
1501 {
1502 ]b4_tname[
1503 };
1504 #endif
1505
1506 #if YYDEBUG
1507 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1508 ]b4_table_define([rline], [b4_rline])[;
1509
1510 // Print the state stack on the debug stream.
1511 void
1512 ]b4_parser_class_name[::yystack_print_ ()
1513 {
1514 *yycdebug_ << "Stack now";
1515 for (stack_type::const_iterator
1516 i = yystack_.begin (),
1517 i_end = yystack_.end ();
1518 i != i_end; ++i)
1519 *yycdebug_ << ' ' << i->state;
1520 *yycdebug_ << std::endl;
1521 }
1522
1523 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1524 void
1525 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1526 {
1527 unsigned int yylno = yyrline_[yyrule];
1528 int yynrhs = yyr2_[yyrule];
1529 /* Print the symbols being reduced, and their result. */
1530 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1531 << " (line " << yylno << "):" << std::endl;
1532 /* The symbols being reduced. */
1533 for (int yyi = 0; yyi < yynrhs; yyi++)
1534 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1535 ]b4_rhs_data(yynrhs, yyi + 1)[);
1536 }
1537 #endif // YYDEBUG
1538
1539 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1540 ]b4_parser_class_name[::token_number_type
1541 ]b4_parser_class_name[::yytranslate_ (int t)
1542 {
1543 static
1544 const token_number_type
1545 translate_table[] =
1546 {
1547 ]b4_translate[
1548 };
1549 const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
1550 const token_number_type undef_token_ = ]b4_undef_token_number[;
1551
1552 if (t <= yyeof_)
1553 return yyeof_;
1554 else if (static_cast<unsigned int> (t) <= user_token_number_max_)
1555 return translate_table[t];
1556 else
1557 return undef_token_;
1558 }
1559
1560 ]b4_namespace_close[
1561
1562 ]b4_epilogue[]dnl
1563 @output(b4_dir_prefix[]stack.hh@)@
1564 b4_copyright([Stack handling for Bison parsers in C++])[
1565
1566 #ifndef BISON_STACK_HH
1567 # define BISON_STACK_HH
1568
1569 #include <deque>
1570
1571 ]b4_namespace_open[
1572 template <class T, class S = std::deque<T> >
1573 class stack
1574 {
1575 public:
1576
1577 // Hide our reversed order.
1578 typedef typename S::reverse_iterator iterator;
1579 typedef typename S::const_reverse_iterator const_iterator;
1580
1581 stack () : seq_ ()
1582 {
1583 }
1584
1585 stack (unsigned int n) : seq_ (n)
1586 {
1587 }
1588
1589 inline
1590 T&
1591 operator [] (unsigned int i)
1592 {
1593 return seq_[i];
1594 }
1595
1596 inline
1597 const T&
1598 operator [] (unsigned int i) const
1599 {
1600 return seq_[i];
1601 }
1602
1603 inline
1604 void
1605 push (const T& t)
1606 {
1607 seq_.push_front (t);
1608 }
1609
1610 inline
1611 void
1612 pop (unsigned int n = 1)
1613 {
1614 for (; n; --n)
1615 seq_.pop_front ();
1616 }
1617
1618 inline
1619 typename S::size_type
1620 size () const
1621 {
1622 return seq_.size ();
1623 }
1624
1625 inline const_iterator begin () const { return seq_.rbegin (); }
1626 inline const_iterator end () const { return seq_.rend (); }
1627
1628 private:
1629 /// The wrapped container.
1630 S seq_;
1631 };
1632
1633 /// Present a slice of the top of a stack.
1634 template <class T, class S = stack<T> >
1635 class slice
1636 {
1637 public:
1638
1639 slice (const S& stack,
1640 unsigned int range) : stack_ (stack),
1641 range_ (range)
1642 {
1643 }
1644
1645 inline
1646 const T&
1647 operator [] (unsigned int i) const
1648 {
1649 return stack_[range_ - i];
1650 }
1651
1652 private:
1653
1654 const S& stack_;
1655 unsigned int range_;
1656 };
1657 ]b4_namespace_close[
1658
1659 #endif // not BISON_STACK_HH[]dnl
1660 ]
1661 m4_divert_pop(0)
1662 m4_popdef([b4_copyright_years])dnl
bison