# C++ skeleton for Bison
-# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
-# Free Software Foundation, Inc.
+# 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
dummy[]_b4_char_sizeof_counter])
-# b4_char_sizeof_(SYMBOL-NUM)
-# ---------------------------
-# A comment describing this symbol.
-m4_define([b4_char_sizeof_],
-[ // b4_symbol([$1], [tag])
-])
-
# b4_char_sizeof(SYMBOL-NUMS)
# ---------------------------
# To be mapped on the list of type names to produce:
m4_define([b4_char_sizeof],
[b4_symbol_if([$1], [has_type],
[
-m4_map([b4_char_sizeof_], [$@])dnl
+m4_map([ b4_symbol_tag_comment], [$@])dnl
char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
])])
-# b4_variant_definition
-# ---------------------
+# b4_variant_includes
+# -------------------
+# The needed includes for variants support.
+m4_define([b4_variant_includes],
+[b4_parse_assert_if([[#include <typeinfo>]])[
+#ifndef YYASSERT
+# include <cassert>
+# define YYASSERT assert
+#endif
+]])
+
+# b4_variant_define
+# -----------------
# Define "variant".
-m4_define([b4_variant_definition],
-[[
- /// A char[S] buffer to store and retrieve objects.
+m4_define([b4_variant_define],
+[[ /// A char[S] buffer to store and retrieve objects.
///
/// Sort of a variant, but does not keep track of the nature
/// of the stored data, since that knowledge is available
/// via the current state.
template <size_t S>
struct variant
- {]b4_assert_if([
- /// Whether something is contained.
- bool built;
-])[
+ {
+ /// Type of *this.
+ typedef variant<S> self_type;
+
/// Empty construction.
- inline
- variant ()]b4_assert_if([
- : built (false)])[
+ variant ()]b4_parse_assert_if([
+ : tname (YY_NULL)])[
{}
- /// Instantiate a \a T in here.
+ /// Construct and fill.
template <typename T>
- inline T&
+ variant (const T& t)]b4_parse_assert_if([
+ : tname (typeid (T).name ())])[
+ {
+ YYASSERT (sizeof (T) <= S);
+ new (buffer.raw) T (t);
+ }
+
+ /// Destruction, allowed only if empty.
+ ~variant ()
+ {]b4_parse_assert_if([
+ YYASSERT (!tname);
+ ])[}
+
+ /// Instantiate an empty \a T in here.
+ template <typename T>
+ T&
build ()
- {]b4_assert_if([
- assert (!built);
- built = true;])[
+ {]b4_parse_assert_if([
+ YYASSERT (!tname);
+ YYASSERT (sizeof (T) <= S);
+ tname = typeid (T).name ();])[
return *new (buffer.raw) T;
}
/// Instantiate a \a T in here from \a t.
template <typename T>
- inline T&
+ T&
build (const T& t)
- {]b4_assert_if([
- assert(!built);
- built = true;])[
- return *new (buffer.raw) T(t);
- }
-
- /// Construct and fill.
- template <typename T>
- inline
- variant (const T& t)]b4_assert_if([
- : built (true)])[
- {
- new (buffer.raw) T(t);
+ {]b4_parse_assert_if([
+ YYASSERT (!tname);
+ YYASSERT (sizeof (T) <= S);
+ tname = typeid (T).name ();])[
+ return *new (buffer.raw) T (t);
}
/// Accessor to a built \a T.
template <typename T>
- inline T&
+ T&
as ()
- {]b4_assert_if([
- assert (built);])[
- return reinterpret_cast<T&>(buffer.raw);
+ {]b4_parse_assert_if([
+ YYASSERT (tname == typeid (T).name ());
+ YYASSERT (sizeof (T) <= S);])[
+ return reinterpret_cast<T&> (buffer.raw);
}
/// Const accessor to a built \a T (for %printer).
template <typename T>
- inline const T&
+ const T&
as () const
- {]b4_assert_if([
- assert(built);])[
- return reinterpret_cast<const T&>(buffer.raw);
+ {]b4_parse_assert_if([
+ YYASSERT (tname == typeid (T).name ());
+ YYASSERT (sizeof (T) <= S);])[
+ return reinterpret_cast<const T&> (buffer.raw);
}
- /// Swap the content with \a other.
+ /// Swap the content with \a other, of same type.
+ ///
+ /// Both variants must be built beforehand, because swapping the actual
+ /// data requires reading it (with as()), and this is not possible on
+ /// unconstructed variants: it would require some dynamic testing, which
+ /// should not be the variant's responsability.
+ /// Swapping between built and (possibly) non-built is done with
+ /// variant::move ().
template <typename T>
- inline void
- swap (variant<S>& other)
- {
+ void
+ swap (self_type& other)
+ {]b4_parse_assert_if([
+ YYASSERT (tname);
+ YYASSERT (tname == other.tname);])[
std::swap (as<T>(), other.as<T>());
}
- /// Assign the content of \a other to this.
+ /// Move the content of \a other to this.
+ ///
/// Destroys \a other.
template <typename T>
- inline void
- build (variant<S>& other)
- {
+ void
+ move (self_type& other)
+ {]b4_parse_assert_if([
+ YYASSERT (!tname);])[
build<T>();
swap<T>(other);
other.destroy<T>();
}
+ /// Copy the content of \a other to this.
+ template <typename T>
+ void
+ copy (const self_type& other)
+ {
+ build<T> (other.as<T> ());
+ }
+
/// Destroy the stored \a T.
template <typename T>
- inline void
+ void
destroy ()
{
- as<T>().~T();]b4_assert_if([
- built = false;])[
+ as<T> ().~T ();]b4_parse_assert_if([
+ tname = YY_NULL;])[
}
+ private:
+ /// Prohibit blind copies.
+ self_type& operator=(const self_type&);
+ variant (const self_type&);
+
/// A buffer large enough to store any of the semantic values.
/// Long double is chosen as it has the strongest alignment
/// constraints.
{
long double align_me;
char raw[S];
- } buffer;
+ } buffer;]b4_parse_assert_if([
+
+ /// Whether the content is built: if defined, the name of the stored type.
+ const char* tname;])[
};
]])
{]b4_type_foreach([b4_char_sizeof])[};
/// Symbol semantic values.
- typedef variant<sizeof(union_type)> semantic_type;])
+ typedef variant<sizeof(union_type)> semantic_type;dnl
+])
# How the semantic value is extracted when using variants.
[m4_ifval([$2],
[$1.template as< $2 >()],
[$1])])
+
+
+
+## ------------- ##
+## make_SYMBOL. ##
+## ------------- ##
+
+
+# b4_symbol_constructor_declare_(SYMBOL-NUMBER)
+# ---------------------------------------------
+# Declare the overloaded version of make_symbol for the (common) type of
+# these SYMBOL-NUMBERS. Use at class-level.
+m4_define([b4_symbol_constructor_declare_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
+[ static inline
+ symbol_type
+ make_[]b4_symbol_([$1], [id]) (dnl
+b4_join(b4_symbol_if([$1], [has_type],
+ [const b4_symbol([$1], [type])& v]),
+ b4_locations_if([const location_type& l])));
+
+])])])
+
+
+# b4_symbol_constructor_declare
+# -----------------------------
+# Declare symbol constructors for all the value types.
+# Use at class-level.
+m4_define([b4_symbol_constructor_declare],
+[ // Symbol constructors declarations.
+b4_symbol_foreach([b4_symbol_constructor_declare_])])
+
+
+
+# b4_symbol_constructor_define_(SYMBOL-NUMBER)
+# --------------------------------------------
+# Define symbol constructor for this SYMBOL-NUMBER.
+m4_define([b4_symbol_constructor_define_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
+[ b4_parser_class_name::symbol_type
+ b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
+b4_join(b4_symbol_if([$1], [has_type],
+ [const b4_symbol([$1], [type])& v]),
+ b4_locations_if([const location_type& l])))
+ {
+ return symbol_type (b4_join([token::b4_symbol([$1], [id])],
+ b4_symbol_if([$1], [has_type], [v]),
+ b4_locations_if([l])));
+
+ }
+
+])])])
+
+
+# b4_basic_symbol_constructor_declare
+# ----------------------------------
+# Generate a constructor declaration for basic_symbol from given type.
+m4_define([b4_basic_symbol_constructor_declare],
+[[
+ basic_symbol (]b4_join(
+ [typename Base::kind_type t],
+ b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
+ b4_locations_if([const location_type& l]))[);
+]])
+
+# b4_basic_symbol_constructor_define
+# ----------------------------------
+# Generate a constructor implementation for basic_symbol from given type.
+m4_define([b4_basic_symbol_constructor_define],
+[[
+ template <typename Base>
+ ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
+ [typename Base::kind_type t],
+ b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
+ b4_locations_if([const location_type& l]))[)
+ : Base (t)
+ , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
+ , location (l)])[
+ {}
+]])
+
+# b4_symbol_constructor_define
+# ----------------------------
+# Define the overloaded versions of make_symbol for all the value types.
+m4_define([b4_symbol_constructor_define],
+[ // Implementation of make_symbol for each symbol type.
+b4_symbol_foreach([b4_symbol_constructor_define_])])
projects / bison.git / blobdiff