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 | m4_define([b4_parser_class_name],
|
---|
22 | [b4_percent_define_get([[parser_class_name]])])
|
---|
23 |
|
---|
24 | # The header is mandatory.
|
---|
25 | b4_defines_if([],
|
---|
26 | [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
|
---|
27 |
|
---|
28 | # Backward compatibility.
|
---|
29 | m4_define([b4_location_constructors])
|
---|
30 | m4_include(b4_pkgdatadir/[location.cc])
|
---|
31 |
|
---|
32 | # We do want M4 expansion after # for CPP macros.
|
---|
33 | m4_changecom()
|
---|
34 | m4_divert_push(0)dnl
|
---|
35 | b4_defines_if(
|
---|
36 | [@output(b4_spec_defines_file@)
|
---|
37 | b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++],
|
---|
38 | [2002, 2003, 2004, 2005, 2006, 2007, 2008])
|
---|
39 | dnl FIXME: This is wrong, we want computed header guards.
|
---|
40 | [
|
---|
41 | /* C++ LALR(1) parser skeleton written by Akim Demaille. */
|
---|
42 |
|
---|
43 | #ifndef PARSER_HEADER_H
|
---|
44 | # define PARSER_HEADER_H
|
---|
45 |
|
---|
46 | ]b4_percent_code_get([[requires]])[
|
---|
47 |
|
---|
48 | #include <string>
|
---|
49 | #include <iostream>
|
---|
50 | #include "stack.hh"
|
---|
51 |
|
---|
52 | ]b4_namespace_open[
|
---|
53 | class position;
|
---|
54 | class location;
|
---|
55 | ]b4_namespace_close[
|
---|
56 |
|
---|
57 | #include "location.hh"
|
---|
58 |
|
---|
59 | /* Enabling traces. */
|
---|
60 | #ifndef YYDEBUG
|
---|
61 | # define YYDEBUG ]b4_debug_flag[
|
---|
62 | #endif
|
---|
63 |
|
---|
64 | /* Enabling verbose error messages. */
|
---|
65 | #ifdef YYERROR_VERBOSE
|
---|
66 | # undef YYERROR_VERBOSE
|
---|
67 | # define YYERROR_VERBOSE 1
|
---|
68 | #else
|
---|
69 | # define YYERROR_VERBOSE ]b4_error_verbose_flag[
|
---|
70 | #endif
|
---|
71 |
|
---|
72 | /* Enabling the token table. */
|
---|
73 | #ifndef YYTOKEN_TABLE
|
---|
74 | # define YYTOKEN_TABLE ]b4_token_table[
|
---|
75 | #endif
|
---|
76 |
|
---|
77 | /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
|
---|
78 | If N is 0, then set CURRENT to the empty location which ends
|
---|
79 | the previous symbol: RHS[0] (always defined). */
|
---|
80 |
|
---|
81 | #ifndef YYLLOC_DEFAULT
|
---|
82 | # define YYLLOC_DEFAULT(Current, Rhs, N) \
|
---|
83 | do { \
|
---|
84 | if (N) \
|
---|
85 | { \
|
---|
86 | (Current).begin = (Rhs)[1].begin; \
|
---|
87 | (Current).end = (Rhs)[N].end; \
|
---|
88 | } \
|
---|
89 | else \
|
---|
90 | { \
|
---|
91 | (Current).begin = (Current).end = (Rhs)[0].end; \
|
---|
92 | } \
|
---|
93 | } while (false)
|
---|
94 | #endif
|
---|
95 |
|
---|
96 | ]b4_namespace_open[
|
---|
97 |
|
---|
98 | /// A Bison parser.
|
---|
99 | class ]b4_parser_class_name[
|
---|
100 | {
|
---|
101 | public:
|
---|
102 | /// Symbol semantic values.
|
---|
103 | #ifndef YYSTYPE
|
---|
104 | ]m4_ifdef([b4_stype],
|
---|
105 | [ union semantic_type
|
---|
106 | {
|
---|
107 | b4_user_stype
|
---|
108 | };],
|
---|
109 | [m4_if(b4_tag_seen_flag, 0,
|
---|
110 | [[ typedef int semantic_type;]],
|
---|
111 | [[ typedef YYSTYPE semantic_type;]])])[
|
---|
112 | #else
|
---|
113 | typedef YYSTYPE semantic_type;
|
---|
114 | #endif
|
---|
115 | /// Symbol locations.
|
---|
116 | typedef ]b4_percent_define_get([[location_type]])[ location_type;
|
---|
117 | /// Tokens.
|
---|
118 | struct token
|
---|
119 | {
|
---|
120 | ]b4_token_enums(b4_tokens)[
|
---|
121 | };
|
---|
122 | /// Token type.
|
---|
123 | typedef token::yytokentype token_type;
|
---|
124 |
|
---|
125 | /// Build a parser object.
|
---|
126 | ]b4_parser_class_name[ (]b4_parse_param_decl[);
|
---|
127 | virtual ~]b4_parser_class_name[ ();
|
---|
128 |
|
---|
129 | /// Parse.
|
---|
130 | /// \returns 0 iff parsing succeeded.
|
---|
131 | virtual int parse ();
|
---|
132 |
|
---|
133 | #if YYDEBUG
|
---|
134 | /// The current debugging stream.
|
---|
135 | std::ostream& debug_stream () const;
|
---|
136 | /// Set the current debugging stream.
|
---|
137 | void set_debug_stream (std::ostream &);
|
---|
138 |
|
---|
139 | /// Type for debugging levels.
|
---|
140 | typedef int debug_level_type;
|
---|
141 | /// The current debugging level.
|
---|
142 | debug_level_type debug_level () const;
|
---|
143 | /// Set the current debugging level.
|
---|
144 | void set_debug_level (debug_level_type l);
|
---|
145 | #endif
|
---|
146 |
|
---|
147 | private:
|
---|
148 | /// Report a syntax error.
|
---|
149 | /// \param loc where the syntax error is found.
|
---|
150 | /// \param msg a description of the syntax error.
|
---|
151 | virtual void error (const location_type& loc, const std::string& msg);
|
---|
152 |
|
---|
153 | /// Generate an error message.
|
---|
154 | /// \param state the state where the error occurred.
|
---|
155 | /// \param tok the lookahead token.
|
---|
156 | virtual std::string yysyntax_error_ (int yystate]dnl
|
---|
157 | b4_error_verbose_if([, int tok])[);
|
---|
158 |
|
---|
159 | #if YYDEBUG
|
---|
160 | /// \brief Report a symbol value on the debug stream.
|
---|
161 | /// \param yytype The token type.
|
---|
162 | /// \param yyvaluep Its semantic value.
|
---|
163 | /// \param yylocationp Its location.
|
---|
164 | virtual void yy_symbol_value_print_ (int yytype,
|
---|
165 | const semantic_type* yyvaluep,
|
---|
166 | const location_type* yylocationp);
|
---|
167 | /// \brief Report a symbol on the debug stream.
|
---|
168 | /// \param yytype The token type.
|
---|
169 | /// \param yyvaluep Its semantic value.
|
---|
170 | /// \param yylocationp Its location.
|
---|
171 | virtual void yy_symbol_print_ (int yytype,
|
---|
172 | const semantic_type* yyvaluep,
|
---|
173 | const location_type* yylocationp);
|
---|
174 | #endif
|
---|
175 |
|
---|
176 |
|
---|
177 | /// State numbers.
|
---|
178 | typedef int state_type;
|
---|
179 | /// State stack type.
|
---|
180 | typedef stack<state_type> state_stack_type;
|
---|
181 | /// Semantic value stack type.
|
---|
182 | typedef stack<semantic_type> semantic_stack_type;
|
---|
183 | /// location stack type.
|
---|
184 | typedef stack<location_type> location_stack_type;
|
---|
185 |
|
---|
186 | /// The state stack.
|
---|
187 | state_stack_type yystate_stack_;
|
---|
188 | /// The semantic value stack.
|
---|
189 | semantic_stack_type yysemantic_stack_;
|
---|
190 | /// The location stack.
|
---|
191 | location_stack_type yylocation_stack_;
|
---|
192 |
|
---|
193 | /// Internal symbol numbers.
|
---|
194 | typedef ]b4_int_type_for([b4_translate])[ token_number_type;
|
---|
195 | /* Tables. */
|
---|
196 | /// For a state, the index in \a yytable_ of its portion.
|
---|
197 | static const ]b4_int_type_for([b4_pact])[ yypact_[];
|
---|
198 | static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
|
---|
199 |
|
---|
200 | /// For a state, default rule to reduce.
|
---|
201 | /// Unless\a yytable_ specifies something else to do.
|
---|
202 | /// Zero means the default is an error.
|
---|
203 | static const ]b4_int_type_for([b4_defact])[ yydefact_[];
|
---|
204 |
|
---|
205 | static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
|
---|
206 | static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
|
---|
207 |
|
---|
208 | /// What to do in a state.
|
---|
209 | /// \a yytable_[yypact_[s]]: what to do in state \a s.
|
---|
210 | /// - if positive, shift that token.
|
---|
211 | /// - if negative, reduce the rule which number is the opposite.
|
---|
212 | /// - if zero, do what YYDEFACT says.
|
---|
213 | static const ]b4_int_type_for([b4_table])[ yytable_[];
|
---|
214 | static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
|
---|
215 |
|
---|
216 | static const ]b4_int_type_for([b4_check])[ yycheck_[];
|
---|
217 |
|
---|
218 | /// For a state, its accessing symbol.
|
---|
219 | static const ]b4_int_type_for([b4_stos])[ yystos_[];
|
---|
220 |
|
---|
221 | /// For a rule, its LHS.
|
---|
222 | static const ]b4_int_type_for([b4_r1])[ yyr1_[];
|
---|
223 | /// For a rule, its RHS length.
|
---|
224 | static const ]b4_int_type_for([b4_r2])[ yyr2_[];
|
---|
225 |
|
---|
226 | #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
|
---|
227 | /// For a symbol, its name in clear.
|
---|
228 | static const char* const yytname_[];
|
---|
229 | #endif
|
---|
230 |
|
---|
231 | #if YYERROR_VERBOSE
|
---|
232 | /// Convert the symbol name \a n to a form suitable for a diagnostic.
|
---|
233 | virtual std::string yytnamerr_ (const char *n);
|
---|
234 | #endif
|
---|
235 |
|
---|
236 | #if YYDEBUG
|
---|
237 | /// A type to store symbol numbers and -1.
|
---|
238 | typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type;
|
---|
239 | /// A `-1'-separated list of the rules' RHS.
|
---|
240 | static const rhs_number_type yyrhs_[];
|
---|
241 | /// For each rule, the index of the first RHS symbol in \a yyrhs_.
|
---|
242 | static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
|
---|
243 | /// For each rule, its source line number.
|
---|
244 | static const ]b4_int_type_for([b4_rline])[ yyrline_[];
|
---|
245 | /// For each scanner token number, its symbol number.
|
---|
246 | static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
|
---|
247 | /// Report on the debug stream that the rule \a r is going to be reduced.
|
---|
248 | virtual void yy_reduce_print_ (int r);
|
---|
249 | /// Print the state stack on the debug stream.
|
---|
250 | virtual void yystack_print_ ();
|
---|
251 |
|
---|
252 | /* Debugging. */
|
---|
253 | int yydebug_;
|
---|
254 | std::ostream* yycdebug_;
|
---|
255 | #endif
|
---|
256 |
|
---|
257 | /// Convert a scanner token number \a t to a symbol number.
|
---|
258 | token_number_type yytranslate_ (int t);
|
---|
259 |
|
---|
260 | /// \brief Reclaim the memory associated to a symbol.
|
---|
261 | /// \param yymsg Why this token is reclaimed.
|
---|
262 | /// \param yytype The symbol type.
|
---|
263 | /// \param yyvaluep Its semantic value.
|
---|
264 | /// \param yylocationp Its location.
|
---|
265 | inline void yydestruct_ (const char* yymsg,
|
---|
266 | int yytype,
|
---|
267 | semantic_type* yyvaluep,
|
---|
268 | location_type* yylocationp);
|
---|
269 |
|
---|
270 | /// Pop \a n symbols the three stacks.
|
---|
271 | inline void yypop_ (unsigned int n = 1);
|
---|
272 |
|
---|
273 | /* Constants. */
|
---|
274 | static const int yyeof_;
|
---|
275 | /* LAST_ -- Last index in TABLE_. */
|
---|
276 | static const int yylast_;
|
---|
277 | static const int yynnts_;
|
---|
278 | static const int yyempty_;
|
---|
279 | static const int yyfinal_;
|
---|
280 | static const int yyterror_;
|
---|
281 | static const int yyerrcode_;
|
---|
282 | static const int yyntokens_;
|
---|
283 | static const unsigned int yyuser_token_number_max_;
|
---|
284 | static const token_number_type yyundef_token_;
|
---|
285 | ]b4_parse_param_vars[
|
---|
286 | };
|
---|
287 | ]b4_namespace_close[
|
---|
288 |
|
---|
289 | ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
|
---|
290 | [b4_token_defines(b4_tokens)
|
---|
291 |
|
---|
292 | #ifndef YYSTYPE
|
---|
293 | /* Redirection for backward compatibility. */
|
---|
294 | # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
|
---|
295 | #endif
|
---|
296 | ])
|
---|
297 | b4_percent_code_get([[provides]])[]dnl
|
---|
298 |
|
---|
299 | [#endif /* ! defined PARSER_HEADER_H */]
|
---|
300 | ])dnl
|
---|
301 | @output(b4_parser_file_name@)
|
---|
302 | b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++],
|
---|
303 | [2002, 2003, 2004, 2005, 2006, 2007, 2008])
|
---|
304 | b4_percent_code_get([[top]])[]dnl
|
---|
305 | m4_if(b4_prefix, [yy], [],
|
---|
306 | [
|
---|
307 | // Take the name prefix into account.
|
---|
308 | #define yylex b4_prefix[]lex])[
|
---|
309 |
|
---|
310 | /* First part of user declarations. */
|
---|
311 | ]b4_user_pre_prologue
|
---|
312 |
|
---|
313 | b4_defines_if([[
|
---|
314 | #include "@basename(]b4_spec_defines_file[@)"]])[
|
---|
315 |
|
---|
316 | /* User implementation prologue. */
|
---|
317 | ]b4_user_post_prologue
|
---|
318 | b4_percent_code_get[]dnl
|
---|
319 |
|
---|
320 | [#ifndef YY_
|
---|
321 | # if YYENABLE_NLS
|
---|
322 | # if ENABLE_NLS
|
---|
323 | # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
|
---|
324 | # define YY_(msgid) dgettext ("bison-runtime", msgid)
|
---|
325 | # endif
|
---|
326 | # endif
|
---|
327 | # ifndef YY_
|
---|
328 | # define YY_(msgid) msgid
|
---|
329 | # endif
|
---|
330 | #endif
|
---|
331 |
|
---|
332 | /* Suppress unused-variable warnings by "using" E. */
|
---|
333 | #define YYUSE(e) ((void) (e))
|
---|
334 |
|
---|
335 | /* Enable debugging if requested. */
|
---|
336 | #if YYDEBUG
|
---|
337 |
|
---|
338 | /* A pseudo ostream that takes yydebug_ into account. */
|
---|
339 | # define YYCDEBUG if (yydebug_) (*yycdebug_)
|
---|
340 |
|
---|
341 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
|
---|
342 | do { \
|
---|
343 | if (yydebug_) \
|
---|
344 | { \
|
---|
345 | *yycdebug_ << Title << ' '; \
|
---|
346 | yy_symbol_print_ ((Type), (Value), (Location)); \
|
---|
347 | *yycdebug_ << std::endl; \
|
---|
348 | } \
|
---|
349 | } while (false)
|
---|
350 |
|
---|
351 | # define YY_REDUCE_PRINT(Rule) \
|
---|
352 | do { \
|
---|
353 | if (yydebug_) \
|
---|
354 | yy_reduce_print_ (Rule); \
|
---|
355 | } while (false)
|
---|
356 |
|
---|
357 | # define YY_STACK_PRINT() \
|
---|
358 | do { \
|
---|
359 | if (yydebug_) \
|
---|
360 | yystack_print_ (); \
|
---|
361 | } while (false)
|
---|
362 |
|
---|
363 | #else /* !YYDEBUG */
|
---|
364 |
|
---|
365 | # define YYCDEBUG if (false) std::cerr
|
---|
366 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
|
---|
367 | # define YY_REDUCE_PRINT(Rule)
|
---|
368 | # define YY_STACK_PRINT()
|
---|
369 |
|
---|
370 | #endif /* !YYDEBUG */
|
---|
371 |
|
---|
372 | #define yyerrok (yyerrstatus_ = 0)
|
---|
373 | #define yyclearin (yychar = yyempty_)
|
---|
374 |
|
---|
375 | #define YYACCEPT goto yyacceptlab
|
---|
376 | #define YYABORT goto yyabortlab
|
---|
377 | #define YYERROR goto yyerrorlab
|
---|
378 | #define YYRECOVERING() (!!yyerrstatus_)
|
---|
379 |
|
---|
380 | ]b4_namespace_open[
|
---|
381 | #if YYERROR_VERBOSE
|
---|
382 |
|
---|
383 | /* Return YYSTR after stripping away unnecessary quotes and
|
---|
384 | backslashes, so that it's suitable for yyerror. The heuristic is
|
---|
385 | that double-quoting is unnecessary unless the string contains an
|
---|
386 | apostrophe, a comma, or backslash (other than backslash-backslash).
|
---|
387 | YYSTR is taken from yytname. */
|
---|
388 | std::string
|
---|
389 | ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
|
---|
390 | {
|
---|
391 | if (*yystr == '"')
|
---|
392 | {
|
---|
393 | std::string yyr = "";
|
---|
394 | char const *yyp = yystr;
|
---|
395 |
|
---|
396 | for (;;)
|
---|
397 | switch (*++yyp)
|
---|
398 | {
|
---|
399 | case '\'':
|
---|
400 | case ',':
|
---|
401 | goto do_not_strip_quotes;
|
---|
402 |
|
---|
403 | case '\\':
|
---|
404 | if (*++yyp != '\\')
|
---|
405 | goto do_not_strip_quotes;
|
---|
406 | /* Fall through. */
|
---|
407 | default:
|
---|
408 | yyr += *yyp;
|
---|
409 | break;
|
---|
410 |
|
---|
411 | case '"':
|
---|
412 | return yyr;
|
---|
413 | }
|
---|
414 | do_not_strip_quotes: ;
|
---|
415 | }
|
---|
416 |
|
---|
417 | return yystr;
|
---|
418 | }
|
---|
419 |
|
---|
420 | #endif
|
---|
421 |
|
---|
422 | /// Build a parser object.
|
---|
423 | ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
|
---|
424 | :])[
|
---|
425 | #if YYDEBUG
|
---|
426 | ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
|
---|
427 | yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
|
---|
428 | #endif]b4_parse_param_cons[
|
---|
429 | {
|
---|
430 | }
|
---|
431 |
|
---|
432 | ]b4_parser_class_name::~b4_parser_class_name[ ()
|
---|
433 | {
|
---|
434 | }
|
---|
435 |
|
---|
436 | #if YYDEBUG
|
---|
437 | /*--------------------------------.
|
---|
438 | | Print this symbol on YYOUTPUT. |
|
---|
439 | `--------------------------------*/
|
---|
440 |
|
---|
441 | inline void
|
---|
442 | ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
|
---|
443 | const semantic_type* yyvaluep, const location_type* yylocationp)
|
---|
444 | {
|
---|
445 | YYUSE (yylocationp);
|
---|
446 | YYUSE (yyvaluep);
|
---|
447 | switch (yytype)
|
---|
448 | {
|
---|
449 | ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
|
---|
450 | [ default:
|
---|
451 | break;
|
---|
452 | }
|
---|
453 | }
|
---|
454 |
|
---|
455 |
|
---|
456 | void
|
---|
457 | ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
|
---|
458 | const semantic_type* yyvaluep, const location_type* yylocationp)
|
---|
459 | {
|
---|
460 | *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
|
---|
461 | << ' ' << yytname_[yytype] << " ("
|
---|
462 | << *yylocationp << ": ";
|
---|
463 | yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
|
---|
464 | *yycdebug_ << ')';
|
---|
465 | }
|
---|
466 | #endif
|
---|
467 |
|
---|
468 | void
|
---|
469 | ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
|
---|
470 | int yytype, semantic_type* yyvaluep, location_type* yylocationp)
|
---|
471 | {
|
---|
472 | YYUSE (yylocationp);
|
---|
473 | YYUSE (yymsg);
|
---|
474 | YYUSE (yyvaluep);
|
---|
475 |
|
---|
476 | YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
|
---|
477 |
|
---|
478 | switch (yytype)
|
---|
479 | {
|
---|
480 | ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
|
---|
481 | default:
|
---|
482 | break;
|
---|
483 | }
|
---|
484 | }
|
---|
485 |
|
---|
486 | void
|
---|
487 | ]b4_parser_class_name[::yypop_ (unsigned int n)
|
---|
488 | {
|
---|
489 | yystate_stack_.pop (n);
|
---|
490 | yysemantic_stack_.pop (n);
|
---|
491 | yylocation_stack_.pop (n);
|
---|
492 | }
|
---|
493 |
|
---|
494 | #if YYDEBUG
|
---|
495 | std::ostream&
|
---|
496 | ]b4_parser_class_name[::debug_stream () const
|
---|
497 | {
|
---|
498 | return *yycdebug_;
|
---|
499 | }
|
---|
500 |
|
---|
501 | void
|
---|
502 | ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
|
---|
503 | {
|
---|
504 | yycdebug_ = &o;
|
---|
505 | }
|
---|
506 |
|
---|
507 |
|
---|
508 | ]b4_parser_class_name[::debug_level_type
|
---|
509 | ]b4_parser_class_name[::debug_level () const
|
---|
510 | {
|
---|
511 | return yydebug_;
|
---|
512 | }
|
---|
513 |
|
---|
514 | void
|
---|
515 | ]b4_parser_class_name[::set_debug_level (debug_level_type l)
|
---|
516 | {
|
---|
517 | yydebug_ = l;
|
---|
518 | }
|
---|
519 | #endif
|
---|
520 |
|
---|
521 | int
|
---|
522 | ]b4_parser_class_name[::parse ()
|
---|
523 | {
|
---|
524 | /// Lookahead and lookahead in internal form.
|
---|
525 | int yychar = yyempty_;
|
---|
526 | int yytoken = 0;
|
---|
527 |
|
---|
528 | /* State. */
|
---|
529 | int yyn;
|
---|
530 | int yylen = 0;
|
---|
531 | int yystate = 0;
|
---|
532 |
|
---|
533 | /* Error handling. */
|
---|
534 | int yynerrs_ = 0;
|
---|
535 | int yyerrstatus_ = 0;
|
---|
536 |
|
---|
537 | /// Semantic value of the lookahead.
|
---|
538 | semantic_type yylval;
|
---|
539 | /// Location of the lookahead.
|
---|
540 | location_type yylloc;
|
---|
541 | /// The locations where the error started and ended.
|
---|
542 | location_type yyerror_range[2];
|
---|
543 |
|
---|
544 | /// $$.
|
---|
545 | semantic_type yyval;
|
---|
546 | /// @@$.
|
---|
547 | location_type yyloc;
|
---|
548 |
|
---|
549 | int yyresult;
|
---|
550 |
|
---|
551 | YYCDEBUG << "Starting parse" << std::endl;
|
---|
552 |
|
---|
553 | ]m4_ifdef([b4_initial_action], [
|
---|
554 | m4_pushdef([b4_at_dollar], [yylloc])dnl
|
---|
555 | m4_pushdef([b4_dollar_dollar], [yylval])dnl
|
---|
556 | /* User initialization code. */
|
---|
557 | b4_user_initial_action
|
---|
558 | m4_popdef([b4_dollar_dollar])dnl
|
---|
559 | m4_popdef([b4_at_dollar])])dnl
|
---|
560 |
|
---|
561 | [ /* Initialize the stacks. The initial state will be pushed in
|
---|
562 | yynewstate, since the latter expects the semantical and the
|
---|
563 | location values to have been already stored, initialize these
|
---|
564 | stacks with a primary value. */
|
---|
565 | yystate_stack_ = state_stack_type (0);
|
---|
566 | yysemantic_stack_ = semantic_stack_type (0);
|
---|
567 | yylocation_stack_ = location_stack_type (0);
|
---|
568 | yysemantic_stack_.push (yylval);
|
---|
569 | yylocation_stack_.push (yylloc);
|
---|
570 |
|
---|
571 | /* New state. */
|
---|
572 | yynewstate:
|
---|
573 | yystate_stack_.push (yystate);
|
---|
574 | YYCDEBUG << "Entering state " << yystate << std::endl;
|
---|
575 |
|
---|
576 | /* Accept? */
|
---|
577 | if (yystate == yyfinal_)
|
---|
578 | goto yyacceptlab;
|
---|
579 |
|
---|
580 | goto yybackup;
|
---|
581 |
|
---|
582 | /* Backup. */
|
---|
583 | yybackup:
|
---|
584 |
|
---|
585 | /* Try to take a decision without lookahead. */
|
---|
586 | yyn = yypact_[yystate];
|
---|
587 | if (yyn == yypact_ninf_)
|
---|
588 | goto yydefault;
|
---|
589 |
|
---|
590 | /* Read a lookahead token. */
|
---|
591 | if (yychar == yyempty_)
|
---|
592 | {
|
---|
593 | YYCDEBUG << "Reading a token: ";
|
---|
594 | yychar = ]b4_c_function_call([yylex], [int],
|
---|
595 | [[YYSTYPE*], [&yylval]][]dnl
|
---|
596 | b4_locations_if([, [[location*], [&yylloc]]])dnl
|
---|
597 | m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
|
---|
598 | }
|
---|
599 |
|
---|
600 |
|
---|
601 | /* Convert token to internal form. */
|
---|
602 | if (yychar <= yyeof_)
|
---|
603 | {
|
---|
604 | yychar = yytoken = yyeof_;
|
---|
605 | YYCDEBUG << "Now at end of input." << std::endl;
|
---|
606 | }
|
---|
607 | else
|
---|
608 | {
|
---|
609 | yytoken = yytranslate_ (yychar);
|
---|
610 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
|
---|
611 | }
|
---|
612 |
|
---|
613 | /* If the proper action on seeing token YYTOKEN is to reduce or to
|
---|
614 | detect an error, take that action. */
|
---|
615 | yyn += yytoken;
|
---|
616 | if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
|
---|
617 | goto yydefault;
|
---|
618 |
|
---|
619 | /* Reduce or error. */
|
---|
620 | yyn = yytable_[yyn];
|
---|
621 | if (yyn <= 0)
|
---|
622 | {
|
---|
623 | if (yyn == 0 || yyn == yytable_ninf_)
|
---|
624 | goto yyerrlab;
|
---|
625 | yyn = -yyn;
|
---|
626 | goto yyreduce;
|
---|
627 | }
|
---|
628 |
|
---|
629 | /* Shift the lookahead token. */
|
---|
630 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
|
---|
631 |
|
---|
632 | /* Discard the token being shifted. */
|
---|
633 | yychar = yyempty_;
|
---|
634 |
|
---|
635 | yysemantic_stack_.push (yylval);
|
---|
636 | yylocation_stack_.push (yylloc);
|
---|
637 |
|
---|
638 | /* Count tokens shifted since error; after three, turn off error
|
---|
639 | status. */
|
---|
640 | if (yyerrstatus_)
|
---|
641 | --yyerrstatus_;
|
---|
642 |
|
---|
643 | yystate = yyn;
|
---|
644 | goto yynewstate;
|
---|
645 |
|
---|
646 | /*-----------------------------------------------------------.
|
---|
647 | | yydefault -- do the default action for the current state. |
|
---|
648 | `-----------------------------------------------------------*/
|
---|
649 | yydefault:
|
---|
650 | yyn = yydefact_[yystate];
|
---|
651 | if (yyn == 0)
|
---|
652 | goto yyerrlab;
|
---|
653 | goto yyreduce;
|
---|
654 |
|
---|
655 | /*-----------------------------.
|
---|
656 | | yyreduce -- Do a reduction. |
|
---|
657 | `-----------------------------*/
|
---|
658 | yyreduce:
|
---|
659 | yylen = yyr2_[yyn];
|
---|
660 | /* If YYLEN is nonzero, implement the default value of the action:
|
---|
661 | `$$ = $1'. Otherwise, use the top of the stack.
|
---|
662 |
|
---|
663 | Otherwise, the following line sets YYVAL to garbage.
|
---|
664 | This behavior is undocumented and Bison
|
---|
665 | users should not rely upon it. */
|
---|
666 | if (yylen)
|
---|
667 | yyval = yysemantic_stack_[yylen - 1];
|
---|
668 | else
|
---|
669 | yyval = yysemantic_stack_[0];
|
---|
670 |
|
---|
671 | {
|
---|
672 | slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
|
---|
673 | YYLLOC_DEFAULT (yyloc, slice, yylen);
|
---|
674 | }
|
---|
675 | YY_REDUCE_PRINT (yyn);
|
---|
676 | switch (yyn)
|
---|
677 | {
|
---|
678 | ]b4_user_actions[
|
---|
679 | default:
|
---|
680 | break;
|
---|
681 | }
|
---|
682 | YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
|
---|
683 |
|
---|
684 | yypop_ (yylen);
|
---|
685 | yylen = 0;
|
---|
686 | YY_STACK_PRINT ();
|
---|
687 |
|
---|
688 | yysemantic_stack_.push (yyval);
|
---|
689 | yylocation_stack_.push (yyloc);
|
---|
690 |
|
---|
691 | /* Shift the result of the reduction. */
|
---|
692 | yyn = yyr1_[yyn];
|
---|
693 | yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
|
---|
694 | if (0 <= yystate && yystate <= yylast_
|
---|
695 | && yycheck_[yystate] == yystate_stack_[0])
|
---|
696 | yystate = yytable_[yystate];
|
---|
697 | else
|
---|
698 | yystate = yydefgoto_[yyn - yyntokens_];
|
---|
699 | goto yynewstate;
|
---|
700 |
|
---|
701 | /*------------------------------------.
|
---|
702 | | yyerrlab -- here on detecting error |
|
---|
703 | `------------------------------------*/
|
---|
704 | yyerrlab:
|
---|
705 | /* If not already recovering from an error, report this error. */
|
---|
706 | if (!yyerrstatus_)
|
---|
707 | {
|
---|
708 | ++yynerrs_;
|
---|
709 | error (yylloc, yysyntax_error_ (yystate]dnl
|
---|
710 | b4_error_verbose_if([, yytoken])[));
|
---|
711 | }
|
---|
712 |
|
---|
713 | yyerror_range[0] = yylloc;
|
---|
714 | if (yyerrstatus_ == 3)
|
---|
715 | {
|
---|
716 | /* If just tried and failed to reuse lookahead token after an
|
---|
717 | error, discard it. */
|
---|
718 |
|
---|
719 | if (yychar <= yyeof_)
|
---|
720 | {
|
---|
721 | /* Return failure if at end of input. */
|
---|
722 | if (yychar == yyeof_)
|
---|
723 | YYABORT;
|
---|
724 | }
|
---|
725 | else
|
---|
726 | {
|
---|
727 | yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
|
---|
728 | yychar = yyempty_;
|
---|
729 | }
|
---|
730 | }
|
---|
731 |
|
---|
732 | /* Else will try to reuse lookahead token after shifting the error
|
---|
733 | token. */
|
---|
734 | goto yyerrlab1;
|
---|
735 |
|
---|
736 |
|
---|
737 | /*---------------------------------------------------.
|
---|
738 | | yyerrorlab -- error raised explicitly by YYERROR. |
|
---|
739 | `---------------------------------------------------*/
|
---|
740 | yyerrorlab:
|
---|
741 |
|
---|
742 | /* Pacify compilers like GCC when the user code never invokes
|
---|
743 | YYERROR and the label yyerrorlab therefore never appears in user
|
---|
744 | code. */
|
---|
745 | if (false)
|
---|
746 | goto yyerrorlab;
|
---|
747 |
|
---|
748 | yyerror_range[0] = yylocation_stack_[yylen - 1];
|
---|
749 | /* Do not reclaim the symbols of the rule which action triggered
|
---|
750 | this YYERROR. */
|
---|
751 | yypop_ (yylen);
|
---|
752 | yylen = 0;
|
---|
753 | yystate = yystate_stack_[0];
|
---|
754 | goto yyerrlab1;
|
---|
755 |
|
---|
756 | /*-------------------------------------------------------------.
|
---|
757 | | yyerrlab1 -- common code for both syntax error and YYERROR. |
|
---|
758 | `-------------------------------------------------------------*/
|
---|
759 | yyerrlab1:
|
---|
760 | yyerrstatus_ = 3; /* Each real token shifted decrements this. */
|
---|
761 |
|
---|
762 | for (;;)
|
---|
763 | {
|
---|
764 | yyn = yypact_[yystate];
|
---|
765 | if (yyn != yypact_ninf_)
|
---|
766 | {
|
---|
767 | yyn += yyterror_;
|
---|
768 | if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
|
---|
769 | {
|
---|
770 | yyn = yytable_[yyn];
|
---|
771 | if (0 < yyn)
|
---|
772 | break;
|
---|
773 | }
|
---|
774 | }
|
---|
775 |
|
---|
776 | /* Pop the current state because it cannot handle the error token. */
|
---|
777 | if (yystate_stack_.height () == 1)
|
---|
778 | YYABORT;
|
---|
779 |
|
---|
780 | yyerror_range[0] = yylocation_stack_[0];
|
---|
781 | yydestruct_ ("Error: popping",
|
---|
782 | yystos_[yystate],
|
---|
783 | &yysemantic_stack_[0], &yylocation_stack_[0]);
|
---|
784 | yypop_ ();
|
---|
785 | yystate = yystate_stack_[0];
|
---|
786 | YY_STACK_PRINT ();
|
---|
787 | }
|
---|
788 |
|
---|
789 | yyerror_range[1] = yylloc;
|
---|
790 | // Using YYLLOC is tempting, but would change the location of
|
---|
791 | // the lookahead. YYLOC is available though.
|
---|
792 | YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
|
---|
793 | yysemantic_stack_.push (yylval);
|
---|
794 | yylocation_stack_.push (yyloc);
|
---|
795 |
|
---|
796 | /* Shift the error token. */
|
---|
797 | YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
|
---|
798 | &yysemantic_stack_[0], &yylocation_stack_[0]);
|
---|
799 |
|
---|
800 | yystate = yyn;
|
---|
801 | goto yynewstate;
|
---|
802 |
|
---|
803 | /* Accept. */
|
---|
804 | yyacceptlab:
|
---|
805 | yyresult = 0;
|
---|
806 | goto yyreturn;
|
---|
807 |
|
---|
808 | /* Abort. */
|
---|
809 | yyabortlab:
|
---|
810 | yyresult = 1;
|
---|
811 | goto yyreturn;
|
---|
812 |
|
---|
813 | yyreturn:
|
---|
814 | if (yychar != yyempty_)
|
---|
815 | yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
|
---|
816 |
|
---|
817 | /* Do not reclaim the symbols of the rule which action triggered
|
---|
818 | this YYABORT or YYACCEPT. */
|
---|
819 | yypop_ (yylen);
|
---|
820 | while (yystate_stack_.height () != 1)
|
---|
821 | {
|
---|
822 | yydestruct_ ("Cleanup: popping",
|
---|
823 | yystos_[yystate_stack_[0]],
|
---|
824 | &yysemantic_stack_[0],
|
---|
825 | &yylocation_stack_[0]);
|
---|
826 | yypop_ ();
|
---|
827 | }
|
---|
828 |
|
---|
829 | return yyresult;
|
---|
830 | }
|
---|
831 |
|
---|
832 | // Generate an error message.
|
---|
833 | std::string
|
---|
834 | ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
|
---|
835 | b4_error_verbose_if([, int tok])[)
|
---|
836 | {
|
---|
837 | std::string res;
|
---|
838 | YYUSE (yystate);
|
---|
839 | #if YYERROR_VERBOSE
|
---|
840 | int yyn = yypact_[yystate];
|
---|
841 | if (yypact_ninf_ < yyn && yyn <= yylast_)
|
---|
842 | {
|
---|
843 | /* Start YYX at -YYN if negative to avoid negative indexes in
|
---|
844 | YYCHECK. */
|
---|
845 | int yyxbegin = yyn < 0 ? -yyn : 0;
|
---|
846 |
|
---|
847 | /* Stay within bounds of both yycheck and yytname. */
|
---|
848 | int yychecklim = yylast_ - yyn + 1;
|
---|
849 | int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
|
---|
850 | int count = 0;
|
---|
851 | for (int x = yyxbegin; x < yyxend; ++x)
|
---|
852 | if (yycheck_[x + yyn] == x && x != yyterror_)
|
---|
853 | ++count;
|
---|
854 |
|
---|
855 | // FIXME: This method of building the message is not compatible
|
---|
856 | // with internationalization. It should work like yacc.c does it.
|
---|
857 | // That is, first build a string that looks like this:
|
---|
858 | // "syntax error, unexpected %s or %s or %s"
|
---|
859 | // Then, invoke YY_ on this string.
|
---|
860 | // Finally, use the string as a format to output
|
---|
861 | // yytname_[tok], etc.
|
---|
862 | // Until this gets fixed, this message appears in English only.
|
---|
863 | res = "syntax error, unexpected ";
|
---|
864 | res += yytnamerr_ (yytname_[tok]);
|
---|
865 | if (count < 5)
|
---|
866 | {
|
---|
867 | count = 0;
|
---|
868 | for (int x = yyxbegin; x < yyxend; ++x)
|
---|
869 | if (yycheck_[x + yyn] == x && x != yyterror_)
|
---|
870 | {
|
---|
871 | res += (!count++) ? ", expecting " : " or ";
|
---|
872 | res += yytnamerr_ (yytname_[x]);
|
---|
873 | }
|
---|
874 | }
|
---|
875 | }
|
---|
876 | else
|
---|
877 | #endif
|
---|
878 | res = YY_("syntax error");
|
---|
879 | return res;
|
---|
880 | }
|
---|
881 |
|
---|
882 |
|
---|
883 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
---|
884 | STATE-NUM. */
|
---|
885 | const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
|
---|
886 | const ]b4_int_type_for([b4_pact])[
|
---|
887 | ]b4_parser_class_name[::yypact_[] =
|
---|
888 | {
|
---|
889 | ]b4_pact[
|
---|
890 | };
|
---|
891 |
|
---|
892 | /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
|
---|
893 | doesn't specify something else to do. Zero means the default is an
|
---|
894 | error. */
|
---|
895 | const ]b4_int_type_for([b4_defact])[
|
---|
896 | ]b4_parser_class_name[::yydefact_[] =
|
---|
897 | {
|
---|
898 | ]b4_defact[
|
---|
899 | };
|
---|
900 |
|
---|
901 | /* YYPGOTO[NTERM-NUM]. */
|
---|
902 | const ]b4_int_type_for([b4_pgoto])[
|
---|
903 | ]b4_parser_class_name[::yypgoto_[] =
|
---|
904 | {
|
---|
905 | ]b4_pgoto[
|
---|
906 | };
|
---|
907 |
|
---|
908 | /* YYDEFGOTO[NTERM-NUM]. */
|
---|
909 | const ]b4_int_type_for([b4_defgoto])[
|
---|
910 | ]b4_parser_class_name[::yydefgoto_[] =
|
---|
911 | {
|
---|
912 | ]b4_defgoto[
|
---|
913 | };
|
---|
914 |
|
---|
915 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
|
---|
916 | positive, shift that token. If negative, reduce the rule which
|
---|
917 | number is the opposite. If zero, do what YYDEFACT says. */
|
---|
918 | const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
|
---|
919 | const ]b4_int_type_for([b4_table])[
|
---|
920 | ]b4_parser_class_name[::yytable_[] =
|
---|
921 | {
|
---|
922 | ]b4_table[
|
---|
923 | };
|
---|
924 |
|
---|
925 | /* YYCHECK. */
|
---|
926 | const ]b4_int_type_for([b4_check])[
|
---|
927 | ]b4_parser_class_name[::yycheck_[] =
|
---|
928 | {
|
---|
929 | ]b4_check[
|
---|
930 | };
|
---|
931 |
|
---|
932 | /* STOS_[STATE-NUM] -- The (internal number of the) accessing
|
---|
933 | symbol of state STATE-NUM. */
|
---|
934 | const ]b4_int_type_for([b4_stos])[
|
---|
935 | ]b4_parser_class_name[::yystos_[] =
|
---|
936 | {
|
---|
937 | ]b4_stos[
|
---|
938 | };
|
---|
939 |
|
---|
940 | #if YYDEBUG
|
---|
941 | /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
|
---|
942 | to YYLEX-NUM. */
|
---|
943 | const ]b4_int_type_for([b4_toknum])[
|
---|
944 | ]b4_parser_class_name[::yytoken_number_[] =
|
---|
945 | {
|
---|
946 | ]b4_toknum[
|
---|
947 | };
|
---|
948 | #endif
|
---|
949 |
|
---|
950 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
---|
951 | const ]b4_int_type_for([b4_r1])[
|
---|
952 | ]b4_parser_class_name[::yyr1_[] =
|
---|
953 | {
|
---|
954 | ]b4_r1[
|
---|
955 | };
|
---|
956 |
|
---|
957 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
|
---|
958 | const ]b4_int_type_for([b4_r2])[
|
---|
959 | ]b4_parser_class_name[::yyr2_[] =
|
---|
960 | {
|
---|
961 | ]b4_r2[
|
---|
962 | };
|
---|
963 |
|
---|
964 | #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
|
---|
965 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
---|
966 | First, the terminals, then, starting at \a yyntokens_, nonterminals. */
|
---|
967 | const char*
|
---|
968 | const ]b4_parser_class_name[::yytname_[] =
|
---|
969 | {
|
---|
970 | ]b4_tname[
|
---|
971 | };
|
---|
972 | #endif
|
---|
973 |
|
---|
974 | #if YYDEBUG
|
---|
975 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */
|
---|
976 | const ]b4_parser_class_name[::rhs_number_type
|
---|
977 | ]b4_parser_class_name[::yyrhs_[] =
|
---|
978 | {
|
---|
979 | ]b4_rhs[
|
---|
980 | };
|
---|
981 |
|
---|
982 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
|
---|
983 | YYRHS. */
|
---|
984 | const ]b4_int_type_for([b4_prhs])[
|
---|
985 | ]b4_parser_class_name[::yyprhs_[] =
|
---|
986 | {
|
---|
987 | ]b4_prhs[
|
---|
988 | };
|
---|
989 |
|
---|
990 | /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
---|
991 | const ]b4_int_type_for([b4_rline])[
|
---|
992 | ]b4_parser_class_name[::yyrline_[] =
|
---|
993 | {
|
---|
994 | ]b4_rline[
|
---|
995 | };
|
---|
996 |
|
---|
997 | // Print the state stack on the debug stream.
|
---|
998 | void
|
---|
999 | ]b4_parser_class_name[::yystack_print_ ()
|
---|
1000 | {
|
---|
1001 | *yycdebug_ << "Stack now";
|
---|
1002 | for (state_stack_type::const_iterator i = yystate_stack_.begin ();
|
---|
1003 | i != yystate_stack_.end (); ++i)
|
---|
1004 | *yycdebug_ << ' ' << *i;
|
---|
1005 | *yycdebug_ << std::endl;
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 | // Report on the debug stream that the rule \a yyrule is going to be reduced.
|
---|
1009 | void
|
---|
1010 | ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
|
---|
1011 | {
|
---|
1012 | unsigned int yylno = yyrline_[yyrule];
|
---|
1013 | int yynrhs = yyr2_[yyrule];
|
---|
1014 | /* Print the symbols being reduced, and their result. */
|
---|
1015 | *yycdebug_ << "Reducing stack by rule " << yyrule - 1
|
---|
1016 | << " (line " << yylno << "):" << std::endl;
|
---|
1017 | /* The symbols being reduced. */
|
---|
1018 | for (int yyi = 0; yyi < yynrhs; yyi++)
|
---|
1019 | YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
|
---|
1020 | yyrhs_[yyprhs_[yyrule] + yyi],
|
---|
1021 | &]b4_rhs_value(yynrhs, yyi + 1)[,
|
---|
1022 | &]b4_rhs_location(yynrhs, yyi + 1)[);
|
---|
1023 | }
|
---|
1024 | #endif // YYDEBUG
|
---|
1025 |
|
---|
1026 | /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
|
---|
1027 | ]b4_parser_class_name[::token_number_type
|
---|
1028 | ]b4_parser_class_name[::yytranslate_ (int t)
|
---|
1029 | {
|
---|
1030 | static
|
---|
1031 | const token_number_type
|
---|
1032 | translate_table[] =
|
---|
1033 | {
|
---|
1034 | ]b4_translate[
|
---|
1035 | };
|
---|
1036 | if ((unsigned int) t <= yyuser_token_number_max_)
|
---|
1037 | return translate_table[t];
|
---|
1038 | else
|
---|
1039 | return yyundef_token_;
|
---|
1040 | }
|
---|
1041 |
|
---|
1042 | const int ]b4_parser_class_name[::yyeof_ = 0;
|
---|
1043 | const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
|
---|
1044 | const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
|
---|
1045 | const int ]b4_parser_class_name[::yyempty_ = -2;
|
---|
1046 | const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
|
---|
1047 | const int ]b4_parser_class_name[::yyterror_ = 1;
|
---|
1048 | const int ]b4_parser_class_name[::yyerrcode_ = 256;
|
---|
1049 | const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
|
---|
1050 |
|
---|
1051 | const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
|
---|
1052 | const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
|
---|
1053 |
|
---|
1054 | ]b4_namespace_close[
|
---|
1055 |
|
---|
1056 | ]b4_epilogue
|
---|
1057 | dnl
|
---|
1058 | @output(b4_dir_prefix[]stack.hh@)
|
---|
1059 | b4_copyright([Stack handling for Bison parsers in C++],
|
---|
1060 | [2002, 2003, 2004, 2005, 2006, 2007, 2008])[
|
---|
1061 |
|
---|
1062 | #ifndef BISON_STACK_HH
|
---|
1063 | # define BISON_STACK_HH
|
---|
1064 |
|
---|
1065 | #include <deque>
|
---|
1066 |
|
---|
1067 | ]b4_namespace_open[
|
---|
1068 | template <class T, class S = std::deque<T> >
|
---|
1069 | class stack
|
---|
1070 | {
|
---|
1071 | public:
|
---|
1072 |
|
---|
1073 | // Hide our reversed order.
|
---|
1074 | typedef typename S::reverse_iterator iterator;
|
---|
1075 | typedef typename S::const_reverse_iterator const_iterator;
|
---|
1076 |
|
---|
1077 | stack () : seq_ ()
|
---|
1078 | {
|
---|
1079 | }
|
---|
1080 |
|
---|
1081 | stack (unsigned int n) : seq_ (n)
|
---|
1082 | {
|
---|
1083 | }
|
---|
1084 |
|
---|
1085 | inline
|
---|
1086 | T&
|
---|
1087 | operator [] (unsigned int i)
|
---|
1088 | {
|
---|
1089 | return seq_[i];
|
---|
1090 | }
|
---|
1091 |
|
---|
1092 | inline
|
---|
1093 | const T&
|
---|
1094 | operator [] (unsigned int i) const
|
---|
1095 | {
|
---|
1096 | return seq_[i];
|
---|
1097 | }
|
---|
1098 |
|
---|
1099 | inline
|
---|
1100 | void
|
---|
1101 | push (const T& t)
|
---|
1102 | {
|
---|
1103 | seq_.push_front (t);
|
---|
1104 | }
|
---|
1105 |
|
---|
1106 | inline
|
---|
1107 | void
|
---|
1108 | pop (unsigned int n = 1)
|
---|
1109 | {
|
---|
1110 | for (; n; --n)
|
---|
1111 | seq_.pop_front ();
|
---|
1112 | }
|
---|
1113 |
|
---|
1114 | inline
|
---|
1115 | unsigned int
|
---|
1116 | height () const
|
---|
1117 | {
|
---|
1118 | return seq_.size ();
|
---|
1119 | }
|
---|
1120 |
|
---|
1121 | inline const_iterator begin () const { return seq_.rbegin (); }
|
---|
1122 | inline const_iterator end () const { return seq_.rend (); }
|
---|
1123 |
|
---|
1124 | private:
|
---|
1125 |
|
---|
1126 | S seq_;
|
---|
1127 | };
|
---|
1128 |
|
---|
1129 | /// Present a slice of the top of a stack.
|
---|
1130 | template <class T, class S = stack<T> >
|
---|
1131 | class slice
|
---|
1132 | {
|
---|
1133 | public:
|
---|
1134 |
|
---|
1135 | slice (const S& stack,
|
---|
1136 | unsigned int range) : stack_ (stack),
|
---|
1137 | range_ (range)
|
---|
1138 | {
|
---|
1139 | }
|
---|
1140 |
|
---|
1141 | inline
|
---|
1142 | const T&
|
---|
1143 | operator [] (unsigned int i) const
|
---|
1144 | {
|
---|
1145 | return stack_[range_ - i];
|
---|
1146 | }
|
---|
1147 |
|
---|
1148 | private:
|
---|
1149 |
|
---|
1150 | const S& stack_;
|
---|
1151 | unsigned int range_;
|
---|
1152 | };
|
---|
1153 | ]b4_namespace_close[
|
---|
1154 |
|
---|
1155 | #endif // not BISON_STACK_HH[]dnl
|
---|
1156 | ]
|
---|
1157 | m4_divert_pop(0)
|
---|