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