[270] | 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)
|
---|