Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/spirit/home/support/make_component.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children c530137014c0
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
1 /*=============================================================================
2 Copyright (c) 2001-2011 Joel de Guzman
3 http://spirit.sourceforge.net/
4
5 Distributed under the Boost Software License, Version 1.0. (See accompanying
6 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 =============================================================================*/
8 #ifndef BOOST_SPIRIT_MAKE_COMPONENT_OCTOBER_16_2008_1250PM
9 #define BOOST_SPIRIT_MAKE_COMPONENT_OCTOBER_16_2008_1250PM
10
11 #if defined(_MSC_VER)
12 #pragma once
13 #endif
14
15 #include <boost/spirit/include/phoenix_core.hpp>
16 #include <boost/proto/proto.hpp>
17 #include <boost/spirit/home/support/detail/make_cons.hpp>
18 #include <boost/spirit/home/support/modify.hpp>
19
20 namespace boost { namespace spirit
21 {
22 // There is no real "component" class. Each domain is responsible
23 // for creating its own components. You need to specialize this for
24 // each component in your domain. Use this as a guide.
25
26 template <typename Domain, typename Tag, typename Enable = void>
27 struct make_component
28 {
29 template <typename Sig>
30 struct result;
31
32 template <typename This, typename Elements, typename Modifiers>
33 struct result<This(Elements, Modifiers)>;
34
35 template <typename Elements, typename Modifiers>
36 typename result<make_component(Elements, Modifiers)>::type
37 operator()(Elements const& elements, Modifiers const& modifiers) const;
38 };
39
40 namespace tag
41 {
42 // Normally, we use proto tags as-is to distinguish operators.
43 // The special case is proto::tag::subscript. Spirit uses this
44 // as either sementic actions or directives. To distinguish between
45 // the two, we use these special tags below.
46
47 struct directive;
48 struct action;
49 }
50
51 template <typename Domain, typename T, typename Enable = void>
52 struct flatten_tree;
53 }}
54
55 namespace boost { namespace spirit { namespace detail
56 {
57 template <typename Expr, typename State, typename Data, typename Domain>
58 struct make_terminal_impl
59 : proto::transform_impl<Expr, State, Data>
60 {
61 typedef typename
62 proto::result_of::value<Expr>::type
63 value;
64
65 typedef typename result_of::make_cons<value>::type elements;
66
67 typedef
68 make_component<Domain, proto::tag::terminal>
69 make_component_;
70
71 typedef typename
72 make_component_::template
73 result<make_component_(elements, Data)>::type
74 result_type;
75
76 result_type operator()(
77 typename make_terminal_impl::expr_param expr
78 , typename make_terminal_impl::state_param /*state*/
79 , typename make_terminal_impl::data_param data
80 ) const
81 {
82 return typename make_terminal_impl::make_component_()(
83 detail::make_cons(proto::value(expr))
84 , data
85 );
86 }
87 };
88
89 template <typename Expr, typename State, typename Data, typename Domain>
90 struct make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
91 : proto::transform_impl<phoenix::actor<Expr>, State, Data>
92 {
93 typedef phoenix::actor<Expr> value;
94 typedef typename result_of::make_cons<value>::type elements;
95 typedef make_component<Domain, proto::tag::terminal> make_component_;
96
97 typedef typename
98 make_component_::template
99 result<make_component_(elements, Data)>::type
100 result_type;
101
102 result_type operator()(
103 typename make_terminal_impl::expr_param expr
104 , typename make_terminal_impl::state_param /*state*/
105 , typename make_terminal_impl::data_param data
106 ) const
107 {
108 return typename make_terminal_impl::make_component_()(
109 detail::make_cons(expr)
110 , data
111 );
112 }
113 };
114
115 template <typename Expr, typename State, typename Data, typename Domain>
116 struct make_terminal_impl<phoenix::actor<Expr> &, State, Data, Domain>
117 : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
118 {};
119
120 template <typename Expr, typename State, typename Data, typename Domain>
121 struct make_terminal_impl<phoenix::actor<Expr> const &, State, Data, Domain>
122 : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
123 {};
124
125 template <typename Domain>
126 struct make_terminal : proto::transform<make_terminal<Domain> >
127 {
128 template<typename Expr, typename State, typename Data>
129 struct impl : make_terminal_impl<Expr, State, Data, Domain> {};
130 };
131
132 template <typename Domain, typename Tag, typename Grammar>
133 struct make_unary : proto::transform<make_unary<Domain, Tag, Grammar> >
134 {
135 template<typename Expr, typename State, typename Data>
136 struct impl : proto::transform_impl<Expr, State, Data>
137 {
138 typedef typename
139 proto::result_of::child_c<Expr, 0>::type
140 child;
141
142 typedef typename Grammar::
143 template result<Grammar(child, State, Data)>::type
144 child_component;
145
146 typedef typename
147 result_of::make_cons<child_component>::type
148 elements;
149
150 typedef make_component<Domain, Tag> make_component_;
151
152 typedef typename
153 make_component_::template
154 result<make_component_(elements, Data)>::type
155 result_type;
156
157 result_type operator()(
158 typename impl::expr_param expr
159 , typename impl::state_param state
160 , typename impl::data_param data
161 ) const
162 {
163 return typename impl::make_component_()(
164 detail::make_cons(
165 Grammar()(proto::child(expr), state, data))
166 , data
167 );
168 }
169 };
170 };
171
172 // un-flattened version
173 template <typename Domain, typename Tag, typename Grammar,
174 bool flatten = flatten_tree<Domain, Tag>::value>
175 struct make_binary
176 {
177 template<typename Expr, typename State, typename Data>
178 struct impl : proto::transform_impl<Expr, State, Data>
179 {
180 typedef typename Grammar::
181 template result<Grammar(
182 typename proto::result_of::child_c<Expr, 0>::type
183 , State, Data)>::type
184 lhs_component;
185
186 typedef typename Grammar::
187 template result<Grammar(
188 typename proto::result_of::child_c<Expr, 1>::type
189 , State, Data)>::type
190 rhs_component;
191
192 typedef typename
193 result_of::make_cons<
194 lhs_component
195 , typename result_of::make_cons<rhs_component>::type
196 >::type
197 elements_type;
198
199 typedef make_component<Domain, Tag> make_component_;
200
201 typedef typename
202 make_component_::template
203 result<make_component_(elements_type, Data)>::type
204 result_type;
205
206 result_type operator()(
207 typename impl::expr_param expr
208 , typename impl::state_param state
209 , typename impl::data_param data
210 ) const
211 {
212 elements_type elements =
213 detail::make_cons(
214 Grammar()(
215 proto::child_c<0>(expr), state, data) // LHS
216 , detail::make_cons(
217 Grammar()(
218 proto::child_c<1>(expr), state, data) // RHS
219 )
220 );
221
222 return make_component_()(elements, data);
223 }
224 };
225 };
226
227 template <typename Grammar>
228 struct make_binary_helper : proto::transform<make_binary_helper<Grammar> >
229 {
230 template<typename Expr, typename State, typename Data>
231 struct impl : proto::transform_impl<Expr, State, Data>
232 {
233 typedef typename Grammar::
234 template result<Grammar(Expr, State, Data)>::type
235 lhs;
236
237 typedef typename result_of::make_cons<lhs, State>::type result_type;
238
239 result_type operator()(
240 typename impl::expr_param expr
241 , typename impl::state_param state
242 , typename impl::data_param data
243 ) const
244 {
245 return detail::make_cons(Grammar()(expr, state, data), state);
246 }
247 };
248 };
249
250 // Flattened version
251 template <typename Domain, typename Tag, typename Grammar>
252 struct make_binary<Domain, Tag, Grammar, true>
253 : proto::transform<make_binary<Domain, Tag, Grammar> >
254 {
255 template<typename Expr, typename State, typename Data>
256 struct impl : proto::transform_impl<Expr, State, Data>
257 {
258 typedef typename
259 proto::reverse_fold_tree<
260 proto::_
261 , proto::make<fusion::nil>
262 , make_binary_helper<Grammar>
263 >::template impl<Expr, State, Data>
264 reverse_fold_tree;
265
266 typedef typename reverse_fold_tree::result_type elements;
267 typedef make_component<Domain, Tag> make_component_;
268
269 typedef typename
270 make_component_::template
271 result<make_component_(elements, Data)>::type
272 result_type;
273
274 result_type operator()(
275 typename impl::expr_param expr
276 , typename impl::state_param state
277 , typename impl::data_param data
278 ) const
279 {
280 return make_component_()(
281 reverse_fold_tree()(expr, state, data), data);
282 }
283 };
284 };
285
286 template <typename Domain, typename Grammar>
287 struct make_directive : proto::transform<make_directive<Domain, Grammar> >
288 {
289 template<typename Expr, typename State, typename Data>
290 struct impl : proto::transform_impl<Expr, State, Data>
291 {
292 typedef typename
293 proto::result_of::child_c<Expr, 0>::type
294 lhs;
295
296 typedef typename
297 proto::result_of::value<lhs>::type
298 tag_type;
299
300 typedef typename modify<Domain>::
301 template result<modify<Domain>(tag_type, Data)>::type
302 modifier_type;
303
304 typedef typename Grammar::
305 template result<Grammar(
306 typename proto::result_of::child_c<Expr, 1>::type
307 , State
308 , modifier_type
309 )>::type
310 rhs_component;
311
312 typedef typename
313 result_of::make_cons<
314 tag_type
315 , typename result_of::make_cons<rhs_component>::type
316 >::type
317 elements_type;
318
319 typedef make_component<Domain, tag::directive> make_component_;
320
321 typedef typename
322 make_component_::template
323 result<make_component_(elements_type, Data)>::type
324 result_type;
325
326 result_type operator()(
327 typename impl::expr_param expr
328 , typename impl::state_param state
329 , typename impl::data_param data
330 ) const
331 {
332 tag_type tag = proto::value(proto::child_c<0>(expr));
333 typename remove_reference<modifier_type>::type
334 modifier = modify<Domain>()(tag, data);
335
336 elements_type elements =
337 detail::make_cons(
338 tag // LHS
339 , detail::make_cons(
340 Grammar()(
341 proto::child_c<1>(expr) // RHS
342 , state, modifier)
343 )
344 );
345
346 return make_component_()(elements, data);
347 }
348 };
349 };
350
351 template <typename Domain, typename Grammar>
352 struct make_action : proto::transform<make_action<Domain, Grammar> >
353 {
354 template<typename Expr, typename State, typename Data>
355 struct impl : proto::transform_impl<Expr, State, Data>
356 {
357 typedef typename Grammar::
358 template result<Grammar(
359 typename proto::result_of::child_c<Expr, 0>::type
360 , State
361 , Data
362 )>::type
363 lhs_component;
364
365 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
366 typedef typename
367 proto::result_of::value<
368 typename proto::result_of::child_c<Expr, 1>::type
369 >::type
370 rhs_component;
371 #else
372 typedef
373 typename mpl::eval_if_c<
374 phoenix::is_actor<
375 typename proto::result_of::child_c<Expr, 1>::type
376 >::type::value
377 , proto::result_of::child_c<Expr, 1>
378 , proto::result_of::value<
379 typename proto::result_of::child_c<Expr, 1>::type
380 >
381 >::type
382 rhs_component;
383 #endif
384
385 typedef typename
386 result_of::make_cons<
387 lhs_component
388 , typename result_of::make_cons<rhs_component>::type
389 >::type
390 elements_type;
391
392 typedef make_component<Domain, tag::action> make_component_;
393
394 typedef typename
395 make_component_::template
396 result<make_component_(elements_type, Data)>::type
397 result_type;
398
399 #ifndef BOOST_SPIRIT_USE_PHOENIX_V3
400 result_type operator()(
401 typename impl::expr_param expr
402 , typename impl::state_param state
403 , typename impl::data_param data
404 ) const
405 {
406 elements_type elements =
407 detail::make_cons(
408 Grammar()(
409 proto::child_c<0>(expr), state, data) // LHS
410 , detail::make_cons(
411 proto::value(proto::child_c<1>(expr))) // RHS
412 );
413
414 return make_component_()(elements, data);
415 }
416 #else
417 result_type operator()(
418 typename impl::expr_param expr
419 , typename impl::state_param state
420 , typename impl::data_param data
421 ) const
422 {
423 return
424 (*this)(
425 expr
426 , state
427 , data
428 , typename phoenix::is_actor<
429 typename proto::result_of::child_c<Expr, 1>::type
430 >::type()
431 );
432 }
433
434 result_type operator()(
435 typename impl::expr_param expr
436 , typename impl::state_param state
437 , typename impl::data_param data
438 , mpl::false_
439 ) const
440 {
441 elements_type elements =
442 detail::make_cons(
443 Grammar()(
444 proto::child_c<0>(expr), state, data) // LHS
445 , detail::make_cons(
446 proto::value(proto::child_c<1>(expr))) // RHS
447 );
448
449 return make_component_()(elements, data);
450 }
451
452 result_type operator()(
453 typename impl::expr_param expr
454 , typename impl::state_param state
455 , typename impl::data_param data
456 , mpl::true_
457 ) const
458 {
459 elements_type elements =
460 detail::make_cons(
461 Grammar()(
462 proto::child_c<0>(expr), state, data) // LHS
463 , detail::make_cons(
464 proto::child_c<1>(expr)) // RHS
465 );
466
467 return make_component_()(elements, data);
468 }
469 #endif
470 };
471 };
472 }}}
473
474 #endif