c96cfeb6b5797a6117176da27154524dd70b5ff4
[bison.git] / 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 #include <cstdlib> // abort
76 #ifndef YYASSERT
77 # include <cassert>
78 # define YYASSERT assert
79 #endif
80 ]])
81
82 # b4_variant_define
83 # -----------------
84 # Define "variant".
85 m4_define([b4_variant_define],
86 [[ /// A char[S] buffer to store and retrieve objects.
87 ///
88 /// Sort of a variant, but does not keep track of the nature
89 /// of the stored data, since that knowledge is available
90 /// via the current state.
91 template <size_t S>
92 struct variant
93 {
94 /// Type of *this.
95 typedef variant<S> self_type;
96
97 /// Empty construction.
98 variant ()]b4_parse_assert_if([
99 : built (false)
100 , tname (YY_NULL)])[
101 {}
102
103 /// Instantiate a \a T in here.
104 template <typename T>
105 T&
106 build ()
107 {]b4_parse_assert_if([
108 //YYASSERT (!built);
109 //YYASSERT (!tname);
110 YYASSERT (sizeof (T) <= S);
111 built = true;
112 tname = typeid (T).name ();])[
113 return *new (buffer.raw) T;
114 }
115
116 /// Instantiate a \a T in here from \a t.
117 template <typename T>
118 T&
119 build (const T& t)
120 {]b4_parse_assert_if([
121 //YYASSERT (!built);
122 //YYASSERT (!tname);
123 YYASSERT (sizeof (T) <= S);
124 built = true;
125 tname = typeid (T).name ();])[
126 return *new (buffer.raw) T (t);
127 }
128
129 /// Construct and fill.
130 template <typename T>
131 variant (const T& t)]b4_parse_assert_if([
132 : built (true)
133 , tname (typeid (T).name ())])[
134 {
135 YYASSERT (sizeof (T) <= S);
136 new (buffer.raw) T (t);
137 }
138
139 /// Accessor to a built \a T.
140 template <typename T>
141 T&
142 as ()
143 {]b4_parse_assert_if([
144 YYASSERT (built);
145 YYASSERT (tname == typeid (T).name ());
146 YYASSERT (sizeof (T) <= S);])[
147 return reinterpret_cast<T&> (buffer.raw);
148 }
149
150 /// Const accessor to a built \a T (for %printer).
151 template <typename T>
152 const T&
153 as () const
154 {]b4_parse_assert_if([
155 YYASSERT (built);
156 YYASSERT (tname == typeid (T).name ());
157 YYASSERT (sizeof (T) <= S);])[
158 return reinterpret_cast<const T&> (buffer.raw);
159 }
160
161 /// Swap the content with \a other, of same type.
162 ///
163 /// Both variants must be built beforehand, because swapping the actual
164 /// data requires reading it (with as()), and this is not possible on
165 /// unconstructed variants: it would require some dynamic testing, which
166 /// should not be the variant's responsability.
167 /// Swapping between built and (possibly) non-built is done with
168 /// variant::move ().
169 template <typename T>
170 void
171 swap (variant<S>& other)
172 {]b4_parse_assert_if([
173 YYASSERT (built);
174 YYASSERT (other.built);
175 YYASSERT (tname == other.tname);])[
176 std::swap (as<T>(), other.as<T>());
177 }
178
179 /// Move the content of \a other to this.
180 ///
181 /// Destroys \a other.
182 template <typename T>
183 void
184 move (variant<S>& other)
185 {]b4_parse_assert_if([
186 YYASSERT (! built);])[
187 build<T>();
188 swap<T>(other);
189 other.destroy<T>();
190 }
191
192 /// Copy the content of \a other to this.
193 template <typename T>
194 void
195 copy (const variant<S>& other)
196 {
197 build<T> (other.as<T> ());
198 }
199
200 /// Destroy the stored \a T.
201 template <typename T>
202 void
203 destroy ()
204 {
205 as<T> ().~T ();]b4_parse_assert_if([
206 built = false;
207 tname = YY_NULL;])[
208 }
209
210 /// Prohibit blind copies.
211 private:
212 self_type& operator=(const self_type&)
213 {
214 abort ();
215 }
216
217 variant (const self_type&)
218 {
219 abort ();
220 }
221
222 private:
223 /// A buffer large enough to store any of the semantic values.
224 /// Long double is chosen as it has the strongest alignment
225 /// constraints.
226 union
227 {
228 long double align_me;
229 char raw[S];
230 } buffer;]b4_parse_assert_if([
231
232 /// Whether the content is built.
233 bool built;
234 /// If defined, the name of the stored type.
235 const char* tname;])[
236 };
237 ]])
238
239
240 ## -------------------------- ##
241 ## Adjustments for variants. ##
242 ## -------------------------- ##
243
244
245 # b4_semantic_type_declare
246 # ------------------------
247 # Declare semantic_type.
248 m4_define([b4_semantic_type_declare],
249 [ /// An auxiliary type to compute the largest semantic type.
250 union union_type
251 {]b4_type_foreach([b4_char_sizeof])[};
252
253 /// Symbol semantic values.
254 typedef variant<sizeof(union_type)> semantic_type;dnl
255 ])
256
257
258 # How the semantic value is extracted when using variants.
259
260 # b4_symbol_value(VAL, [TYPE])
261 # ----------------------------
262 m4_define([b4_symbol_value],
263 [m4_ifval([$2],
264 [$1.as< $2 >()],
265 [$1])])
266
267 # b4_symbol_value_template(VAL, [TYPE])
268 # -------------------------------------
269 # Same as b4_symbol_value, but used in a template method.
270 m4_define([b4_symbol_value_template],
271 [m4_ifval([$2],
272 [$1.template as< $2 >()],
273 [$1])])
274
275
276
277 ## ------------- ##
278 ## make_SYMBOL. ##
279 ## ------------- ##
280
281
282 # b4_symbol_constructor_declare_(SYMBOL-NUMBER)
283 # ---------------------------------------------
284 # Declare the overloaded version of make_symbol for the (common) type of
285 # these SYMBOL-NUMBERS. Use at class-level.
286 m4_define([b4_symbol_constructor_declare_],
287 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
288 [ static inline
289 symbol_type
290 make_[]b4_symbol_([$1], [id]) (dnl
291 b4_join(b4_symbol_if([$1], [has_type],
292 [const b4_symbol([$1], [type])& v]),
293 b4_locations_if([const location_type& l])));
294
295 ])])])
296
297
298 # b4_symbol_constructor_declare
299 # -----------------------------
300 # Declare symbol constructors for all the value types.
301 # Use at class-level.
302 m4_define([b4_symbol_constructor_declare],
303 [ // Symbol constructors declarations.
304 b4_symbol_foreach([b4_symbol_constructor_declare_])])
305
306
307
308 # b4_symbol_constructor_define_(SYMBOL-NUMBER)
309 # --------------------------------------------
310 # Define symbol constructor for this SYMBOL-NUMBER.
311 m4_define([b4_symbol_constructor_define_],
312 [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
313 [ b4_parser_class_name::symbol_type
314 b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
315 b4_join(b4_symbol_if([$1], [has_type],
316 [const b4_symbol([$1], [type])& v]),
317 b4_locations_if([const location_type& l])))
318 {
319 return symbol_type (b4_join([token::b4_symbol([$1], [id])],
320 b4_symbol_if([$1], [has_type], [v]),
321 b4_locations_if([l])));
322 }
323
324 ])])])
325
326
327 # b4_symbol_constructor_define
328 # ----------------------------
329 # Define the overloaded versions of make_symbol for all the value types.
330 m4_define([b4_symbol_constructor_define],
331 [ // Implementation of make_symbol for each symbol type.
332 b4_symbol_foreach([b4_symbol_constructor_define_])])