api.token.prefix: use code values

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index 5ff0c54da82a0cce588ce90885d5b43591d8c756..ac4f7a78507c49250d12dc789e0acf70ec61ff70 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -26,7 +26,7 @@
 # YYTYPE.
 m4_define([b4_symbol_variant],
 [m4_pushdef([b4_dollar_dollar],
 # 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
   switch ($1)
     {
 b4_type_foreach([b4_type_action_])[]dnl


@@ -63,7 +63,7 @@ m4_define([b4_char_sizeof],
 [b4_symbol_if([$1], [has_type],
 [
 m4_map([      b4_symbol_tag_comment], [$@])dnl
 [b4_symbol_if([$1], [has_type],
 [
 m4_map([      b4_symbol_tag_comment], [$@])dnl

-      char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
+      char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@};

 ])])
 
 
 ])])
 
 


@@ -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>]])[
 # 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
 #ifndef YYASSERT
 # include <cassert>
 # define YYASSERT assert


@@ -95,144 +94,147 @@ m4_define([b4_variant_define],
     typedef variant<S> self_type;
 
     /// Empty construction.
     typedef variant<S> self_type;
 
     /// Empty construction.

-    inline

     variant ()]b4_parse_assert_if([
     variant ()]b4_parse_assert_if([

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

     {}
 
     {}
 

-    /// Instantiate a \a T in here.
+    /// Construct and fill.

     template <typename T>
     template <typename T>

-    inline T&
-    build ()
-    {]b4_parse_assert_if([
-      //YYASSERT (!built);
-      //YYASSERT (!tname);
+    variant (const T& t)]b4_parse_assert_if([
+      : yytname_ (typeid (T).name ())])[
+    {

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

-      built = true;
-      tname = typeid (T).name ();])[
-      return *new (buffer.raw) T;
+      new (yyas_<T> ()) T (t);

     }
 
     }
 

-    /// Instantiate a \a T in here from \a t.
+    /// Destruction, allowed only if empty.
+    ~variant ()
+    {]b4_parse_assert_if([
+      YYASSERT (!yytname_);
+    ])[}
+
+    /// Instantiate an empty \a T in here.

     template <typename T>
     template <typename T>

-    inline T&
-    build (const T& t)
+    T&
+    build ()

     {]b4_parse_assert_if([
     {]b4_parse_assert_if([

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

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

-      built = true;
-      tname = typeid (T).name ();])[
-      return *new (buffer.raw) T (t);
+      yytname_ = typeid (T).name ();])[
+      return *new (yyas_<T> ()) T;

     }
 
     }
 

-    /// Construct and fill.
+    /// Instantiate a \a T in here from \a t.

     template <typename T>
     template <typename T>

-    inline
-    variant (const T& t)]b4_parse_assert_if([
-      : built (true)
-      , tname (typeid (T).name ())])[
-    {
+    T&
+    build (const T& t)
+    {]b4_parse_assert_if([
+      YYASSERT (!yytname_);

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

-      new (buffer.raw) T (t);
+      yytname_ = typeid (T).name ();])[
+      return *new (yyas_<T> ()) T (t);

     }
 
     /// Accessor to a built \a T.
     template <typename T>
     }
 
     /// Accessor to a built \a T.
     template <typename T>

-    inline T&
+    T&

     as ()
     {]b4_parse_assert_if([
     as ()
     {]b4_parse_assert_if([

-      YYASSERT (built);
-      YYASSERT (tname == typeid (T).name ());
+      YYASSERT (yytname_ == typeid (T).name ());

       YYASSERT (sizeof (T) <= S);])[
       YYASSERT (sizeof (T) <= S);])[

-      return reinterpret_cast<T&> (buffer.raw);
+      return *yyas_<T> ();

     }
 
     /// Const accessor to a built \a T (for %printer).
     template <typename T>
     }
 
     /// Const accessor to a built \a T (for %printer).
     template <typename T>

-    inline const T&
+    const T&

     as () const
     {]b4_parse_assert_if([
     as () const
     {]b4_parse_assert_if([

-      YYASSERT (built);
-      YYASSERT (tname == typeid (T).name ());
+      YYASSERT (yytname_ == typeid (T).name ());

       YYASSERT (sizeof (T) <= S);])[
       YYASSERT (sizeof (T) <= S);])[

-      return reinterpret_cast<const T&> (buffer.raw);
+      return *yyas_<T> ();

     }
 
     /// Swap the content with \a other, of same type.
     }
 
     /// 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.
     /// 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>
     /// variant::move ().
     template <typename T>

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

     {]b4_parse_assert_if([
     {]b4_parse_assert_if([

-      YYASSERT (built);
-      YYASSERT (other.built);
-      YYASSERT (tname == other.tname);])[
-      std::swap (as<T>(), other.as<T>());
+      YYASSERT (yytname_);
+      YYASSERT (yytname_ == other.yytname_);])[
+      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>
     /// Destroys \a other.
     template <typename T>

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

     {]b4_parse_assert_if([
     {]b4_parse_assert_if([

-      YYASSERT (! built);])[
-      build<T>();
-      swap<T>(other);
-      other.destroy<T>();
+      YYASSERT (!yytname_);])[
+      build<T> ();
+      swap<T> (other);
+      other.destroy<T> ();

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

-    /// Destroys \a other.

     template <typename T>
     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>
     {
       build<T> (other.as<T> ());
     }
 
     /// Destroy the stored \a T.
     template <typename T>

-    inline void
+    void

     destroy ()
     {
       as<T> ().~T ();]b4_parse_assert_if([
     destroy ()
     {
       as<T> ().~T ();]b4_parse_assert_if([

-      built = false;
-      tname = YY_NULL;])[
+      yytname_ = YY_NULL;])[

     }
 
     }
 

+  private:

     /// Prohibit blind copies.
     /// 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*
+    yyas_ ()

     {
     {

-      abort ();
-    }
+      void *yyp = yybuffer_.yyraw;
+      return static_cast<T*> (yyp);
+     }

 
 

-    variant (const self_type&)
+    /// Const accessor to raw memory as \a T.
+    template <typename T>
+    const T*
+    yyas_ () const

     {
     {

-      abort ();
-    }
+      const void *yyp = yybuffer_.yyraw;
+      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.

     union
     {
     union
     {

-      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;])[
+      /// Strongest alignment constraints.
+      long double yyalign_me;
+      /// A buffer large enough to store any of the semantic values.
+      char yyraw[S];
+    } yybuffer_;]b4_parse_assert_if([
+
+    /// Whether the content is built: if defined, the name of the stored type.
+    const char *yytname_;])[

   };
 ]])
 
   };
 ]])
 


@@ -242,16 +244,16 @@ m4_define([b4_variant_define],
 ## -------------------------- ##
 
 
 ## -------------------------- ##
 
 

-# b4_semantic_type_declare
-# ------------------------
+# b4_value_type_declare
+# ---------------------

 # Declare semantic_type.
 # Declare semantic_type.

-m4_define([b4_semantic_type_declare],
-[    /// An auxiliary type to compute the largest semantic type.
+m4_define([b4_value_type_declare],
+[[    /// An auxiliary type to compute the largest semantic type.

     union union_type
     {]b4_type_foreach([b4_char_sizeof])[};
 
     /// Symbol semantic values.
     union union_type
     {]b4_type_foreach([b4_char_sizeof])[};
 
     /// Symbol semantic values.

-    typedef variant<sizeof(union_type)> semantic_type;dnl
+    typedef variant<sizeof(union_type)> semantic_type;][]dnl

 ])
 
 
 ])
 
 


@@ -261,7 +263,7 @@ m4_define([b4_semantic_type_declare],
 # ----------------------------
 m4_define([b4_symbol_value],
 [m4_ifval([$2],
 # ----------------------------
 m4_define([b4_symbol_value],
 [m4_ifval([$2],

-          [$1.as< $2 >()],
+          [$1.as< $2 > ()],

           [$1])])
 
 # b4_symbol_value_template(VAL, [TYPE])
           [$1])])
 
 # b4_symbol_value_template(VAL, [TYPE])


@@ -269,7 +271,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],
 # 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])])
 
 
           [$1])])
 
 


@@ -319,11 +321,39 @@ b4_join(b4_symbol_if([$1], [has_type],
     return symbol_type (b4_join([token::b4_symbol([$1], [id])],
                                 b4_symbol_if([$1], [has_type], [v]),
                                 b4_locations_if([l])));
     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.
 # b4_symbol_constructor_define
 # ----------------------------
 # Define the overloaded versions of make_symbol for all the value types.