build: restore C90 compatibility

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index 893673383d8fe741f7c0960462a710818da1809e..91548d849b49e79cc6d0cef5d3c70d1d7916498d 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -1,7 +1,6 @@
 # C++ skeleton for Bison
 
 # C++ skeleton for Bison
 

-# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
-# 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
 
 # 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


@@ -52,13 +51,6 @@ m4_define([_b4_char_sizeof_dummy],
 dummy[]_b4_char_sizeof_counter])
 
 
 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:
 # b4_char_sizeof(SYMBOL-NUMS)
 # ---------------------------
 # To be mapped on the list of type names to produce:


@@ -70,108 +62,157 @@ m4_define([b4_char_sizeof_],
 m4_define([b4_char_sizeof],
 [b4_symbol_if([$1], [has_type],
 [
 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])])@};
 ])])
 
 
       char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
 ])])
 
 

-# b4_variant_definition
-# ---------------------
+# b4_variant_includes
+# -------------------
+# The needed includes for variants support.
+m4_define([b4_variant_includes],
+[b4_parse_assert_if([[#include <typeinfo>]])[
+#ifndef YYASSERT
+# include <cassert>
+# define YYASSERT assert
+#endif
+]])
+
+# b4_variant_define
+# -----------------

 # Define "variant".
 # Define "variant".

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

     /// Empty construction.
     /// Empty construction.

-    inline
-    variant ()]b4_assert_if([
-      : built (false)])[
+    variant ()]b4_parse_assert_if([
+      : tname (YY_NULL)])[

     {}
 
     {}
 

-    /// Instantiate a \a T in here.
+    /// Construct and fill.
+    template <typename T>
+    variant (const T& t)]b4_parse_assert_if([
+      : tname (typeid (T).name ())])[
+    {
+      YYASSERT (sizeof (T) <= S);
+      new (buffer.raw) T (t);
+    }
+
+    /// Destruction, allowed only if empty.
+    ~variant ()
+    {]b4_parse_assert_if([
+      YYASSERT (!tname);
+    ])[}
+
+    /// Instantiate an empty \a T in here.

     template <typename T>
     template <typename T>

-    inline T&
+    T&

     build ()
     build ()

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

       return *new (buffer.raw) T;
     }
 
     /// Instantiate a \a T in here from \a t.
     template <typename T>
       return *new (buffer.raw) T;
     }
 
     /// Instantiate a \a T in here from \a t.
     template <typename T>

-    inline T&
+    T&

     build (const T& t)
     build (const T& t)

-    {]b4_assert_if([
-      assert(!built);
-      built = true;])[
-      return *new (buffer.raw) T(t);
-    }
-
-    /// Construct and fill.
-    template <typename T>
-    inline
-    variant (const T& t)]b4_assert_if([
-      : built (true)])[
-    {
-      new (buffer.raw) T(t);
+    {]b4_parse_assert_if([
+      YYASSERT (!tname);
+      YYASSERT (sizeof (T) <= S);
+      tname = typeid (T).name ();])[
+      return *new (buffer.raw) T (t);

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

-    inline T&
+    T&

     as ()
     as ()

-    {]b4_assert_if([
-      assert (built);])[
-      return reinterpret_cast<T&>(buffer.raw);
+    {]b4_parse_assert_if([
+      YYASSERT (tname == typeid (T).name ());
+      YYASSERT (sizeof (T) <= S);])[
+      {
+        void *dummy = buffer.raw;
+        return *static_cast<T*> (dummy);
+      }

     }
 
     /// 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
     as () const

-    {]b4_assert_if([
-      assert(built);])[
-      return reinterpret_cast<const T&>(buffer.raw);
+    {]b4_parse_assert_if([
+      YYASSERT (tname == typeid (T).name ());
+      YYASSERT (sizeof (T) <= S);])[
+      {
+        const void *dummy = buffer.raw;
+        return *static_cast<const T*> (dummy);
+      }

     }
 
     }
 

-    /// Swap the content with \a other.
+    /// 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>
     template <typename T>

-    inline void
-    swap (variant<S>& other)
-    {
+    void
+    swap (self_type& other)
+    {]b4_parse_assert_if([
+      YYASSERT (tname);
+      YYASSERT (tname == other.tname);])[

       std::swap (as<T>(), other.as<T>());
     }
 
       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
-    build (variant<S>& other)
-    {
+    void
+    move (self_type& other)
+    {]b4_parse_assert_if([
+      YYASSERT (!tname);])[

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

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

     /// Destroy the stored \a T.
     template <typename T>
     /// Destroy the stored \a T.
     template <typename T>

-    inline void
+    void

     destroy ()
     {
     destroy ()
     {

-      as<T>().~T();]b4_assert_if([
-      built = false;])[
+      as<T> ().~T ();]b4_parse_assert_if([
+      tname = YY_NULL;])[

     }
 
     }
 

+  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.
     /// A buffer large enough to store any of the semantic values.
     /// Long double is chosen as it has the strongest alignment
     /// constraints.


@@ -179,7 +220,10 @@ m4_define([b4_variant_definition],
     {
       long double align_me;
       char raw[S];
     {
       long double align_me;
       char raw[S];

-    } buffer;
+    } buffer;]b4_parse_assert_if([
+
+    /// Whether the content is built: if defined, the name of the stored type.
+    const char *tname;])[

   };
 ]])
 
   };
 ]])
 


@@ -189,6 +233,19 @@ m4_define([b4_variant_definition],
 ## -------------------------- ##
 
 
 ## -------------------------- ##
 
 

+# b4_semantic_type_declare
+# ------------------------
+# Declare semantic_type.
+m4_define([b4_semantic_type_declare],
+[    /// An auxiliary type to compute the largest semantic type.
+    union union_type
+    {]b4_type_foreach([b4_char_sizeof])[};
+
+    /// Symbol semantic values.
+    typedef variant<sizeof(union_type)> semantic_type;dnl
+])
+
+

 # How the semantic value is extracted when using variants.
 
 # b4_symbol_value(VAL, [TYPE])
 # How the semantic value is extracted when using variants.
 
 # b4_symbol_value(VAL, [TYPE])


@@ -205,3 +262,90 @@ m4_define([b4_symbol_value_template],
 [m4_ifval([$2],
           [$1.template as< $2 >()],
           [$1])])
 [m4_ifval([$2],
           [$1.template as< $2 >()],
           [$1])])

+
+
+
+## ------------- ##
+## make_SYMBOL.  ##
+## ------------- ##
+
+
+# b4_symbol_constructor_declare_(SYMBOL-NUMBER)
+# ---------------------------------------------
+# Declare the overloaded version of make_symbol for the (common) type of
+# these SYMBOL-NUMBERS.  Use at class-level.
+m4_define([b4_symbol_constructor_declare_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
+[    static inline
+    symbol_type
+    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_symbol_constructor_declare
+# -----------------------------
+# Declare symbol constructors for all the value types.
+# Use at class-level.
+m4_define([b4_symbol_constructor_declare],
+[    // Symbol constructors declarations.
+b4_symbol_foreach([b4_symbol_constructor_declare_])])
+
+
+
+# b4_symbol_constructor_define_(SYMBOL-NUMBER)
+# --------------------------------------------
+# Define symbol constructor for this SYMBOL-NUMBER.
+m4_define([b4_symbol_constructor_define_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
+[  b4_parser_class_name::symbol_type
+  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])))
+  {
+    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.
+m4_define([b4_symbol_constructor_define],
+[  // Implementation of make_symbol for each symbol type.
+b4_symbol_foreach([b4_symbol_constructor_define_])])