mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 20:33:03 +00:00
827bc59ca1
Bison supports a union tag, for obscure reasons. But it does a poor job at it, especially since Bison 3.0. Reported by Stephen Cameron and Tobias Frost. It did not ensure that the name was not given several times. An easy way to do this is to make the %union tag be handled as a %define variable, as they cannot be defined several times. Since Bison 3.0, the synclines were wrongly placed, resulting in invalid code. Addressing this issue, because of the way the union tag was stored (as a code muscle), would have been tedious. Unless we rather define the %union tag as a %percent variable, whose synclines are easier to manipulate. So replace the b4_union_name muscle by the api.value.union.name %define variable, document, and check. * data/bison.m4: Make sure that api.value.union.name has a keyword value. * data/c++.m4: Make sure that api.value.union.name is not defined. * data/c.m4 (b4_union_name): No longer use it, use api.value.union.name. * doc/bison.texi (%define Summary): Document it. * src/parse-gram.y (union_name): No longer define b4_uion_name, but api.value.union.name. * tests/input.at (Redefined %union name): New. * tests/synclines.at (%union name syncline): New. * tests/types.at: Check named %unions.
550 lines
16 KiB
Plaintext
550 lines
16 KiB
Plaintext
-*- Autoconf -*-
|
|
|
|
# C++ skeleton for Bison
|
|
|
|
# Copyright (C) 2002-2015 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/>.
|
|
|
|
# Sanity checks, before defaults installed by c.m4.
|
|
b4_percent_define_ifdef([[api.value.union.name]],
|
|
[b4_complain_at(b4_percent_define_get_loc([[api.value.union.name]]),
|
|
[named %union is invalid in C++])])
|
|
|
|
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// ])])
|
|
|
|
## -------- ##
|
|
## Checks. ##
|
|
## -------- ##
|
|
|
|
b4_percent_define_check_kind([api.namespace], [code], [deprecated])
|
|
b4_percent_define_check_kind([parser_class_name], [code], [deprecated])
|
|
|
|
## ---------------- ##
|
|
## 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]])
|
|
# Make it a warning for those who used betas of Bison 3.0.
|
|
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_value_type_declare
|
|
# ---------------------
|
|
# Declare semantic_type.
|
|
m4_define([b4_value_type_declare],
|
|
[b4_value_type_setup[]dnl
|
|
[ /// Symbol semantic values.
|
|
]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]),
|
|
[code],
|
|
[[ typedef ]b4_percent_define_get([[api.value.type]])[ semantic_type;]],
|
|
[m4_bmatch(b4_percent_define_get([[api.value.type]]),
|
|
[union\|union-directive],
|
|
[[ union semantic_type
|
|
{
|
|
]b4_user_union_members[
|
|
};]])])dnl
|
|
])
|
|
|
|
|
|
# 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_value_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[
|
|
};
|
|
|
|
/// (External) token type, as returned by yylex.
|
|
typedef token::yytokentype token_type;
|
|
|
|
/// Internal symbol number.
|
|
typedef int symbol_number_type;
|
|
|
|
/// Internal symbol number for tokens (subsumed by symbol_number_type).
|
|
typedef ]b4_int_type_for([b4_translate])[ token_number_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.
|
|
basic_symbol ();
|
|
|
|
/// Copy constructor.
|
|
basic_symbol (const basic_symbol& other);
|
|
]b4_variant_if([[
|
|
/// Constructor for valueless symbols, and symbols from each type.
|
|
]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[
|
|
/// Constructor for valueless symbols.
|
|
basic_symbol (typename Base::kind_type t]b4_locations_if([,
|
|
const location_type& l])[);]])[
|
|
|
|
/// Constructor for symbols with semantic value.
|
|
basic_symbol (typename Base::kind_type t,
|
|
const semantic_type& v]b4_locations_if([,
|
|
const location_type& l])[);
|
|
|
|
~basic_symbol ();
|
|
|
|
/// Destructive move, \a s is emptied into this.
|
|
void move (basic_symbol& s);
|
|
|
|
/// The semantic value.
|
|
semantic_type value;]b4_locations_if([
|
|
|
|
/// The location.
|
|
location_type location;])[
|
|
|
|
private:
|
|
/// Assignment operator.
|
|
basic_symbol& operator= (const basic_symbol& other);
|
|
};
|
|
|
|
/// Type access provider for token (enum) based symbols.
|
|
struct by_type
|
|
{
|
|
/// Default constructor.
|
|
by_type ();
|
|
|
|
/// Copy constructor.
|
|
by_type (const by_type& other);
|
|
|
|
/// The symbol type as needed by the constructor.
|
|
typedef token_type kind_type;
|
|
|
|
/// Constructor from (external) token numbers.
|
|
by_type (kind_type t);
|
|
|
|
/// Steal the symbol type from \a that.
|
|
void move (by_type& that);
|
|
|
|
/// The (internal) type number (corresponding to \a type).
|
|
/// -1 when this symbol is empty.
|
|
symbol_number_type type_get () const;
|
|
|
|
/// The token.
|
|
token_type token () const;
|
|
|
|
enum { empty = 0 };
|
|
|
|
/// The symbol type.
|
|
/// -1 when this symbol is empty.
|
|
token_number_type 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>
|
|
inline
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
|
|
: value ()
|
|
{}
|
|
|
|
template <typename Base>
|
|
inline
|
|
]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>
|
|
inline
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
|
|
[typename Base::kind_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])])[}
|
|
|
|
]b4_variant_if([[
|
|
// Implementation of basic_symbol constructor for each type.
|
|
]b4_type_foreach([b4_basic_symbol_constructor_define])], [[
|
|
/// Constructor for valueless symbols.
|
|
template <typename Base>
|
|
inline
|
|
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
|
|
[typename Base::kind_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.
|
|
symbol_number_type 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>
|
|
inline
|
|
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.
|
|
inline
|
|
]b4_parser_class_name[::by_type::by_type ()
|
|
: type (empty)
|
|
{}
|
|
|
|
inline
|
|
]b4_parser_class_name[::by_type::by_type (const by_type& other)
|
|
: type (other.type)
|
|
{}
|
|
|
|
inline
|
|
]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 = empty;
|
|
}
|
|
|
|
inline
|
|
int
|
|
]b4_parser_class_name[::by_type::type_get () const
|
|
{
|
|
return type;
|
|
}
|
|
]b4_token_ctor_if([[
|
|
inline
|
|
]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.
|
|
inline
|
|
]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
|
|
]])
|
|
|
|
## -------- ##
|
|
## Checks. ##
|
|
## -------- ##
|
|
|
|
b4_token_ctor_if([b4_variant_if([],
|
|
[b4_fatal_at(b4_percent_define_get_loc(api.token.constructor),
|
|
[cannot use '%s' without '%s'],
|
|
[%define api.token.constructor],
|
|
[%define api.value.type variant]))])])
|