# The needed includes for variants support.
m4_define([b4_variant_includes],
[b4_parse_assert_if([[#include <typeinfo>]])[
-#include <cstdlib> // abort
#ifndef YYASSERT
# include <cassert>
# define YYASSERT assert
typedef variant<S> self_type;
/// Empty construction.
- inline
variant ()]b4_parse_assert_if([
- : built (false)
- , tname (YY_NULL)])[
+ : tname (YY_NULL)])[
{}
- /// Instantiate a \a T in here.
+ /// Construct and fill.
+ template <typename 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>
- inline T&
+ T&
build ()
{]b4_parse_assert_if([
- //YYASSERT (!built);
- //YYASSERT (!tname);
+ YYASSERT (!tname);
YYASSERT (sizeof (T) <= S);
- built = true;
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_parse_assert_if([
- //YYASSERT (!built);
- //YYASSERT (!tname);
+ YYASSERT (!tname);
YYASSERT (sizeof (T) <= S);
- built = true;
tname = typeid (T).name ();])[
return *new (buffer.raw) T (t);
}
- /// Construct and fill.
- template <typename T>
- inline
- variant (const T& t)]b4_parse_assert_if([
- : built (true)
- , tname (typeid (T).name ())])[
- {
- YYASSERT (sizeof (T) <= S);
- new (buffer.raw) T (t);
- }
-
/// Accessor to a built \a T.
template <typename T>
- inline T&
+ T&
as ()
{]b4_parse_assert_if([
- YYASSERT (built);
YYASSERT (tname == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
- return reinterpret_cast<T&> (buffer.raw);
+ {
+ void *dummy = buffer.raw;
+ return *static_cast<T*> (dummy);
+ }
}
/// Const accessor to a built \a T (for %printer).
template <typename T>
- inline const T&
+ const T&
as () const
{]b4_parse_assert_if([
- YYASSERT (built);
YYASSERT (tname == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
- return reinterpret_cast<const T&> (buffer.raw);
+ {
+ const void *dummy = buffer.raw;
+ return *static_cast<const T*> (dummy);
+ }
}
/// 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
+ /// 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 (built);
- YYASSERT (other.built);
+ 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
- move (variant<S>& other)
+ void
+ move (self_type& other)
{]b4_parse_assert_if([
- YYASSERT (! built);])[
+ YYASSERT (!tname);])[
build<T>();
swap<T>(other);
other.destroy<T>();
}
/// Copy the content of \a other to this.
- /// Destroys \a other.
template <typename T>
- inline void
- copy (const variant<S>& other)
+ 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_parse_assert_if([
- built = false;
tname = YY_NULL;])[
}
+ private:
/// Prohibit blind copies.
- private:
- self_type& operator=(const self_type&)
- {
- abort ();
- }
-
- variant (const self_type&)
- {
- abort ();
- }
+ self_type& operator=(const self_type&);
+ variant (const self_type&);
- private:
/// 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;]b4_parse_assert_if([
- /// Whether something is contained.
- bool built;
- /// If defined, the name of the stored type.
- const char* tname;])[
+
+ /// Whether the content is built: if defined, the name of the stored type.
+ const char *tname;])[
};
]])
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.
projects / bison.git / blobdiff