variants: prohibit simple copies

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index 65f0026e9ca174de2378446247af79fb4be6f7e1..454f360ad6be0e598437cbcd3af8d130567da98c 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -74,26 +74,38 @@ m4_map([b4_char_sizeof_], [$@])dnl
 ])])
 
 
 ])])
 
 

+# b4_variant_includes
+# -------------------
+# 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
+#endif
+]])
+

 # b4_variant_define
 # -----------------
 # Define "variant".
 m4_define([b4_variant_define],
 # b4_variant_define
 # -----------------
 # Define "variant".
 m4_define([b4_variant_define],

-[[
-  /// A char[S] buffer to store and retrieve objects.
+[[  /// 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
   ///
   /// 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_parse_assert_if([
-    /// Whether something is contained.
-    bool built;
-])[
+  {
+    /// Type of *this.
+    typedef variant<S> self_type;
+

     /// Empty construction.
     inline
     variant ()]b4_parse_assert_if([
     /// Empty construction.
     inline
     variant ()]b4_parse_assert_if([

-      : built (false)])[
+      : built (false)
+      , tname (YY_NULL)])[

     {}
 
     /// Instantiate a \a T in here.
     {}
 
     /// Instantiate a \a T in here.


@@ -101,8 +113,11 @@ m4_define([b4_variant_define],
     inline T&
     build ()
     {]b4_parse_assert_if([
     inline T&
     build ()
     {]b4_parse_assert_if([

-      assert (!built);
-      built = true;])[
+      YYASSERT (!built);
+      YYASSERT (!tname);
+      YYASSERT (sizeof (T) <= S);
+      built = true;
+      tname = typeid (T).name ();])[

       return *new (buffer.raw) T;
     }
 
       return *new (buffer.raw) T;
     }
 


@@ -111,18 +126,23 @@ m4_define([b4_variant_define],
     inline T&
     build (const T& t)
     {]b4_parse_assert_if([
     inline T&
     build (const T& t)
     {]b4_parse_assert_if([

-      assert(!built);
-      built = true;])[
-      return *new (buffer.raw) T(t);
+      YYASSERT (!built);
+      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([
     }
 
     /// Construct and fill.
     template <typename T>
     inline
     variant (const T& t)]b4_parse_assert_if([

-      : built (true)])[
+      : built (true)
+      , tname (typeid (T).name ())])[

     {
     {

-      new (buffer.raw) T(t);
+      YYASSERT (sizeof (T) <= S);
+      new (buffer.raw) T (t);

     }
 
     /// Accessor to a built \a T.
     }
 
     /// Accessor to a built \a T.


@@ -130,8 +150,10 @@ m4_define([b4_variant_define],
     inline T&
     as ()
     {]b4_parse_assert_if([
     inline T&
     as ()
     {]b4_parse_assert_if([

-      assert (built);])[
-      return reinterpret_cast<T&>(buffer.raw);
+      YYASSERT (built);
+      YYASSERT (tname == typeid (T).name ());
+      YYASSERT (sizeof (T) <= S);])[
+      return reinterpret_cast<T&> (buffer.raw);

     }
 
     /// Const accessor to a built \a T (for %printer).
     }
 
     /// Const accessor to a built \a T (for %printer).


@@ -139,16 +161,21 @@ m4_define([b4_variant_define],
     inline const T&
     as () const
     {]b4_parse_assert_if([
     inline const T&
     as () const
     {]b4_parse_assert_if([

-      assert(built);])[
-      return reinterpret_cast<const T&>(buffer.raw);
+      YYASSERT (built);
+      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.

     template <typename T>
     inline void
     swap (variant<S>& other)
     template <typename T>
     inline void
     swap (variant<S>& other)

-    {
-      std::swap (as<T>(), other.as<T>());
+    {]b4_parse_assert_if([
+      YYASSERT (tname == other.tname);])[
+      std::swap (as<T>(), other.as<T>());]b4_parse_assert_if([
+      std::swap (built, other.built);
+      std::swap (tname, other.tname);])[

     }
 
     /// Assign the content of \a other to this.
     }
 
     /// Assign the content of \a other to this.


@@ -162,15 +189,33 @@ m4_define([b4_variant_define],
       other.destroy<T>();
     }
 
       other.destroy<T>();
     }
 

+    /// Copy the content of \a other to this.
+    /// Destroys \a other.
+    template <typename T>
+    inline void
+    copy (const variant<S>& other)
+    {
+      build<T> (other.as<T> ());
+    }
+

     /// Destroy the stored \a T.
     template <typename T>
     inline void
     destroy ()
     {
     /// Destroy the stored \a T.
     template <typename T>
     inline void
     destroy ()
     {

-      as<T>().~T();]b4_parse_assert_if([
-      built = false;])[
+      as<T> ().~T ();]b4_parse_assert_if([
+      built = false;
+      tname = YY_NULL;])[
+    }
+
+    /// Prohibit blind copies.
+    //  private:
+    self_type& operator=(const self_type&)
+    {
+      abort ();

     }
 
     }
 

+  private:

     /// A buffer large enough to store any of the semantic values.
     /// Long double is chosen as it has the strongest alignment
     /// constraints.
     /// A buffer large enough to store any of the semantic values.
     /// Long double is chosen as it has the strongest alignment
     /// constraints.


@@ -178,7 +223,11 @@ m4_define([b4_variant_define],
     {
       long double align_me;
       char raw[S];
     {
       long double align_me;
       char raw[S];

-    } buffer;
+    } buffer;]b4_parse_assert_if([
+    /// Whether something is contained.
+    bool built;
+    /// If defined, the name of the stored type.
+    const char* tname;])[

   };
 ]])
 
   };
 ]])
 


@@ -197,7 +246,8 @@ m4_define([b4_semantic_type_declare],
     {]b4_type_foreach([b4_char_sizeof])[};
 
     /// Symbol semantic values.
     {]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.
 
 
 # How the semantic value is extracted when using variants.