parser: use %empty

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index da0d2a394091a81a2136c38ed1eb8bf4832ebe23..91548d849b49e79cc6d0cef5d3c70d1d7916498d 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -95,15 +95,13 @@ m4_define([b4_variant_define],
 
     /// Empty construction.
     variant ()]b4_parse_assert_if([
 
     /// 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([
     {}
 
     /// 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);
     {
       YYASSERT (sizeof (T) <= S);
       new (buffer.raw) T (t);


@@ -112,7 +110,7 @@ m4_define([b4_variant_define],
     /// Destruction, allowed only if empty.
     ~variant ()
     {]b4_parse_assert_if([
     /// Destruction, allowed only if empty.
     ~variant ()
     {]b4_parse_assert_if([

-      YYASSERT (!built);
+      YYASSERT (!tname);

     ])[}
 
     /// Instantiate an empty \a T in here.
     ])[}
 
     /// Instantiate an empty \a T in here.


@@ -120,10 +118,8 @@ m4_define([b4_variant_define],
     T&
     build ()
     {]b4_parse_assert_if([
     T&
     build ()
     {]b4_parse_assert_if([

-      YYASSERT (!built);

       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);
       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);

-      built = true;

       tname = typeid (T).name ();])[
       return *new (buffer.raw) T;
     }
       tname = typeid (T).name ();])[
       return *new (buffer.raw) T;
     }


@@ -133,10 +129,8 @@ m4_define([b4_variant_define],
     T&
     build (const T& t)
     {]b4_parse_assert_if([
     T&
     build (const T& t)
     {]b4_parse_assert_if([

-      YYASSERT (!built);

       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);
       YYASSERT (!tname);
       YYASSERT (sizeof (T) <= S);

-      built = true;

       tname = typeid (T).name ();])[
       return *new (buffer.raw) T (t);
     }
       tname = typeid (T).name ();])[
       return *new (buffer.raw) T (t);
     }


@@ -146,10 +140,12 @@ m4_define([b4_variant_define],
     T&
     as ()
     {]b4_parse_assert_if([
     T&
     as ()
     {]b4_parse_assert_if([

-      YYASSERT (built);

       YYASSERT (tname == typeid (T).name ());
       YYASSERT (sizeof (T) <= S);])[
       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).
     }
 
     /// Const accessor to a built \a T (for %printer).


@@ -157,10 +153,12 @@ m4_define([b4_variant_define],
     const T&
     as () const
     {]b4_parse_assert_if([
     const T&
     as () const
     {]b4_parse_assert_if([

-      YYASSERT (built);

       YYASSERT (tname == typeid (T).name ());
       YYASSERT (sizeof (T) <= S);])[
       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.
     }
 
     /// Swap the content with \a other, of same type.


@@ -173,10 +171,9 @@ m4_define([b4_variant_define],
     /// variant::move ().
     template <typename T>
     void
     /// variant::move ().
     template <typename T>
     void

-    swap (variant<S>& other)
+    swap (self_type& other)

     {]b4_parse_assert_if([
     {]b4_parse_assert_if([

-      YYASSERT (built);
-      YYASSERT (other.built);
+      YYASSERT (tname);

       YYASSERT (tname == other.tname);])[
       std::swap (as<T>(), other.as<T>());
     }
       YYASSERT (tname == other.tname);])[
       std::swap (as<T>(), other.as<T>());
     }


@@ -186,9 +183,9 @@ m4_define([b4_variant_define],
     /// Destroys \a other.
     template <typename T>
     void
     /// Destroys \a other.
     template <typename T>
     void

-    move (variant<S>& other)
+    move (self_type& other)

     {]b4_parse_assert_if([
     {]b4_parse_assert_if([

-      YYASSERT (! built);])[
+      YYASSERT (!tname);])[

       build<T>();
       swap<T>(other);
       other.destroy<T>();
       build<T>();
       swap<T>(other);
       other.destroy<T>();


@@ -197,7 +194,7 @@ m4_define([b4_variant_define],
     /// Copy the content of \a other to this.
     template <typename T>
     void
     /// 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> ());
     }
     {
       build<T> (other.as<T> ());
     }


@@ -208,7 +205,6 @@ m4_define([b4_variant_define],
     destroy ()
     {
       as<T> ().~T ();]b4_parse_assert_if([
     destroy ()
     {
       as<T> ().~T ();]b4_parse_assert_if([

-      built = false;

       tname = YY_NULL;])[
     }
 
       tname = YY_NULL;])[
     }
 


@@ -226,10 +222,8 @@ m4_define([b4_variant_define],
       char raw[S];
     } buffer;]b4_parse_assert_if([
 
       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;])[

   };
 ]])
 
   };
 ]])
 


@@ -311,16 +305,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_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
 # ----------------------------
 
 # b4_symbol_constructor_define
 # ----------------------------