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