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       : yytname_ (YY_NULL)])[
  99     {}
 100
 101     /// Construct and fill.
 102     template <typename T>
 103     variant (const T& t)]b4_parse_assert_if([
 104       : yytname_ (typeid (T).name ())])[
 105     {
 106       YYASSERT (sizeof (T) <= S);
 107       new (yyas_<T> ()) T (t);
 108     }
 109
 110     /// Destruction, allowed only if empty.
 111     ~variant ()
 112     {]b4_parse_assert_if([
 113       YYASSERT (!yytname_);
 114     ])[}
 115
 116     /// Instantiate an empty \a T in here.
 117     template <typename T>
 118     T&
 119     build ()
 120     {]b4_parse_assert_if([
 121       YYASSERT (!yytname_);
 122       YYASSERT (sizeof (T) <= S);
 123       yytname_ = typeid (T).name ();])[
 124       return *new (yyas_<T> ()) T;
 125     }
 126
 127     /// Instantiate a \a T in here from \a t.
 128     template <typename T>
 129     T&
 130     build (const T& t)
 131     {]b4_parse_assert_if([
 132       YYASSERT (!yytname_);
 133       YYASSERT (sizeof (T) <= S);
 134       yytname_ = typeid (T).name ();])[
 135       return *new (yyas_<T> ()) T (t);
 136     }
 137
 138     /// Accessor to a built \a T.
 139     template <typename T>
 140     T&
 141     as ()
 142     {]b4_parse_assert_if([
 143       YYASSERT (yytname_ == typeid (T).name ());
 144       YYASSERT (sizeof (T) <= S);])[
 145       return *yyas_<T> ();
 146     }
 147
 148     /// Const accessor to a built \a T (for %printer).
 149     template <typename T>
 150     const T&
 151     as () const
 152     {]b4_parse_assert_if([
 153       YYASSERT (yytname_ == typeid (T).name ());
 154       YYASSERT (sizeof (T) <= S);])[
 155       return *yyas_<T> ();
 156     }
 157
 158     /// Swap the content with \a other, of same type.
 159     ///
 160     /// Both variants must be built beforehand, because swapping the actual
 161     /// data requires reading it (with as()), and this is not possible on
 162     /// unconstructed variants: it would require some dynamic testing, which
 163     /// should not be the variant's responsability.
 164     /// Swapping between built and (possibly) non-built is done with
 165     /// variant::move ().
 166     template <typename T>
 167     void
 168     swap (self_type& other)
 169     {]b4_parse_assert_if([
 170       YYASSERT (yytname_);
 171       YYASSERT (yytname_ == other.yytname_);])[
 172       std::swap (as<T> (), other.as<T> ());
 173     }
 174
 175     /// Move the content of \a other to this.
 176     ///
 177     /// Destroys \a other.
 178     template <typename T>
 179     void
 180     move (self_type& other)
 181     {]b4_parse_assert_if([
 182       YYASSERT (!yytname_);])[
 183       build<T> ();
 184       swap<T> (other);
 185       other.destroy<T> ();
 186     }
 187
 188     /// Copy the content of \a other to this.
 189     template <typename T>
 190     void
 191     copy (const self_type& other)
 192     {
 193       build<T> (other.as<T> ());
 194     }
 195
 196     /// Destroy the stored \a T.
 197     template <typename T>
 198     void
 199     destroy ()
 200     {
 201       as<T> ().~T ();]b4_parse_assert_if([
 202       yytname_ = YY_NULL;])[
 203     }
 204
 205   private:
 206     /// Prohibit blind copies.
 207     self_type& operator=(const self_type&);
 208     variant (const self_type&);
 209
 210     /// Accessor to raw memory as \a T.
 211     template <typename T>
 212     T*
 213     yyas_ ()
 214     {
 215       void *yyp = yybuffer_.yyraw;
 216       return static_cast<T*> (yyp);
 217      }
 218
 219     /// Const accessor to raw memory as \a T.
 220     template <typename T>
 221     const T*
 222     yyas_ () const
 223     {
 224       const void *yyp = yybuffer_.yyraw;
 225       return static_cast<const T*> (yyp);
 226      }
 227
 228     union
 229     {
 230       /// Strongest alignment constraints.
 231       long double yyalign_me;
 232       /// A buffer large enough to store any of the semantic values.
 233       char yyraw[S];
 234     } yybuffer_;]b4_parse_assert_if([
 235
 236     /// Whether the content is built: if defined, the name of the stored type.
 237     const char *yytname_;])[
 238   };
 239 ]])
 240
 241
 242 ## -------------------------- ##
 243 ## Adjustments for variants.  ##
 244 ## -------------------------- ##
 245
 246
 247 # b4_semantic_type_declare
 248 # ------------------------
 249 # Declare semantic_type.
 250 m4_define([b4_semantic_type_declare],
 251 [    /// An auxiliary type to compute the largest semantic type.
 252     union union_type
 253     {]b4_type_foreach([b4_char_sizeof])[};
 254
 255     /// Symbol semantic values.
 256     typedef variant<sizeof(union_type)> semantic_type;dnl
 257 ])
 258
 259
 260 # How the semantic value is extracted when using variants.
 261
 262 # b4_symbol_value(VAL, [TYPE])
 263 # ----------------------------
 264 m4_define([b4_symbol_value],
 265 [m4_ifval([$2],
 266           [$1.as< $2 > ()],
 267           [$1])])
 268
 269 # b4_symbol_value_template(VAL, [TYPE])
 270 # -------------------------------------
 271 # Same as b4_symbol_value, but used in a template method.
 272 m4_define([b4_symbol_value_template],
 273 [m4_ifval([$2],
 274           [$1.template as< $2 > ()],
 275           [$1])])
 276
 277
 278
 279 ## ------------- ##
 280 ## make_SYMBOL.  ##
 281 ## ------------- ##
 282
 283
 284 # b4_symbol_constructor_declare_(SYMBOL-NUMBER)
 285 # ---------------------------------------------
 286 # Declare the overloaded version of make_symbol for the (common) type of
 287 # these SYMBOL-NUMBERS.  Use at class-level.
 288 m4_define([b4_symbol_constructor_declare_],
 289 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
 290 [    static inline
 291     symbol_type
 292     make_[]b4_symbol_([$1], [id]) (dnl
 293 b4_join(b4_symbol_if([$1], [has_type],
 294                      [const b4_symbol([$1], [type])& v]),
 295         b4_locations_if([const location_type& l])));
 296
 297 ])])])
 298
 299
 300 # b4_symbol_constructor_declare
 301 # -----------------------------
 302 # Declare symbol constructors for all the value types.
 303 # Use at class-level.
 304 m4_define([b4_symbol_constructor_declare],
 305 [    // Symbol constructors declarations.
 306 b4_symbol_foreach([b4_symbol_constructor_declare_])])
 307
 308
 309
 310 # b4_symbol_constructor_define_(SYMBOL-NUMBER)
 311 # --------------------------------------------
 312 # Define symbol constructor for this SYMBOL-NUMBER.
 313 m4_define([b4_symbol_constructor_define_],
 314 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
 315 [  b4_parser_class_name::symbol_type
 316   b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
 317 b4_join(b4_symbol_if([$1], [has_type],
 318                      [const b4_symbol([$1], [type])& v]),
 319         b4_locations_if([const location_type& l])))
 320   {
 321     return symbol_type (b4_join([token::b4_symbol([$1], [id])],
 322                                 b4_symbol_if([$1], [has_type], [v]),
 323                                 b4_locations_if([l])));
 324
 325   }
 326
 327 ])])])
 328
 329
 330 # b4_basic_symbol_constructor_declare
 331 # ----------------------------------
 332 # Generate a constructor declaration for basic_symbol from given type.
 333 m4_define([b4_basic_symbol_constructor_declare],
 334 [[
 335   basic_symbol (]b4_join(
 336           [typename Base::kind_type t],
 337           b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
 338           b4_locations_if([const location_type& l]))[);
 339 ]])
 340
 341 # b4_basic_symbol_constructor_define
 342 # ----------------------------------
 343 # Generate a constructor implementation for basic_symbol from given type.
 344 m4_define([b4_basic_symbol_constructor_define],
 345 [[
 346   template <typename Base>
 347   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
 348           [typename Base::kind_type t],
 349           b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
 350           b4_locations_if([const location_type& l]))[)
 351     : Base (t)
 352     , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
 353     , location (l)])[
 354   {}
 355 ]])
 356
 357 # b4_symbol_constructor_define
 358 # ----------------------------
 359 # Define the overloaded versions of make_symbol for all the value types.
 360 m4_define([b4_symbol_constructor_define],
 361 [  // Implementation of make_symbol for each symbol type.
 362 b4_symbol_foreach([b4_symbol_constructor_define_])])