Regen.

[bison.git] / data / variant.hh

diff --git a/data/variant.hh b/data/variant.hh
index 893673383d8fe741f7c0960462a710818da1809e..14884ecb8fc7cbfb5da85d917efcdd4722159a8f 100644 (file)
--- a/data/variant.hh
+++ b/data/variant.hh
@@ -75,10 +75,10 @@ m4_map([b4_char_sizeof_], [$@])dnl
 ])])
 
 
 ])])
 
 

-# b4_variant_definition
-# ---------------------
+# b4_variant_define
+# -----------------

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

-m4_define([b4_variant_definition],
+m4_define([b4_variant_define],

 [[
   /// A char[S] buffer to store and retrieve objects.
   ///
 [[
   /// A char[S] buffer to store and retrieve objects.
   ///


@@ -87,13 +87,13 @@ m4_define([b4_variant_definition],
   /// via the current state.
   template <size_t S>
   struct variant
   /// via the current state.
   template <size_t S>
   struct variant

-  {]b4_assert_if([
+  {]b4_parse_assert_if([

     /// Whether something is contained.
     bool built;
 ])[
     /// Empty construction.
     inline
     /// Whether something is contained.
     bool built;
 ])[
     /// Empty construction.
     inline

-    variant ()]b4_assert_if([
+    variant ()]b4_parse_assert_if([

       : built (false)])[
     {}
 
       : built (false)])[
     {}
 


@@ -101,7 +101,7 @@ m4_define([b4_variant_definition],
     template <typename T>
     inline T&
     build ()
     template <typename T>
     inline T&
     build ()

-    {]b4_assert_if([
+    {]b4_parse_assert_if([

       assert (!built);
       built = true;])[
       return *new (buffer.raw) T;
       assert (!built);
       built = true;])[
       return *new (buffer.raw) T;


@@ -111,7 +111,7 @@ m4_define([b4_variant_definition],
     template <typename T>
     inline T&
     build (const T& t)
     template <typename T>
     inline T&
     build (const T& t)

-    {]b4_assert_if([
+    {]b4_parse_assert_if([

       assert(!built);
       built = true;])[
       return *new (buffer.raw) T(t);
       assert(!built);
       built = true;])[
       return *new (buffer.raw) T(t);


@@ -120,7 +120,7 @@ m4_define([b4_variant_definition],
     /// Construct and fill.
     template <typename T>
     inline
     /// Construct and fill.
     template <typename T>
     inline

-    variant (const T& t)]b4_assert_if([
+    variant (const T& t)]b4_parse_assert_if([

       : built (true)])[
     {
       new (buffer.raw) T(t);
       : built (true)])[
     {
       new (buffer.raw) T(t);


@@ -130,7 +130,7 @@ m4_define([b4_variant_definition],
     template <typename T>
     inline T&
     as ()
     template <typename T>
     inline T&
     as ()

-    {]b4_assert_if([
+    {]b4_parse_assert_if([

       assert (built);])[
       return reinterpret_cast<T&>(buffer.raw);
     }
       assert (built);])[
       return reinterpret_cast<T&>(buffer.raw);
     }


@@ -139,7 +139,7 @@ m4_define([b4_variant_definition],
     template <typename T>
     inline const T&
     as () const
     template <typename T>
     inline const T&
     as () const

-    {]b4_assert_if([
+    {]b4_parse_assert_if([

       assert(built);])[
       return reinterpret_cast<const T&>(buffer.raw);
     }
       assert(built);])[
       return reinterpret_cast<const T&>(buffer.raw);
     }


@@ -168,7 +168,7 @@ m4_define([b4_variant_definition],
     inline void
     destroy ()
     {
     inline void
     destroy ()
     {

-      as<T>().~T();]b4_assert_if([
+      as<T>().~T();]b4_parse_assert_if([

       built = false;])[
     }
 
       built = false;])[
     }
 


@@ -189,6 +189,18 @@ 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;])
+
+

 # 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 +217,62 @@ 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_args(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_args(b4_symbol_if([$1], [has_type],
+                     [const b4_symbol([$1], [type])& v]),
+        b4_locations_if([const location_type& l])))
+  {
+    return symbol_type (b4_args([yytranslate_ (token::b4_symbol([$1], [id]))],
+                                b4_symbol_if([$1], [has_type], [v]),
+                                b4_locations_if([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_])])