]>
Commit | Line | Data |
---|---|---|
60491a94 | 1 | # C++ skeleton for Bison |
b4721715 | 2 | |
34136e65 | 3 | # Copyright (C) 2002-2012 Free Software Foundation, Inc. |
60491a94 | 4 | |
f16b0819 | 5 | # This program is free software: you can redistribute it and/or modify |
60491a94 | 6 | # it under the terms of the GNU General Public License as published by |
f16b0819 | 7 | # the Free Software Foundation, either version 3 of the License, or |
60491a94 | 8 | # (at your option) any later version. |
f16b0819 | 9 | # |
60491a94 AD |
10 | # This program is distributed in the hope that it will be useful, |
11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | # GNU General Public License for more details. | |
f16b0819 | 14 | # |
60491a94 | 15 | # You should have received a copy of the GNU General Public License |
f16b0819 | 16 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
60491a94 | 17 | |
cf147260 | 18 | m4_include(b4_pkgdatadir/[c++.m4]) |
7eb8a0bc | 19 | |
2ea7730c | 20 | |
ba206cf4 AD |
21 | # b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT) |
22 | # -------------------------------------------------------------- | |
0fddb3d5 | 23 | # Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT. |
ba206cf4 | 24 | m4_define([b4_integral_parser_table_declare], |
15f66669 | 25 | [m4_ifval([$3], [b4_comment([$3], [ ]) |
6ab1adbe AD |
26 | ])dnl |
27 | static const b4_int_type_for([$2]) yy$1_[[]];dnl | |
0fddb3d5 AD |
28 | ]) |
29 | ||
ba206cf4 | 30 | # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) |
2b08bceb | 31 | # ------------------------------------------------------------- |
8901f32e | 32 | # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT. |
ba206cf4 | 33 | m4_define([b4_integral_parser_table_define], |
6ab1adbe | 34 | [ const b4_int_type_for([$2]) |
8901f32e AD |
35 | b4_parser_class_name::yy$1_[[]] = |
36 | { | |
37 | $2 | |
6ab1adbe AD |
38 | };dnl |
39 | ]) | |
40 | ||
a9ce3f54 | 41 | |
5de9c593 AD |
42 | # b4_symbol_value_template(VAL, [TYPE]) |
43 | # ------------------------------------- | |
507aa0e2 AD |
44 | # Same as b4_symbol_value, but used in a template method. It makes |
45 | # a difference when using variants. | |
5de9c593 AD |
46 | m4_copy([b4_symbol_value], [b4_symbol_value_template]) |
47 | ||
5ab8c47b | 48 | |
e1f93869 AD |
49 | # b4_lhs_value([TYPE]) |
50 | # -------------------- | |
51 | # Expansion of $<TYPE>$. | |
52 | m4_define([b4_lhs_value], | |
507aa0e2 | 53 | [b4_symbol_value([yylhs.value], [$1])]) |
e1f93869 AD |
54 | |
55 | ||
56 | # b4_lhs_location() | |
57 | # ----------------- | |
58 | # Expansion of @$. | |
59 | m4_define([b4_lhs_location], | |
507aa0e2 | 60 | [yylhs.location]) |
e1f93869 AD |
61 | |
62 | ||
33c195cc AD |
63 | # b4_rhs_data(RULE-LENGTH, NUM) |
64 | # ----------------------------- | |
65 | # Return the data corresponding to the symbol #NUM, where the current | |
66 | # rule has RULE-LENGTH symbols on RHS. | |
67 | m4_define([b4_rhs_data], | |
3204049e | 68 | [yystack_@{b4_subtract($@)@}]) |
33c195cc AD |
69 | |
70 | ||
71 | # b4_rhs_state(RULE-LENGTH, NUM) | |
51bacae6 | 72 | # ------------------------------ |
33c195cc AD |
73 | # The state corresponding to the symbol #NUM, where the current |
74 | # rule has RULE-LENGTH symbols on RHS. | |
75 | m4_define([b4_rhs_state], | |
76 | [b4_rhs_data([$1], [$2]).state]) | |
77 | ||
78 | ||
8901f32e AD |
79 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) |
80 | # -------------------------------------- | |
81 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
82 | # symbols on RHS. | |
83 | m4_define([b4_rhs_value], | |
33c195cc AD |
84 | [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])]) |
85 | ||
8901f32e AD |
86 | |
87 | # b4_rhs_location(RULE-LENGTH, NUM) | |
88 | # --------------------------------- | |
89 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
90 | # on RHS. | |
91 | m4_define([b4_rhs_location], | |
33c195cc | 92 | [b4_rhs_data([$1], [$2]).location]) |
8901f32e | 93 | |
507aa0e2 | 94 | |
2bde9113 AD |
95 | # b4_symbol_action(SYMBOL-NUM, KIND) |
96 | # ---------------------------------- | |
97 | # Run the action KIND (destructor or printer) for SYMBOL-NUM. | |
c4585f1e | 98 | # Same as in C, but using references instead of pointers. |
2bde9113 AD |
99 | m4_define([b4_symbol_action], |
100 | [b4_symbol_if([$1], [has_$2], | |
4323e0da AD |
101 | [m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl |
102 | b4_dollar_pushdef([yysym.value], | |
103 | b4_symbol_if([$1], [has_type], | |
104 | [m4_dquote(b4_symbol([$1], [type]))]), | |
105 | [yysym.location])dnl | |
fb7c5b1f | 106 | b4_symbol_case_([$1]) |
2bde9113 AD |
107 | b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"]) |
108 | b4_symbol([$1], [$2]) | |
c4585f1e AD |
109 | b4_syncline([@oline@], [@ofile@]) |
110 | break; | |
2bde9113 | 111 | |
4323e0da AD |
112 | m4_popdef([b4_symbol_value])[]dnl |
113 | b4_dollar_popdef[]dnl | |
2bde9113 AD |
114 | ])]) |
115 | ||
2873fdf8 | 116 | |
8901f32e | 117 | m4_pushdef([b4_copyright_years], |
34136e65 | 118 | [2002-2012]) |
8901f32e | 119 | |
6afc30cc | 120 | m4_define([b4_parser_class_name], |
a4e25e1d | 121 | [b4_percent_define_get([[parser_class_name]])]) |
34376418 | 122 | |
bcd80897 | 123 | b4_bison_locations_if([# Backward compatibility. |
c547693a | 124 | m4_define([b4_location_constructors]) |
bcd80897 | 125 | m4_include(b4_pkgdatadir/[location.cc])]) |
51bacae6 | 126 | m4_include(b4_pkgdatadir/[stack.hh]) |
507aa0e2 | 127 | b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])]) |
a5eb1ed2 | 128 | |
d27c5e65 AD |
129 | # b4_shared_declarations |
130 | # ---------------------- | |
131 | # Declaration that might either go into the header (if --defines) | |
132 | # or open coded in the parser body. | |
133 | m4_define([b4_shared_declarations], | |
134 | [b4_percent_code_get([[requires]])[ | |
ff348970 | 135 | ]b4_parse_assert_if([# include <cassert>])[ |
5de5b987 | 136 | # include <deque> |
ff348970 | 137 | # include <iostream> |
5de5b987 AD |
138 | # include <stdexcept> |
139 | # include <string>]b4_defines_if([[ | |
ff348970 | 140 | # include "stack.hh" |
bcd80897 | 141 | ]b4_bison_locations_if([[# include "location.hh"]])])[ |
5de5b987 AD |
142 | |
143 | ]b4_YYDEBUG_define[ | |
50997c6e | 144 | |
93549bcd | 145 | ]b4_namespace_open[ |
4162fa07 | 146 | |
5de5b987 AD |
147 | ]b4_defines_if([], |
148 | [b4_stack_define | |
bcd80897 AD |
149 | b4_bison_locations_if([b4_position_define |
150 | b4_location_define])])[ | |
69e2658b | 151 | |
93549bcd | 152 | ]b4_variant_if([b4_variant_define])[ |
3f3eed27 | 153 | |
efeed023 | 154 | /// A Bison parser. |
07fed891 | 155 | class ]b4_parser_class_name[ |
2b548aa6 | 156 | { |
fb9712a9 | 157 | public: |
4f84717d | 158 | ]b4_public_types_declare[ |
efeed023 | 159 | /// Build a parser object. |
98ae9643 AD |
160 | ]b4_parser_class_name[ (]b4_parse_param_decl[); |
161 | virtual ~]b4_parser_class_name[ (); | |
2b548aa6 | 162 | |
f69a4142 AD |
163 | /// Parse. |
164 | /// \returns 0 iff parsing succeeded. | |
e019c247 | 165 | virtual int parse (); |
2b548aa6 | 166 | |
5f108727 | 167 | #if ]b4_api_PREFIX[DEBUG |
f69a4142 | 168 | /// The current debugging stream. |
9a1e9989 AD |
169 | std::ostream& debug_stream () const; |
170 | /// Set the current debugging stream. | |
171 | void set_debug_stream (std::ostream &); | |
172 | ||
a3cb6248 AD |
173 | /// Type for debugging levels. |
174 | typedef int debug_level_type; | |
175 | /// The current debugging level. | |
176 | debug_level_type debug_level () const; | |
177 | /// Set the current debugging level. | |
178 | void set_debug_level (debug_level_type l); | |
52cbbe84 | 179 | #endif |
a3cb6248 | 180 | |
34904c57 AD |
181 | /// Report a syntax error.]b4_locations_if([[ |
182 | /// \param loc where the syntax error is found.]])[ | |
efeed023 | 183 | /// \param msg a description of the syntax error. |
34904c57 | 184 | virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); |
efeed023 | 185 | |
a6552c5d AD |
186 | /// Report a syntax error. |
187 | void error (const syntax_error& err); | |
188 | ||
49572920 | 189 | private: |
e019c247 | 190 | /// State numbers. |
f479c6c6 | 191 | typedef int state_type; |
2b548aa6 | 192 | |
ceb8b8e6 AD |
193 | /// Generate an error message. |
194 | /// \param yystate the state where the error occurred. | |
195 | /// \param yytoken the lookahead token. | |
196 | virtual std::string yysyntax_error_ (state_type yystate, int yytoken); | |
197 | ||
7580c379 AD |
198 | /// Compute post-reduction state. |
199 | /// \param yystate the current state | |
200 | /// \param yylhs the nonterminal to push on the stack | |
201 | state_type yy_lr_goto_state_ (state_type yystate, int yylhs); | |
202 | ||
f2b30bdf JD |
203 | /// Whether the given \c yypact_ value indicates a defaulted state. |
204 | /// \param yyvalue the value to check | |
205 | static bool yy_pact_value_is_default_ (int yyvalue); | |
206 | ||
207 | /// Whether the given \c yytable_ value indicates a syntax error. | |
208 | /// \param yyvalue the value to check | |
209 | static bool yy_table_value_is_error_ (int yyvalue); | |
210 | ||
e019c247 | 211 | /// Internal symbol numbers. |
f479c6c6 | 212 | typedef ]b4_int_type_for([b4_translate])[ token_number_type; |
617a8f12 | 213 | static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; |
617a8f12 | 214 | static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; |
efeed023 | 215 | |
7aaaad6c AD |
216 | // Tables. |
217 | ]b4_parser_tables_declare[]b4_error_verbose_if([ | |
9e0876fb | 218 | |
9e0876fb | 219 | /// Convert the symbol name \a n to a form suitable for a diagnostic. |
422c18f4 | 220 | static std::string yytnamerr_ (const char *n);])[ |
2b548aa6 | 221 | |
5f108727 | 222 | ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ |
258cddbc AD |
223 | /// For a symbol, its name in clear. |
224 | static const char* const yytname_[]; | |
5f108727 | 225 | ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ |
ba206cf4 AD |
226 | ]b4_integral_parser_table_declare([rline], [b4_rline], |
227 | [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[ | |
efeed023 | 228 | /// Report on the debug stream that the rule \a r is going to be reduced. |
d1ff7a7c | 229 | virtual void yy_reduce_print_ (int r); |
efeed023 | 230 | /// Print the state stack on the debug stream. |
f69a4142 | 231 | virtual void yystack_print_ (); |
fa7b79c0 | 232 | |
7aaaad6c | 233 | // Debugging. |
fa7b79c0 PE |
234 | int yydebug_; |
235 | std::ostream* yycdebug_; | |
ccdc1577 | 236 | #endif // ]b4_api_PREFIX[DEBUG |
2b548aa6 | 237 | |
32c96bd7 | 238 | /// Convert a scanner token number \a t to a symbol number. |
e36ec1f4 | 239 | static inline token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t); |
f69a4142 | 240 | |
ccdc1577 | 241 | #if ]b4_api_PREFIX[DEBUG |
1f7d007b AD |
242 | /// \brief Display a symbol type, value and location. |
243 | /// \param yyo The output stream. | |
244 | /// \param yysym The symbol. | |
5de9c593 AD |
245 | template <typename Exact> |
246 | void yy_print_ (std::ostream& yyo, | |
247 | const symbol_base_type<Exact>& yysym) const; | |
57295d14 AD |
248 | #endif |
249 | ||
1f7d007b AD |
250 | /// \brief Reclaim the memory associated to a symbol. |
251 | /// \param yymsg Why this token is reclaimed. | |
252 | /// If null, print nothing. | |
253 | /// \param s The symbol. | |
5de9c593 AD |
254 | template <typename Exact> |
255 | inline void yy_destroy_ (const char* yymsg, | |
256 | symbol_base_type<Exact>& yysym) const; | |
1f7d007b | 257 | |
2873fdf8 | 258 | private: |
1f7d007b | 259 | /// Element of the stack: a state and its attributes. |
5de9c593 | 260 | struct stack_symbol_type : symbol_base_type<stack_symbol_type> |
1f7d007b | 261 | { |
5de9c593 AD |
262 | /// The parent class. |
263 | typedef symbol_base_type<stack_symbol_type> super_type; | |
264 | ||
1f7d007b | 265 | /// Default constructor. |
d3be4f6d | 266 | inline stack_symbol_type (); |
1f7d007b AD |
267 | |
268 | /// Constructor. | |
710c4a65 | 269 | inline stack_symbol_type (]b4_join([state_type s], |
2ea7730c AD |
270 | [const semantic_type& v], |
271 | b4_locations_if([const location_type& l]))[); | |
1f7d007b AD |
272 | |
273 | /// The state. | |
274 | state_type state; | |
57295d14 | 275 | |
2b08bceb | 276 | /// The type (corresponding to \a state). |
5de9c593 | 277 | inline int type_get_ () const; |
1f7d007b | 278 | }; |
57295d14 | 279 | |
8901f32e | 280 | /// Stack type. |
bc0b0477 | 281 | typedef stack<stack_symbol_type> stack_type; |
8901f32e AD |
282 | |
283 | /// The stack. | |
284 | stack_type yystack_; | |
285 | ||
7dedf26e | 286 | /// Push a new state on the stack. |
9380cfd0 AD |
287 | /// \param m a debug message to display |
288 | /// if null, no trace is output. | |
e9b0834e AD |
289 | /// \param s the symbol |
290 | /// \warning the contents of \a s.value is stolen. | |
bc0b0477 | 291 | inline void yypush_ (const char* m, stack_symbol_type& s); |
7dedf26e | 292 | |
1f7d007b AD |
293 | /// Push a new look ahead token on the state on the stack. |
294 | /// \param m a debug message to display | |
295 | /// if null, no trace is output. | |
296 | /// \param s the state | |
297 | /// \param sym the symbol (for its value and location). | |
298 | /// \warning the contents of \a s.value is stolen. | |
299 | inline void yypush_ (const char* m, state_type s, symbol_type& sym); | |
300 | ||
52d5733f | 301 | /// Pop \a n symbols the three stacks. |
f69a4142 | 302 | inline void yypop_ (unsigned int n = 1); |
52d5733f | 303 | |
762a801e | 304 | /* Constants. */ |
914202bd AD |
305 | enum |
306 | { | |
307 | yyeof_ = 0, | |
308 | yylast_ = ]b4_last[, //< Last index in yytable_. | |
309 | yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols. | |
310 | yyempty_ = -2, | |
311 | yyfinal_ = ]b4_final_state_number[, //< Termination state number. | |
312 | yyterror_ = 1, | |
313 | yyerrcode_ = 256, | |
f3bd3f78 | 314 | yyntokens_ = ]b4_tokens_number[ //< Number of tokens. |
914202bd AD |
315 | }; |
316 | ||
caf37a36 | 317 | ]b4_parse_param_vars[ |
2b548aa6 | 318 | }; |
1c4af381 | 319 | |
e36ec1f4 | 320 | ]b4_token_ctor_if([b4_yytranslate_define |
0623bacc | 321 | b4_public_types_define])[ |
793fbca5 | 322 | ]b4_namespace_close[ |
2b548aa6 | 323 | |
592d0b1e | 324 | ]b4_percent_define_flag_if([[global_tokens_and_yystype]], |
6687da34 | 325 | [b4_token_defines |
fb9712a9 | 326 | |
4b3847c3 | 327 | #ifndef ]b4_api_PREFIX[STYPE |
9d9b8b70 | 328 | /* Redirection for backward compatibility. */ |
4b3847c3 | 329 | # define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type |
fb9712a9 | 330 | #endif |
22172d47 AD |
331 | ])[ |
332 | ]b4_percent_code_get([[provides]])[ | |
d27c5e65 AD |
333 | ]]) |
334 | ||
335 | # We do want M4 expansion after # for CPP macros. | |
336 | m4_changecom() | |
85f0b29e AD |
337 | b4_defines_if( |
338 | [m4_divert_push(0)dnl | |
d27c5e65 AD |
339 | @output(b4_spec_defines_file@)@ |
340 | b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++]) | |
341 | [ | |
342 | /** | |
343 | ** \file ]b4_spec_defines_file[ | |
344 | ** Define the ]b4_namespace_ref[::parser class. | |
345 | */ | |
346 | ||
347 | /* C++ LALR(1) parser skeleton written by Akim Demaille. */ | |
348 | ||
349 | ]b4_cpp_guard_open([b4_spec_defines_file])[ | |
350 | ]b4_shared_declarations[ | |
22172d47 | 351 | ]b4_cpp_guard_close([b4_spec_defines_file]) |
1c7ec959 | 352 | b4_output_end() |
85f0b29e AD |
353 | ]) |
354 | ||
355 | ||
1c7ec959 | 356 | b4_output_begin([b4_parser_file_name]) |
a9ce3f54 | 357 | b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++]) |
a4e25e1d | 358 | b4_percent_code_get([[top]])[]dnl |
aa08666d | 359 | m4_if(b4_prefix, [yy], [], |
c5b95ccf AD |
360 | [ |
361 | // Take the name prefix into account. | |
9bc0dd67 JD |
362 | #define yylex b4_prefix[]lex])[ |
363 | ||
28427f57 | 364 | // First part of user declarations. |
c944f7f2 | 365 | ]b4_user_pre_prologue[ |
9bc0dd67 | 366 | |
28427f57 AD |
367 | ]b4_null_define[ |
368 | ||
85f0b29e AD |
369 | ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], |
370 | [b4_shared_declarations])[ | |
50997c6e | 371 | |
fb9712a9 | 372 | /* User implementation prologue. */ |
771dc643 AD |
373 | ]b4_user_post_prologue[ |
374 | ]b4_percent_code_get[ | |
375 | ||
771dc643 | 376 | #ifndef YY_ |
ae93128c | 377 | # if defined YYENABLE_NLS && YYENABLE_NLS |
30757c8c PE |
378 | # if ENABLE_NLS |
379 | # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */ | |
380 | # define YY_(msgid) dgettext ("bison-runtime", msgid) | |
381 | # endif | |
382 | # endif | |
383 | # ifndef YY_ | |
384 | # define YY_(msgid) msgid | |
385 | # endif | |
989b5b8e AD |
386 | #endif |
387 | ||
38435078 | 388 | ]b4_locations_if([dnl |
ccdc1577 AD |
389 | [#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) |
390 | ]b4_yylloc_default_define])[ | |
38435078 | 391 | |
2a4647a3 | 392 | /* Suppress unused-variable warnings by "using" E. */ |
12ce2df6 | 393 | #define YYUSE(e) ((void) (e)) |
2a4647a3 | 394 | |
2b548aa6 | 395 | /* Enable debugging if requested. */ |
5f108727 | 396 | #if ]b4_api_PREFIX[DEBUG |
284acc8b | 397 | |
fa7b79c0 PE |
398 | /* A pseudo ostream that takes yydebug_ into account. */ |
399 | # define YYCDEBUG if (yydebug_) (*yycdebug_) | |
400 | ||
1f7d007b | 401 | # define YY_SYMBOL_PRINT(Title, Symbol) \ |
57295d14 AD |
402 | do { \ |
403 | if (yydebug_) \ | |
404 | { \ | |
405 | *yycdebug_ << Title << ' '; \ | |
1f7d007b | 406 | yy_print_ (*yycdebug_, Symbol); \ |
57295d14 AD |
407 | *yycdebug_ << std::endl; \ |
408 | } \ | |
8901f32e | 409 | } while (false) |
284acc8b | 410 | |
e9690142 JD |
411 | # define YY_REDUCE_PRINT(Rule) \ |
412 | do { \ | |
8901f32e | 413 | if (yydebug_) \ |
e9690142 | 414 | yy_reduce_print_ (Rule); \ |
8901f32e | 415 | } while (false) |
284acc8b | 416 | |
e9690142 JD |
417 | # define YY_STACK_PRINT() \ |
418 | do { \ | |
8901f32e AD |
419 | if (yydebug_) \ |
420 | yystack_print_ (); \ | |
421 | } while (false) | |
284acc8b | 422 | |
5f108727 | 423 | #else /* !]b4_api_PREFIX[DEBUG */ |
284acc8b | 424 | |
a36b333c | 425 | # define YYCDEBUG if (false) std::cerr |
beadb220 | 426 | # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol) |
1f7d007b AD |
427 | # define YY_REDUCE_PRINT(Rule) static_cast<void>(0) |
428 | # define YY_STACK_PRINT() static_cast<void>(0) | |
284acc8b | 429 | |
5f108727 | 430 | #endif /* !]b4_api_PREFIX[DEBUG */ |
2b548aa6 | 431 | |
39be9022 AD |
432 | #define yyerrok (yyerrstatus_ = 0) |
433 | #define yyclearin (yyempty = true) | |
98e26a92 | 434 | |
39be9022 AD |
435 | #define YYACCEPT goto yyacceptlab |
436 | #define YYABORT goto yyabortlab | |
437 | #define YYERROR goto yyerrorlab | |
98e26a92 | 438 | #define YYRECOVERING() (!!yyerrstatus_) |
60a777aa | 439 | |
422c18f4 | 440 | ]b4_namespace_open[]b4_error_verbose_if([[ |
9e0876fb | 441 | |
aa08666d AD |
442 | /* Return YYSTR after stripping away unnecessary quotes and |
443 | backslashes, so that it's suitable for yyerror. The heuristic is | |
444 | that double-quoting is unnecessary unless the string contains an | |
445 | apostrophe, a comma, or backslash (other than backslash-backslash). | |
446 | YYSTR is taken from yytname. */ | |
447 | std::string | |
448 | ]b4_parser_class_name[::yytnamerr_ (const char *yystr) | |
449 | { | |
450 | if (*yystr == '"') | |
451 | { | |
452 | std::string yyr = ""; | |
453 | char const *yyp = yystr; | |
193d7c70 | 454 | |
aa08666d AD |
455 | for (;;) |
456 | switch (*++yyp) | |
457 | { | |
458 | case '\'': | |
459 | case ',': | |
460 | goto do_not_strip_quotes; | |
193d7c70 | 461 | |
aa08666d AD |
462 | case '\\': |
463 | if (*++yyp != '\\') | |
464 | goto do_not_strip_quotes; | |
465 | /* Fall through. */ | |
466 | default: | |
467 | yyr += *yyp; | |
468 | break; | |
193d7c70 | 469 | |
aa08666d AD |
470 | case '"': |
471 | return yyr; | |
472 | } | |
473 | do_not_strip_quotes: ; | |
474 | } | |
193d7c70 | 475 | |
aa08666d AD |
476 | return yystr; |
477 | } | |
422c18f4 | 478 | ]])[ |
9e0876fb | 479 | |
98ae9643 | 480 | /// Build a parser object. |
fa7b79c0 PE |
481 | ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ |
482 | :])[ | |
5f108727 | 483 | #if ]b4_api_PREFIX[DEBUG |
fa7b79c0 PE |
484 | ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), |
485 | yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ | |
486 | #endif]b4_parse_param_cons[ | |
98ae9643 AD |
487 | { |
488 | } | |
a0e68930 | 489 | |
98ae9643 AD |
490 | ]b4_parser_class_name::~b4_parser_class_name[ () |
491 | { | |
492 | } | |
a0e68930 | 493 | |
a0e68930 | 494 | |
1f7d007b AD |
495 | /*---------------. |
496 | | Symbol types. | | |
497 | `---------------*/ | |
498 | ||
e36ec1f4 | 499 | ]b4_token_ctor_if([], [b4_public_types_define])[ |
2873fdf8 | 500 | |
1f7d007b AD |
501 | // stack_symbol_type. |
502 | ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type () | |
5de9c593 AD |
503 | : super_type () |
504 | , state () | |
1f7d007b AD |
505 | { |
506 | } | |
507 | ||
710c4a65 | 508 | ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_join( |
2ea7730c AD |
509 | [state_type s], |
510 | [const semantic_type& v], | |
511 | b4_locations_if([const location_type& l]))[) | |
512 | : super_type (v]b4_locations_if([, l])[) | |
5de9c593 | 513 | , state (s) |
1f7d007b AD |
514 | { |
515 | } | |
516 | ||
517 | int | |
5de9c593 | 518 | ]b4_parser_class_name[::stack_symbol_type::type_get_ () const |
1f7d007b AD |
519 | { |
520 | return yystos_[state]; | |
521 | } | |
522 | ||
523 | ||
5de9c593 | 524 | template <typename Exact> |
98ae9643 | 525 | void |
5de9c593 AD |
526 | ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, |
527 | symbol_base_type<Exact>& yysym) const | |
98ae9643 | 528 | { |
8901f32e | 529 | if (yymsg) |
1f7d007b | 530 | YY_SYMBOL_PRINT (yymsg, yysym); |
98ae9643 | 531 | |
8901f32e | 532 | // User destructor. |
c5026327 | 533 | int yytype = yysym.type_get (); |
98ae9643 AD |
534 | switch (yytype) |
535 | { | |
e3c52a63 | 536 | ]b4_symbol_foreach([b4_symbol_destructor])dnl |
2bde9113 AD |
537 | [ default: |
538 | break; | |
8901f32e AD |
539 | }]b4_variant_if([ |
540 | ||
541 | // Type destructor. | |
4c3cc7da | 542 | b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[ |
8901f32e AD |
543 | } |
544 | ||
ccdc1577 | 545 | #if ]b4_api_PREFIX[DEBUG |
5de9c593 | 546 | template <typename Exact> |
1f7d007b | 547 | void |
5de9c593 AD |
548 | ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, |
549 | const symbol_base_type<Exact>& yysym) const | |
8901f32e | 550 | { |
c5026327 AD |
551 | std::ostream& yyoutput = yyo; |
552 | YYUSE (yyoutput); | |
1f7d007b AD |
553 | int yytype = yysym.type_get (); |
554 | yyo << (yytype < yyntokens_ ? "token" : "nterm") | |
2ea7730c AD |
555 | << ' ' << yytname_[yytype] << " ("]b4_locations_if([ |
556 | << yysym.location << ": "])[; | |
1f7d007b AD |
557 | switch (yytype) |
558 | { | |
e3c52a63 | 559 | ]b4_symbol_foreach([b4_symbol_printer])dnl |
2bde9113 | 560 | [ default: |
e9690142 | 561 | break; |
1f7d007b AD |
562 | } |
563 | yyo << ')'; | |
8901f32e | 564 | } |
1f7d007b | 565 | #endif |
8901f32e | 566 | |
1f7d007b AD |
567 | void |
568 | ]b4_parser_class_name[::yypush_ (const char* m, state_type s, | |
569 | symbol_type& sym) | |
8901f32e | 570 | { |
1f7d007b AD |
571 | if (m) |
572 | YY_SYMBOL_PRINT (m, sym); | |
573 | ]b4_variant_if( | |
710c4a65 | 574 | [[ yystack_.push (stack_symbol_type (]b4_join( |
2ea7730c AD |
575 | [s], |
576 | [semantic_type()], | |
577 | b4_locations_if([sym.location]))[)); | |
1f7d007b AD |
578 | ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], |
579 | [build], [sym.value])], | |
710c4a65 | 580 | [[ yystack_.push (stack_symbol_type (]b4_join( |
2ea7730c AD |
581 | [s], |
582 | [sym.value], | |
583 | b4_locations_if([sym.location]))[));]])[ | |
98ae9643 | 584 | } |
60a777aa | 585 | |
7dedf26e | 586 | void |
bc0b0477 | 587 | ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s) |
7dedf26e | 588 | { |
9380cfd0 | 589 | if (m) |
1f7d007b | 590 | YY_SYMBOL_PRINT (m, s); |
8901f32e | 591 | ]b4_variant_if( |
710c4a65 | 592 | [[ yystack_.push (stack_symbol_type (]b4_join( |
2ea7730c AD |
593 | [s.state], |
594 | [semantic_type()], | |
595 | b4_locations_if([s.location]))[)); | |
1f7d007b | 596 | ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]], |
e9b0834e AD |
597 | [build], [s.value])], |
598 | [ yystack_.push (s);])[ | |
7dedf26e AD |
599 | } |
600 | ||
98ae9643 AD |
601 | void |
602 | ]b4_parser_class_name[::yypop_ (unsigned int n) | |
603 | { | |
8901f32e | 604 | yystack_.pop (n); |
98ae9643 | 605 | } |
52d5733f | 606 | |
5f108727 | 607 | #if ]b4_api_PREFIX[DEBUG |
98ae9643 AD |
608 | std::ostream& |
609 | ]b4_parser_class_name[::debug_stream () const | |
610 | { | |
611 | return *yycdebug_; | |
612 | } | |
9a1e9989 | 613 | |
98ae9643 AD |
614 | void |
615 | ]b4_parser_class_name[::set_debug_stream (std::ostream& o) | |
616 | { | |
617 | yycdebug_ = &o; | |
618 | } | |
9a1e9989 AD |
619 | |
620 | ||
98ae9643 AD |
621 | ]b4_parser_class_name[::debug_level_type |
622 | ]b4_parser_class_name[::debug_level () const | |
623 | { | |
624 | return yydebug_; | |
625 | } | |
a3cb6248 | 626 | |
98ae9643 AD |
627 | void |
628 | ]b4_parser_class_name[::set_debug_level (debug_level_type l) | |
629 | { | |
630 | yydebug_ = l; | |
631 | } | |
ccdc1577 | 632 | #endif // ]b4_api_PREFIX[DEBUG |
a3cb6248 | 633 | |
7580c379 AD |
634 | inline ]b4_parser_class_name[::state_type |
635 | ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs) | |
636 | { | |
637 | int yyr = yypgoto_[yylhs - yyntokens_] + yystate; | |
638 | if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) | |
639 | return yytable_[yyr]; | |
640 | else | |
641 | return yydefgoto_[yylhs - yyntokens_]; | |
642 | } | |
643 | ||
f2b30bdf JD |
644 | inline bool |
645 | ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue) | |
646 | { | |
647 | return yyvalue == yypact_ninf_; | |
648 | } | |
649 | ||
650 | inline bool | |
651 | ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue) | |
652 | { | |
aa0cb40d | 653 | return yyvalue == yytable_ninf_; |
f2b30bdf JD |
654 | } |
655 | ||
98ae9643 AD |
656 | int |
657 | ]b4_parser_class_name[::parse () | |
658 | { | |
39be9022 AD |
659 | /// Whether yyla contains a lookahead. |
660 | bool yyempty = true; | |
d4fb5e3c | 661 | |
b720fedf | 662 | // State. |
98ae9643 | 663 | int yyn; |
a85284cf | 664 | int yylen = 0; |
d4fb5e3c | 665 | |
b720fedf | 666 | // Error handling. |
98ae9643 AD |
667 | int yynerrs_ = 0; |
668 | int yyerrstatus_ = 0; | |
dbcdae2d | 669 | |
6082531a | 670 | /// The lookahead symbol. |
2ea7730c | 671 | symbol_type yyla;]b4_locations_if([[ |
6082531a | 672 | |
98ae9643 | 673 | /// The locations where the error started and ended. |
44c2b42d | 674 | stack_symbol_type yyerror_range[3];]])[ |
dbcdae2d | 675 | |
e1f93869 | 676 | /// $$ and @@$. |
bc0b0477 | 677 | stack_symbol_type yylhs; |
dbcdae2d | 678 | |
ff348970 | 679 | /// The return value of parse (). |
98ae9643 | 680 | int yyresult; |
ad745863 | 681 | |
7e1fabbe AD |
682 | // FIXME: This shoud be completely indented. It is not yet to |
683 | // avoid gratuitous conflicts when merging into the master branch. | |
684 | try | |
685 | { | |
98ae9643 | 686 | YYCDEBUG << "Starting parse" << std::endl; |
451364ed | 687 | |
451364ed | 688 | ]m4_ifdef([b4_initial_action], [ |
4323e0da | 689 | b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl |
9d9b8b70 | 690 | /* User initialization code. */ |
8ec0a172 | 691 | b4_user_initial_action |
cd735a8c | 692 | b4_dollar_popdef])[]dnl |
451364ed | 693 | |
8901f32e | 694 | [ /* Initialize the stack. The initial state will be set in |
98ae9643 AD |
695 | yynewstate, since the latter expects the semantical and the |
696 | location values to have been already stored, initialize these | |
697 | stacks with a primary value. */ | |
8901f32e | 698 | yystack_ = stack_type (0); |
eeaf1dc6 | 699 | yypush_ (YY_NULL, 0, yyla); |
98ae9643 | 700 | |
7580c379 | 701 | // A new symbol was pushed on the stack. |
98ae9643 | 702 | yynewstate: |
7580c379 | 703 | YYCDEBUG << "Entering state " << yystack_[0].state << std::endl; |
868d2d96 JD |
704 | |
705 | /* Accept? */ | |
7580c379 | 706 | if (yystack_[0].state == yyfinal_) |
868d2d96 JD |
707 | goto yyacceptlab; |
708 | ||
98ae9643 AD |
709 | goto yybackup; |
710 | ||
711 | /* Backup. */ | |
712 | yybackup: | |
713 | ||
742e4900 | 714 | /* Try to take a decision without lookahead. */ |
7580c379 | 715 | yyn = yypact_[yystack_[0].state]; |
f2b30bdf | 716 | if (yy_pact_value_is_default_ (yyn)) |
98ae9643 AD |
717 | goto yydefault; |
718 | ||
742e4900 | 719 | /* Read a lookahead token. */ |
39be9022 | 720 | if (yyempty) |
98ae9643 | 721 | { |
09277875 | 722 | YYCDEBUG << "Reading a token: "; |
a6552c5d | 723 | try |
77a1a208 | 724 | { |
e36ec1f4 | 725 | ]b4_token_ctor_if( |
77a1a208 | 726 | [ yyla = b4_function_call([yylex], [symbol_type], |
a6552c5d | 727 | m4_ifdef([b4_lex_param], b4_lex_param));], |
77a1a208 | 728 | [ yyla.type = yytranslate_ (b4_function_call([yylex], [int], |
5458913a | 729 | [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl |
6082531a | 730 | b4_locations_if([, [[location*], [&yyla.location]]])dnl |
09277875 | 731 | m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[ |
77a1a208 | 732 | } |
a6552c5d | 733 | catch (const syntax_error& yyexc) |
77a1a208 AD |
734 | { |
735 | error (yyexc); | |
736 | goto yyerrlab1; | |
737 | } | |
39be9022 | 738 | yyempty = false; |
98ae9643 | 739 | } |
aba12ad1 | 740 | YY_SYMBOL_PRINT ("Next token is", yyla); |
98ae9643 | 741 | |
1f7d007b AD |
742 | /* If the proper action on seeing token YYLA.TYPE is to reduce or |
743 | to detect an error, take that action. */ | |
744 | yyn += yyla.type; | |
745 | if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type) | |
98ae9643 AD |
746 | goto yydefault; |
747 | ||
748 | /* Reduce or error. */ | |
749 | yyn = yytable_[yyn]; | |
750 | if (yyn <= 0) | |
751 | { | |
e9690142 JD |
752 | if (yy_table_value_is_error_ (yyn)) |
753 | goto yyerrlab; | |
754 | yyn = -yyn; | |
755 | goto yyreduce; | |
98ae9643 AD |
756 | } |
757 | ||
868d2d96 | 758 | /* Discard the token being shifted. */ |
39be9022 | 759 | yyempty = true; |
98ae9643 AD |
760 | |
761 | /* Count tokens shifted since error; after three, turn off error | |
762 | status. */ | |
763 | if (yyerrstatus_) | |
764 | --yyerrstatus_; | |
765 | ||
9380cfd0 | 766 | /* Shift the lookahead token. */ |
7580c379 | 767 | yypush_ ("Shifting", yyn, yyla); |
98ae9643 AD |
768 | goto yynewstate; |
769 | ||
770 | /*-----------------------------------------------------------. | |
771 | | yydefault -- do the default action for the current state. | | |
772 | `-----------------------------------------------------------*/ | |
773 | yydefault: | |
7580c379 | 774 | yyn = yydefact_[yystack_[0].state]; |
98ae9643 AD |
775 | if (yyn == 0) |
776 | goto yyerrlab; | |
777 | goto yyreduce; | |
778 | ||
779 | /*-----------------------------. | |
780 | | yyreduce -- Do a reduction. | | |
781 | `-----------------------------*/ | |
782 | yyreduce: | |
c4dc4c46 | 783 | yylen = yyr2_[yyn]; |
7580c379 | 784 | yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([ |
5ab8c47b | 785 | /* Variants are always initialized to an empty instance of the |
3eead995 AD |
786 | correct type. The default $$=$1 action is NOT applied when using |
787 | variants. */ | |
c4dc4c46 | 788 | b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[ |
a85284cf | 789 | /* If YYLEN is nonzero, implement the default value of the action: |
98ae9643 AD |
790 | `$$ = $1'. Otherwise, use the top of the stack. |
791 | ||
e1f93869 | 792 | Otherwise, the following line sets YYLHS.VALUE to garbage. |
98ae9643 AD |
793 | This behavior is undocumented and Bison |
794 | users should not rely upon it. */ | |
795 | if (yylen) | |
e1f93869 | 796 | yylhs.value = yystack_@{yylen - 1@}.value; |
98ae9643 | 797 | else |
e1f93869 | 798 | yylhs.value = yystack_@{0@}.value;])[ |
2ea7730c AD |
799 | ]b4_locations_if([dnl |
800 | [ | |
8901f32e | 801 | // Compute the default @@$. |
2b548aa6 | 802 | { |
bc0b0477 | 803 | slice<stack_symbol_type, stack_type> slice (yystack_, yylen); |
e1f93869 | 804 | YYLLOC_DEFAULT (yylhs.location, slice, yylen); |
2ea7730c | 805 | }]])[ |
8901f32e AD |
806 | |
807 | // Perform the reduction. | |
98ae9643 | 808 | YY_REDUCE_PRINT (yyn); |
ff601366 | 809 | try |
98ae9643 | 810 | { |
77a1a208 AD |
811 | switch (yyn) |
812 | { | |
30bb2edc | 813 | ]b4_user_actions[ |
77a1a208 AD |
814 | default: |
815 | break; | |
816 | } | |
98ae9643 | 817 | } |
ff601366 | 818 | catch (const syntax_error& yyexc) |
77a1a208 AD |
819 | { |
820 | error (yyexc); | |
821 | YYERROR; | |
822 | } | |
1f7d007b | 823 | YY_SYMBOL_PRINT ("-> $$ =", yylhs); |
8901f32e | 824 | ]b4_variant_if([[ |
9c6a8966 | 825 | // Destroy the rhs symbols. |
8901f32e | 826 | for (int i = 0; i < yylen; ++i) |
9c6a8966 AD |
827 | // Destroy a variant which value may have been swapped with |
828 | // yylhs.value (for instance if the action was "std::swap($$, | |
829 | // $1)"). The value of yylhs.value (hence possibly one of these | |
5237cd1a | 830 | // rhs symbols) depends on the default construction for this |
9c6a8966 AD |
831 | // type. In the case of pointers for instance, no |
832 | // initialization is done, so the value is junk. Therefore do | |
833 | // not try to report the value of symbols about to be destroyed | |
834 | // in the debug trace, it's possibly junk. Hence yymsg = 0. | |
835 | // Besides, that keeps exactly the same traces as with the other | |
836 | // Bison skeletons. | |
eeaf1dc6 | 837 | yy_destroy_ (YY_NULL, yystack_[i]);]])[ |
98ae9643 AD |
838 | |
839 | yypop_ (yylen); | |
a85284cf | 840 | yylen = 0; |
98ae9643 | 841 | YY_STACK_PRINT (); |
98ae9643 AD |
842 | |
843 | /* Shift the result of the reduction. */ | |
eeaf1dc6 | 844 | yypush_ (YY_NULL, yylhs); |
98ae9643 AD |
845 | goto yynewstate; |
846 | ||
9c6a8966 AD |
847 | /*--------------------------------------. |
848 | | yyerrlab -- here on detecting error. | | |
849 | `--------------------------------------*/ | |
98ae9643 AD |
850 | yyerrlab: |
851 | /* If not already recovering from an error, report this error. */ | |
852 | if (!yyerrstatus_) | |
853 | { | |
e9690142 | 854 | ++yynerrs_; |
710c4a65 | 855 | error (]b4_join(b4_locations_if([yyla.location]), |
d2060f06 JD |
856 | [[yysyntax_error_ (yystack_[0].state, |
857 | yyempty ? yyempty_ : yyla.type)]])[); | |
98ae9643 AD |
858 | } |
859 | ||
2ea7730c | 860 | ]b4_locations_if([[ |
44c2b42d | 861 | yyerror_range[1].location = yyla.location;]])[ |
98ae9643 AD |
862 | if (yyerrstatus_ == 3) |
863 | { | |
e9690142 | 864 | /* If just tried and failed to reuse lookahead token after an |
27cb5b59 AD |
865 | error, discard it. */ |
866 | ||
867 | /* Return failure if at end of input. */ | |
aba12ad1 | 868 | if (yyla.type == yyeof_) |
27cb5b59 | 869 | YYABORT; |
d59beda0 | 870 | else if (!yyempty) |
39be9022 | 871 | { |
27cb5b59 | 872 | yy_destroy_ ("Error: discarding", yyla); |
39be9022 | 873 | yyempty = true; |
e9690142 | 874 | } |
98ae9643 AD |
875 | } |
876 | ||
742e4900 | 877 | /* Else will try to reuse lookahead token after shifting the error |
98ae9643 AD |
878 | token. */ |
879 | goto yyerrlab1; | |
880 | ||
881 | ||
882 | /*---------------------------------------------------. | |
883 | | yyerrorlab -- error raised explicitly by YYERROR. | | |
884 | `---------------------------------------------------*/ | |
885 | yyerrorlab: | |
886 | ||
887 | /* Pacify compilers like GCC when the user code never invokes | |
888 | YYERROR and the label yyerrorlab therefore never appears in user | |
889 | code. */ | |
890 | if (false) | |
c4dc4c46 | 891 | goto yyerrorlab;]b4_locations_if([[ |
44c2b42d | 892 | yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[ |
c4dc4c46 AD |
893 | /* $$ was initialized before running the user action. */ |
894 | yy_destroy_ ("Error: discarding", yylhs);]])[ | |
a85284cf | 895 | /* Do not reclaim the symbols of the rule which action triggered |
9d9b8b70 | 896 | this YYERROR. */ |
98ae9643 | 897 | yypop_ (yylen); |
a85284cf | 898 | yylen = 0; |
98ae9643 AD |
899 | goto yyerrlab1; |
900 | ||
901 | /*-------------------------------------------------------------. | |
902 | | yyerrlab1 -- common code for both syntax error and YYERROR. | | |
903 | `-------------------------------------------------------------*/ | |
904 | yyerrlab1: | |
e9690142 | 905 | yyerrstatus_ = 3; /* Each real token shifted decrements this. */ |
e1f93869 | 906 | { |
bc0b0477 | 907 | stack_symbol_type error_token; |
e1f93869 AD |
908 | for (;;) |
909 | { | |
7580c379 | 910 | yyn = yypact_[yystack_[0].state]; |
f2b30bdf | 911 | if (!yy_pact_value_is_default_ (yyn)) |
e1f93869 AD |
912 | { |
913 | yyn += yyterror_; | |
914 | if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) | |
915 | { | |
916 | yyn = yytable_[yyn]; | |
917 | if (0 < yyn) | |
918 | break; | |
919 | } | |
920 | } | |
98ae9643 | 921 | |
e1f93869 AD |
922 | // Pop the current state because it cannot handle the error token. |
923 | if (yystack_.size () == 1) | |
924 | YYABORT; | |
2ea7730c | 925 | ]b4_locations_if([[ |
44c2b42d | 926 | yyerror_range[1].location = yystack_[0].location;]])[ |
1f7d007b | 927 | yy_destroy_ ("Error: popping", yystack_[0]); |
e1f93869 | 928 | yypop_ (); |
e1f93869 AD |
929 | YY_STACK_PRINT (); |
930 | } | |
2ea7730c | 931 | ]b4_locations_if([[ |
44c2b42d JD |
932 | yyerror_range[2].location = yyla.location; |
933 | YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[ | |
e1f93869 AD |
934 | |
935 | /* Shift the error token. */ | |
7580c379 | 936 | error_token.state = yyn; |
e9b0834e | 937 | yypush_ ("Shifting", error_token); |
e1f93869 | 938 | } |
98ae9643 AD |
939 | goto yynewstate; |
940 | ||
941 | /* Accept. */ | |
942 | yyacceptlab: | |
943 | yyresult = 0; | |
944 | goto yyreturn; | |
945 | ||
946 | /* Abort. */ | |
947 | yyabortlab: | |
948 | yyresult = 1; | |
949 | goto yyreturn; | |
950 | ||
951 | yyreturn: | |
39be9022 | 952 | if (!yyempty) |
1f7d007b | 953 | yy_destroy_ ("Cleanup: discarding lookahead", yyla); |
98ae9643 | 954 | |
a85284cf | 955 | /* Do not reclaim the symbols of the rule which action triggered |
9d9b8b70 | 956 | this YYABORT or YYACCEPT. */ |
a85284cf | 957 | yypop_ (yylen); |
23d13411 | 958 | while (1 < yystack_.size ()) |
98ae9643 | 959 | { |
e9690142 JD |
960 | yy_destroy_ ("Cleanup: popping", yystack_[0]); |
961 | yypop_ (); | |
98ae9643 AD |
962 | } |
963 | ||
964 | return yyresult; | |
965 | } | |
7e1fabbe AD |
966 | catch (...) |
967 | { | |
25a6ad2f AD |
968 | YYCDEBUG << "Exception caught: cleaning lookahead and stack" |
969 | << std::endl; | |
970 | // Do not try to display the values of the reclaimed symbols, | |
971 | // as their printer might throw an exception. | |
23d13411 AD |
972 | if (!yyempty) |
973 | yy_destroy_ (YY_NULL, yyla); | |
7e1fabbe | 974 | |
23d13411 | 975 | while (1 < yystack_.size ()) |
7e1fabbe | 976 | { |
23d13411 | 977 | yy_destroy_ (YY_NULL, yystack_[0]); |
7e1fabbe AD |
978 | yypop_ (); |
979 | } | |
980 | throw; | |
981 | } | |
98ae9643 | 982 | } |
2b548aa6 | 983 | |
a6552c5d AD |
984 | void |
985 | ]b4_parser_class_name[::error (const syntax_error& yyexc) | |
986 | { | |
710c4a65 | 987 | error (]b4_join(b4_locations_if([yyexc.location]), |
a6552c5d AD |
988 | [[yyexc.what()]])[); |
989 | } | |
990 | ||
98ae9643 AD |
991 | // Generate an error message. |
992 | std::string | |
422c18f4 | 993 | ]b4_parser_class_name[::yysyntax_error_ (]dnl |
ceb8b8e6 | 994 | b4_error_verbose_if([state_type yystate, int yytoken], |
422c18f4 | 995 | [int, int])[) |
25a648d8 JD |
996 | {]b4_error_verbose_if([[ |
997 | std::string yyres; | |
d2060f06 JD |
998 | // Number of reported tokens (one for the "unexpected", one per |
999 | // "expected"). | |
1000 | size_t yycount = 0; | |
1001 | // Its maximum. | |
1002 | enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; | |
1003 | // Arguments of yyformat. | |
1004 | char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; | |
1005 | ||
1006 | /* There are many possibilities here to consider: | |
1007 | - If this state is a consistent state with a default action, then | |
1008 | the only way this function was invoked is if the default action | |
1009 | is an error action. In that case, don't check for expected | |
1010 | tokens because there are none. | |
1011 | - The only way there can be no lookahead present (in yytoken) is | |
1012 | if this state is a consistent state with a default action. | |
1013 | Thus, detecting the absence of a lookahead is sufficient to | |
1014 | determine that there is no unexpected or expected token to | |
1015 | report. In that case, just report a simple "syntax error". | |
1016 | - Don't assume there isn't a lookahead just because this state is | |
1017 | a consistent state with a default action. There might have | |
1018 | been a previous inconsistent state, consistent state with a | |
1019 | non-default action, or user semantic action that manipulated | |
1020 | yyla. (However, yyla is currently not documented for users.) | |
1021 | - Of course, the expected token list depends on states to have | |
1022 | correct lookahead information, and it depends on the parser not | |
1023 | to perform extra reductions after fetching a lookahead from the | |
1024 | scanner and before detecting a syntax error. Thus, state | |
1025 | merging (from LALR or IELR) and default reductions corrupt the | |
1026 | expected token list. However, the list is correct for | |
1027 | canonical LR with one exception: it will still contain any | |
1028 | token that will not be accepted due to an error action in a | |
1029 | later state. | |
1030 | */ | |
1031 | if (yytoken != yyempty_) | |
98ae9643 | 1032 | { |
d2060f06 JD |
1033 | yyarg[yycount++] = yytname_[yytoken]; |
1034 | int yyn = yypact_[yystate]; | |
1035 | if (!yy_pact_value_is_default_ (yyn)) | |
1036 | { | |
b4bbc4a0 JD |
1037 | /* Start YYX at -YYN if negative to avoid negative indexes in |
1038 | YYCHECK. In other words, skip the first -YYN actions for | |
1039 | this state because they are default actions. */ | |
1040 | int yyxbegin = yyn < 0 ? -yyn : 0; | |
b4bbc4a0 JD |
1041 | /* Stay within bounds of both yycheck and yytname. */ |
1042 | int yychecklim = yylast_ - yyn + 1; | |
1043 | int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; | |
b4bbc4a0 JD |
1044 | for (int yyx = yyxbegin; yyx < yyxend; ++yyx) |
1045 | if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ | |
1046 | && !yy_table_value_is_error_ (yytable_[yyx + yyn])) | |
1047 | { | |
1048 | if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) | |
1049 | { | |
1050 | yycount = 1; | |
1051 | break; | |
1052 | } | |
1053 | else | |
1054 | yyarg[yycount++] = yytname_[yyx]; | |
1055 | } | |
d2060f06 JD |
1056 | } |
1057 | } | |
a0ffc175 | 1058 | |
ef51bfa7 | 1059 | char const* yyformat = YY_NULL; |
b4bbc4a0 JD |
1060 | switch (yycount) |
1061 | { | |
1062 | #define YYCASE_(N, S) \ | |
1063 | case N: \ | |
1064 | yyformat = S; \ | |
1065 | break | |
d2060f06 | 1066 | YYCASE_(0, YY_("syntax error")); |
b4bbc4a0 JD |
1067 | YYCASE_(1, YY_("syntax error, unexpected %s")); |
1068 | YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); | |
1069 | YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); | |
1070 | YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); | |
1071 | YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); | |
a0ffc175 | 1072 | #undef YYCASE_ |
98ae9643 | 1073 | } |
d2060f06 | 1074 | |
b4bbc4a0 JD |
1075 | // Argument number. |
1076 | size_t yyi = 0; | |
1077 | for (char const* yyp = yyformat; *yyp; ++yyp) | |
1078 | if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) | |
1079 | { | |
1080 | yyres += yytnamerr_ (yyarg[yyi++]); | |
1081 | ++yyp; | |
1082 | } | |
1083 | else | |
1084 | yyres += *yyp; | |
25a648d8 JD |
1085 | return yyres;]], [[ |
1086 | return YY_("syntax error");]])[ | |
98ae9643 | 1087 | } |
a08460b0 | 1088 | |
5348bfbe | 1089 | |
98ae9643 | 1090 | const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; |
2b548aa6 | 1091 | |
0fddb3d5 AD |
1092 | const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; |
1093 | ||
ba206cf4 | 1094 | ]b4_parser_tables_define[ |
2b548aa6 | 1095 | |
5f108727 | 1096 | ]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ |
98ae9643 | 1097 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
9d9b8b70 | 1098 | First, the terminals, then, starting at \a yyntokens_, nonterminals. */ |
98ae9643 AD |
1099 | const char* |
1100 | const ]b4_parser_class_name[::yytname_[] = | |
1101 | { | |
8901f32e | 1102 | ]b4_tname[ |
98ae9643 | 1103 | }; |
2b548aa6 | 1104 | |
5f108727 | 1105 | ]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ |
ba206cf4 | 1106 | ]b4_integral_parser_table_define([rline], [b4_rline])[ |
5348bfbe | 1107 | |
98ae9643 AD |
1108 | // Print the state stack on the debug stream. |
1109 | void | |
1110 | ]b4_parser_class_name[::yystack_print_ () | |
1111 | { | |
1112 | *yycdebug_ << "Stack now"; | |
8901f32e AD |
1113 | for (stack_type::const_iterator |
1114 | i = yystack_.begin (), | |
1115 | i_end = yystack_.end (); | |
e9690142 | 1116 | i != i_end; ++i) |
8901f32e | 1117 | *yycdebug_ << ' ' << i->state; |
98ae9643 AD |
1118 | *yycdebug_ << std::endl; |
1119 | } | |
25f66e1a | 1120 | |
98ae9643 AD |
1121 | // Report on the debug stream that the rule \a yyrule is going to be reduced. |
1122 | void | |
d1ff7a7c | 1123 | ]b4_parser_class_name[::yy_reduce_print_ (int yyrule) |
98ae9643 AD |
1124 | { |
1125 | unsigned int yylno = yyrline_[yyrule]; | |
d1ff7a7c | 1126 | int yynrhs = yyr2_[yyrule]; |
98ae9643 AD |
1127 | /* Print the symbols being reduced, and their result. */ |
1128 | *yycdebug_ << "Reducing stack by rule " << yyrule - 1 | |
e9690142 | 1129 | << " (line " << yylno << "):" << std::endl; |
d1ff7a7c AD |
1130 | /* The symbols being reduced. */ |
1131 | for (int yyi = 0; yyi < yynrhs; yyi++) | |
1132 | YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", | |
1f7d007b | 1133 | ]b4_rhs_data(yynrhs, yyi + 1)[); |
98ae9643 | 1134 | } |
5f108727 | 1135 | #endif // ]b4_api_PREFIX[DEBUG |
69e2658b | 1136 | |
e36ec1f4 | 1137 | ]b4_token_ctor_if([], [b4_yytranslate_define])[ |
793fbca5 | 1138 | ]b4_namespace_close[ |
8901f32e | 1139 | ]b4_epilogue[]dnl |
1c7ec959 | 1140 | b4_output_end() |
064e42b0 AD |
1141 | |
1142 | ||
a9ce3f54 | 1143 | m4_popdef([b4_copyright_years])dnl |