1 ///////////////////////////////////////////////////////////////////////////////
3 /// Contains definition of the _default transform, which gives operators their
4 /// usual C++ meanings and uses Boost.Typeof to deduce return types.
6 // Copyright 2008 Eric Niebler. Distributed under the Boost
7 // Software License, Version 1.0. (See accompanying file
8 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
10 #ifndef BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
11 #define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
13 #include <boost/preprocessor/iteration/iterate.hpp>
14 #include <boost/preprocessor/repetition/repeat.hpp>
15 #include <boost/preprocessor/arithmetic/add.hpp>
16 #include <boost/preprocessor/arithmetic/sub.hpp>
17 #include <boost/preprocessor/repetition/enum.hpp>
18 #include <boost/preprocessor/repetition/enum_shifted.hpp>
19 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
20 #include <boost/ref.hpp>
21 #include <boost/get_pointer.hpp>
22 #include <boost/utility/enable_if.hpp>
23 #include <boost/type_traits/is_member_pointer.hpp>
24 #include <boost/type_traits/is_member_object_pointer.hpp>
25 #include <boost/type_traits/is_member_function_pointer.hpp>
26 #include <boost/proto/proto_fwd.hpp>
27 #include <boost/proto/traits.hpp>
28 #include <boost/proto/transform/impl.hpp>
29 #include <boost/proto/transform/arg.hpp>
30 #include <boost/proto/detail/decltype.hpp>
32 namespace boost { namespace proto
36 template<typename Grammar, typename Tag>
41 template<typename Grammar>
42 struct default_case<Grammar, tag::terminal>
43 : when<terminal<_>, _value>
46 template<typename Grammar>
49 template<typename Tag>
51 : default_case<Grammar, Tag>
55 #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \
56 template<typename Grammar> \
57 struct BOOST_PP_CAT(default_, TAG) \
58 : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
60 template<typename Expr, typename State, typename Data> \
62 : transform_impl<Expr, State, Data> \
65 typedef typename result_of::child_c<Expr, 0>::type e0; \
66 typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
68 BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \
69 result_type operator ()( \
70 typename impl::expr_param e \
71 , typename impl::state_param s \
72 , typename impl::data_param d \
75 typename Grammar::template impl<e0, State, Data> t0; \
76 return OP t0(proto::child_c<0>(e), s, d); \
81 template<typename Grammar> \
82 struct default_case<Grammar, tag::TAG> \
83 : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
87 #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \
88 template<typename Grammar> \
89 struct BOOST_PP_CAT(default_, TAG) \
90 : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
92 template<typename Expr, typename State, typename Data> \
94 : transform_impl<Expr, State, Data> \
97 typedef typename result_of::child_c<Expr, 0>::type e0; \
98 typedef typename result_of::child_c<Expr, 1>::type e1; \
99 typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
100 typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \
102 BOOST_PROTO_DECLTYPE_( \
103 proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \
106 result_type operator ()( \
107 typename impl::expr_param e \
108 , typename impl::state_param s \
109 , typename impl::data_param d \
112 typename Grammar::template impl<e0, State, Data> t0; \
113 typename Grammar::template impl<e1, State, Data> t1; \
114 return t0(proto::child_c<0>(e), s, d) \
115 OP t1(proto::child_c<1>(e), s, d); \
120 template<typename Grammar> \
121 struct default_case<Grammar, tag::TAG> \
122 : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
126 BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make)
127 BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make)
128 BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make)
129 BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make)
130 BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make)
131 BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make)
132 BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable)
133 BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable)
135 BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make)
136 BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable)
137 BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make)
138 BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make)
139 BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make)
140 BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make)
141 BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make)
142 BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make)
143 BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make)
144 BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make)
145 BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make)
146 BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make)
147 BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make)
148 BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make)
149 BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make)
150 BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make)
151 BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make)
152 BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make)
154 BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make)
155 BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make)
156 BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make)
157 BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make)
158 BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make)
159 BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make)
160 BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make)
161 BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make)
162 BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make)
163 BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make)
164 BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make)
166 #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
167 #undef BOOST_PROTO_BINARY_DEFAULT_EVAL
170 template<typename Grammar, typename Expr, typename State, typename Data>
171 struct is_member_function_invocation
172 : is_member_function_pointer<
174 typename Grammar::template impl<
175 typename result_of::child_c<Expr, 1>::type
184 template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall>
185 struct default_mem_ptr_impl
186 : transform_impl<Expr, State, Data>
189 typedef typename result_of::child_c<Expr, 0>::type e0;
190 typedef typename result_of::child_c<Expr, 1>::type e1;
191 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
192 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
194 typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
195 result_type operator ()(
196 typename default_mem_ptr_impl::expr_param e
197 , typename default_mem_ptr_impl::state_param s
198 , typename default_mem_ptr_impl::data_param d
201 typename Grammar::template impl<e0, State, Data> t0;
202 typename Grammar::template impl<e1, State, Data> t1;
203 return detail::mem_ptr_fun<r0, r1>()(
204 t0(proto::child_c<0>(e), s, d)
205 , t1(proto::child_c<1>(e), s, d)
211 template<typename Grammar, typename Expr, typename State, typename Data>
212 struct default_mem_ptr_impl<Grammar, Expr, State, Data, true>
213 : transform_impl<Expr, State, Data>
216 typedef typename result_of::child_c<Expr, 0>::type e0;
217 typedef typename result_of::child_c<Expr, 1>::type e1;
218 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
219 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
221 typedef detail::memfun<r0, r1> result_type;
222 result_type const operator ()(
223 typename default_mem_ptr_impl::expr_param e
224 , typename default_mem_ptr_impl::state_param s
225 , typename default_mem_ptr_impl::data_param d
228 typename Grammar::template impl<e0, State, Data> t0;
229 typename Grammar::template impl<e1, State, Data> t1;
230 return detail::memfun<r0, r1>(
231 t0(proto::child_c<0>(e), s, d)
232 , t1(proto::child_c<1>(e), s, d)
237 template<typename Grammar>
238 struct default_mem_ptr
239 : transform<default_mem_ptr<Grammar> >
241 template<typename Expr, typename State, typename Data>
243 : default_mem_ptr_impl<
248 , is_member_function_invocation<Grammar, Expr, State, Data>::value
253 template<typename Grammar>
254 struct default_case<Grammar, tag::mem_ptr>
255 : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> >
258 template<typename Grammar>
259 struct default_post_inc
260 : transform<default_post_inc<Grammar> >
262 template<typename Expr, typename State, typename Data>
264 : transform_impl<Expr, State, Data>
267 typedef typename result_of::child_c<Expr, 0>::type e0;
268 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
270 BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
271 result_type operator ()(
272 typename impl::expr_param e
273 , typename impl::state_param s
274 , typename impl::data_param d
277 typename Grammar::template impl<e0, State, Data> t0;
278 return t0(proto::child_c<0>(e), s, d) ++;
283 template<typename Grammar>
284 struct default_case<Grammar, tag::post_inc>
285 : when<post_inc<Grammar>, default_post_inc<Grammar> >
288 template<typename Grammar>
289 struct default_post_dec
290 : transform<default_post_dec<Grammar> >
292 template<typename Expr, typename State, typename Data>
294 : transform_impl<Expr, State, Data>
297 typedef typename result_of::child_c<Expr, 0>::type e0;
298 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
300 BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
301 result_type operator ()(
302 typename impl::expr_param e
303 , typename impl::state_param s
304 , typename impl::data_param d
307 typename Grammar::template impl<e0, State, Data> t0;
308 return t0(proto::child_c<0>(e), s, d) --;
313 template<typename Grammar>
314 struct default_case<Grammar, tag::post_dec>
315 : when<post_dec<Grammar>, default_post_dec<Grammar> >
318 template<typename Grammar>
319 struct default_subscript
320 : transform<default_subscript<Grammar> >
322 template<typename Expr, typename State, typename Data>
324 : transform_impl<Expr, State, Data>
327 typedef typename result_of::child_c<Expr, 0>::type e0;
328 typedef typename result_of::child_c<Expr, 1>::type e1;
329 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
330 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
332 BOOST_PROTO_DECLTYPE_(
333 proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]
336 result_type operator ()(
337 typename impl::expr_param e
338 , typename impl::state_param s
339 , typename impl::data_param d
342 typename Grammar::template impl<e0, State, Data> t0;
343 typename Grammar::template impl<e1, State, Data> t1;
344 return t0(proto::child_c<0>(e), s, d) [
345 t1(proto::child_c<1>(e), s, d) ];
350 template<typename Grammar>
351 struct default_case<Grammar, tag::subscript>
352 : when<subscript<Grammar, Grammar>, default_subscript<Grammar> >
355 template<typename Grammar>
356 struct default_if_else_
358 template<typename Expr, typename State, typename Data>
360 : transform_impl<Expr, State, Data>
363 typedef typename result_of::child_c<Expr, 0>::type e0;
364 typedef typename result_of::child_c<Expr, 1>::type e1;
365 typedef typename result_of::child_c<Expr, 2>::type e2;
366 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
367 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
368 typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
370 BOOST_PROTO_DECLTYPE_(
371 proto::detail::make<r0>()
372 ? proto::detail::make<r1>()
373 : proto::detail::make<r2>()
376 result_type operator ()(
377 typename impl::expr_param e
378 , typename impl::state_param s
379 , typename impl::data_param d
382 typename Grammar::template impl<e0, State, Data> t0;
383 typename Grammar::template impl<e1, State, Data> t1;
384 typename Grammar::template impl<e2, State, Data> t2;
385 return t0(proto::child_c<0>(e), s, d)
386 ? t1(proto::child_c<1>(e), s, d)
387 : t2(proto::child_c<2>(e), s, d);
392 template<typename Grammar>
393 struct default_case<Grammar, tag::if_else_>
394 : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> >
397 template<typename Grammar>
399 : transform<default_comma<Grammar> >
401 template<typename Expr, typename State, typename Data>
403 : transform_impl<Expr, State, Data>
406 typedef typename result_of::child_c<Expr, 0>::type e0;
407 typedef typename result_of::child_c<Expr, 1>::type e1;
408 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
409 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
411 typedef typename proto::detail::comma_result<r0, r1>::type result_type;
412 result_type operator ()(
413 typename impl::expr_param e
414 , typename impl::state_param s
415 , typename impl::data_param d
418 typename Grammar::template impl<e0, State, Data> t0;
419 typename Grammar::template impl<e1, State, Data> t1;
420 return t0(proto::child_c<0>(e), s, d)
421 , t1(proto::child_c<1>(e), s, d);
426 template<typename Grammar>
427 struct default_case<Grammar, tag::comma>
428 : when<comma<Grammar, Grammar>, default_comma<Grammar> >
431 template<typename Grammar, typename Expr, typename State, typename Data, long Arity>
432 struct default_function_impl;
434 template<typename Grammar>
435 struct default_function
436 : transform<default_function<Grammar> >
438 template<typename Expr, typename State, typename Data>
440 : default_function_impl<
445 , transform_impl<Expr, State, Data>::expr::proto_arity_c
450 template<typename Grammar>
451 struct default_case<Grammar, tag::function>
452 : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> >
455 #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \
457 typename result_of::child_c<DATA, N>::type \
458 BOOST_PP_CAT(e, N); \
461 typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \
462 BOOST_PP_CAT(r, N); \
465 #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \
466 typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \
467 proto::child_c<N>(DATA), s, d \
471 template<typename Grammar, typename Expr, typename State, typename Data>
472 struct default_function_impl<Grammar, Expr, State, Data, 1>
473 : transform_impl<Expr, State, Data>
475 BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
478 typename proto::detail::result_of_fixup<r0>::type
482 typename BOOST_PROTO_RESULT_OF<function_type()>::type
485 result_type operator ()(
486 typename default_function_impl::expr_param e
487 , typename default_function_impl::state_param s
488 , typename default_function_impl::data_param d
491 return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)();
495 template<typename Grammar, typename Expr, typename State, typename Data>
496 struct default_function_impl<Grammar, Expr, State, Data, 2>
497 : transform_impl<Expr, State, Data>
499 BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
500 BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)
503 typename proto::detail::result_of_fixup<r0>::type
507 typename detail::result_of_<function_type(r1)>::type
510 result_type operator ()(
511 typename default_function_impl::expr_param e
512 , typename default_function_impl::state_param s
513 , typename default_function_impl::data_param d
520 , is_member_function_pointer<function_type>()
521 , is_member_object_pointer<function_type>()
527 typename default_function_impl::expr_param e
528 , typename default_function_impl::state_param s
529 , typename default_function_impl::data_param d
534 return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e));
538 typename default_function_impl::expr_param e
539 , typename default_function_impl::state_param s
540 , typename default_function_impl::data_param d
545 BOOST_PROTO_USE_GET_POINTER();
546 typedef typename detail::class_member_traits<function_type>::class_type class_type;
548 BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->*
549 BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
554 typename default_function_impl::expr_param e
555 , typename default_function_impl::state_param s
556 , typename default_function_impl::data_param d
561 BOOST_PROTO_USE_GET_POINTER();
562 typedef typename detail::class_member_traits<function_type>::class_type class_type;
564 BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->*
565 BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
570 #include <boost/proto/transform/detail/default_function_impl.hpp>
572 #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
573 #undef BOOST_PROTO_DEFAULT_EVAL
576 template<typename Grammar /*= detail::_default*/>
578 : switch_<detail::default_cases<Grammar> >
581 template<typename Grammar>
582 struct is_callable<_default<Grammar> >
588 // Loopy indirection that allows proto::_default<> to be
589 // used without specifying a Grammar argument.