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


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