]> git.saurik.com Git - bison.git/blobdiff - data/variant.hh
style: space changes
[bison.git] / data / variant.hh
index bbae8cb9bebe2f0e2b9e3f3cba4e65b7ff42eeee..968d64964406e6a414f01ca52afce677c96598fb 100644 (file)
@@ -26,7 +26,7 @@
 # YYTYPE.
 m4_define([b4_symbol_variant],
 [m4_pushdef([b4_dollar_dollar],
-            [$2.$3< $][3 >(m4_shift3($@))])dnl
+            [$2.$3< $][3 > (m4_shift3($@))])dnl
   switch ($1)
     {
 b4_type_foreach([b4_type_action_])[]dnl
@@ -72,7 +72,6 @@ m4_map([      b4_symbol_tag_comment], [$@])dnl
 # 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
@@ -96,24 +95,22 @@ m4_define([b4_variant_define],
 
     /// Empty construction.
     variant ()]b4_parse_assert_if([
-      : built (false)
-      , tname (YY_NULL)])[
+      : tname (YY_NULL)])[
     {}
 
     /// Construct and fill.
     template <typename T>
     variant (const T& t)]b4_parse_assert_if([
-      : built (true)
-      , tname (typeid (T).name ())])[
+      : tname (typeid (T).name ())])[
     {
       YYASSERT (sizeof (T) <= S);
-      new (buffer.raw) T (t);
+      new (as_ <T> ()) T (t);
     }
 
     /// Destruction, allowed only if empty.
     ~variant ()
     {]b4_parse_assert_if([
-      YYASSERT (!built);
+      YYASSERT (!tname);
     ])[}
 
     /// Instantiate an empty \a T in here.
@@ -121,12 +118,10 @@ m4_define([b4_variant_define],
     T&
     build ()
     {]b4_parse_assert_if([
-      YYASSERT (!built);
       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);
-      built = true;
       tname = typeid (T).name ();])[
-      return *new (buffer.raw) T;
+      return *new (as_<T> ()) T;
     }
 
     /// Instantiate a \a T in here from \a t.
@@ -134,12 +129,10 @@ m4_define([b4_variant_define],
     T&
     build (const T& t)
     {]b4_parse_assert_if([
-      YYASSERT (!built);
       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);
-      built = true;
       tname = typeid (T).name ();])[
-      return *new (buffer.raw) T (t);
+      return *new (as_<T> ()) T (t);
     }
 
     /// Accessor to a built \a T.
@@ -147,10 +140,9 @@ m4_define([b4_variant_define],
     T&
     as ()
     {]b4_parse_assert_if([
-      YYASSERT (built);
       YYASSERT (tname == typeid (T).name ());
       YYASSERT (sizeof (T) <= S);])[
-      return reinterpret_cast<T&> (buffer.raw);
+      return *as_<T> ();
     }
 
     /// Const accessor to a built \a T (for %printer).
@@ -158,10 +150,9 @@ m4_define([b4_variant_define],
     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);
+      return *as_<T> ();
     }
 
     /// Swap the content with \a other, of same type.
@@ -174,12 +165,11 @@ m4_define([b4_variant_define],
     /// variant::move ().
     template <typename T>
     void
-    swap (variant<S>& other)
+    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>());
+      std::swap (as<T> (), other.as<T> ());
     }
 
     /// Move the content of \a other to this.
@@ -187,18 +177,18 @@ m4_define([b4_variant_define],
     /// Destroys \a other.
     template <typename T>
     void
-    move (variant<S>& other)
+    move (self_type& other)
     {]b4_parse_assert_if([
-      YYASSERT (! built);])[
-      build<T>();
-      swap<T>(other);
-      other.destroy<T>();
+      YYASSERT (!tname);])[
+      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)
+    copy (const self_type& other)
     {
       build<T> (other.as<T> ());
     }
@@ -209,23 +199,32 @@ m4_define([b4_variant_define],
     destroy ()
     {
       as<T> ().~T ();]b4_parse_assert_if([
-      built = false;
       tname = YY_NULL;])[
     }
 
+  private:
     /// Prohibit blind copies.
-    private:
-    self_type& operator=(const self_type&)
+    self_type& operator=(const self_type&);
+    variant (const self_type&);
+
+    /// Accessor to raw memory as \a T.
+    template <typename T>
+    T*
+    as_ ()
     {
-      abort ();
-    }
+      void *yyp = buffer.raw;
+      return static_cast<T*> (yyp);
+     }
 
-    variant (const self_type&)
+    /// Const accessor to raw memory as \a T.
+    template <typename T>
+    const T*
+    as_ () const
     {
-      abort ();
-    }
+      const void *yyp = buffer.raw;
+      return static_cast<const T*> (yyp);
+     }
 
-  private:
     /// A buffer large enough to store any of the semantic values.
     /// Long double is chosen as it has the strongest alignment
     /// constraints.
@@ -235,10 +234,8 @@ m4_define([b4_variant_define],
       char raw[S];
     } buffer;]b4_parse_assert_if([
 
-    /// Whether the content is built.
-    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;])[
   };
 ]])
 
@@ -267,7 +264,7 @@ m4_define([b4_semantic_type_declare],
 # ----------------------------
 m4_define([b4_symbol_value],
 [m4_ifval([$2],
-          [$1.as< $2 >()],
+          [$1.as< $2 > ()],
           [$1])])
 
 # b4_symbol_value_template(VAL, [TYPE])
@@ -275,7 +272,7 @@ m4_define([b4_symbol_value],
 # Same as b4_symbol_value, but used in a template method.
 m4_define([b4_symbol_value_template],
 [m4_ifval([$2],
-          [$1.template as< $2 >()],
+          [$1.template as< $2 > ()],
           [$1])])
 
 
@@ -320,16 +317,43 @@ 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])))
   {
-    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;
+    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
 # ----------------------------