c++: use more explicit types than int

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index 684f9e35bda0a64f9087ae58b074b08b231df78e..da0d2a394091a81a2136c38ed1eb8bf4832ebe23 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -1,6 +1,6 @@
 # C++ skeleton for Bison
 
-# Copyright (C) 2002-2012 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
@@ -51,13 +51,6 @@ m4_define([_b4_char_sizeof_dummy],
 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:
@@ -69,7 +62,7 @@ m4_define([b4_char_sizeof_],
 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])])@};
 ])])
 
@@ -101,15 +94,30 @@ m4_define([b4_variant_define],
     typedef variant<S> self_type;
 
     /// Empty construction.
-    inline
     variant ()]b4_parse_assert_if([
       : built (false)
       , tname (YY_NULL)])[
     {}
 
-    /// Instantiate a \a T in here.
+    /// Construct and fill.
+    template <typename T>
+    variant (const T& t)]b4_parse_assert_if([
+      : built (true)
+      , tname (typeid (T).name ())])[
+    {
+      YYASSERT (sizeof (T) <= S);
+      new (buffer.raw) T (t);
+    }
+
+    /// Destruction, allowed only if empty.
+    ~variant ()
+    {]b4_parse_assert_if([
+      YYASSERT (!built);
+    ])[}
+
+    /// Instantiate an empty \a T in here.
     template <typename T>
-    inline T&
+    T&
     build ()
     {]b4_parse_assert_if([
       YYASSERT (!built);
@@ -122,7 +130,7 @@ m4_define([b4_variant_define],
 
     /// 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);
@@ -133,20 +141,9 @@ m4_define([b4_variant_define],
       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);
@@ -157,7 +154,7 @@ m4_define([b4_variant_define],
 
     /// 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);
@@ -167,30 +164,47 @@ m4_define([b4_variant_define],
     }
 
     /// 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
+    void
     swap (variant<S>& other)
     {]b4_parse_assert_if([
+      YYASSERT (built);
+      YYASSERT (other.built);
       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);])[
+      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 (variant<S>& other)
+    {]b4_parse_assert_if([
+      YYASSERT (! built);])[
       build<T>();
       swap<T>(other);
       other.destroy<T>();
     }
 
+    /// Copy the content of \a other to this.
+    template <typename T>
+    void
+    copy (const variant<S>& 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([
@@ -199,6 +213,10 @@ m4_define([b4_variant_define],
     }
 
   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.
@@ -207,7 +225,8 @@ m4_define([b4_variant_define],
       long double align_me;
       char raw[S];
     } buffer;]b4_parse_assert_if([
-    /// Whether something is contained.
+
+    /// Whether the content is built.
     bool built;
     /// If defined, the name of the stored type.
     const char* tname;])[
@@ -292,14 +311,15 @@ m4_define([b4_symbol_constructor_define_],
   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])))
+        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])));
+    symbol_type res (token::]b4_symbol([$1], [id])[]b4_locations_if([, l])[);
+    ]b4_symbol_if([$1], [has_type], [res.value.build (v);])[
+    //    ]b4_locations_if([res.location = l;])[
+    return res;
   }
 
-])])])
+]])])])
 
 
 # b4_symbol_constructor_define