data/variant.hh

   1 # C++ skeleton for Bison
   2
   3 # Copyright (C) 2002-2013 Free Software Foundation, Inc.
   4
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 ## --------- ##
  20 ## variant.  ##
  21 ## --------- ##
  22
  23 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
  24 # ------------------------------------------------
  25 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
  26 # YYTYPE.
  27 m4_define([b4_symbol_variant],
  28 [m4_pushdef([b4_dollar_dollar],
  29             [$2.$3< $][3 >(m4_shift3($@))])dnl
  30   switch ($1)
  31     {
  32 b4_type_foreach([b4_type_action_])[]dnl
  33       default:
  34         break;
  35     }
  36 m4_popdef([b4_dollar_dollar])dnl
  37 ])
  38
  39
  40 # _b4_char_sizeof_counter
  41 # -----------------------
  42 # A counter used by _b4_char_sizeof_dummy to create fresh symbols.
  43 m4_define([_b4_char_sizeof_counter],
  44 [0])
  45
  46 # _b4_char_sizeof_dummy
  47 # ---------------------
  48 # At each call return a new C++ identifier.
  49 m4_define([_b4_char_sizeof_dummy],
  50 [m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
  51 dummy[]_b4_char_sizeof_counter])
  52
  53
  54 # b4_char_sizeof(SYMBOL-NUMS)
  55 # ---------------------------
  56 # To be mapped on the list of type names to produce:
  57 #
  58 #    char dummy1[sizeof(type_name_1)];
  59 #    char dummy2[sizeof(type_name_2)];
  60 #
  61 # for defined type names.
  62 m4_define([b4_char_sizeof],
  63 [b4_symbol_if([$1], [has_type],
  64 [
  65 m4_map([      b4_symbol_tag_comment], [$@])dnl
  66       char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
  67 ])])
  68
  69
  70 # b4_variant_includes
  71 # -------------------
  72 # The needed includes for variants support.
  73 m4_define([b4_variant_includes],
  74 [b4_parse_assert_if([[#include <typeinfo>]])[
  75 #ifndef YYASSERT
  76 # include <cassert>
  77 # define YYASSERT assert
  78 #endif
  79 ]])
  80
  81 # b4_variant_define
  82 # -----------------
  83 # Define "variant".
  84 m4_define([b4_variant_define],
  85 [[  /// A char[S] buffer to store and retrieve objects.
  86   ///
  87   /// Sort of a variant, but does not keep track of the nature
  88   /// of the stored data, since that knowledge is available
  89   /// via the current state.
  90   template <size_t S>
  91   struct variant
  92   {
  93     /// Type of *this.
  94     typedef variant<S> self_type;
  95
  96     /// Empty construction.
  97     variant ()]b4_parse_assert_if([
  98       : built (false)
  99       , tname (YY_NULL)])[
 100     {}
 101
 102     /// Construct and fill.
 103     template <typename T>
 104     variant (const T& t)]b4_parse_assert_if([
 105       : built (true)
 106       , tname (typeid (T).name ())])[
 107     {
 108       YYASSERT (sizeof (T) <= S);
 109       new (buffer.raw) T (t);
 110     }
 111
 112     /// Destruction, allowed only if empty.
 113     ~variant ()
 114     {]b4_parse_assert_if([
 115       YYASSERT (!built);
 116     ])[}
 117
 118     /// Instantiate an empty \a T in here.
 119     template <typename T>
 120     T&
 121     build ()
 122     {]b4_parse_assert_if([
 123       YYASSERT (!built);
 124       YYASSERT (!tname);
 125       YYASSERT (sizeof (T) <= S);
 126       built = true;
 127       tname = typeid (T).name ();])[
 128       return *new (buffer.raw) T;
 129     }
 130
 131     /// Instantiate a \a T in here from \a t.
 132     template <typename T>
 133     T&
 134     build (const T& t)
 135     {]b4_parse_assert_if([
 136       YYASSERT (!built);
 137       YYASSERT (!tname);
 138       YYASSERT (sizeof (T) <= S);
 139       built = true;
 140       tname = typeid (T).name ();])[
 141       return *new (buffer.raw) T (t);
 142     }
 143
 144     /// Accessor to a built \a T.
 145     template <typename T>
 146     T&
 147     as ()
 148     {]b4_parse_assert_if([
 149       YYASSERT (built);
 150       YYASSERT (tname == typeid (T).name ());
 151       YYASSERT (sizeof (T) <= S);])[
 152       return reinterpret_cast<T&> (buffer.raw);
 153     }
 154
 155     /// Const accessor to a built \a T (for %printer).
 156     template <typename T>
 157     const T&
 158     as () const
 159     {]b4_parse_assert_if([
 160       YYASSERT (built);
 161       YYASSERT (tname == typeid (T).name ());
 162       YYASSERT (sizeof (T) <= S);])[
 163       return reinterpret_cast<const T&> (buffer.raw);
 164     }
 165
 166     /// Swap the content with \a other, of same type.
 167     ///
 168     /// Both variants must be built beforehand, because swapping the actual
 169     /// data requires reading it (with as()), and this is not possible on
 170     /// unconstructed variants: it would require some dynamic testing, which
 171     /// should not be the variant's responsability.
 172     /// Swapping between built and (possibly) non-built is done with
 173     /// variant::move ().
 174     template <typename T>
 175     void
 176     swap (self_type& other)
 177     {]b4_parse_assert_if([
 178       YYASSERT (built);
 179       YYASSERT (other.built);
 180       YYASSERT (tname == other.tname);])[
 181       std::swap (as<T>(), other.as<T>());
 182     }
 183
 184     /// Move the content of \a other to this.
 185     ///
 186     /// Destroys \a other.
 187     template <typename T>
 188     void
 189     move (self_type& other)
 190     {]b4_parse_assert_if([
 191       YYASSERT (! built);])[
 192       build<T>();
 193       swap<T>(other);
 194       other.destroy<T>();
 195     }
 196
 197     /// Copy the content of \a other to this.
 198     template <typename T>
 199     void
 200     copy (const self_type& other)
 201     {
 202       build<T> (other.as<T> ());
 203     }
 204
 205     /// Destroy the stored \a T.
 206     template <typename T>
 207     void
 208     destroy ()
 209     {
 210       as<T> ().~T ();]b4_parse_assert_if([
 211       built = false;
 212       tname = YY_NULL;])[
 213     }
 214
 215   private:
 216     /// Prohibit blind copies.
 217     self_type& operator=(const self_type&);
 218     variant (const self_type&);
 219
 220     /// A buffer large enough to store any of the semantic values.
 221     /// Long double is chosen as it has the strongest alignment
 222     /// constraints.
 223     union
 224     {
 225       long double align_me;
 226       char raw[S];
 227     } buffer;]b4_parse_assert_if([
 228
 229     /// Whether the content is built.
 230     bool built;
 231     /// If defined, the name of the stored type.
 232     const char* tname;])[
 233   };
 234 ]])
 235
 236
 237 ## -------------------------- ##
 238 ## Adjustments for variants.  ##
 239 ## -------------------------- ##
 240
 241
 242 # b4_semantic_type_declare
 243 # ------------------------
 244 # Declare semantic_type.
 245 m4_define([b4_semantic_type_declare],
 246 [    /// An auxiliary type to compute the largest semantic type.
 247     union union_type
 248     {]b4_type_foreach([b4_char_sizeof])[};
 249
 250     /// Symbol semantic values.
 251     typedef variant<sizeof(union_type)> semantic_type;dnl
 252 ])
 253
 254
 255 # How the semantic value is extracted when using variants.
 256
 257 # b4_symbol_value(VAL, [TYPE])
 258 # ----------------------------
 259 m4_define([b4_symbol_value],
 260 [m4_ifval([$2],
 261           [$1.as< $2 >()],
 262           [$1])])
 263
 264 # b4_symbol_value_template(VAL, [TYPE])
 265 # -------------------------------------
 266 # Same as b4_symbol_value, but used in a template method.
 267 m4_define([b4_symbol_value_template],
 268 [m4_ifval([$2],
 269           [$1.template as< $2 >()],
 270           [$1])])
 271
 272
 273
 274 ## ------------- ##
 275 ## make_SYMBOL.  ##
 276 ## ------------- ##
 277
 278
 279 # b4_symbol_constructor_declare_(SYMBOL-NUMBER)
 280 # ---------------------------------------------
 281 # Declare the overloaded version of make_symbol for the (common) type of
 282 # these SYMBOL-NUMBERS.  Use at class-level.
 283 m4_define([b4_symbol_constructor_declare_],
 284 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
 285 [    static inline
 286     symbol_type
 287     make_[]b4_symbol_([$1], [id]) (dnl
 288 b4_join(b4_symbol_if([$1], [has_type],
 289                      [const b4_symbol([$1], [type])& v]),
 290         b4_locations_if([const location_type& l])));
 291
 292 ])])])
 293
 294
 295 # b4_symbol_constructor_declare
 296 # -----------------------------
 297 # Declare symbol constructors for all the value types.
 298 # Use at class-level.
 299 m4_define([b4_symbol_constructor_declare],
 300 [    // Symbol constructors declarations.
 301 b4_symbol_foreach([b4_symbol_constructor_declare_])])
 302
 303
 304
 305 # b4_symbol_constructor_define_(SYMBOL-NUMBER)
 306 # --------------------------------------------
 307 # Define symbol constructor for this SYMBOL-NUMBER.
 308 m4_define([b4_symbol_constructor_define_],
 309 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
 310 [  b4_parser_class_name::symbol_type
 311   b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
 312 b4_join(b4_symbol_if([$1], [has_type],
 313                      [const b4_symbol([$1], [type])& v]),
 314         b4_locations_if([const location_type& l])))
 315   {
 316     return symbol_type (b4_join([token::b4_symbol([$1], [id])],
 317                                 b4_symbol_if([$1], [has_type], [v]),
 318                                 b4_locations_if([l])));
 319
 320   }
 321
 322 ])])])
 323
 324
 325 # b4_basic_symbol_constructor_declare
 326 # ----------------------------------
 327 # Generate a constructor declaration for basic_symbol from given type.
 328 m4_define([b4_basic_symbol_constructor_declare],
 329 [[
 330   basic_symbol (]b4_join(
 331           [typename Base::kind_type t],
 332           b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
 333           b4_locations_if([const location_type& l]))[);
 334 ]])
 335
 336 # b4_basic_symbol_constructor_define
 337 # ----------------------------------
 338 # Generate a constructor implementation for basic_symbol from given type.
 339 m4_define([b4_basic_symbol_constructor_define],
 340 [[
 341   template <typename Base>
 342   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
 343           [typename Base::kind_type t],
 344           b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
 345           b4_locations_if([const location_type& l]))[)
 346     : Base (t)
 347     , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
 348     , location (l)])[
 349   {}
 350 ]])
 351
 352 # b4_symbol_constructor_define
 353 # ----------------------------
 354 # Define the overloaded versions of make_symbol for all the value types.
 355 m4_define([b4_symbol_constructor_define],
 356 [  // Implementation of make_symbol for each symbol type.
 357 b4_symbol_foreach([b4_symbol_constructor_define_])])