Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 04:13:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
82d913741bbebec4b8be974141801ce328920f67
bison/data/skeletons/glr2.cc
Akim Demaille 82d913741b glr2.cc: avoid warnings about long long 
* data/skeletons/glr2.cc: Disable the warning before triggering it.
2020-08-30 20:05:34 +02:00

3306 lines
104 KiB
C++
Raw Blame History

# C++ GLR skeleton for Bison
# Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# b4_tname_if(TNAME-NEEDED, TNAME-NOT-NEEDED)
# -------------------------------------------
m4_define([b4_tname_if],
[m4_case(b4_percent_define_get([[parse.error]]),
[verbose], [$1],
[b4_token_table_if([$1],
[$2])])])
# This skeleton produces a C++ class that encapsulates a C glr parser.
# This is in order to reduce the maintenance burden. The glr.c
# skeleton is clean and pure enough so that there are no real
# problems. The C++ interface is the same as that of lalr1.cc. In
# fact, glr.c can replace yacc.c without the user noticing any
# difference, and similarly for glr.cc replacing lalr1.cc.
#
# The passing of parse-params
#
# The additional arguments are stored as members of the parser
# object, yyparser. The C routines need to carry yyparser
# throughout the C parser; that's easy: make yyparser an
# additional parse-param. But because the C++ skeleton needs to
# know the "real" original parse-param, we save them
# (b4_parse_param_orig). Note that b4_parse_param is overquoted
# (and c.m4 strips one level of quotes). This is a PITA, and
# explains why there are so many levels of quotes.
#
# The locations
#
# We use location.cc just like lalr1.cc, but because glr.c stores
# the locations in a union, the position and location classes
# must not have a constructor. Therefore, contrary to lalr1.cc, we
# must not define "b4_location_constructors". As a consequence the
# user must initialize the first positions (in particular the
# filename member).
# We require a pure interface.
m4_define([b4_pure_flag], [1])
m4_include(b4_skeletonsdir/[c++.m4])
b4_bison_locations_if([m4_include(b4_skeletonsdir/[location.cc])])
m4_define([b4_parser_class],
[b4_percent_define_get([[api.parser.class]])])
# Save the parse parameters.
m4_define([b4_parse_param_orig], m4_defn([b4_parse_param]))
# b4_parse_param_wrap
# -------------------
# New ones.
m4_ifset([b4_parse_param],
[m4_define([b4_parse_param_wrap],
[[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]],]
m4_defn([b4_parse_param]))],
[m4_define([b4_parse_param_wrap],
[[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]]])
])
# b4_yy_symbol_print_define
# -------------------------
# Bypass the default implementation to generate the "yy_symbol_print"
# and "yy_symbol_value_print" functions.
m4_define([b4_yy_symbol_print_define],
[[/*--------------------.
| Print this symbol. |
`--------------------*/
static void
yy_symbol_print (FILE *, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken,
const ]b4_namespace_ref::b4_parser_class[::semantic_type *yyvaluep]b4_locations_if([[,
const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp]])[]b4_user_formals[)
{
]b4_parse_param_use[]dnl
[ yyparser.yy_symbol_print_ (yytoken, yyvaluep]b4_locations_if([, yylocationp])[);
}
]])[
# Hijack the initial action to initialize the locations.
]b4_bison_locations_if([m4_define([b4_initial_action],
[yylloc.initialize ();]m4_ifdef([b4_initial_action], [
m4_defn([b4_initial_action])]))])[
# Hijack the post prologue to declare yyerror.
]m4_append([b4_post_prologue],
[b4_syncline([@oline@], [@ofile@])dnl
[static void
yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp,
]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param),
])[const std::string& msg);]])[
]m4_define([b4_define_symbol_kind],
[m4_format([#define %-15s %s],
b4_symbol($][1, kind_base),
b4_namespace_ref[::]b4_parser_class[::symbol_kind::]b4_symbol($1, kind_base))
])
# b4_glr_cc_setup
# ---------------
# Setup redirections for glr.c: Map the names used in c.m4 to the ones used
# in c++.m4.
m4_define([b4_glr_cc_setup],
[[#ifndef ]b4_api_PREFIX[STYPE
# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class[::semantic_type
#endif
#ifndef ]b4_api_PREFIX[LTYPE
# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class[::location_type
#endif
typedef ]b4_namespace_ref[::]b4_parser_class[::symbol_kind_type yysymbol_kind_t;
]])
# b4_glr_cc_cleanup
# -----------------
# Remove redirections for glr.c.
m4_define([b4_glr_cc_cleanup],
[[#undef ]b4_symbol(-2, [id])[
#undef ]b4_symbol(0, [id])[
#undef ]b4_symbol(1, [id])[
#undef ]b4_symbol_prefix[YYEMPTY
#undef ]b4_symbol_prefix[YYerror
#undef ]b4_symbol_prefix[YYEOF
#undef ]b4_symbol_prefix[YYUNDEF
]])
# b4_shared_declarations(hh|cc)
# -----------------------------
# Declaration that might either go into the header (if --defines, $1 = hh)
# or in the implementation file.
m4_define([b4_shared_declarations],
[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
b4_percent_code_get([[requires]])[
#include <algorithm>
#include <cstddef> // ptrdiff_t
#include <iostream>
#include <stdexcept>
#include <stdint.h>
#include <string>
#include <vector>
]b4_cxx_portability[
]m4_ifdef([b4_location_include],
[[# include ]b4_location_include])[
]b4_variant_if([b4_variant_includes])[
]b4_attribute_define[
]b4_cast_define[
]b4_null_define[
// This skeleton is based on C, yet compiles it as C++.
// So expect warnings about C style casts.
#if defined __clang__ && 306 <= __clang_major__ * 100 + __clang_minor__
# pragma clang diagnostic ignored "-Wold-style-cast"
#elif defined __GNUC__ && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
// On MacOS, PTRDIFF_MAX is defined as long long, which Clang's
// -pedantic reports as being a C++11 extension.
#if defined __APPLE__ && YY_CPLUSPLUS < 201103L \
&& defined __clang__ && 4 <= __clang_major__
# pragma clang diagnostic ignored "-Wc++11-long-long"
#endif
template <typename Parameter>
class StrongIndexAlias
{
public:
static StrongIndexAlias create(std::ptrdiff_t value) {
StrongIndexAlias result;
result.value_ = value;
return result;
}
std::ptrdiff_t const& get() const {return value_; }
size_t uget() const {return YY_CAST(size_t, value_); }
StrongIndexAlias operator+(std::ptrdiff_t other) const {
return StrongIndexAlias(get() + other);
}
void operator+=(std::ptrdiff_t other) {
value_ += other;
}
StrongIndexAlias operator-(std::ptrdiff_t other) {
return StrongIndexAlias(get() - other);
}
void operator-=(std::ptrdiff_t other) {
value_ -= other;
}
size_t operator-(StrongIndexAlias other) {
return StrongIndexAlias(get() - other.get());
}
StrongIndexAlias& operator++() {
++value_;
return *this;
}
bool isValid() const {
return value_ != INVALID_INDEX;
}
void setInvalid() {
value_ = INVALID_INDEX;
}
bool operator==(StrongIndexAlias other) {
return get() == other.get();
}
bool operator!=(StrongIndexAlias other) {
return get() != other.get();
}
bool operator<(StrongIndexAlias other) {
return get() < other.get();
}
private:
static const ptrdiff_t INVALID_INDEX = PTRDIFF_MAX;
// WARNING: 0-initialized.
std::ptrdiff_t value_;
};
// Whether we are compiled with exception support.
#ifndef YY_EXCEPTIONS
# if defined __GNUC__ && !defined __EXCEPTIONS
# define YY_EXCEPTIONS 0
# else
# define YY_EXCEPTIONS 1
# endif
#endif
]b4_YYDEBUG_define[
]b4_namespace_open[
]b4_bison_locations_if([m4_ifndef([b4_location_file],
[b4_location_define])])[
/// A Bison parser.
class ]b4_parser_class[
{
public:
]b4_public_types_declare[
]b4_symbol_type_define[
/// Build a parser object.
]b4_parser_class[ (]b4_parse_param_decl[);
virtual ~]b4_parser_class[ ();
/// Parse. An alias for parse ().
/// \returns 0 iff parsing succeeded.
int operator() ();
/// Parse.
/// \returns 0 iff parsing succeeded.
virtual int parse ();
#if ]b4_api_PREFIX[DEBUG
/// The current debugging stream.
std::ostream& debug_stream () const;
/// Set the current debugging stream.
void set_debug_stream (std::ostream &);
/// Type for debugging levels.
typedef int debug_level_type;
/// The current debugging level.
debug_level_type debug_level () const;
/// Set the current debugging level.
void set_debug_level (debug_level_type l);
#endif
/// Report a syntax error.]b4_locations_if([[
/// \param loc where the syntax error is found.]])[
/// \param msg a description of the syntax error.
virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);
]b4_parse_error_bmatch(
[custom\|detailed],
[[ /// The user-facing name of the symbol whose (internal) number is
/// YYSYMBOL. No bounds checking.
static const char *symbol_name (symbol_kind_type yysymbol);]],
[simple],
[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
/// The user-facing name of the symbol whose (internal) number is
/// YYSYMBOL. No bounds checking.
static const char *symbol_name (symbol_kind_type yysymbol);
#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
]],
[verbose],
[[ /// The user-facing name of the symbol whose (internal) number is
/// YYSYMBOL. No bounds checking.
static std::string symbol_name (symbol_kind_type yysymbol);]])[
# if ]b4_api_PREFIX[DEBUG
public:
/// \brief Report a symbol value on the debug stream.
/// \param yykind The symbol kind.
/// \param yyvaluep Its semantic value.]b4_locations_if([[
/// \param yylocationp Its location.]])[
virtual void yy_symbol_value_print_ (symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[) const;
/// \brief Report a symbol on the debug stream.
/// \param yykind The symbol kind.
/// \param yyvaluep Its semantic value.]b4_locations_if([[
/// \param yylocationp Its location.]])[
virtual void yy_symbol_print_ (symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[) const;
private:
/// Debug stream.
std::ostream* yycdebug_;
#endif
public: // FIXME: Private
]b4_parse_error_bmatch(
[simple],
[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
/// For a symbol, its name in clear.
static const char* const yytname_[];
#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
]],
[verbose],
[[ /// Convert the symbol name \a n to a form suitable for a diagnostic.
static std::string yytnamerr_ (const char *yystr);
/// For a symbol, its name in clear.
static const char* const yytname_[];
]])[
/// \brief Reclaim the memory associated to a symbol.
/// \param yymsg Why this token is reclaimed.
/// If null, print nothing.
/// \param yykind The symbol kind.
void yy_destroy_ (const char* yymsg, symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[);
]b4_parse_param_vars[
};
]b4_namespace_close[
]b4_percent_code_get([[provides]])[
]m4_popdef([b4_parse_param])dnl
])[
]b4_defines_if(
[b4_output_begin([b4_spec_header_file])
b4_copyright([Skeleton interface for Bison GLR parsers in C++],
[2002-2015, 2018-2020])[
// C++ GLR parser skeleton written by Valentin Tolmer.
]b4_disclaimer[
]b4_cpp_guard_open([b4_spec_mapped_header_file])[
]b4_shared_declarations[
]b4_cpp_guard_close([b4_spec_mapped_header_file])[
]b4_output_end])
# Let glr.c (and b4_shared_declarations) believe that the user
# arguments include the parser itself.
m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap]))
## ---------------- ##
## Default values. ##
## ---------------- ##
# Stack parameters.
m4_define_default([b4_stack_depth_max], [10000])
m4_define_default([b4_stack_depth_init], [200])
## ------------------------ ##
## Pure/impure interfaces. ##
## ------------------------ ##
b4_define_flag_if([pure])
# b4_user_formals
# ---------------
# The possible parse-params formal arguments preceded by a comma.
#
# This is not shared with yacc.c in c.m4 because GLR relies on ISO C
# formal argument declarations.
m4_define([b4_user_formals],
[m4_ifset([b4_parse_param], [, b4_user_formals_no_comma])])
# b4_user_formals_no_comma
# ---------------
# The possible parse-params formal arguments.
m4_define([b4_user_formals_no_comma],
[m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)])])
# b4_yyerror_args
# ---------------
# Optional effective arguments passed to yyerror: user args plus yylloc, and
# a trailing comma.
m4_define([b4_yyerror_args],
[b4_pure_if([b4_locations_if([yylocp, ])])dnl
m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
# b4_lyyerror_args
# ----------------
# Same as above, but on the lookahead, hence &yylloc instead of yylocp.
m4_define([b4_lyyerror_args],
[b4_pure_if([b4_locations_if([&yylloc, ])])dnl
m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
# b4_pure_args
# ------------
# Same as b4_yyerror_args, but with a leading comma.
m4_define([b4_pure_args],
[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])
# b4_lpure_args
# -------------
# Same as above, but on the lookahead, hence &yylloc instead of yylocp.
m4_define([b4_lpure_args],
[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
# b4_pure_formals
# ---------------
# Arguments passed to yyerror: user formals plus yylocp with leading comma.
m4_define([b4_pure_formals],
[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
# b4_locuser_formals(LOC = yylocp)
# --------------------------------
# User formal arguments, possibly preceded by location argument.
m4_define([b4_locuser_formals],
[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals])
# b4_locuser_args(LOC = yylocp)
# -----------------------------
m4_define([b4_locuser_args],
[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args])
# b4_symbol_kind(NUM)
# -------------------
m4_define([b4_symbol_kind],
[symbol_kind::b4_symbol_kind_base($@)])
## ----------------- ##
## Semantic Values. ##
## ----------------- ##
# b4_lhs_value(SYMBOL-NUM, [TYPE])
# --------------------------------
# See README.
m4_define([b4_lhs_value],
[b4_symbol_value([(*yyvalp)], [$1], [$2])])
# b4_rhs_data(RULE-LENGTH, POS)
# -----------------------------
# See README.
m4_define([b4_rhs_data],
[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.getState()])
# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE])
# --------------------------------------------------
# Expansion of $$ or $<TYPE>$, for symbol SYMBOL-NUM.
m4_define([b4_rhs_value],
[b4_symbol_value([b4_rhs_data([$1], [$2]).semanticVal()], [$3], [$4])])
## ----------- ##
## Locations. ##
## ----------- ##
# b4_lhs_location()
# -----------------
# Expansion of @$.
m4_define([b4_lhs_location],
[(*yylocp)])
# b4_rhs_location(RULE-LENGTH, NUM)
# ---------------------------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
[(b4_rhs_data([$1], [$2]).yyloc)])
## -------------- ##
## Output files. ##
## -------------- ##
# Unfortunately the order of generation between the header and the
# implementation file matters (for glr.c) because of the current
# implementation of api.value.type=union. In that case we still use a
# union for YYSTYPE, but we generate the contents of this union when
# setting up YYSTYPE. This is needed for other aspects, such as
# defining yy_symbol_value_print, since we need to now the name of the
# members of this union.
#
# To avoid this issue, just generate the header before the
# implementation file. But we should also make them more independant.
# ------------------------- #
# The implementation file. #
# ------------------------- #
b4_output_begin([b4_parser_file_name])
b4_copyright([Skeleton implementation for Bison GLR parsers in C],
[2002-2015, 2018-2019])[
/* New C++ GLR parser skeleton written by Akim Demaille, adapted by Valentin
* Tolmer. */
]b4_disclaimer[
]b4_identification[
]b4_percent_code_get([[top]])[
]m4_if(b4_api_prefix, [yy], [],
[[/* Substitute the type names. */
#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[
#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[
]m4_if(b4_prefix, [yy], [],
[[/* Substitute the variable and function names. */
#define yyparse ]b4_prefix[parse
#define yylex ]b4_prefix[lex
#define yyerror ]b4_prefix[error
#define yydebug ]b4_prefix[debug]]b4_pure_if([], [[
#define yylval ]b4_prefix[lval
#define yychar ]b4_prefix[char
#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
#define yylloc ]b4_prefix[lloc]])]))[
]b4_user_pre_prologue[
]b4_null_define[
]b4_defines_if([[#include "@basename(]b4_spec_header_file[@)"]],
[b4_shared_declarations])[
]b4_glr_cc_setup[
#ifndef ]b4_api_PREFIX[STYPE
# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class[::semantic_type
#endif
#ifndef ]b4_api_PREFIX[LTYPE
# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class[::location_type
#endif
typedef ]b4_namespace_ref[::]b4_parser_class[::symbol_kind_type yysymbol_kind_t;
/* Default (constant) value used for initialization for null
right-hand sides. Unlike the standard yacc.c template, here we set
the default value of $$ to a zeroed-out value. Since the default
value is undefined, this behavior is technically correct. */
static YYSTYPE yyval_default;]b4_locations_if([[
static YYLTYPE yyloc_default][]b4_yyloc_default;])[
]b4_user_post_prologue[
]b4_percent_code_get[]dnl
[#include <cstdio>
#include <cstdlib>
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
#ifndef YYFREE
# define YYFREE free
#endif
#ifndef YYMALLOC
# define YYMALLOC malloc
#endif
#define YYSIZEMAX YY_CAST(size_t, -1)
#ifndef YYSETJMP
# include <setjmp.h>
# define YYJMP_BUF jmp_buf
# define YYSETJMP(Env) setjmp (Env)
/* Pacify Clang and ICC. */
# define YYLONGJMP(Env, Val) \
do { \
longjmp (Env, Val); \
YYASSERT (0); \
} while (false)
#endif
]b4_attribute_define([noreturn])[
#ifndef YYASSERT
# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0)))
#endif
#ifdef YYDEBUG
# define YYDASSERT(Condition) YYASSERT(Condition)
#else
# define YYDASSERT(Condition)
#endif
/* YYFINAL -- State number of the termination state. */
#define YYFINAL ]b4_final_state_number[
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST ]b4_last[
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS ]b4_tokens_number[
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS ]b4_nterms_number[
/* YYNRULES -- Number of rules. */
#define YYNRULES ]b4_rules_number[
/* YYNSTATES -- Number of states. */
#define YYNSTATES ]b4_states_number[
/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
#define YYMAXRHS ]b4_r2_max[
/* YYMAXLEFT -- Maximum number of symbols to the left of a handle
accessed by $0, $-1, etc., in any rule. */
#define YYMAXLEFT ]b4_max_left_semantic_context[
/* YYUNDEFTOK -- Symbol number (for yytoken) that denotes an unknown
token. */
#define YYUNDEFTOK ]b4_undef_token_number[
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, with out-of-bounds checking. */
]b4_api_token_raw_if(dnl
[[#define YYTRANSLATE(YYX) YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, YYX)]],
[[#define YYTRANSLATE(YYX) \
(0 <= (YYX) && (YYX) <= ]b4_code_max[ \
? YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yytranslate[YYX]) \
: ]b4_namespace_ref::b4_parser_class::symbol_kind::b4_symbol(-2, kind)[)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex. */
static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
{
]b4_translate[
};]])[
#if ]b4_api_PREFIX[DEBUG
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const ]b4_int_type_for([b4_rline])[ yyrline[] =
{
]b4_rline[
};
#endif
#define YYPACT_NINF ]b4_pact_ninf[
#define YYTABLE_NINF ]b4_table_ninf[
]b4_parser_tables_define[
/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
static const ]b4_int_type_for([b4_dprec])[ yydprec[] =
{
]b4_dprec[
};
/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
static const ]b4_int_type_for([b4_merger])[ yymerger[] =
{
]b4_merger[
};
/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as
in the case of predicates. */
static const bool yyimmediate[] =
{
]b4_immediate[
};
/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
list of conflicting reductions corresponding to action entry for
state STATE-NUM in yytable. 0 means no conflicts. The list in
yyconfl is terminated by a rule number of 0. */
static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =
{
]b4_conflict_list_heads[
};
/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
0, pointed into by YYCONFLP. */
]dnl Do not use b4_int_type_for here, since there are places where
dnl pointers onto yyconfl are taken, whose type is "short*".
dnl We probably ought to introduce a type for confl.
[static const short yyconfl[] =
{
]b4_conflicting_rules[
};
/* Error token number */
#define YYTERROR 1
]b4_locations_if([[
]b4_yylloc_default_define[
# define YYRHSLOC(Rhs, K) ((Rhs)[K].getState().yyloc)
]])[
]b4_pure_if(
[
#undef yynerrs
#define yynerrs (yystackp->yyerrcnt)
#undef yychar
#define yychar (yystackp->yyrawchar)
#undef yylval
#define yylval (yystackp->yyval)
#undef yylloc
#define yylloc (yystackp->yyloc)
m4_if(b4_prefix[], [yy], [],
[#define b4_prefix[]nerrs yynerrs
#define b4_prefix[]char yychar
#define b4_prefix[]lval yylval
#define b4_prefix[]lloc yylloc])],
[YYSTYPE yylval;]b4_locations_if([[
YYLTYPE yylloc;]])[
int yynerrs;
int yychar;])[
typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
#define YYCHK(YYE) \
do { \
YYRESULTTAG yychk_flag = YYE; \
if (yychk_flag != yyok) \
return yychk_flag; \
} while (0)
#if ]b4_api_PREFIX[DEBUG
# ifndef YYFPRINTF
# define YYFPRINTF fprintf
# endif
]b4_yy_location_print_define[
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
]b4_yy_symbol_print_define[
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
struct yyGLRStack;
static void yypstack (struct yyGLRStack* yystackp, size_t yyk)
YY_ATTRIBUTE_UNUSED;
static void yypdumpstack (struct yyGLRStack* yystackp)
YY_ATTRIBUTE_UNUSED;
#else /* !]b4_api_PREFIX[DEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#endif /* !]b4_api_PREFIX[DEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH ]b4_stack_depth_init[
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH ]b4_stack_depth_max[
#endif
/* Minimum number of free items on the stack allowed after an
allocation. This is to allow allocation and initialization
to be completed by functions that call yyexpandGLRStack before the
stack is expanded, thus insuring that all necessary pointers get
properly redirected to new data. */
#define YYHEADROOM 2
#ifndef YYSTACKEXPANDABLE
# define YYSTACKEXPANDABLE 1
#endif
/** State numbers, as in LALR(1) machine */
typedef int yyStateNum;
/** Rule numbers, as in LALR(1) machine */
typedef int yyRuleNum;
/** Item references, as in LALR(1) machine */
typedef short yyItemNum;
// Forward declarations.
class yyGLRState;
struct yySemanticOption;
struct yyGLRStackItem;
struct yyGLRStack;
typedef StrongIndexAlias<struct yyGLRStateSetTag> yyStateSetIndex;
yyStateSetIndex yycreateStateSetIndex(std::ptrdiff_t value) {
return yyStateSetIndex::create(value);
}
#define yypact_value_is_default(Yystate) \
]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf], [YYPACT_NINF])[
#define yytable_value_is_error(Yytable_value) \
]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf], [YYTABLE_NINF])[
]m4_define([b4_yygetToken_call],
[[yygetToken (&yychar][]b4_pure_if([, yystackp])[]b4_user_args[)]])[
static inline ]b4_namespace_ref::b4_parser_class[::symbol_kind_type
yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals[);
static inline bool
yyisShiftAction (int yyaction)
{
return 0 < yyaction;
}
static inline bool
yyisErrorAction (int yyaction)
{
return yyaction == 0;
}
static inline int
yygetLRActions (yyStateNum yystate, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken, const short** yyconflicts);
/** True iff LR state YYSTATE has only a default reduction (regardless
* of token). */
static inline bool
yyisDefaultedState (yyStateNum yystate)
{
return yypact_value_is_default (yypact[yystate]);
}
/** The default reduction for YYSTATE, assuming it has one. */
static inline yyRuleNum
yydefaultAction (yyStateNum yystate)
{
return yydefact[yystate];
}
static inline int
yyrhsLength (yyRuleNum yyrule);
class yyGLRState {
public:
yyGLRState()
: yyresolved(false)
, yylrState(0)
, yyposn(0)
, yypred(0)
{}
/// Build with a semantic value.
yyGLRState(yyStateNum lrState, size_t posn, YYSTYPE sval]b4_locations_if([[, YYLTYPE loc]])[)
: yyresolved(true)
, yylrState(lrState)
, yyposn(posn)
, yypred(0)]b4_locations_if([[
, yyloc(loc)]])[ {
semanticVal() = sval;
}
/// Build with a semantic option.
yyGLRState(yyStateNum lrState, size_t posn)
: yyresolved(false)
, yylrState(lrState)
, yyposn(posn)
, yypred(0)
, yyfirstVal(0)
{}
void copyFrom(const yyGLRState& other) {
*this = other;
setPred(other.pred());
setFirstVal(other.firstVal());
}
/** Type tag for If true, yysval applies, otherwise
* yyfirstVal applies. */
bool yyresolved;
/** Number of corresponding LALR(1) machine state. */
yyStateNum yylrState;
/** Source position of the last token produced by my symbol */
size_t yyposn;
/// Only call pred() and setPred() on objects in yyitems, not temporaries.
yyGLRState* pred();
const yyGLRState* pred() const;
void setPred(const yyGLRState* state);
/// Only call firstVal() and setFirstVal() on objects in yyitems, not
/// temporaries.
yySemanticOption* firstVal();
const yySemanticOption* firstVal() const;
void setFirstVal(const yySemanticOption* option);
YYSTYPE& semanticVal() {
return yysval;
}
const YYSTYPE& semanticVal() const {
return yysval;
}
void
destroy (char const *yymsg]b4_user_formals[);
/* DEBUGGING ONLY */
#if ]b4_api_PREFIX[DEBUG
void yy_yypstack() const
{
if (pred() != YY_NULLPTR)
{
pred()->yy_yypstack();
YYFPRINTF (stderr, " -> ");
}
YYFPRINTF (stderr, "%d@@%lu", yylrState,
(unsigned long) yyposn);
}
#endif
std::ptrdiff_t indexIn(yyGLRStackItem* array);
yyGLRStackItem* asItem() {
return asItem(this);
}
private:
template <typename T>
static const yyGLRStackItem* asItem(const T* state) {
return reinterpret_cast<const yyGLRStackItem*>(state);
}
template <typename T>
static yyGLRStackItem* asItem(T* state) {
return reinterpret_cast<yyGLRStackItem*>(state);
}
/** Preceding state in this stack */
std::ptrdiff_t yypred;
union {
/** First in a chain of alternative reductions producing the
* nonterminal corresponding to this state, threaded through
* yyfirstVal. */
std::ptrdiff_t yyfirstVal;
/** Semantic value for this state. */
YYSTYPE yysval;
};]b4_locations_if([[
public:
/** Source location for this state. */
YYLTYPE yyloc;]])[
};
/** A stack of GLRState representing the different heads during
* nondeterministic evaluation. */
class yyGLRStateSet {
public:
/** Initialize YYSET to a singleton set containing an empty stack. */
yyGLRStateSet()
: yylastDeleted(YY_NULLPTR)
{
yystates.push_back(YY_NULLPTR);
yylookaheadNeeds.push_back(false);
}
// Behave like a vector of states.
yyGLRState*& operator[](yyStateSetIndex index) {
return yystates[index.uget()];
}
yyGLRState* operator[](yyStateSetIndex index) const {
return yystates[index.uget()];
}
size_t size() const {
return yystates.size();
}
std::vector<yyGLRState*>::iterator begin() {
return yystates.begin();
}
std::vector<yyGLRState*>::iterator end() {
return yystates.end();
}
bool lookaheadNeeds(yyStateSetIndex index) const {
return yylookaheadNeeds[index.uget()];
}
bool setLookaheadNeeds(yyStateSetIndex index, bool value) {
return yylookaheadNeeds[index.uget()] = value;
}
/** Invalidate stack #YYK. */
inline void
yymarkStackDeleted (yyStateSetIndex yyk)
{
size_t k = yyk.uget();
if (yystates[k] != YY_NULLPTR)
yylastDeleted = yystates[k];
yystates[k] = YY_NULLPTR;
}
/** Undelete the last stack in *this that was marked as deleted. Can
only be done once after a deletion, and only when all other stacks have
been deleted. */
void
yyundeleteLastStack ()
{
if (yylastDeleted == YY_NULLPTR || !yystates.empty())
return;
yystates.push_back(yylastDeleted);
YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
clearLastDeleted();
}
/** Remove the dead stacks (yystates[i] == YY_NULLPTR) and shift the later
* ones. */
inline void
yyremoveDeletes ()
{
std::ptrdiff_t newsize = YY_CAST(std::ptrdiff_t, yystates.size());
/* j is the number of live stacks we have seen. */
for (size_t i = 0, j = 0; i < yystates.size(); ++i)
{
if (yystates[i] == YY_NULLPTR)
{
if (i == j)
{
YYDPRINTF ((stderr, "Removing dead stacks.\n"));
}
newsize -= 1;
}
else
{
yystates[j] = yystates[i];
/* In the current implementation, it's unnecessary to copy
yylookaheadNeeds[i] since, after
yyremoveDeletes returns, the parser immediately either enters
deterministic operation or shifts a token. However, it doesn't
hurt, and the code might evolve to need it. */
yylookaheadNeeds[j] = yylookaheadNeeds[i];
if (j != i)
{
YYDPRINTF ((stderr, "Rename stack %zu -> %zu.\n", i, j));
}
j += 1;
}
i += 1;
}
yystates.erase(yystates.begin() + newsize, yystates.end());
yylookaheadNeeds.erase(yylookaheadNeeds.begin() + newsize,
yylookaheadNeeds.end());
}
yyStateSetIndex
yysplitStack (yyStateSetIndex yyk)
{
size_t k = yyk.uget();
yystates.push_back(yystates[k]);
yylookaheadNeeds.push_back(yylookaheadNeeds[k]);
return yycreateStateSetIndex(YY_CAST (std::ptrdiff_t, yystates.size() - 1));
}
void clearLastDeleted() {
yylastDeleted = YY_NULLPTR;
}
private:
std::vector<yyGLRState*> yystates;
/** During nondeterministic operation, yylookaheadNeeds tracks which
* stacks have actually needed the current lookahead. During deterministic
* operation, yylookaheadNeeds[0] is not maintained since it would merely
* duplicate yychar != ]b4_symbol(-2, id)[. */
std::vector<bool> yylookaheadNeeds;
/** The last stack we invalidated. */
yyGLRState* yylastDeleted;
static const size_t INITIAL_NUMBER_STATES = 16;
};
struct yySemanticOption {
yySemanticOption()
: yyrule(0)
, yystate(0)
, yynext(0)
, yyrawchar(0)
{}
yySemanticOption(yyRuleNum rule, int rawChar)
: yyrule(rule)
, yystate(0)
, yynext(0)
, yyrawchar(rawChar)
{}
/// Only call state() and setState() on objects in yyitems, not temporaries.
yyGLRState* state();
const yyGLRState* state() const;
void setState(const yyGLRState* s);
yySemanticOption* next();
void setNext(const yySemanticOption* s);
std::ptrdiff_t indexIn(yyGLRStackItem* array);
/** True iff YYY0 and YYY1 represent identical options at the top level.
* That is, they represent the same rule applied to RHS symbols
* that produce the same terminal symbols. */
bool
isIdenticalTo (yySemanticOption* yyy1)
{
if (this->yyrule == yyy1->yyrule)
{
yyGLRState *yys0, *yys1;
int yyn;
for (yys0 = this->state(),
yys1 = yyy1->state(),
yyn = yyrhsLength (this->yyrule);
yyn > 0;
yys0 = yys0->pred(),
yys1 = yys1->pred(), yyn -= 1)
if (yys0->yyposn != yys1->yyposn)
return false;
return true;
}
else
return false;
}
/** Assuming identicalOptions (YYY0,YYY1), destructively merge the
* alternative semantic values for the RHS-symbols of YYY1 and YYY0. */
void
mergeWith (yySemanticOption* yyy1)
{
yyGLRState *yys0 = this->state();
yyGLRState *yys1 = yyy1->state();
for (int yyn = yyrhsLength (this->yyrule);
yyn > 0;
yyn -= 1,
yys0 = yys0->pred(),
yys1 = yys1->pred())
{
if (yys0 == yys1)
break;
else if (yys0->yyresolved)
{
yys1->yyresolved = true;
yys1->semanticVal() = yys0->semanticVal();
}
else if (yys1->yyresolved)
{
yys0->yyresolved = true;
yys0->semanticVal() = yys1->semanticVal();
}
else
{
yySemanticOption* yyz0prev = YY_NULLPTR;
yySemanticOption* yyz0 = yys0->firstVal();
yySemanticOption* yyz1 = yys1->firstVal();
while (true)
{
if (yyz1 == yyz0 || yyz1 == YY_NULLPTR)
break;
else if (yyz0 == YY_NULLPTR)
{
if (yyz0prev != YY_NULLPTR) {
yyz0prev->setNext(yyz1);
} else {
yys0->setFirstVal(yyz1);
}
break;
}
else if (yyz0 < yyz1)
{
yySemanticOption* yyz = yyz0;
if (yyz0prev != YY_NULLPTR) {
yyz0prev->setNext(yyz1);
} else {
yys0->setFirstVal(yyz1);
}
yyz1 = yyz1->next();
yyz0->setNext(yyz);
}
yyz0prev = yyz0;
yyz0 = yyz0->next();
}
yys1->setFirstVal(yys0->firstVal());
}
}
}
/** Rule number for this reduction */
yyRuleNum yyrule;
private:
template <typename T>
static const yyGLRStackItem* asItem(const T* state) {
return reinterpret_cast<const yyGLRStackItem*>(state);
}
template <typename T>
static yyGLRStackItem* asItem(T* state) {
return reinterpret_cast<yyGLRStackItem*>(state);
}
/** The last RHS state in the list of states to be reduced. */
std::ptrdiff_t yystate;
/** Next sibling in chain of options. To facilitate merging,
* options are chained in decreasing order by address. */
std::ptrdiff_t yynext;
public:
/** The lookahead for this reduction. */
int yyrawchar;
YYSTYPE yyval;]b4_locations_if([[
YYLTYPE yyloc;]])[
};
/** Type of the items in the GLR stack. The isState_ field
* indicates which item of the union is valid. */
struct yyGLRStackItem {
yyGLRStackItem(bool isState = true)
: isState_(isState) {
if (isState) {
new (&raw_) yyGLRState;
} else {
new (&raw_) yySemanticOption;
}
}
~yyGLRStackItem() {
if (isState()) {
getState().~yyGLRState();
} else {
getOption().~yySemanticOption();
}
}
yyGLRState& getState() {
YYDASSERT(isState());
return *(yyGLRState*)&raw_;
}
const yyGLRState& getState() const {
YYDASSERT(isState());
return *(yyGLRState*)&raw_;
}
yySemanticOption& getOption() {
YYDASSERT(!isState());
return *(yySemanticOption*)&raw_;
}
const yySemanticOption& getOption() const {
YYDASSERT(!isState());
return *(yySemanticOption*)&raw_;
}
bool isState() const {
return isState_;
}
private:
/// The possible contents of raw_. Since they have constructors, they cannot
/// be directly included in the union.
struct contents {
union {
char yystate[sizeof(yyGLRState)];
char yyoption[sizeof(yySemanticOption)];
};
};
enum { union_size = sizeof(contents) };
union {
/// Strongest alignment constraints.
long double yyalign_me;
/// A buffer large enough to store the contents.
char raw_[union_size];
};
/** Type tag for the union. */
bool isState_;
};
yyGLRState* yyGLRState::pred() {
return yypred ? &(asItem(this) - yypred)->getState() : YY_NULLPTR;
}
const yyGLRState* yyGLRState::pred() const {
return yypred ? &(asItem(this) - yypred)->getState() : YY_NULLPTR;
}
void yyGLRState::setPred(const yyGLRState* state) {
yypred = state ? asItem(this) - asItem(state) : 0;
}
yySemanticOption* yyGLRState::firstVal() {
return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR;
}
const yySemanticOption* yyGLRState::firstVal() const {
return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR;
}
void yyGLRState::setFirstVal(const yySemanticOption* option) {
yyfirstVal = option ? asItem(this) - asItem(option) : 0;
}
std::ptrdiff_t yyGLRState::indexIn(yyGLRStackItem* array) {
return asItem(this) - array;
}
std::ptrdiff_t yySemanticOption::indexIn(yyGLRStackItem* array) {
return asItem(this) - array;
}
yyGLRState* yySemanticOption::state() {
return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR;
}
const yyGLRState* yySemanticOption::state() const {
return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR;
}
void yySemanticOption::setState(const yyGLRState* s) {
yystate = s ? asItem(this) - asItem(s) : 0;
}
yySemanticOption* yySemanticOption::next() {
return yynext ? &(asItem(this) - yynext)->getOption() : YY_NULLPTR;
}
void yySemanticOption::setNext(const yySemanticOption* s) {
yynext = s ? asItem(this) - asItem(s) : 0;
}
void yyGLRState::destroy (char const *yymsg]b4_user_formals[)
{
if (yyresolved)
yyparser.yy_destroy_ (yymsg, YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yylrState]),
&semanticVal()]b4_locations_if([, &yyloc])[);
else
{
#if ]b4_api_PREFIX[DEBUG
if (yydebug)
{
if (firstVal() != YY_NULLPTR)
YYFPRINTF (stderr, "%s unresolved", yymsg);
else
YYFPRINTF (stderr, "%s incomplete", yymsg);
YY_SYMBOL_PRINT ("", YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yylrState]), YY_NULLPTR, &yyloc);
}
#endif
if (firstVal() != YY_NULLPTR)
{
yySemanticOption *yyoption = firstVal();
yyGLRState *yyrh = yyoption->state();
for (int yyn = yyrhsLength (yyoption->yyrule); yyn > 0; yyn -= 1)
{
yyrh->destroy (yymsg]b4_user_args[);
yyrh = yyrh->pred();
}
}
}
}
static int
yypreference (yySemanticOption* y0, yySemanticOption* y1);
static void
yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1);
/** Left-hand-side symbol for rule #YYRULE. */
static inline ]b4_namespace_ref::b4_parser_class[::symbol_kind_type
yylhsNonterm (yyRuleNum yyrule)
{
return YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yyr1[yyrule]);
}
static inline yyStateNum
yyLRgotoState (yyStateNum yystate, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yysym);
#undef YYFILL
#define YYFILL(N) yyfill (yyvsp, &yylow, (N), yynormal)
struct yyStateStack {
public:
/** Initialize to a single empty stack, with total maximum
* capacity for all stacks of YYSIZE. */
yyStateStack (size_t yysize)
: yysplitPoint(YY_NULLPTR)
{
yyitems.reserve(yysize);
}
#if YYSTACKEXPANDABLE
/** Returns false if it tried to expand but could not. */
bool
yyexpandGLRStackIfNeeded() {
return spaceLeft() < YYHEADROOM && yyexpandGLRStack();
}
private:
/** If *this is expandable, extend it. WARNING: Pointers into the
stack from outside should be considered invalid after this call.
We always expand when there are 1 or fewer items left AFTER an
allocation, so that we can avoid having external pointers exist
across an allocation. */
bool
yyexpandGLRStack()
{
if (YYMAXDEPTH - YYHEADROOM < yyitems.size())
return false;
const size_t yynewSize = YYMAXDEPTH < 2 * yyitems.size() ? YYMAXDEPTH : 2 * yyitems.size();
yyitems.reserve(yynewSize);
return true;
}
public:
#else
bool yyexpandGLRStackIfNeeded() {
return yystateStack.spaceLeft() < YYHEADROOM;
}
#endif
static bool yyGLRStateNotNull(yyGLRState* s) {
return s != YY_NULLPTR;
}
bool
reduceToOneStack() {
const std::vector<yyGLRState*>::iterator begin =
yytops.begin();
const std::vector<yyGLRState*>::iterator end =
yytops.end();
std::vector<yyGLRState*>::iterator yyit =
std::find_if(begin, end, yyGLRStateNotNull);
if (yyit == end)
return false;
for (yyStateSetIndex yyk = yycreateStateSetIndex(yyit + 1 - begin);
yyk.uget() != numTops(); ++yyk)
yytops.yymarkStackDeleted (yyk);
yytops.yyremoveDeletes ();
yycompressStack ();
return true;
}
void
yycompressStack ()
{
if (yytops.size() != 1 || !isSplit())
return;
yyGLRState* yyr = YY_NULLPTR;
for (yyGLRState *yyp = firstTop(), *yyq = yyp->pred();
yyp != yysplitPoint;
yyr = yyp, yyp = yyq, yyq = yyp->pred())
yyp->setPred(yyr);
yyGLRStackItem* nextFreeItem = yysplitPoint->asItem() + 1;
yysplitPoint = YY_NULLPTR;
yytops.clearLastDeleted();
while (yyr != YY_NULLPTR)
{
yyGLRState& nextFreeState = nextFreeItem->getState();
nextFreeState.copyFrom(*yyr);
yyr = yyr->pred();
nextFreeState.setPred(&(nextFreeItem - 1)->getState());
setFirstTop(&nextFreeState);
++nextFreeItem;
}
yyitems.resize(YY_CAST (size_t, nextFreeItem - yyitems.data()));
}
bool isSplit() const {
return yysplitPoint != YY_NULLPTR;
}
// Present the interface of a vector of yyGLRStackItem.
std::vector<yyGLRStackItem>::const_iterator begin() const {
return yyitems.begin();
}
std::vector<yyGLRStackItem>::const_iterator end() const {
return yyitems.end();
}
size_t size() const {
return yyitems.size();
}
yyGLRStackItem& operator[](size_t i) {
return yyitems[i];
}
yyGLRStackItem& stackItemAt(size_t index) {
return yyitems[index];
}
size_t numTops() const {
return yytops.size();
}
yyGLRState* firstTop() {
return yytops[yycreateStateSetIndex(0)];
}
yyGLRState* topAt(yyStateSetIndex i) {
return yytops[i];
}
void setFirstTop(yyGLRState* value) {
yytops[yycreateStateSetIndex(0)] = value;
}
void setTopAt(yyStateSetIndex i, yyGLRState* value) {
yytops[i] = value;
}
void pop_back() {
yyitems.pop_back();
}
void pop_back(size_t n) {
yyitems.resize(yyitems.size() - n);
}
yyStateSetIndex
yysplitStack (yyStateSetIndex yyk)
{
if (!isSplit())
{
YYASSERT (yyk.get() == 0);
yysplitPoint = topAt(yyk);
}
return yytops.yysplitStack(yyk);
}
/** Assuming that YYS is a GLRState somewhere on *this, update the
* splitpoint of *this, if needed, so that it is at least as deep as
* YYS. */
inline void
yyupdateSplit (yyGLRState& yys)
{
if (isSplit() && &yys < yysplitPoint)
yysplitPoint = &yys;
}
/** Return a fresh GLRState.
* Callers should call yyreserveStack afterwards to make sure there is
* sufficient headroom. */
yyGLRState& yynewGLRState(yyGLRState newState) {
yyGLRState& state = yyitems[yynewGLRStackItem(true)].getState();
#if 201103L <= YY_CPLUSPLUS
state = std::move(newState);
#else
state = newState;
#endif
return state;
}
/** Return a fresh SemanticOption.
* Callers should call yyreserveStack afterwards to make sure there is
* sufficient headroom. */
yySemanticOption& yynewSemanticOption(yySemanticOption newOption) {
yySemanticOption& option = yyitems[yynewGLRStackItem(false)].getOption();
#if 201103L <= YY_CPLUSPLUS
option = std::move(newOption);
#else
option = newOption;
#endif
return option;
}
/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in
* YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
* For convenience, always return YYLOW1. */
inline int
yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, bool yynormal)
{
if (!yynormal && yylow1 < *yylow)
{
yyfillin (yyvsp, *yylow, yylow1);
*yylow = yylow1;
}
return yylow1;
}
/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
* at YYVSP[YYLOW0].getState().pred(). Leaves YYVSP[YYLOW1].getState().pred()
* containing the pointer to the next state in the chain. */
void
yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
{
yyGLRState* s = yyvsp[yylow0].getState().pred();
for (int i = yylow0-1; i >= yylow1; i -= 1, s = s->pred())
{
yyGLRState& yys = yyvsp[i].getState();
#if ]b4_api_PREFIX[DEBUG
yys.yylrState = s->yylrState;
#endif
yys.yyresolved = s->yyresolved;
if (s->yyresolved)
yys.semanticVal() = s->semanticVal();
else
/* The effect of using semanticVal or yyloc (in an immediate rule) is
* undefined. */
yys.setFirstVal(YY_NULLPTR);]b4_locations_if([[
yys.yyloc = s->yyloc;]])[
yys.setPred(s->pred());
}
}
#if !]b4_api_PREFIX[DEBUG
# define YY_REDUCE_PRINT(Args)
#else
# define YY_REDUCE_PRINT(Args) \
do { \
if (yydebug) \
yystateStack.yy_reduce_print Args; \
} while (0)
/*----------------------------------------------------------------------.
| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
`----------------------------------------------------------------------*/
inline void
yy_reduce_print (bool yynormal, yyGLRStackItem* yyvsp, yyStateSetIndex yyk,
yyRuleNum yyrule]b4_user_formals[)
{
int yynrhs = yyrhsLength (yyrule);]b4_locations_if([
int yylow = 1;])[
int yyi;
YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
(unsigned long) yyk.get(), yyrule - 1,
(unsigned long) yyrline[yyrule]);
if (! yynormal)
yyfillin (yyvsp, 1, -yynrhs);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr,
YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yyvsp[yyi - yynrhs + 1].getState().yylrState]),
&yyvsp[yyi - yynrhs + 1].getState().semanticVal()]b4_locations_if([,
&]b4_rhs_location(yynrhs, yyi + 1))[]dnl
b4_user_args[);
if (!yyvsp[yyi - yynrhs + 1].getState().yyresolved)
YYFPRINTF (stderr, " (unresolved)");
YYFPRINTF (stderr, "\n");
}
}
#define YYINDEX(YYX) \
((YYX) == YY_NULLPTR ? -1 : (YYX)->indexIn(yyitems.data()))
void
dumpStack ()
{
for (size_t yyi = 0; yyi < size(); ++yyi)
{
yyGLRStackItem& item = yyitems[yyi];
YYFPRINTF (stderr, "%3zu. ", yyi);
if (item.isState())
{
YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %zu, pred: %td",
item.getState().yyresolved, item.getState().yylrState,
item.getState().yyposn,
YYINDEX(item.getState().pred()));
if (! item.getState().yyresolved)
YYFPRINTF (stderr, ", firstVal: %td",
YYINDEX(item.getState().firstVal()));
}
else
{
YYFPRINTF (stderr, "Option. rule: %d, state: %td, next: %td",
item.getOption().yyrule - 1,
YYINDEX(item.getOption().state()),
YYINDEX(item.getOption().next()));
}
YYFPRINTF (stderr, "\n");
}
YYFPRINTF (stderr, "Tops:");
for (yyStateSetIndex yyi = yycreateStateSetIndex(0); yyi.uget() < numTops(); ++yyi) {
YYFPRINTF (stderr, "%lu: %td; ",
(unsigned long) yyi.get(),
YYINDEX(topAt(yyi)));
}
YYFPRINTF (stderr, "\n");
}
#undef YYINDEX
#endif
YYRESULTTAG
yyreportAmbiguity (yySemanticOption* yyx0,
yySemanticOption* yyx1]b4_pure_formals[)
{
YYUSE (yyx0);
YYUSE (yyx1);
#if ]b4_api_PREFIX[DEBUG
YYFPRINTF (stderr, "Ambiguity detected.\n");
YYFPRINTF (stderr, "Option 1,\n");
yyreportTree (yyx0, 2);
YYFPRINTF (stderr, "\nOption 2,\n");
yyreportTree (yyx1, 2);
YYFPRINTF (stderr, "\n");
#endif
yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
return yyabort;
}
/* DEBUGGING ONLY */
#if ]b4_api_PREFIX[DEBUG
void
yypstates (const yyGLRState* yyst)
{
if (yyst != YY_NULLPTR)
yyst->yy_yypstack();
else
YYFPRINTF (stderr, "<null>");
YYFPRINTF (stderr, "\n");
}
#endif
private:
size_t spaceLeft() const {
return yyitems.capacity() - yyitems.size();
}
/** Return a fresh GLRStackItem in this. The item is an LR state
* if YYISSTATE, and otherwise a semantic option. Callers should call
* yyreserveStack afterwards to make sure there is sufficient
* headroom. */
inline size_t
yynewGLRStackItem (bool yyisState)
{
YYDASSERT(yyitems.size() < yyitems.capacity());
yyitems.push_back(yyGLRStackItem(yyisState));
return yyitems.size() - 1;
}
#if ]b4_api_PREFIX[DEBUG
void
yyreportTree (yySemanticOption* yyx, int yyindent)
{
int yynrhs = yyrhsLength (yyx->yyrule);
yyGLRState* yystates[1 + YYMAXRHS];
yyGLRState yyleftmost_state;
{
yyGLRState* yys = yyx->state();
for (int yyi = yynrhs; 0 < yyi; yyi -= 1)
{
yystates[yyi] = yys;
yys = yys->pred();
}
if (yys == YY_NULLPTR)
{
yyleftmost_state.yyposn = 0;
yystates[0] = &yyleftmost_state;
}
else
yystates[0] = yys;
}
std::string yylhs = ]b4_namespace_ref::b4_parser_class[::symbol_name (yylhsNonterm (yyx->yyrule));
if (yyx->state()->yyposn < yystates[0]->yyposn + 1)
YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
yyindent, "", yylhs.c_str(),
yyx->yyrule - 1);
else
YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %zu .. %zu>\n",
yyindent, "", yylhs.c_str(),
yyx->yyrule - 1, yystates[0]->yyposn + 1,
yyx->state()->yyposn);
for (int yyi = 1; yyi <= yynrhs; yyi += 1)
{
if (yystates[yyi]->yyresolved)
{
std::string yysym = ]b4_namespace_ref::b4_parser_class[::symbol_name (YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yystates[yyi]->yylrState]));
if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
yysym.c_str());
else
YYFPRINTF (stderr, "%*s%s <tokens %zu .. %zu>\n", yyindent+2, "",
yysym.c_str(),
yystates[yyi-1]->yyposn + 1,
yystates[yyi]->yyposn);
}
else
yyreportTree (yystates[yyi]->firstVal(),
yyindent+2);
}
}
#endif
public:
std::vector<yyGLRStackItem> yyitems;
yyGLRState* yysplitPoint;
yyGLRStateSet yytops;
};
#undef YYFILL
#define YYFILL(N) yystateStack.yyfill (yyvsp, &yylow, (N), yynormal)
#define yystackp this
struct yyGLRStack {
yyGLRStack(size_t yysize, ]b4_parse_param_decl[)
: yyerrState(0)
, yystateStack(yysize)
, yyerrcnt(0)
, yyrawchar(0)
,]b4_parse_param_cons[
{}
~yyGLRStack ()
{
if (yychar != ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[)
yyparser.yy_destroy_ ("Cleanup: discarding lookahead",
YYTRANSLATE (yychar), &yylval]b4_locations_if([, &yylloc])[);
popall();
}
int yyerrState;
]b4_locations_if([[ /* To compute the location of the error token. */
yyGLRStackItem yyerror_range[3];]])[
]b4_pure_if(
[
yyStateStack yystateStack;
int yyerrcnt;
int yyrawchar;
YYSTYPE yyval;]b4_locations_if([[
YYLTYPE yyloc;]])[
])[
YYJMP_BUF yyexception_buffer;
void yyreserveGlrStack() {
if (yystateStack.yyexpandGLRStackIfNeeded ())
yyMemoryExhausted();
}
_Noreturn void
yyMemoryExhausted ()
{
YYLONGJMP (yyexception_buffer, 2);
}
_Noreturn void
yyFail (const char* yymsg]b4_pure_formals[)
{
if (yymsg != YY_NULLPTR)
yyerror (]b4_yyerror_args[yymsg);
YYLONGJMP (yyexception_buffer, 1);
}
/* GLRStates */
/** Add a new semantic action that will execute the action for rule
* YYRULE on the semantic values in YYRHS to the list of
* alternative actions for YYSTATE. Assumes that YYRHS comes from
* stack #YYK of *this. */
void
yyaddDeferredAction (yyStateSetIndex yyk, yyGLRState* yystate,
yyGLRState* yyrhs, yyRuleNum yyrule)
{
yySemanticOption& yynewOption =
yystateStack.yynewSemanticOption(yySemanticOption(yyrule, ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[));
yynewOption.setState(yyrhs);
yynewOption.setNext(yystate->firstVal());
if (yystateStack.yytops.lookaheadNeeds(yyk))
{
yynewOption.yyrawchar = yychar;
yynewOption.yyval = yylval;]b4_locations_if([
yynewOption.yyloc = yylloc;])[
}
yystate->setFirstVal(&yynewOption);
yyreserveGlrStack();
}
#if ]b4_api_PREFIX[DEBUG
void yypdumpstack () {
yystateStack.dumpStack();
}
#endif
void
yyreportSyntaxError (]b4_user_formals_no_comma[)
{
if (yyerrState != 0)
return;
]b4_parse_error_bmatch(
[simple],
[[ yyerror (]b4_lyyerror_args[YY_("syntax error"));]],
[[ {
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken
= yychar == ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[
? ]b4_namespace_ref::b4_parser_class::symbol_kind::b4_symbol(-2, kind)[
: YYTRANSLATE (yychar);
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Arguments of yyformat. */
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
"expected"). */
int yycount = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
if (yytoken != ]b4_namespace_ref::b4_parser_class::symbol_kind::b4_symbol(-2, kind)[)
{
int yyn = yypact[firstTopState()->yylrState];
yyarg[yycount++] = yytoken;
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for this
state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != ]b4_namespace_ref::b4_parser_class::symbol_kind::b4_symbol(1, kind)[
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
break;
}
yyarg[yycount++] = YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yyx);
}
}
}
/* Internationalized format string. */
const char *yyformat = YY_NULLPTR;
switch (yycount)
{
#define YYCASE_(N, S) \
case N: \
yyformat = S; \
break
default: /* Avoid compiler warnings. */
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
#undef YYCASE_
}
std::string yymsg;
// Argument number.
std::ptrdiff_t yyi = 0;
for (char const* yyp = yyformat; *yyp; ++yyp)
if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
{
yymsg += ]b4_namespace_ref::b4_parser_class[::symbol_name (yyarg[yyi++]);
++yyp;
}
else
yymsg += *yyp;
yyerror (]b4_lyyerror_args[yymsg);
}
]])[
yynerrs += 1;
}
/* Recover from a syntax error on this, assuming that YYTOKENP,
yylval, and yylloc are the syntactic category, semantic value, and location
of the lookahead. */
void
yyrecoverSyntaxError (]b4_user_formals_no_comma[)
{
if (yyerrState == 3)
/* We just shifted the error token and (perhaps) took some
reductions. Skip tokens until we can proceed. */
while (true)
{
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken;
int yyj;
if (yychar == ]b4_namespace_ref::b4_parser_class::token::b4_symbol(0, id)[)
yyFail (YY_NULLPTR][]b4_lpure_args[);
if (yychar != ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[)
{]b4_locations_if([[
/* We throw away the lookahead, but the error range
of the shifted error token must take it into account. */
yyGLRState *yys = firstTopState();
yyGLRStackItem yyerror_range[3];
yyerror_range[1].getState().yyloc = yys->yyloc;
yyerror_range[2].getState().yyloc = yylloc;
YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
yytoken = YYTRANSLATE (yychar);
yyparser.yy_destroy_ ("Error: discarding",
yytoken, &yylval]b4_locations_if([, &yylloc])[);
yychar = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[;
}
yytoken = ]b4_yygetToken_call[;
yyj = yypact[firstTopState()->yylrState];
if (yypact_value_is_default (yyj))
return;
yyj += yytoken;
if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
{
if (yydefact[firstTopState()->yylrState] != 0)
return;
}
else if (! yytable_value_is_error (yytable[yyj]))
return;
}
if (!yystateStack.reduceToOneStack())
yyFail (YY_NULLPTR][]b4_lpure_args[);
/* Now pop stack until we find a state that shifts the error token. */
yyerrState = 3;
while (firstTopState() != YY_NULLPTR)
{
yyGLRState *yys = firstTopState();
int yyj = yypact[yys->yylrState];
if (! yypact_value_is_default (yyj))
{
yyj += YYTERROR;
if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
&& yyisShiftAction (yytable[yyj]))
{
/* Shift the error token. */]b4_locations_if([[
/* First adjust its location.*/
YYLTYPE yyerrloc;
yyerror_range[2].getState().yyloc = yylloc;
YYLLOC_DEFAULT (yyerrloc, (yyerror_range), 2);]])[
YY_SYMBOL_PRINT ("Shifting", YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yytable[yyj]]),
&yylval, &yyerrloc);
yyglrShift (yycreateStateSetIndex(0), yytable[yyj],
yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[);
yys = firstTopState();
break;
}
}]b4_locations_if([[
yyerror_range[1].getState().yyloc = yys->yyloc;]])[
if (yys->pred() != YY_NULLPTR)
yys->destroy ("Error: popping"]b4_user_args[);
yystateStack.setFirstTop(yys->pred());
yystateStack.pop_back();
}
if (firstTopState() == YY_NULLPTR)
yyFail (YY_NULLPTR][]b4_lpure_args[);
}
YYRESULTTAG
yyprocessOneStack (yyStateSetIndex yyk,
size_t yyposn]b4_pure_formals[)
{
while (yystateStack.topAt(yyk) != YY_NULLPTR)
{
yyStateNum yystate = topState(yyk)->yylrState;
YYDPRINTF ((stderr, "Stack %zu Entering state %d\n",
yyk.get(), yystate));
YYASSERT (yystate != YYFINAL);
if (yyisDefaultedState (yystate))
{
yyRuleNum yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{
YYDPRINTF ((stderr, "Stack %zu dies.\n",
yyk.get()));
yystateStack.yytops.yymarkStackDeleted (yyk);
return yyok;
}
YYRESULTTAG yyflag = yyglrReduce (yyk, yyrule,
yyimmediate[yyrule]]b4_user_args[);
if (yyflag == yyerr)
{
YYDPRINTF ((stderr,
"Stack %zu dies "
"(predicate failure or explicit user error).\n",
yyk.get()));
yystateStack.yytops.yymarkStackDeleted (yyk);
return yyok;
}
if (yyflag != yyok)
return yyflag;
}
else
{
yystateStack.yytops.setLookaheadNeeds(yyk, true);
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken = ]b4_yygetToken_call[;
const short* yyconflicts;
int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts);
for (; *yyconflicts != 0; ++yyconflicts)
{
yyStateSetIndex yynewStack = yystateStack.yysplitStack (yyk);
YYDPRINTF ((stderr, "Splitting off stack %lu from %zu.\n",
(unsigned long) yynewStack.get(),
yyk.get()));
YYRESULTTAG yyflag =
yyglrReduce (yynewStack, *yyconflicts,
yyimmediate[*yyconflicts]]b4_user_args[);
if (yyflag == yyok)
YYCHK (yyprocessOneStack (yynewStack,
yyposn]b4_pure_args[));
else if (yyflag == yyerr)
{
YYDPRINTF ((stderr, "Stack %zu dies.\n",
yynewStack.get()));
yystateStack.yytops.yymarkStackDeleted (yynewStack);
}
else
return yyflag;
}
if (yyisShiftAction (yyaction))
break;
else if (yyisErrorAction (yyaction))
{
YYDPRINTF ((stderr, "Stack %lu dies.\n",
(unsigned long) yyk.get()));
yystateStack.yytops.yymarkStackDeleted (yyk);
break;
}
else
{
YYRESULTTAG yyflag = yyglrReduce (yyk, -yyaction,
yyimmediate[-yyaction]]b4_user_args[);
if (yyflag == yyerr)
{
YYDPRINTF ((stderr,
"Stack %lu dies "
"(predicate failure or explicit user error).\n",
(unsigned long) yyk.get()));
yystateStack.yytops.yymarkStackDeleted (yyk);
break;
}
else if (yyflag != yyok)
return yyflag;
}
}
}
return yyok;
}
/** Perform user action for rule number YYN, with RHS length YYRHSLEN,
* and top stack item YYVSP. YYVALP points to place to put semantic
* value ($$), and yylocp points to place for location information
* (@@$). Returns yyok for normal return, yyaccept for YYACCEPT,
* yyerr for YYERROR, yyabort for YYABORT. */
YYRESULTTAG
yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)
{
bool yynormal YY_ATTRIBUTE_UNUSED = !yystateStack.isSplit();
int yylow;
]b4_parse_param_use([yyvalp], [yylocp])dnl
[ YYUSE (yyrhslen);
# undef yyerrok
# define yyerrok (yyerrState = 0)
# undef YYACCEPT
# define YYACCEPT return yyaccept
# undef YYABORT
# define YYABORT return yyabort
# undef YYERROR
# define YYERROR return yyerrok, yyerr
# undef YYRECOVERING
# define YYRECOVERING() (yyerrState != 0)
# undef yyclearin
# define yyclearin (yychar = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[)
# undef YYBACKUP
# define YYBACKUP(Token, Value) \
return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \
yyerrok, yyerr
yylow = 1;
if (yyrhslen == 0)
*yyvalp = yyval_default;
else
*yyvalp = yyvsp[YYFILL (1-yyrhslen)].getState().semanticVal();]b4_locations_if([[
/* Default location. */
YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
yyerror_range[1].getState().yyloc = *yylocp;
]])[
#if YY_EXCEPTIONS
typedef ]b4_namespace_ref[::]b4_parser_class[::syntax_error syntax_error;
try
{
#endif // YY_EXCEPTIONS
switch (yyn)
{
]b4_user_actions[
default: break;
}
#if YY_EXCEPTIONS
}
catch (const syntax_error& yyexc)
{
YYDPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([
*yylocp = yyexc.location;])[
yyerror (]b4_yyerror_args[yyexc.what ());
YYERROR;
}
#endif // YY_EXCEPTIONS
return yyok;
# undef yyerrok
# undef YYABORT
# undef YYACCEPT
# undef YYERROR
# undef YYBACKUP
# undef yyclearin
# undef YYRECOVERING
}
YYRESULTTAG
yyresolveStack (]b4_user_formals_no_comma[)
{
if (yystateStack.isSplit())
{
int yyn = 0;
for (yyGLRState* yys = firstTopState();
yys != yystateStack.yysplitPoint;
yys = yys->pred())
yyn += 1;
YYCHK (yyresolveStates (firstTopState(), yyn
]b4_user_args[));
}
return yyok;
}
/** Pop the symbols consumed by reduction #YYRULE from the top of stack
* #YYK of *YYSTACKP, and perform the appropriate semantic action on their
* semantic values. Assumes that all ambiguities in semantic values
* have been previously resolved. Set *YYVALP to the resulting value,
* and *YYLOCP to the computed location (if any). Return value is as
* for userAction. */
inline YYRESULTTAG
yydoAction (yyStateSetIndex yyk, yyRuleNum yyrule,
YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)
{
int yynrhs = yyrhsLength (yyrule);
if (!yystateStack.isSplit())
{
/* Standard special case: single stack. */
YYASSERT (yyk.get() == 0);
yyGLRStackItem* yyrhs = yystateStack.topAt(yyk)->asItem();
yystateStack.pop_back(YY_CAST (size_t, yynrhs));
yystateStack.setFirstTop(&yystateStack[yystateStack.size() - 1].getState());
YY_REDUCE_PRINT ((true, yyrhs, yyk, yyrule]b4_user_args[));
return yyuserAction (yyrule, yynrhs, yyrhs,
yyvalp]b4_locations_if([, yylocp])[);
}
else
{
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
yyGLRState* yys = yystateStack.topAt(yyk);
yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yys);]b4_locations_if([[
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yys->yyloc;]])[
for (int yyi = 0; yyi < yynrhs; yyi += 1)
{
yys = yys->pred();
YYASSERT (yys != YY_NULLPTR);
}
yystateStack.yyupdateSplit (*yys);
yystateStack.setTopAt(yyk, yys);
YY_REDUCE_PRINT ((false, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[));
return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
yyvalp]b4_locations_if([, yylocp])[);
}
}
/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE,
* and push back on the resulting nonterminal symbol. Perform the
* semantic action associated with YYRULE and store its value with the
* newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently
* unambiguous. Otherwise, store the deferred semantic action with
* the new state. If the new state would have an identical input
* position, LR state, and predecessor to an existing state on the stack,
* it is identified with that existing state, eliminating stack #YYK from
* *YYSTACKP. In this case, the semantic value is
* added to the options for the existing state's semantic value.
*/
inline YYRESULTTAG
yyglrReduce (yyStateSetIndex yyk, yyRuleNum yyrule,
bool yyforceEval]b4_user_formals[)
{
size_t yyposn = topState(yyk)->yyposn;
if (yyforceEval || !yystateStack.isSplit())
{
YYSTYPE yysval;]b4_locations_if([[
YYLTYPE yyloc;]])[
YYRESULTTAG yyflag = yydoAction (yyk, yyrule, &yysval]b4_locations_if([, &yyloc])[);
if (yyflag == yyerr && yystateStack.isSplit())
{
YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
(unsigned long) yyk.get(), yyrule - 1));
}
if (yyflag != yyok)
return yyflag;
YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yyr1[yyrule]), &yysval, &yyloc);
yyglrShift (yyk,
yyLRgotoState (topState(yyk)->yylrState,
yylhsNonterm (yyrule)),
yyposn, &yysval]b4_locations_if([, &yyloc])[);
}
else
{
yyGLRState *yys = yystateStack.topAt(yyk);
yyGLRState *yys0 = yys;
for (int yyn = yyrhsLength (yyrule); 0 < yyn; yyn -= 1)
{
yys = yys->pred();
YYASSERT (yys != YY_NULLPTR);
}
yystateStack.yyupdateSplit (*yys);
yyStateNum yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
YYDPRINTF ((stderr,
"Reduced stack %lu by rule #%d; action deferred. "
"Now in state %d.\n",
(unsigned long) yyk.get(), yyrule - 1, yynewLRState));
for (yyStateSetIndex yyi = yycreateStateSetIndex(0); yyi.uget() < yystateStack.numTops(); ++yyi)
if (yyi != yyk && yystateStack.topAt(yyi) != YY_NULLPTR)
{
yyGLRState* yysplit = yystateStack.yysplitPoint;
yyGLRState* yyp = yystateStack.topAt(yyi);
while (yyp != yys && yyp != yysplit
&& yyp->yyposn >= yyposn)
{
if (yyp->yylrState == yynewLRState
&& yyp->pred() == yys)
{
yyaddDeferredAction (yyk, yyp, yys0, yyrule);
yystateStack.yytops.yymarkStackDeleted (yyk);
YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
(unsigned long) yyk.get(),
(unsigned long) yyi.get()));
return yyok;
}
yyp = yyp->pred();
}
}
yystateStack.setTopAt(yyk, yys);
yyglrShiftDefer (yyk, yynewLRState, yyposn, yys0, yyrule);
}
return yyok;
}
/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR
* state YYLRSTATE, at input position YYPOSN, with the (unresolved)
* semantic value of YYRHS under the action for YYRULE. */
inline void
yyglrShiftDefer (yyStateSetIndex yyk, yyStateNum yylrState,
size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
{
yyGLRState& yynewState = yystateStack.yynewGLRState(
yyGLRState(yylrState, yyposn));
yynewState.setPred(yystateStack.topAt(yyk));
yystateStack.setTopAt(yyk, &yynewState);
/* Invokes yyreserveStack. */
yyaddDeferredAction (yyk, &yynewState, yyrhs, yyrule);
}
/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR
* state YYLRSTATE, at input position YYPOSN, with (resolved) semantic
* value *YYVALP and source location *YYLOCP. */
inline void
yyglrShift (yyStateSetIndex yyk, yyStateNum yylrState,
size_t yyposn,
YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)
{
yyGLRState& yynewState = yystateStack.yynewGLRState(
yyGLRState(yylrState, yyposn, *yyvalp
]b4_locations_if([, *yylocp])[));
yynewState.setPred(yystateStack.topAt(yyk));
yystateStack.setTopAt(yyk, &yynewState);
yyreserveGlrStack();
}
#if ]b4_api_PREFIX[DEBUG
void
yypstack (yyStateSetIndex yyk)
{
yystateStack.yypstates (yystateStack.topAt(yyk));
}
#endif
yyGLRState* topState(yyStateSetIndex i) {
return yystateStack.topAt(i);
}
yyGLRState* firstTopState() {
return yystateStack.firstTop();
}
private:
void popall() {
/* If the stack is well-formed, pop the stack until it is empty,
destroying its entries as we go. But free the stack regardless
of whether it is well-formed. */
for (yyStateSetIndex k = yycreateStateSetIndex(0); k.uget() < yystateStack.numTops(); k += 1)
if (yystateStack.topAt(k) != YY_NULLPTR)
{
while (yystateStack.topAt(k) != YY_NULLPTR)
{
yyGLRState* state = topState(k);]b4_locations_if([[
yyerror_range[1].getState().yyloc = state->yyloc;]])[
if (state->pred() != YY_NULLPTR)
state->destroy ("Cleanup: popping"]b4_user_args[);
yystateStack.setTopAt(k, state->pred());
yystateStack.pop_back();
}
break;
}
}
/** Resolve the previous YYN states starting at and including state YYS
* on *YYSTACKP. If result != yyok, some states may have been left
* unresolved possibly with empty semantic option chains. Regardless
* of whether result = yyok, each state has been left with consistent
* data so that destroy can be invoked if necessary. */
YYRESULTTAG
yyresolveStates (yyGLRState* yys, int yyn]b4_user_formals[)
{
if (0 < yyn)
{
YYASSERT (yys->pred() != YY_NULLPTR);
YYCHK (yyresolveStates (yys->pred(), yyn-1]b4_user_args[));
if (! yys->yyresolved)
YYCHK (yyresolveValue (yys]b4_user_args[));
}
return yyok;
}
/** Resolve the ambiguity represented in state YYS in *YYSTACKP,
* perform the indicated actions, and set the semantic value of YYS.
* If result != yyok, the chain of semantic options in YYS has been
* cleared instead or it has been left unmodified except that
* redundant options may have been removed. Regardless of whether
* result = yyok, YYS has been left with consistent data so that
* destroy can be invoked if necessary. */
YYRESULTTAG
yyresolveValue (yyGLRState* yys]b4_user_formals[)
{
yySemanticOption* yybest = yys->firstVal();
bool yymerge = false;
YYSTYPE yysval;
YYRESULTTAG yyflag;]b4_locations_if([
YYLTYPE *yylocp = &yys->yyloc;])[
yySemanticOption* yypPrev = yybest;
for (yySemanticOption* yyp = yybest->next();
yyp != YY_NULLPTR; )
{
if (yybest->isIdenticalTo (yyp))
{
yybest->mergeWith (yyp);
yypPrev->setNext(yyp->next());
}
else
{
switch (yypreference (yybest, yyp))
{
case 0:]b4_locations_if([[
yyresolveLocations (yys, 1]b4_user_args[);]])[
return yystateStack.yyreportAmbiguity (yybest, yyp]b4_pure_args[);
break;
case 1:
yymerge = true;
break;
case 2:
break;
case 3:
yybest = yyp;
yymerge = false;
break;
default:
/* This cannot happen so it is not worth a YYASSERT (false),
but some compilers complain if the default case is
omitted. */
break;
}
yypPrev = yyp;
yyp = yyp->next();
}
}
if (yymerge)
{
int yyprec = yydprec[yybest->yyrule];
yyflag = yyresolveAction (yybest, &yysval]b4_locations_if([, yylocp])[);
if (yyflag == yyok)
for (yySemanticOption* yyp = yybest->next();
yyp != YY_NULLPTR;
yyp = yyp->next())
{
if (yyprec == yydprec[yyp->yyrule])
{
YYSTYPE yysval_other;]b4_locations_if([
YYLTYPE yydummy;])[
yyflag = yyresolveAction (yyp, &yysval_other]b4_locations_if([, &yydummy])[);
if (yyflag != yyok)
{
yyparser.yy_destroy_ ("Cleanup: discarding incompletely merged value for",
YY_CAST (]b4_namespace_ref::b4_parser_class[::symbol_kind_type, yystos[yys->yylrState]),
&yysval]b4_locations_if([, yylocp])[);
break;
}
yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
}
}
}
else
yyflag = yyresolveAction (yybest, &yysval]b4_locations_if([, yylocp])[);
if (yyflag == yyok)
{
yys->yyresolved = true;
yys->semanticVal() = yysval;
}
else
yys->setFirstVal(YY_NULLPTR);
return yyflag;
}
/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its
* user action, and return the semantic value and location in *YYVALP
* and *YYLOCP. Regardless of whether result = yyok, all RHS states
* have been destroyed (assuming the user action destroys all RHS
* semantic values if invoked). */
YYRESULTTAG
yyresolveAction (yySemanticOption* yyopt, YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)
{
yyGLRState* yyoptState = yyopt->state();
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
int yynrhs = yyrhsLength (yyopt->yyrule);
YYRESULTTAG yyflag =
yyresolveStates (yyoptState, yynrhs]b4_user_args[);
if (yyflag != yyok)
{
for (yyGLRState *yys = yyoptState; yynrhs > 0; yys = yys->pred(), yynrhs -= 1)
yys->destroy ("Cleanup: popping"]b4_user_args[);
return yyflag;
}
yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yyopt->state());]b4_locations_if([[
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yyoptState->yyloc;]])[
{
int yychar_current = yychar;
YYSTYPE yylval_current = yylval;]b4_locations_if([
YYLTYPE yylloc_current = yylloc;])[
yychar = yyopt->yyrawchar;
yylval = yyopt->yyval;]b4_locations_if([
yylloc = yyopt->yyloc;])[
yyflag = yyuserAction (yyopt->yyrule, yynrhs,
yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyvalp]b4_locations_if([, yylocp])[);
yychar = yychar_current;
yylval = yylval_current;]b4_locations_if([
yylloc = yylloc_current;])[
}
return yyflag;
}]b4_locations_if([[
/** Resolve the locations for each of the YYN1 states in *YYSTACKP,
* ending at YYS1. Has no effect on previously resolved states.
* The first semantic option of a state is always chosen. */
void
yyresolveLocations (yyGLRState *yys1, int yyn1]b4_user_formals[)
{
if (0 < yyn1)
{
yyresolveLocations (yys1->pred(), yyn1 - 1]b4_user_args[);
if (!yys1->yyresolved)
{
yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
int yynrhs;
yySemanticOption* yyoption = yys1->firstVal();
YYASSERT (yyoption != YY_NULLPTR);
yynrhs = yyrhsLength (yyoption->yyrule);
if (0 < yynrhs)
{
yyresolveLocations (yyoption->state(), yynrhs]b4_user_args[);
yyGLRState *yys = yyoption->state();
for (int yyn = yynrhs; yyn > 0; yyn -= 1)
{
yyrhsloc[yyn].getState().yyloc = yys->yyloc;
yys = yys->pred();
}
}
else
{
/* Both yyresolveAction and yyresolveLocations traverse the GSS
in reverse rightmost order. It is only necessary to invoke
yyresolveLocations on a subforest for which yyresolveAction
would have been invoked next had an ambiguity not been
detected. Thus the location of the previous state (but not
necessarily the previous state itself) is guaranteed to be
resolved already. */
yyrhsloc[0].getState().yyloc = yyoption->state()->yyloc;
}
YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
}
}
}]])[
]b4_parse_param_vars[
};
#undef yystackp
#undef YYSTACKEXPANDABLE
/** If yychar is empty, fetch the next token. */
static inline ]b4_namespace_ref::b4_parser_class[::symbol_kind_type
yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals[)
{
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken;
]b4_parse_param_use()dnl
[ if (*yycharp == ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[)
{
YYDPRINTF ((stderr, "Reading a token\n"));
#if YY_EXCEPTIONS
try
{
#endif // YY_EXCEPTIONS
*yycharp = ]b4_lex[;
#if YY_EXCEPTIONS
}
catch (const ]b4_namespace_ref[::]b4_parser_class[::syntax_error& yyexc)
{
YYDPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([
yylloc = yyexc.location;])[
yyerror (]b4_lyyerror_args[yyexc.what ());
// Map errors caught in the scanner to the error token, so that error
// handling is started.
*yycharp = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(1, id)[;
}
#endif // YY_EXCEPTIONS
}
if (*yycharp <= ]b4_namespace_ref::b4_parser_class::token::b4_symbol(0, id)[)
{
*yycharp = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(0, id)[;
yytoken = ]b4_namespace_ref::b4_parser_class::symbol_kind::b4_symbol(0, kind)[;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (*yycharp);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
return yytoken;
}
static void
yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
{
YYUSE (yy0);
YYUSE (yy1);
switch (yyn)
{
]b4_mergers[
default: break;
}
}
/* Bison grammar-table manipulation. */
/** Number of symbols composing the right hand side of rule #RULE. */
static inline int
yyrhsLength (yyRuleNum yyrule)
{
return yyr2[yyrule];
}
/** The action to take in YYSTATE on seeing YYTOKEN.
* Result R means
* R < 0: Reduce on rule -R.
* R = 0: Error.
* R > 0: Shift to state R.
* Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list
* of conflicting reductions.
*/
static inline int
yygetLRActions (yyStateNum yystate, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken, const short** yyconflicts)
{
int yyindex = yypact[yystate] + yytoken;
if (yytoken == ]b4_namespace_ref::b4_parser_class[::symbol_kind::]b4_symbol(1, kind)[)
{
// This is the error token.
*yyconflicts = yyconfl;
return 0;
}
else if (yyisDefaultedState (yystate)
|| yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
{
*yyconflicts = yyconfl;
return -yydefact[yystate];
}
else if (! yytable_value_is_error (yytable[yyindex]))
{
*yyconflicts = yyconfl + yyconflp[yyindex];
return yytable[yyindex];
}
else
{
*yyconflicts = yyconfl + yyconflp[yyindex];
return 0;
}
}
/** Compute post-reduction state.
* \param yystate the current state
* \param yysym the nonterminal to push on the stack
*/
static inline yyStateNum
yyLRgotoState (yyStateNum yystate, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yysym)
{
int yyr = yypgoto[yysym - YYNTOKENS] + yystate;
if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
return yytable[yyr];
else
return yydefgoto[yysym - YYNTOKENS];
}
/* GLRStacks */
/** Y0 and Y1 represent two possible actions to take in a given
* parsing state; return 0 if no combination is possible,
* 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
static int
yypreference (yySemanticOption* y0, yySemanticOption* y1)
{
yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
int p0 = yydprec[r0], p1 = yydprec[r1];
if (p0 == p1)
{
if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
return 0;
else
return 1;
}
if (p0 == 0 || p1 == 0)
return 0;
if (p0 < p1)
return 3;
if (p1 < p0)
return 2;
return 0;
}
#define YYCHK1(YYE) \
do { \
switch (YYE) { \
case yyok: \
break; \
case yyabort: \
goto yyabortlab; \
case yyaccept: \
goto yyacceptlab; \
case yyerr: \
goto yyuser_error; \
default: \
goto yybuglab; \
} \
} while (0)
/*----------.
| yyparse. |
`----------*/
int
yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)
{
int yyresult;
yyGLRStack yystack(YYINITDEPTH]b4_user_args[);
yyGLRStack* const yystackp = &yystack;
size_t yyposn;
YYDPRINTF ((stderr, "Starting parse\n"));
yychar = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[;
yylval = yyval_default;]b4_locations_if([
yylloc = yyloc_default;])[
]m4_ifdef([b4_initial_action], [
b4_dollar_pushdef([yylval], [], [], [yylloc])dnl
b4_user_initial_action
b4_dollar_popdef])[]dnl
[
switch (YYSETJMP (yystack.yyexception_buffer))
{
case 0: break;
case 1: goto yyabortlab;
case 2: goto yyexhaustedlab;
default: goto yybuglab;
}
yystack.yyglrShift (yycreateStateSetIndex(0), 0, 0, &yylval]b4_locations_if([, &yylloc])[);
yyposn = 0;
while (true)
{
/* For efficiency, we have two loops, the first of which is
specialized to deterministic operation (single stack, no
potential ambiguity). */
/* Standard mode */
while (true)
{
yyStateNum yystate = yystack.firstTopState()->yylrState;
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
goto yyacceptlab;
if (yyisDefaultedState (yystate))
{
yyRuleNum yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{]b4_locations_if([[
yystack.yyerror_range[1].getState().yyloc = yylloc;]])[
yystack.yyreportSyntaxError (]b4_user_args_no_comma[);
goto yyuser_error;
}
YYCHK1 (yystack.yyglrReduce (yycreateStateSetIndex(0), yyrule, true]b4_user_args[));
}
else
{
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken = ]b4_yygetToken_call;[
const short* yyconflicts;
int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
{
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
yychar = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[;
yyposn += 1;
yystack.yyglrShift (yycreateStateSetIndex(0), yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[);
if (0 < yystack.yyerrState)
yystack.yyerrState -= 1;
}
else if (yyisErrorAction (yyaction))
{]b4_locations_if([[
yystack.yyerror_range[1].getState().yyloc = yylloc;]])[
/* Don't issue an error message again for exceptions
thrown from the scanner. */
if (yychar != ]b4_namespace_ref::b4_parser_class::token::b4_symbol(1, id)[)
yystack.yyreportSyntaxError (]b4_user_args_no_comma[);
goto yyuser_error;
}
else
YYCHK1 (yystack.yyglrReduce (yycreateStateSetIndex(0), -yyaction, true]b4_user_args[));
}
}
while (true)
{
]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken_to_shift;
for (yyStateSetIndex yys = yycreateStateSetIndex(0); yys.uget() < yystack.yystateStack.numTops(); ++yys)
yystackp->yystateStack.yytops.setLookaheadNeeds(yys, yychar != ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[);
/* yyprocessOneStack returns one of three things:
- An error flag. If the caller is yyprocessOneStack, it
immediately returns as well. When the caller is finally
yyparse, it jumps to an error label via YYCHK1.
- yyok, but yyprocessOneStack has invoked yymarkStackDeleted
(yys), which sets the top state of yys to NULL. Thus,
yyparse's following invocation of yyremoveDeletes will remove
the stack.
- yyok, when ready to shift a token.
Except in the first case, yyparse will invoke yyremoveDeletes and
then shift the next token onto all remaining stacks. This
synchronization of the shift (that is, after all preceding
reductions on all stacks) helps prevent double destructor calls
on yylval in the event of memory exhaustion. */
for (yyStateSetIndex yys = yycreateStateSetIndex(0); yys.uget() < yystack.yystateStack.numTops(); ++yys)
YYCHK1 (yystack.yyprocessOneStack (yys, yyposn]b4_lpure_args[));
yystack.yystateStack.yytops.yyremoveDeletes ();
if (yystack.yystateStack.yytops.size() == 0)
{
yystack.yystateStack.yytops.yyundeleteLastStack ();
if (yystack.yystateStack.yytops.size() == 0)
yystack.yyFail (YY_("syntax error")][]b4_lpure_args[);
YYCHK1 (yystack.yyresolveStack (]b4_user_args_no_comma[));
YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));]b4_locations_if([[
yystack.yyerror_range[1].getState().yyloc = yylloc;]])[
yystack.yyreportSyntaxError (]b4_user_args_no_comma[);
goto yyuser_error;
}
/* If any yyglrShift call fails, it will fail after shifting. Thus,
a copy of yylval will already be on stack 0 in the event of a
failure in the following loop. Thus, yychar is set to ]b4_symbol(-2, id)[
before the loop to make sure the user destructor for yylval isn't
called twice. */
yytoken_to_shift = YYTRANSLATE (yychar);
yychar = ]b4_namespace_ref::b4_parser_class::token::b4_symbol(-2, id)[;
yyposn += 1;
for (yyStateSetIndex yys = yycreateStateSetIndex(0); yys.uget() < yystack.yystateStack.numTops(); ++yys)
{
yyStateNum yystate = yystack.topState(yys)->yylrState;
const short* yyconflicts;
int yyaction = yygetLRActions (yystate, yytoken_to_shift,
&yyconflicts);
/* Note that yyconflicts were handled by yyprocessOneStack. */
YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long) yys.get()));
YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
yystack.yyglrShift (yys, yyaction, yyposn,
&yylval]b4_locations_if([, &yylloc])[);
YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
(unsigned long) yys.get(),
yystack.topState(yys)->yylrState));
}
if (yystack.yystateStack.yytops.size() == 1)
{
YYCHK1 (yystack.yyresolveStack (]b4_user_args_no_comma[));
YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
yystack.yystateStack.yycompressStack ();
break;
}
}
continue;
yyuser_error:
yystack.yyrecoverSyntaxError (]b4_user_args_no_comma[);
yyposn = yystack.firstTopState()->yyposn;
}
yyacceptlab:
yyresult = 0;
goto yyreturn;
yybuglab:
YYASSERT (false);
goto yyabortlab;
yyabortlab:
yyresult = 1;
goto yyreturn;
yyexhaustedlab:
yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
yyresult = 2;
goto yyreturn;
yyreturn:
return yyresult;
}
/* DEBUGGING ONLY */
#if ]b4_api_PREFIX[DEBUG
static void
yypstack (yyGLRStack* yystackp, size_t yyk)
{
yystackp->yypstack(yycreateStateSetIndex(YY_CAST(std::ptrdiff_t, yyk)));
}
static void yypdumpstack (struct yyGLRStack* yystackp) {
yystackp->yypdumpstack();
}
#endif
#undef yylval
#undef yychar
#undef yynerrs]b4_locations_if([
#undef yylloc])
m4_if(b4_prefix, [yy], [],
[[/* Substitute the variable and function names. */
#define yyparse ]b4_prefix[parse
#define yylex ]b4_prefix[lex
#define yyerror ]b4_prefix[error
#define yylval ]b4_prefix[lval
#define yychar ]b4_prefix[char
#define yydebug ]b4_prefix[debug
#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
#define yylloc ]b4_prefix[lloc]])])[
/*------------------.
| Report an error. |
`------------------*/
static void
yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp,
]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param),
])[const std::string& msg)
{
]b4_parse_param_use[]dnl
[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg);
}
]b4_namespace_open[
]dnl In this section, the parse params are the original parse_params.
m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
[ /// Build a parser object.
]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
:])[
#if ]b4_api_PREFIX[DEBUG
]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
#endif]b4_parse_param_cons[
{}
]b4_parser_class::~b4_parser_class[ ()
{}
]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
{}
int
]b4_parser_class[::operator() ()
{
return parse ();
}
int
]b4_parser_class[::parse ()
{
return ::yyparse (*this]b4_user_args[);
}
]b4_parse_error_bmatch([custom\|detailed],
[[ const char *
]b4_parser_class[::symbol_name (symbol_kind_type yysymbol)
{
static const char *const yy_sname[] =
{
]b4_symbol_names[
};]b4_has_translations_if([[
/* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is
internationalizable. */
static ]b4_int_type_for([b4_translatable])[ yytranslatable[] =
{
]b4_translatable[
};
return (yysymbol < YYNTOKENS && yytranslatable[yysymbol]
? _(yy_sname[yysymbol])
: yy_sname[yysymbol]);]], [[
return yy_sname[yysymbol];]])[
}
]],
[simple],
[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
const char *
]b4_parser_class[::symbol_name (symbol_kind_type yysymbol)
{
return yytname_[yysymbol];
}
#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[
]],
[verbose],
[[ /* Return YYSTR after stripping away unnecessary quotes and
backslashes, so that it's suitable for yyerror. The heuristic is
that double-quoting is unnecessary unless the string contains an
apostrophe, a comma, or backslash (other than backslash-backslash).
YYSTR is taken from yytname. */
std::string
]b4_parser_class[::yytnamerr_ (const char *yystr)
{
if (*yystr == '"')
{
std::string yyr;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
else
goto append;
append:
default:
yyr += *yyp;
break;
case '"':
return yyr;
}
do_not_strip_quotes: ;
}
return yystr;
}
std::string
]b4_parser_class[::symbol_name (symbol_kind_type yysymbol)
{
return yytnamerr_ (yytname_[yysymbol]);
}
]])[
]b4_parse_error_bmatch([simple\|verbose],
[[#if ]b4_api_PREFIX[DEBUG]b4_tname_if([[ || 1]])[
// YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
// First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
const char*
const ]b4_parser_class[::yytname_[] =
{
]b4_tname[
};
#endif
]])[
void
]b4_parser_class[::yy_destroy_ (const char* yymsg, symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[)
{
YYUSE (yyvaluep);]b4_locations_if([[
YYUSE (yylocationp);]])[
if (!yymsg)
yymsg = "Deleting";
]b4_namespace_ref::b4_parser_class[& yyparser = *this;
YYUSE (yyparser);
YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
]b4_symbol_actions([destructor])[
YY_IGNORE_MAYBE_UNINITIALIZED_END
}
#if ]b4_api_PREFIX[DEBUG
/*--------------------.
| Print this symbol. |
`--------------------*/
void
]b4_parser_class[::yy_symbol_value_print_ (symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[) const
{]b4_locations_if([[
YYUSE (yylocationp);]])[
YYUSE (yyvaluep);
std::ostream& yyo = debug_stream ();
std::ostream& yyoutput = yyo;
YYUSE (yyoutput);
]b4_symbol_actions([printer])[
}
void
]b4_parser_class[::yy_symbol_print_ (symbol_kind_type yykind,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[) const
{
*yycdebug_ << (yykind < YYNTOKENS ? "token" : "nterm")
<< ' ' << ]b4_namespace_ref::b4_parser_class[::symbol_name (yykind) << " ("]b4_locations_if([[
<< *yylocationp << ": "]])[;
yy_symbol_value_print_ (yykind, yyvaluep]b4_locations_if([[, yylocationp]])[);
*yycdebug_ << ')';
}
std::ostream&
]b4_parser_class[::debug_stream () const
{
return *yycdebug_;
}
void
]b4_parser_class[::set_debug_stream (std::ostream& o)
{
yycdebug_ = &o;
}
]b4_parser_class[::debug_level_type
]b4_parser_class[::debug_level () const
{
return yydebug;
}
void
]b4_parser_class[::set_debug_level (debug_level_type l)
{
// Actually, it is yydebug which is really used.
yydebug = l;
}
#endif
]m4_popdef([b4_parse_param])dnl
b4_namespace_close[]dnl
b4_glr_cc_cleanup[]dnl
b4_epilogue[]dnl
b4_output_end
m4_popdef([b4_parse_param])
Reference in New Issue View Git Blame Copy Permalink