mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
97ae878ec3
The current approach was too adhoc: the symbols were not sufficiently self-contained, in particular wrt memory management. The "new" guideline is the one that should have been followed from the start: let the symbols handle themslves, instead of leaving their users to it. It was justified by the will to avoid gratuitious moves and copies, but the current approach does not seem to be slower, yet it will probably be simpler to adjust to support move semantics from C++11. The documentation says that the %parse-param are available from the %destructor. In retrospect, that was a silly design decision, which we can break for variants, as its a new feature. It should be phased out for non-variants too. * data/variant.hh: A variant never knows if it stores something or not, it is up to its users to store this information. Yet, in parse.assert mode, make sure the empty/filled variants are properly used. (b4_symbol_constructor_define_): Don't call directly the symbol constructor, to save a useless temporary. * data/stack.hh (push): Steal the pushed value instead of duplicating it. This will simplify the callers of push, who handled this "move" approach themselves. * data/c++.m4 (basic_symbol): Let -1, as kind, denote the fact that a symbol is empty. This is needed for instance when shifting the lookahead: yyla is given as argument to "push", and its value is then moved on the stack. But then yyla must be declared "empty" so that its destructor won't be called. (basic_symbol::move): New. Move the responsibility of calling the destructor from yy_destroy to ~basic_symbol in the case of variants. * data/lalr1.cc (stack_symbol_type): Now a derived class from its previous value, so that we can add a constructor from a symbol_type. (by_state): State -1 means empty. (yypush_): Factor, by calling one overload from the other one, and using the new semantics of stack::push. No longer reclaim by hand the memory from rhs symbols, since now that we store objects with proper destructors, they will be reclaimed automatically. Conversely, be sure to delete yylhs. * tests/c++.at (C++ Variant-based Symbols): New "unit" test for symbols.
514 lines
15 KiB
Plaintext
514 lines
15 KiB
Plaintext
-*- Autoconf -*-
|
|
|
|
# C++ skeleton for Bison
|
|
|
|
# Copyright (C) 2002-2013 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/>.
|
|
|
|
m4_include(b4_pkgdatadir/[c.m4])
|
|
|
|
# b4_comment(TEXT, [PREFIX])
|
|
# --------------------------
|
|
# Put TEXT in comment. Prefix all the output lines with PREFIX.
|
|
m4_define([b4_comment],
|
|
[b4_comment_([$1], [$2// ], [$2// ])])
|
|
|
|
|
|
## ---------------- ##
|
|
## Default values. ##
|
|
## ---------------- ##
|
|
|
|
b4_percent_define_default([[parser_class_name]], [[parser]])
|
|
|
|
# Don't do that so that we remember whether we're using a user
|
|
# request, or the default value.
|
|
#
|
|
# b4_percent_define_default([[api.location.type]], [[location]])
|
|
|
|
b4_percent_define_default([[filename_type]], [[std::string]])
|
|
b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
|
|
|
|
b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
|
|
b4_percent_define_default([[define_location_comparison]],
|
|
[m4_if(b4_percent_define_get([[filename_type]]),
|
|
[std::string], [[true]], [[false]])])
|
|
|
|
|
|
|
|
## ----------- ##
|
|
## Namespace. ##
|
|
## ----------- ##
|
|
|
|
m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
|
|
|
|
|
|
# Don't permit an empty b4_namespace_ref. Any `::parser::foo' appended to it
|
|
# would compile as an absolute reference with `parser' in the global namespace.
|
|
# b4_namespace_open would open an anonymous namespace and thus establish
|
|
# internal linkage. This would compile. However, it's cryptic, and internal
|
|
# linkage for the parser would be specified in all translation units that
|
|
# include the header, which is always generated. If we ever need to permit
|
|
# internal linkage somehow, surely we can find a cleaner approach.
|
|
m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [],
|
|
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
|
|
[[namespace reference is empty]])])
|
|
|
|
# Instead of assuming the C++ compiler will do it, Bison should reject any
|
|
# invalid b4_namepsace_ref that would be converted to a valid
|
|
# b4_namespace_open. The problem is that Bison doesn't always output
|
|
# b4_namespace_ref to uncommented code but should reserve the ability to do so
|
|
# in future releases without risking breaking any existing user grammars.
|
|
# Specifically, don't allow empty names as b4_namespace_open would just convert
|
|
# those into anonymous namespaces, and that might tempt some users.
|
|
m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [],
|
|
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
|
|
[[namespace reference has consecutive "::"]])])
|
|
m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [],
|
|
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
|
|
[[namespace reference has a trailing "::"]])])
|
|
|
|
m4_define([b4_namespace_open],
|
|
[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
|
|
[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
|
|
[^\(.\)[ ]*::], [\1])),
|
|
[::], [ { namespace ])[ {]])])
|
|
|
|
m4_define([b4_namespace_close],
|
|
[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
|
|
m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
|
|
[^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*],
|
|
[\1])),
|
|
[::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
|
|
|
|
|
|
# b4_token_enums
|
|
# --------------
|
|
# Output the definition of the tokens as enums.
|
|
m4_define([b4_token_enums],
|
|
[[enum yytokentype
|
|
{
|
|
]m4_join([,
|
|
],
|
|
b4_symbol_map([b4_token_enum]))[
|
|
};]dnl
|
|
])
|
|
|
|
|
|
|
|
|
|
## ----------------- ##
|
|
## Semantic Values. ##
|
|
## ----------------- ##
|
|
|
|
# b4_semantic_type_declare
|
|
# ------------------------
|
|
# Declare semantic_type.
|
|
m4_define([b4_semantic_type_declare],
|
|
[ /// Symbol semantic values.
|
|
m4_ifdef([b4_stype],
|
|
[ union semantic_type
|
|
{
|
|
b4_user_stype
|
|
};],
|
|
[m4_if(b4_tag_seen_flag, 0,
|
|
[[ typedef int semantic_type;]],
|
|
[[ typedef ]b4_api_PREFIX[STYPE semantic_type;]])])])
|
|
|
|
|
|
# b4_public_types_declare
|
|
# -----------------------
|
|
# Define the public types: token, semantic value, location, and so forth.
|
|
# Depending on %define token_lex, may be output in the header or source file.
|
|
m4_define([b4_public_types_declare],
|
|
[[#ifndef ]b4_api_PREFIX[STYPE
|
|
]b4_semantic_type_declare[
|
|
#else
|
|
typedef ]b4_api_PREFIX[STYPE semantic_type;
|
|
#endif]b4_locations_if([
|
|
/// Symbol locations.
|
|
typedef b4_percent_define_get([[api.location.type]],
|
|
[[location]]) location_type;])[
|
|
|
|
/// Syntax errors thrown from user actions.
|
|
struct syntax_error : std::runtime_error
|
|
{
|
|
syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
|
|
location_type location;])[
|
|
};
|
|
|
|
/// Tokens.
|
|
struct token
|
|
{
|
|
]b4_token_enums[
|
|
};
|
|
|
|
/// Token type.
|
|
typedef token::yytokentype token_type;
|
|
|
|
/// A complete symbol.
|
|
///
|
|
/// Expects its Base type to provide access to the symbol type
|
|
/// via type_get().
|
|
///
|
|
/// Provide access to semantic value]b4_locations_if([ and location])[.
|
|
template <typename Base>
|
|
struct basic_symbol : Base
|
|
{
|
|
/// Alias to Base.
|
|
typedef Base super_type;
|
|
|
|
/// Default constructor.
|
|
inline basic_symbol ();
|
|
]b4_locations_if([
|
|
/// Constructor.
|
|
inline basic_symbol (const location_type& l);])[
|
|
|
|
/// Copy constructor.
|
|
inline basic_symbol (const basic_symbol& other);
|
|
|
|
/// Constructor for valueless symbols.
|
|
inline basic_symbol (typename Base::value_type t]b4_locations_if([,
|
|
const location_type& l])[);
|
|
|
|
/// Constructor for symbols with semantic value.
|
|
inline basic_symbol (typename Base::value_type t,
|
|
const semantic_type& v]b4_locations_if([,
|
|
const location_type& l])[);
|
|
|
|
~basic_symbol ();
|
|
/// Assignment operator.
|
|
inline basic_symbol& operator= (const basic_symbol& other);
|
|
|
|
/// Destructive move, \a s is emptied into this.
|
|
inline void move (basic_symbol& s);
|
|
|
|
/// The semantic value.
|
|
semantic_type value;]b4_locations_if([
|
|
|
|
/// The location.
|
|
location_type location;])[
|
|
};
|
|
|
|
/// Type access provider for token (enum) based symbols.
|
|
struct by_type
|
|
{
|
|
/// Default constructor.
|
|
inline by_type ();
|
|
|
|
/// Copy constructor.
|
|
inline by_type (const by_type& other);
|
|
|
|
/// Constructor.
|
|
inline by_type (token_type t);
|
|
|
|
/// Steal the type of \a that.
|
|
void move (by_type& that);
|
|
|
|
/// The symbol type.
|
|
///
|
|
/// -1 when this symbol is empty.
|
|
int type;
|
|
|
|
/// The type (corresponding to \a type).
|
|
///
|
|
/// -1 when this symbol is empty.
|
|
inline int type_get () const;
|
|
|
|
/// The token.
|
|
inline token_type token () const;
|
|
|
|
/// The type used to store the symbol type.
|
|
typedef token_type value_type;
|
|
};
|
|
|
|
/// "External" symbols: returned by the scanner.
|
|
typedef basic_symbol<by_type> symbol_type;
|
|
|
|
]b4_symbol_constructor_declare])
|
|
|
|
|
|
# b4_public_types_define
|
|
# ----------------------
|
|
# Provide the implementation needed by the public types.
|
|
m4_define([b4_public_types_define],
|
|
[[ inline
|
|
]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
|
|
: std::runtime_error (m)]b4_locations_if([
|
|
, location (l)])[
|
|
{}
|
|
|
|
// basic_symbol.
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
|
|
: value ()
|
|
{}
|
|
]b4_locations_if([
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const location_type& l)
|
|
: value ()
|
|
, location (l)
|
|
{}])[
|
|
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>&
|
|
]b4_parser_class_name[::basic_symbol<Base>::operator= (const basic_symbol&)
|
|
{
|
|
abort ();
|
|
}
|
|
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
|
|
: Base (other)
|
|
, value ()]b4_locations_if([
|
|
, location (other.location)])[
|
|
{
|
|
]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy],
|
|
[other.value])],
|
|
[value = other.value;])[
|
|
}
|
|
|
|
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
|
|
[typename Base::value_type t],
|
|
[const semantic_type& v],
|
|
b4_locations_if([const location_type& l]))[)
|
|
: Base (t)
|
|
, value (]b4_variant_if([], [v])[)]b4_locations_if([
|
|
, location (l)])[
|
|
{]b4_variant_if([[
|
|
(void) v;
|
|
]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[}
|
|
|
|
template <typename Base>
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
|
|
[typename Base::value_type t],
|
|
b4_locations_if([const location_type& l]))[)
|
|
: Base (t)
|
|
, value ()]b4_locations_if([
|
|
, location (l)])[
|
|
{}
|
|
|
|
template <typename Base>
|
|
inline
|
|
]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol ()
|
|
{]b4_variant_if([[
|
|
// User destructor.
|
|
int yytype = this->type_get ();
|
|
switch (yytype)
|
|
{
|
|
]b4_symbol_foreach([b4_symbol_destructor])dnl
|
|
[ default:
|
|
break;
|
|
}
|
|
|
|
// Type destructor.
|
|
]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[
|
|
}
|
|
|
|
template <typename Base>
|
|
void
|
|
]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
|
|
{
|
|
super_type::move(s);
|
|
]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move],
|
|
[s.value])],
|
|
[value = s.value;])[]b4_locations_if([
|
|
location = s.location;])[
|
|
}
|
|
|
|
// by_type.
|
|
]b4_parser_class_name[::by_type::by_type ()
|
|
: type (-1)
|
|
{}
|
|
|
|
]b4_parser_class_name[::by_type::by_type (const by_type& other)
|
|
: type (other.type)
|
|
{}
|
|
|
|
]b4_parser_class_name[::by_type::by_type (token_type t)
|
|
: type (yytranslate_ (t))
|
|
{}
|
|
|
|
inline
|
|
void
|
|
]b4_parser_class_name[::by_type::move (by_type& that)
|
|
{
|
|
type = that.type;
|
|
that.type = -1;
|
|
}
|
|
|
|
int
|
|
]b4_parser_class_name[::by_type::type_get () const
|
|
{
|
|
return type;
|
|
}
|
|
]b4_token_ctor_if([[
|
|
]b4_parser_class_name[::token_type
|
|
]b4_parser_class_name[::by_type::token () const
|
|
{
|
|
// YYTOKNUM[NUM] -- (External) token number corresponding to the
|
|
// (internal) symbol number NUM (which must be that of a token). */
|
|
static
|
|
const ]b4_int_type_for([b4_toknum])[
|
|
yytoken_number_[] =
|
|
{
|
|
]b4_toknum[
|
|
};
|
|
return static_cast<token_type> (yytoken_number_[type]);
|
|
}
|
|
]])[]dnl
|
|
b4_symbol_constructor_define])
|
|
|
|
|
|
# b4_symbol_constructor_declare
|
|
# b4_symbol_constructor_define
|
|
# -----------------------------
|
|
# Declare/define symbol constructors for all the value types.
|
|
# Use at class-level. Redefined in variant.hh.
|
|
m4_define([b4_symbol_constructor_declare], [])
|
|
m4_define([b4_symbol_constructor_define], [])
|
|
|
|
|
|
# b4_yytranslate_define
|
|
# ---------------------
|
|
# Define yytranslate_. Sometimes used in the header file,
|
|
# sometimes in the cc file.
|
|
m4_define([b4_yytranslate_define],
|
|
[[ // Symbol number corresponding to token number t.
|
|
]b4_parser_class_name[::token_number_type
|
|
]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
|
|
[int])[ t)
|
|
{
|
|
static
|
|
const token_number_type
|
|
translate_table[] =
|
|
{
|
|
]b4_translate[
|
|
};
|
|
const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
|
|
const token_number_type undef_token_ = ]b4_undef_token_number[;
|
|
|
|
if (static_cast<int>(t) <= yyeof_)
|
|
return yyeof_;
|
|
else if (static_cast<unsigned int> (t) <= user_token_number_max_)
|
|
return translate_table[t];
|
|
else
|
|
return undef_token_;
|
|
}
|
|
]])
|
|
|
|
|
|
# b4_lhs_value([TYPE])
|
|
# --------------------
|
|
# Expansion of $<TYPE>$.
|
|
m4_define([b4_lhs_value],
|
|
[b4_symbol_value([yyval], [$1])])
|
|
|
|
|
|
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
|
|
# --------------------------------------
|
|
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
|
|
# symbols on RHS.
|
|
m4_define([b4_rhs_value],
|
|
[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
|
|
|
|
|
|
# b4_lhs_location()
|
|
# -----------------
|
|
# Expansion of @$.
|
|
m4_define([b4_lhs_location],
|
|
[(yyloc)])
|
|
|
|
|
|
# b4_rhs_location(RULE-LENGTH, NUM)
|
|
# ---------------------------------
|
|
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
|
|
# on RHS.
|
|
m4_define([b4_rhs_location],
|
|
[(yylocation_stack_@{($1) - ($2)@})])
|
|
|
|
|
|
# b4_parse_param_decl
|
|
# -------------------
|
|
# Extra formal arguments of the constructor.
|
|
# Change the parameter names from "foo" into "foo_yyarg", so that
|
|
# there is no collision bw the user chosen attribute name, and the
|
|
# argument name in the constructor.
|
|
m4_define([b4_parse_param_decl],
|
|
[m4_ifset([b4_parse_param],
|
|
[m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
|
|
|
|
m4_define([b4_parse_param_decl_1],
|
|
[$1_yyarg])
|
|
|
|
|
|
|
|
# b4_parse_param_cons
|
|
# -------------------
|
|
# Extra initialisations of the constructor.
|
|
m4_define([b4_parse_param_cons],
|
|
[m4_ifset([b4_parse_param],
|
|
[
|
|
b4_cc_constructor_calls(b4_parse_param)])])
|
|
m4_define([b4_cc_constructor_calls],
|
|
[m4_map_sep([b4_cc_constructor_call], [,
|
|
], [$@])])
|
|
m4_define([b4_cc_constructor_call],
|
|
[$2 ($2_yyarg)])
|
|
|
|
# b4_parse_param_vars
|
|
# -------------------
|
|
# Extra instance variables.
|
|
m4_define([b4_parse_param_vars],
|
|
[m4_ifset([b4_parse_param],
|
|
[
|
|
// User arguments.
|
|
b4_cc_var_decls(b4_parse_param)])])
|
|
m4_define([b4_cc_var_decls],
|
|
[m4_map_sep([b4_cc_var_decl], [
|
|
], [$@])])
|
|
m4_define([b4_cc_var_decl],
|
|
[ $1;])
|
|
|
|
|
|
## ---------##
|
|
## Values. ##
|
|
## ---------##
|
|
|
|
# b4_yylloc_default_define
|
|
# ------------------------
|
|
# Define YYLLOC_DEFAULT.
|
|
m4_define([b4_yylloc_default_define],
|
|
[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
|
|
If N is 0, then set CURRENT to the empty location which ends
|
|
the previous symbol: RHS[0] (always defined). */
|
|
|
|
# ifndef YYLLOC_DEFAULT
|
|
# define YYLLOC_DEFAULT(Current, Rhs, N) \
|
|
do \
|
|
if (N) \
|
|
{ \
|
|
(Current).begin = YYRHSLOC (Rhs, 1).begin; \
|
|
(Current).end = YYRHSLOC (Rhs, N).end; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
|
|
} \
|
|
while (/*CONSTCOND*/ false)
|
|
# endif
|
|
]])
|