Upgrade win_flex/win_bison to 2.5.5 (bison 3.0)
[mirror/qt/qt5.git] / gnuwin32 / bin / 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_value_type_declare
248 # ---------------------
249 # Declare semantic_type.
250 m4_define([b4_value_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_])])