1 # C++ skeleton for Bison
3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 # Free Software Foundation, Inc.
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.
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.
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/>.
19 m4_include(b4_pkgdatadir
/[c
++.m4
])
21 # How the semantic value is extracted when using variants.
23 # b4_symbol_value(VAL, [TYPE])
24 # ----------------------------
25 m4_define([b4_symbol_value
],
32 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
33 # --------------------------------------
34 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
36 m4_define([b4_rhs_value
],
37 [b4_symbol_value([yystack_@
{($
1) - ($
2)@
}.value
], [$
3])])
39 # b4_rhs_location(RULE-LENGTH, NUM)
40 # ---------------------------------
41 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
43 m4_define([b4_rhs_location
],
44 [(yystack_@
{($
1) - ($
2)@
}.location
)])
47 # b4_symbol_actions(FILENAME, LINENO,
48 # SYMBOL-TAG, SYMBOL-NUM,
49 # SYMBOL-ACTION, SYMBOL-TYPENAME)
50 # -------------------------------------------------
51 # Same as in C, but using references instead of pointers.
52 m4_define([b4_symbol_actions
],
53 [m4_pushdef([b4_dollar_dollar
],
54 [b4_symbol_value([yyvalue
], [$
6])])dnl
55 m4_pushdef([b4_at_dollar
], [yylocation
])dnl
57 b4_syncline([$
2], [$
1])
59 b4_syncline([@oline@
], [@ofile@
])
61 m4_popdef([b4_at_dollar
])dnl
62 m4_popdef([b4_dollar_dollar
])dnl
66 # b4_symbol_action_(SYMBOL-TAG, SYMBOL-NUM, SYMBOL-TYPENAME)
67 # ----------------------------------------------------------
68 # Invoke b4_dollar_dollar(SYMBOL_TYPENAME) for each symbol.
69 m4_define([b4_symbol_action_
],
77 # b4_symbol_variant(YYTYPE, YYVAL, ACTION)
78 # ----------------------------------------
79 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
81 m4_define([b4_symbol_variant
],
82 [m4_pushdef([b4_dollar_dollar
],
86 m4_map([b4_symbol_action_
], m4_defn([b4_type_names
]))
90 m4_popdef([b4_dollar_dollar
])dnl
94 # _b4_char_sizeof_counter
95 # -----------------------
96 # A counter used by _b4_char_sizeof_dummy to create fresh symbols.
97 m4_define([_b4_char_sizeof_counter
],
100 # _b4_char_sizeof_dummy
101 # ---------------------
102 # At each call return a new C++ identifier.
103 m4_define([_b4_char_sizeof_dummy
],
104 [m4_define([_b4_char_sizeof_counter
], m4_incr(_b4_char_sizeof_counter
))dnl
105 dummy
[]_b4_char_sizeof_counter
])
108 # b4_char_sizeof(SYMBOL-TAG, SYMBOL-NUM, SYMBOL-TYPENAME)
109 # -------------------------------------------------------
110 # To be mapped on the list of type names to produce:
112 # char dummy1[sizeof(type_name_1)];
113 # char dummy2[sizeof(type_name_2)];
115 # for defined type names.
116 # $3 is doubly-quoted, do not quote it again.
117 m4_define([b4_char_sizeof
],
120 char _b4_char_sizeof_dummy@
{sizeof($
3)@
}; // $1])dnl
124 m4_define([b4_parser_class_name
],
125 [b4_percent_define_get([[parser_class_name]])])
127 # The header is mandatory.
129 [b4_fatal([b4_skeleton
[: using %%defines is mandatory
]])])
131 # Backward compatibility.
132 m4_define([b4_location_constructors
])
133 m4_include(b4_pkgdatadir
/[location
.cc
])
135 # We do want M4 expansion after # for CPP macros.
139 [@
output(b4_spec_defines_file@
)
140 b4_copyright([Skeleton interface
for Bison
LALR(1) parsers in C
++],
141 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
142 dnl FIXME
: This is wrong
, we want computed header guards
.
144 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
146 #ifndef PARSER_HEADER_H
147 # define PARSER_HEADER_H
149 ]b4_percent_code_get([[requires]])[
160 /// A char[S] buffer to store and retrieve objects.
162 /// Sort of a variant, but does not keep track of the nature
163 /// of the stored data, since that knowledge is available
164 /// via the current state.
168 /// Instantiate a \a T in here.
169 template <typename T
>
176 /// Destroy the stored \a T.
177 template <typename T
>
181 reinterpret_cast<T
&>(buffer
).~T();
184 /// Accessor to a built \a T.
185 template <typename T
>
189 return reinterpret_cast<T
&>(buffer
);
192 /// Const accessor to a built \a T (for %printer).
193 template <typename T
>
197 return reinterpret_cast<const T
&>(buffer
);
200 /// A buffer large enough to store any of the semantic values.
206 #include "location.hh"
208 /* Enabling traces. */
210 # define YYDEBUG ]b4_debug_flag[
213 /* Enabling verbose error messages. */
214 #ifdef YYERROR_VERBOSE
215 # undef YYERROR_VERBOSE
216 # define YYERROR_VERBOSE 1
218 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
221 /* Enabling the token table. */
222 #ifndef YYTOKEN_TABLE
223 # define YYTOKEN_TABLE ]b4_token_table[
226 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
227 If N is 0, then set CURRENT to the empty location which ends
228 the previous symbol: RHS[0] (always defined). */
230 #ifndef YYLLOC_DEFAULT
231 # define YYLLOC_DEFAULT(Current, Rhs, N) \
235 (Current).begin = (Rhs)[1].location.begin; \
236 (Current).end = (Rhs)[N].location.end; \
240 (Current).begin = (Current).end = (Rhs)[0].location.end; \
248 class ]b4_parser_class_name
[
253 [ /// An auxiliary type to compute the largest semantic type.
255 {]m4_map([b4_char_sizeof
], m4_defn([b4_type_names
]))[
258 /// Symbol semantic values.
259 typedef variant
<sizeof(union_type
)> semantic_type
;],
260 [ /// Symbol semantic values.
262 [ union semantic_type
265 [m4_if(b4_tag_seen_flag
, 0,
266 [[ typedef int semantic_type
;]],
267 [[ typedef YYSTYPE semantic_type
;]])])])[
269 typedef YYSTYPE semantic_type
;
271 /// Symbol locations.
272 typedef ]b4_percent_define_get([[location_type]])[ location_type
;
276 ]b4_token_enums(b4_tokens
)[
279 typedef token::yytokentype token_type
;
281 /// Build a parser object.
282 ]b4_parser_class_name
[ (]b4_parse_param_decl
[);
283 virtual ~]b4_parser_class_name
[ ();
286 /// \returns 0 iff parsing succeeded.
287 virtual int parse ();
290 /// The current debugging stream.
291 std::ostream
& debug_stream () const;
292 /// Set the current debugging stream.
293 void set_debug_stream (std::ostream
&);
295 /// Type for debugging levels.
296 typedef int debug_level_type
;
297 /// The current debugging level.
298 debug_level_type
debug_level () const;
299 /// Set the current debugging level.
300 void set_debug_level (debug_level_type l
);
304 /// Report a syntax error.
305 /// \param loc where the syntax error is found.
306 /// \param msg a description of the syntax error.
307 virtual void error (const location_type
& loc
, const std::string
& msg
);
309 /// Generate an error message.
310 /// \param state the state where the error occurred.
311 /// \param tok the lookahead token.
312 virtual std::string
yysyntax_error_ (int yystate
]dnl
313 b4_error_verbose_if([, int tok
])[);
316 /// \brief Report a symbol value on the debug stream.
317 /// \param yytype The token type.
318 /// \param yyvalue Its semantic value.
319 /// \param yylocation Its location.
320 virtual void yy_symbol_value_print_ (int yytype
,
321 const semantic_type
& yyvalue
,
322 const location_type
& yylocation
);
323 /// \brief Report a symbol on the debug stream.
324 /// \param yytype The token type.
325 /// \param yyvalue Its semantic value.
326 /// \param yylocation Its location.
327 virtual void yy_symbol_print_ (int yytype
,
328 const semantic_type
& yyvalue
,
329 const location_type
& yylocation
);
333 typedef int state_type
;
335 /// Internal symbol numbers.
336 typedef ]b4_int_type_for([b4_translate
])[ token_number_type
;
338 /// For a state, the index in \a yytable_ of its portion.
339 static const ]b4_int_type_for([b4_pact
])[ yypact_
[];
340 static const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
)[ yypact_ninf_
;
342 /// For a state, default rule to reduce.
343 /// Unless\a yytable_ specifies something else to do.
344 /// Zero means the default is an error.
345 static const ]b4_int_type_for([b4_defact
])[ yydefact_
[];
347 static const ]b4_int_type_for([b4_pgoto
])[ yypgoto_
[];
348 static const ]b4_int_type_for([b4_defgoto
])[ yydefgoto_
[];
350 /// What to do in a state.
351 /// \a yytable_[yypact_[s]]: what to do in state \a s.
352 /// - if positive, shift that token.
353 /// - if negative, reduce the rule which number is the opposite.
354 /// - if zero, do what YYDEFACT says.
355 static const ]b4_int_type_for([b4_table
])[ yytable_
[];
356 static const ]b4_int_type(b4_table_ninf
, b4_table_ninf
)[ yytable_ninf_
;
358 static const ]b4_int_type_for([b4_check
])[ yycheck_
[];
360 /// For a state, its accessing symbol.
361 static const ]b4_int_type_for([b4_stos
])[ yystos_
[];
363 /// For a rule, its LHS.
364 static const ]b4_int_type_for([b4_r1
])[ yyr1_
[];
365 /// For a rule, its RHS length.
366 static const ]b4_int_type_for([b4_r2
])[ yyr2_
[];
368 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
369 /// For a symbol, its name in clear.
370 static const char* const yytname_
[];
374 /// Convert the symbol name \a n to a form suitable for a diagnostic.
375 virtual std::string
yytnamerr_ (const char *n
);
379 /// A type to store symbol numbers and -1.
380 typedef ]b4_int_type_for([b4_rhs
])[ rhs_number_type
;
381 /// A `-1'-separated list of the rules' RHS.
382 static const rhs_number_type yyrhs_
[];
383 /// For each rule, the index of the first RHS symbol in \a yyrhs_.
384 static const ]b4_int_type_for([b4_prhs
])[ yyprhs_
[];
385 /// For each rule, its source line number.
386 static const ]b4_int_type_for([b4_rline
])[ yyrline_
[];
387 /// For each scanner token number, its symbol number.
388 static const ]b4_int_type_for([b4_toknum
])[ yytoken_number_
[];
389 /// Report on the debug stream that the rule \a r is going to be reduced.
390 virtual void yy_reduce_print_ (int r
);
391 /// Print the state stack on the debug stream.
392 virtual void yystack_print_ ();
396 std::ostream
* yycdebug_
;
399 /// Convert a scanner token number \a t to a symbol number.
400 token_number_type
yytranslate_ (int t
);
402 /// \brief Reclaim the memory associated to a symbol.
403 /// \param yymsg Why this token is reclaimed.
404 /// \param yytype The symbol type.
405 /// \param yyvalue Its semantic value.
406 /// \param yylocation Its location.
407 inline void yydestruct_ (const char* yymsg
,
409 semantic_type
& yyvalue
,
410 location_type
& yylocation
);
412 /// Element of the stack: a state and its attributes.
415 /// Default constructor.
419 data_type (state_type s
, const semantic_type
& v
, const location_type
& l
);
424 /// The semantic value.
428 location_type location
;
432 typedef stack
<data_type
> stack_type
;
437 /// Push a new state on the stack.
438 /// \warning the contents of \a v is stolen.
439 inline void yypush_ (state_type s
,
440 semantic_type
& v
, const location_type
& l
);
442 /// Pop \a n symbols the three stacks.
443 inline void yypop_ (unsigned int n
= 1);
446 static const int yyeof_
;
447 /* LAST_ -- Last index in TABLE_. */
448 static const int yylast_
;
449 static const int yynnts_
;
450 static const int yyempty_
;
451 static const int yyfinal_
;
452 static const int yyterror_
;
453 static const int yyerrcode_
;
454 static const int yyntokens_
;
455 static const unsigned int yyuser_token_number_max_
;
456 static const token_number_type yyundef_token_
;
457 ]b4_parse_param_vars
[
461 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
462 [b4_token_defines(b4_tokens
)
465 /* Redirection for backward compatibility. */
466 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
469 b4_percent_code_get([[provides]])[]dnl
471 [#endif /* ! defined PARSER_HEADER_H */]
473 @
output(b4_parser_file_name@
)
474 b4_copyright([Skeleton implementation
for Bison
LALR(1) parsers in C
++],
475 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
476 b4_percent_code_get([[top]])[]dnl
477 m4_if(b4_prefix
, [yy
], [],
479 // Take the name prefix into account.
480 #define yylex b4_prefix[]lex])[
482 /* First part of user declarations. */
483 ]b4_user_pre_prologue
486 #include "@basename(]b4_spec_defines_file[@)"]])[
488 /* User implementation prologue. */
489 ]b4_user_post_prologue
490 b4_percent_code_get
[]dnl
495 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
496 # define YY_(msgid) dgettext ("bison-runtime", msgid)
500 # define YY_(msgid) msgid
504 /* Suppress unused-variable warnings by "using" E. */
505 #define YYUSE(e) ((void) (e))
507 /* Enable debugging if requested. */
510 /* A pseudo ostream that takes yydebug_ into account. */
511 # define YYCDEBUG if (yydebug_) (*yycdebug_)
513 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
517 *yycdebug_ << Title << ' '; \
518 yy_symbol_print_ ((Type), (Value), (Location)); \
519 *yycdebug_ << std::endl; \
523 # define YY_REDUCE_PRINT(Rule) \
526 yy_reduce_print_ (Rule); \
529 # define YY_STACK_PRINT() \
537 # define YYCDEBUG if (false) std::cerr
538 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
539 # define YY_REDUCE_PRINT(Rule)
540 # define YY_STACK_PRINT()
542 #endif /* !YYDEBUG */
544 #define yyerrok (yyerrstatus_ = 0)
545 #define yyclearin (yychar = yyempty_)
547 #define YYACCEPT goto yyacceptlab
548 #define YYABORT goto yyabortlab
549 #define YYERROR goto yyerrorlab
550 #define YYRECOVERING() (!!yyerrstatus_)
555 /* Return YYSTR after stripping away unnecessary quotes and
556 backslashes, so that it's suitable for yyerror. The heuristic is
557 that double-quoting is unnecessary unless the string contains an
558 apostrophe, a comma, or backslash (other than backslash-backslash).
559 YYSTR is taken from yytname. */
561 ]b4_parser_class_name
[::yytnamerr_ (const char *yystr
)
565 std::string yyr
= "";
566 char const *yyp
= yystr
;
573 goto do_not_strip_quotes
;
577 goto do_not_strip_quotes
;
586 do_not_strip_quotes
: ;
594 /// Build a parser object.
595 ]b4_parser_class_name::b4_parser_class_name
[ (]b4_parse_param_decl
[)]m4_ifset([b4_parse_param
], [
598 ]m4_ifset([b4_parse_param
], [ ], [ :])[yydebug_ (false),
599 yycdebug_ (&std::cerr
)]m4_ifset([b4_parse_param
], [,])[
600 #endif]b4_parse_param_cons[
604 ]b4_parser_class_name::~b4_parser_class_name
[ ()
609 /*--------------------------------.
610 | Print this symbol on YYOUTPUT. |
611 `--------------------------------*/
614 ]b4_parser_class_name
[::yy_symbol_value_print_ (int yytype
,
615 const semantic_type
& yyvalue
, const location_type
& yylocation
)
621 ]m4_map([b4_symbol_actions
], m4_defn([b4_symbol_printers
]))dnl
629 ]b4_parser_class_name
[::yy_symbol_print_ (int yytype
,
630 const semantic_type
& yyvalue
, const location_type
& yylocation
)
632 *yycdebug_
<< (yytype
< yyntokens_
? "token" : "nterm")
633 << ' ' << yytname_
[yytype
] << " ("
634 << yylocation
<< ": ";
635 yy_symbol_value_print_ (yytype
, yyvalue
, yylocation
);
641 ]b4_parser_class_name
[::yydestruct_ (const char* yymsg
,
642 int yytype
, semantic_type
& yyvalue
, location_type
& yylocation
)
648 YY_SYMBOL_PRINT (yymsg
, yytype
, yyvalue
, yylocation
);
652 ]m4_map([b4_symbol_actions
], m4_defn([b4_symbol_destructors
]))[
658 ]b4_parser_class_name
[::data_type::data_type ()
665 ]b4_parser_class_name
[::data_type::data_type (state_type s
,
666 const semantic_type
& v
, const location_type
& l
)
674 ]b4_parser_class_name
[::yypush_ (state_type s
,
675 semantic_type
& v
, const location_type
& l
)
677 yystack_
.push (data_type (s
, v
, l
));
681 ]b4_parser_class_name
[::yypop_ (unsigned int n
)
688 ]b4_parser_class_name
[::debug_stream () const
694 ]b4_parser_class_name
[::set_debug_stream (std::ostream
& o
)
700 ]b4_parser_class_name
[::debug_level_type
701 ]b4_parser_class_name
[::debug_level () const
707 ]b4_parser_class_name
[::set_debug_level (debug_level_type l
)
714 ]b4_parser_class_name
[::parse ()
716 /// Lookahead and lookahead in internal form.
717 int yychar
= yyempty_
;
725 /* Error handling. */
727 int yyerrstatus_
= 0;
729 /// Semantic value of the lookahead.
730 semantic_type yylval
;
731 /// Location of the lookahead.
732 location_type yylloc
;
733 /// The locations where the error started and ended.
734 data_type yyerror_range
[2];
743 YYCDEBUG
<< "Starting parse" << std::endl
;
745 ]m4_ifdef([b4_initial_action
], [
746 m4_pushdef([b4_at_dollar
], [yylloc
])dnl
747 m4_pushdef([b4_dollar_dollar
], [yylval
])dnl
748 /* User initialization code. */
749 b4_user_initial_action
750 m4_popdef([b4_dollar_dollar
])dnl
751 m4_popdef([b4_at_dollar
])])dnl
753 [ /* Initialize the stack. The initial state will be set in
754 yynewstate, since the latter expects the semantical and the
755 location values to have been already stored, initialize these
756 stacks with a primary value. */
757 yystack_
= stack_type (0);
758 yypush_ (yystate
, yylval
, yylloc
);
760 // A new state was pushed on the stack.
761 // Invariant: yystate == yystack_[0].state, i.e.,
762 // yystate was just pushed onto the state stack.
764 YYCDEBUG
<< "Entering state " << yystate
<< std::endl
;
767 if (yystate
== yyfinal_
)
775 /* Try to take a decision without lookahead. */
776 yyn
= yypact_
[yystate
];
777 if (yyn
== yypact_ninf_
)
780 /* Read a lookahead token. */
781 if (yychar
== yyempty_
)
783 YYCDEBUG
<< "Reading a token: ";
784 yychar
= ]b4_c_function_call([yylex
], [int],
785 [[YYSTYPE
*], [&yylval
]][]dnl
786 b4_locations_if([, [[location
*], [&yylloc
]]])dnl
787 m4_ifdef([b4_lex_param
], [, ]b4_lex_param
))[;
791 /* Convert token to internal form. */
792 if (yychar
<= yyeof_
)
794 yychar
= yytoken
= yyeof_
;
795 YYCDEBUG
<< "Now at end of input." << std::endl
;
799 yytoken
= yytranslate_ (yychar
);
800 YY_SYMBOL_PRINT ("Next token is", yytoken
, yylval
, yylloc
);
803 /* If the proper action on seeing token YYTOKEN is to reduce or to
804 detect an error, take that action. */
806 if (yyn
< 0 || yylast_
< yyn
|| yycheck_
[yyn
] != yytoken
)
809 /* Reduce or error. */
813 if (yyn
== 0 || yyn
== yytable_ninf_
)
819 /* Shift the lookahead token. */
820 YY_SYMBOL_PRINT ("Shifting", yytoken
, yylval
, yylloc
);
822 /* Discard the token being shifted. */
825 /* Count tokens shifted since error; after three, turn off error
831 yypush_ (yystate
, yylval
, yylloc
);
834 /*-----------------------------------------------------------.
835 | yydefault -- do the default action for the current state. |
836 `-----------------------------------------------------------*/
838 yyn
= yydefact_
[yystate
];
843 /*-----------------------------.
844 | yyreduce -- Do a reduction. |
845 `-----------------------------*/
847 yylen
= yyr2_
[yyn
];]b4_variant_if([
848 /* Variants are always initialized to an empty instance of the
849 correct type. The default $$=$1 rule is NOT applied when using
851 ]b4_symbol_variant([[yyr1_@
{yyn@
}]], [yyval
], [build
])[],[
852 /* If YYLEN is nonzero, implement the default value of the action:
853 `$$ = $1'. Otherwise, use the top of the stack.
855 Otherwise, the following line sets YYVAL to garbage.
856 This behavior is undocumented and Bison
857 users should not rely upon it. */
859 yyval
= yystack_@
{yylen
- 1@
}.value
;
861 yyval
= yystack_@
{0@
}.value
;])[
864 slice
<data_type
, stack_type
> slice (yystack_
, yylen
);
865 YYLLOC_DEFAULT (yyloc
, slice
, yylen
);
867 YY_REDUCE_PRINT (yyn
);
874 YY_SYMBOL_PRINT ("-> $$ =", yyr1_
[yyn
], yyval
, yyloc
);
880 /* Shift the result of the reduction. */
882 yystate
= yypgoto_
[yyn
- yyntokens_
] + yystack_
[0].state
;
883 if (0 <= yystate
&& yystate
<= yylast_
884 && yycheck_
[yystate
] == yystack_
[0].state
)
885 yystate
= yytable_
[yystate
];
887 yystate
= yydefgoto_
[yyn
- yyntokens_
];
888 yypush_ (yystate
, yyval
, yyloc
);
891 /*------------------------------------.
892 | yyerrlab -- here on detecting error |
893 `------------------------------------*/
895 /* If not already recovering from an error, report this error. */
899 error (yylloc
, yysyntax_error_ (yystate
]dnl
900 b4_error_verbose_if([, yytoken
])[));
903 yyerror_range
[0].location
= yylloc
;
904 if (yyerrstatus_
== 3)
906 /* If just tried and failed to reuse lookahead token after an
907 error, discard it. */
909 if (yychar
<= yyeof_
)
911 /* Return failure if at end of input. */
912 if (yychar
== yyeof_
)
917 yydestruct_ ("Error: discarding", yytoken
, yylval
, yylloc
);
922 /* Else will try to reuse lookahead token after shifting the error
927 /*---------------------------------------------------.
928 | yyerrorlab -- error raised explicitly by YYERROR. |
929 `---------------------------------------------------*/
932 /* Pacify compilers like GCC when the user code never invokes
933 YYERROR and the label yyerrorlab therefore never appears in user
938 yyerror_range
[0].location
= yystack_
[yylen
- 1].location
;
939 /* Do not reclaim the symbols of the rule which action triggered
943 yystate
= yystack_
[0].state
;
946 /*-------------------------------------------------------------.
947 | yyerrlab1 -- common code for both syntax error and YYERROR. |
948 `-------------------------------------------------------------*/
950 yyerrstatus_
= 3; /* Each real token shifted decrements this. */
954 yyn
= yypact_
[yystate
];
955 if (yyn
!= yypact_ninf_
)
958 if (0 <= yyn
&& yyn
<= yylast_
&& yycheck_
[yyn
] == yyterror_
)
966 // Pop the current state because it cannot handle the error token.
967 if (yystack_
.size () == 1)
970 yyerror_range
[0].location
= yystack_
[0].location
;
971 yydestruct_ ("Error: popping",
973 yystack_
[0].value
, yystack_
[0].location
);
975 yystate
= yystack_
[0].state
;
979 yyerror_range
[1].location
= yylloc
;
980 // Using YYLLOC is tempting, but would change the location of
981 // the lookahead. YYLOC is available though.
982 YYLLOC_DEFAULT (yyloc
, (yyerror_range
- 1), 2);
984 /* Shift the error token. */
985 YY_SYMBOL_PRINT ("Shifting", yystos_
[yyn
],
986 yystack_
[0].value
, yystack_
[0].location
);
989 yypush_ (yystate
, yylval
, yyloc
);
1003 if (yychar
!= yyempty_
)
1004 yydestruct_ ("Cleanup: discarding lookahead", yytoken
, yylval
, yylloc
);
1006 /* Do not reclaim the symbols of the rule which action triggered
1007 this YYABORT or YYACCEPT. */
1009 while (yystack_
.size () != 1)
1011 yydestruct_ ("Cleanup: popping",
1012 yystos_
[yystack_
[0].state
],
1013 yystack_
[0].value
, yystack_
[0].location
);
1020 // Generate an error message.
1022 ]b4_parser_class_name
[::yysyntax_error_ (int yystate
]dnl
1023 b4_error_verbose_if([, int tok
])[)
1028 int yyn
= yypact_
[yystate
];
1029 if (yypact_ninf_
< yyn
&& yyn
<= yylast_
)
1031 /* Start YYX at -YYN if negative to avoid negative indexes in
1033 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
1035 /* Stay within bounds of both yycheck and yytname. */
1036 int yychecklim
= yylast_
- yyn
+ 1;
1037 int yyxend
= yychecklim
< yyntokens_
? yychecklim
: yyntokens_
;
1039 for (int x
= yyxbegin
; x
< yyxend
; ++x
)
1040 if (yycheck_
[x
+ yyn
] == x
&& x
!= yyterror_
)
1043 // FIXME: This method of building the message is not compatible
1044 // with internationalization. It should work like yacc.c does it.
1045 // That is, first build a string that looks like this:
1046 // "syntax error, unexpected %s or %s or %s"
1047 // Then, invoke YY_ on this string.
1048 // Finally, use the string as a format to output
1049 // yytname_[tok], etc.
1050 // Until this gets fixed, this message appears in English only.
1051 res
= "syntax error, unexpected ";
1052 res
+= yytnamerr_ (yytname_
[tok
]);
1056 for (int x
= yyxbegin
; x
< yyxend
; ++x
)
1057 if (yycheck_
[x
+ yyn
] == x
&& x
!= yyterror_
)
1059 res
+= (!count
++) ? ", expecting " : " or ";
1060 res
+= yytnamerr_ (yytname_
[x
]);
1066 res
= YY_("syntax error");
1071 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1073 const ]b4_int_type(b4_pact_ninf
, b4_pact_ninf
) b4_parser_class_name::yypact_ninf_
= b4_pact_ninf
[;
1074 const ]b4_int_type_for([b4_pact
])[
1075 ]b4_parser_class_name
[::yypact_
[] =
1080 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1081 doesn't specify something else to do. Zero means the default is an
1083 const ]b4_int_type_for([b4_defact
])[
1084 ]b4_parser_class_name
[::yydefact_
[] =
1089 /* YYPGOTO[NTERM-NUM]. */
1090 const ]b4_int_type_for([b4_pgoto
])[
1091 ]b4_parser_class_name
[::yypgoto_
[] =
1096 /* YYDEFGOTO[NTERM-NUM]. */
1097 const ]b4_int_type_for([b4_defgoto
])[
1098 ]b4_parser_class_name
[::yydefgoto_
[] =
1103 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1104 positive, shift that token. If negative, reduce the rule which
1105 number is the opposite. If zero, do what YYDEFACT says. */
1106 const ]b4_int_type(b4_table_ninf
, b4_table_ninf
) b4_parser_class_name::yytable_ninf_
= b4_table_ninf
[;
1107 const ]b4_int_type_for([b4_table
])[
1108 ]b4_parser_class_name
[::yytable_
[] =
1114 const ]b4_int_type_for([b4_check
])[
1115 ]b4_parser_class_name
[::yycheck_
[] =
1120 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1121 symbol of state STATE-NUM. */
1122 const ]b4_int_type_for([b4_stos
])[
1123 ]b4_parser_class_name
[::yystos_
[] =
1129 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1131 const ]b4_int_type_for([b4_toknum
])[
1132 ]b4_parser_class_name
[::yytoken_number_
[] =
1138 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1139 const ]b4_int_type_for([b4_r1
])[
1140 ]b4_parser_class_name
[::yyr1_
[] =
1145 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1146 const ]b4_int_type_for([b4_r2
])[
1147 ]b4_parser_class_name
[::yyr2_
[] =
1152 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1153 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1154 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1156 const ]b4_parser_class_name
[::yytname_
[] =
1163 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1164 const ]b4_parser_class_name
[::rhs_number_type
1165 ]b4_parser_class_name
[::yyrhs_
[] =
1170 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1172 const ]b4_int_type_for([b4_prhs
])[
1173 ]b4_parser_class_name
[::yyprhs_
[] =
1178 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1179 const ]b4_int_type_for([b4_rline
])[
1180 ]b4_parser_class_name
[::yyrline_
[] =
1185 // Print the state stack on the debug stream.
1187 ]b4_parser_class_name
[::yystack_print_ ()
1189 *yycdebug_
<< "Stack now";
1190 for (stack_type::const_iterator
1191 i
= yystack_
.begin (),
1192 i_end
= yystack_
.end ();
1194 *yycdebug_
<< ' ' << i
->state
;
1195 *yycdebug_
<< std::endl
;
1198 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1200 ]b4_parser_class_name
[::yy_reduce_print_ (int yyrule
)
1202 unsigned int yylno
= yyrline_
[yyrule
];
1203 int yynrhs
= yyr2_
[yyrule
];
1204 /* Print the symbols being reduced, and their result. */
1205 *yycdebug_
<< "Reducing stack by rule " << yyrule
- 1
1206 << " (line " << yylno
<< "):" << std::endl
;
1207 /* The symbols being reduced. */
1208 for (int yyi
= 0; yyi
< yynrhs
; yyi
++)
1209 YY_SYMBOL_PRINT (" $" << yyi
+ 1 << " =",
1210 yyrhs_
[yyprhs_
[yyrule
] + yyi
],
1211 ]b4_rhs_value(yynrhs
, yyi
+ 1)[,
1212 ]b4_rhs_location(yynrhs
, yyi
+ 1)[);
1216 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1217 ]b4_parser_class_name
[::token_number_type
1218 ]b4_parser_class_name
[::yytranslate_ (int t
)
1221 const token_number_type
1226 if ((unsigned int) t
<= yyuser_token_number_max_
)
1227 return translate_table
[t
];
1229 return yyundef_token_
;
1232 const int ]b4_parser_class_name
[::yyeof_
= 0;
1233 const int ]b4_parser_class_name
[::yylast_
= ]b4_last
[;
1234 const int ]b4_parser_class_name
[::yynnts_
= ]b4_nterms_number
[;
1235 const int ]b4_parser_class_name
[::yyempty_
= -2;
1236 const int ]b4_parser_class_name
[::yyfinal_
= ]b4_final_state_number
[;
1237 const int ]b4_parser_class_name
[::yyterror_
= 1;
1238 const int ]b4_parser_class_name
[::yyerrcode_
= 256;
1239 const int ]b4_parser_class_name
[::yyntokens_
= ]b4_tokens_number
[;
1241 const unsigned int ]b4_parser_class_name
[::yyuser_token_number_max_
= ]b4_user_token_number_max
[;
1242 const ]b4_parser_class_name
[::token_number_type
]b4_parser_class_name
[::yyundef_token_
= ]b4_undef_token_number
[;
1244 ]b4_namespace_close
[
1248 @
output(b4_dir_prefix
[]stack
.hh@
)
1249 b4_copyright([Stack handling
for Bison parsers in C
++],
1250 [2002, 2003, 2004, 2005, 2006, 2007, 2008])[
1252 #ifndef BISON_STACK_HH
1253 # define BISON_STACK_HH
1258 template <class T
, class S
= std::deque
<T
> >
1263 // Hide our reversed order.
1264 typedef typename
S::reverse_iterator iterator
;
1265 typedef typename
S::const_reverse_iterator const_iterator
;
1271 stack (unsigned int n
) : seq_ (n
)
1277 operator [] (unsigned int i
)
1284 operator [] (unsigned int i
) const
1293 seq_
.push_front (t
);
1298 pop (unsigned int n
= 1)
1305 typename
S::size_type
1308 return seq_
.size ();
1311 inline const_iterator
begin () const { return seq_
.rbegin (); }
1312 inline const_iterator
end () const { return seq_
.rend (); }
1315 /// The wrapped container.
1319 /// Present a slice of the top of a stack.
1320 template <class T
, class S
= stack
<T
> >
1325 slice (const S
& stack
,
1326 unsigned int range
) : stack_ (stack
),
1333 operator [] (unsigned int i
) const
1335 return stack_
[range_
- i
];
1341 unsigned int range_
;
1343 ]b4_namespace_close
[
1345 #endif // not BISON_STACK_HH[]dnl