Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/proto/extends.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 /// \file extends.hpp
3 /// Macros and a base class for defining end-user expression types
4 //
5 // Copyright 2008 Eric Niebler. Distributed under the Boost
6 // Software License, Version 1.0. (See accompanying file
7 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8
9 #ifndef BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
10 #define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
11
12 #include <cstddef> // for offsetof
13 #include <boost/config.hpp>
14 #include <boost/detail/workaround.hpp>
15 #include <boost/preprocessor/facilities/empty.hpp>
16 #include <boost/preprocessor/tuple/elem.hpp>
17 #include <boost/preprocessor/control/if.hpp>
18 #include <boost/preprocessor/arithmetic/inc.hpp>
19 #include <boost/preprocessor/arithmetic/dec.hpp>
20 #include <boost/preprocessor/iteration/local.hpp>
21 #include <boost/preprocessor/repetition/enum_params.hpp>
22 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
23 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
24 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
25 #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
26 #include <boost/preprocessor/seq/for_each.hpp>
27 #include <boost/utility/addressof.hpp>
28 #include <boost/utility/result_of.hpp>
29 #include <boost/proto/proto_fwd.hpp>
30 #include <boost/proto/traits.hpp>
31 #include <boost/proto/expr.hpp>
32 #include <boost/proto/args.hpp>
33 #include <boost/proto/traits.hpp>
34 #include <boost/proto/generate.hpp>
35 #include <boost/proto/detail/remove_typename.hpp>
36
37 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
38 # pragma warning(push)
39 # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
40 #endif
41
42 namespace boost { namespace proto
43 {
44 #ifdef __GNUC__
45 /// INTERNAL ONLY
46 ///
47 # define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x))
48 /// INTERNAL ONLY
49 ///
50 # define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this)))
51 #else
52 /// INTERNAL ONLY
53 ///
54 # define BOOST_PROTO_OFFSETOF offsetof
55 #endif
56
57 /// INTERNAL ONLY
58 ///
59 #define BOOST_PROTO_CONST() const
60
61 /// INTERNAL ONLY
62 ///
63 #define BOOST_PROTO_TYPENAME() typename
64
65 /// INTERNAL ONLY
66 ///
67 #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>
68
69 /// INTERNAL ONLY
70 ///
71 #define BOOST_PROTO_TEMPLATE_NO_(Z, N)
72
73 /// INTERNAL ONLY
74 ///
75 #define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \
76 BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \
77 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
78 typename BOOST_PROTO_RESULT_OF< \
79 proto_generator( \
80 typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
81 proto_derived_expr Const() \
82 , proto_domain \
83 BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
84 >::type \
85 ) \
86 >::type const \
87 operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \
88 { \
89 typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
90 proto_derived_expr Const() \
91 , proto_domain \
92 BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
93 > funop; \
94 return proto_generator()( \
95 funop::call( \
96 *static_cast<proto_derived_expr Const() *>(this) \
97 BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \
98 ) \
99 ); \
100 } \
101 /**/
102
103 /// INTERNAL ONLY
104 ///
105 #define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \
106 template<typename... A> \
107 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
108 typename BOOST_PROTO_RESULT_OF< \
109 proto_generator( \
110 typename boost::proto::result_of::funop< \
111 proto_derived_expr Const()(A const &...) \
112 , proto_derived_expr \
113 , proto_domain \
114 >::type \
115 ) \
116 >::type const \
117 operator ()(A const &...a) Const() \
118 { \
119 typedef boost::proto::result_of::funop< \
120 proto_derived_expr Const()(A const &...) \
121 , proto_derived_expr \
122 , proto_domain \
123 > funop; \
124 return proto_generator()( \
125 funop::call( \
126 *static_cast<proto_derived_expr Const() *>(this) \
127 , a... \
128 ) \
129 ); \
130 } \
131 /**/
132
133 /// INTERNAL ONLY
134 ///
135 #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
136 BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \
137 /**/
138
139 /// INTERNAL ONLY
140 ///
141 #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
142 BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \
143 /**/
144
145 /// INTERNAL ONLY
146 ///
147 #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \
148 BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
149 BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
150 /**/
151
152 /// INTERNAL ONLY
153 ///
154 #define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \
155 typedef \
156 typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \
157 BOOST_PP_CAT(proto_child, N); \
158 /**/
159
160 #define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
161 Expr proto_expr_; \
162 \
163 typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \
164 typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \
165 typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \
166 typedef Derived proto_derived_expr; \
167 typedef Domain::proto_generator proto_generator; \
168 typedef typename proto_base_expr::proto_tag proto_tag; \
169 typedef typename proto_base_expr::proto_args proto_args; \
170 typedef typename proto_base_expr::proto_arity proto_arity; \
171 typedef typename proto_base_expr::proto_grammar proto_grammar; \
172 typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
173 typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
174 static const long proto_arity_c = proto_base_expr::proto_arity_c; \
175 typedef boost::proto::tag::proto_expr<proto_tag, proto_domain> fusion_tag; \
176 BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
177 \
178 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
179 static proto_derived_expr const make(Expr const &e) \
180 { \
181 proto_derived_expr that = {e}; \
182 return that; \
183 } \
184 \
185 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
186 proto_base_expr &proto_base() \
187 { \
188 return this->proto_expr_.proto_base(); \
189 } \
190 \
191 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
192 proto_base_expr const &proto_base() const \
193 { \
194 return this->proto_expr_.proto_base(); \
195 } \
196 \
197 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
198 operator proto_address_of_hack_type_() const \
199 { \
200 return boost::addressof(this->proto_base().child0); \
201 } \
202 /**/
203
204 #define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
205 BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
206 typedef void proto_is_aggregate_; \
207 /**< INTERNAL ONLY */
208
209 #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \
210 BOOST_PROTO_DISABLE_MSVC_C4522 \
211 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
212 Typename() BOOST_PROTO_RESULT_OF< \
213 Typename() This::proto_generator( \
214 Typename() boost::proto::base_expr< \
215 Typename() This::proto_domain \
216 , boost::proto::tag::assign \
217 , boost::proto::list2< \
218 This & \
219 , This Const() & \
220 > \
221 >::type \
222 ) \
223 >::type const \
224 operator =(This Const() &a) \
225 { \
226 typedef \
227 Typename() boost::proto::base_expr< \
228 Typename() This::proto_domain \
229 , boost::proto::tag::assign \
230 , boost::proto::list2< \
231 This & \
232 , This Const() & \
233 > \
234 >::type \
235 that_type; \
236 that_type const that = { \
237 *this \
238 , a \
239 }; \
240 return Typename() This::proto_generator()(that); \
241 } \
242 /**/
243
244 // MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both*
245 // const and non-const rhs arguments.
246 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310)
247 #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
248 BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \
249 BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
250 /**/
251 #else
252 #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
253 BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
254 /**/
255 #endif
256
257 /// INTERNAL ONLY
258 ///
259 #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \
260 template<typename A> \
261 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
262 typename BOOST_PROTO_RESULT_OF< \
263 proto_generator( \
264 typename boost::proto::base_expr< \
265 proto_domain \
266 , boost::proto::tag::assign \
267 , boost::proto::list2< \
268 proto_derived_expr ThisConst() & \
269 , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
270 > \
271 >::type \
272 ) \
273 >::type const \
274 operator =(A ThatConst() &a) ThisConst() \
275 { \
276 typedef \
277 typename boost::proto::base_expr< \
278 proto_domain \
279 , boost::proto::tag::assign \
280 , boost::proto::list2< \
281 proto_derived_expr ThisConst() & \
282 , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
283 > \
284 >::type \
285 that_type; \
286 that_type const that = { \
287 *static_cast<proto_derived_expr ThisConst() *>(this) \
288 , boost::proto::as_child<proto_domain>(a) \
289 }; \
290 return proto_generator()(that); \
291 } \
292 /**/
293
294 #define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
295 BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
296 BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
297 /**/
298
299 #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
300 BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
301 BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
302 /**/
303
304 #define BOOST_PROTO_EXTENDS_ASSIGN_() \
305 BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
306 BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
307 /**/
308
309 #define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \
310 BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
311 BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
312 /**/
313
314 #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \
315 BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
316 BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
317 /**/
318
319 #define BOOST_PROTO_EXTENDS_ASSIGN() \
320 BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
321 BOOST_PROTO_EXTENDS_ASSIGN_() \
322 /**/
323
324 /// INTERNAL ONLY
325 ///
326 #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \
327 template<typename A> \
328 BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
329 typename BOOST_PROTO_RESULT_OF< \
330 proto_generator( \
331 typename boost::proto::base_expr< \
332 proto_domain \
333 , boost::proto::tag::subscript \
334 , boost::proto::list2< \
335 proto_derived_expr ThisConst() & \
336 , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
337 > \
338 >::type \
339 ) \
340 >::type const \
341 operator [](A ThatConst() &a) ThisConst() \
342 { \
343 typedef \
344 typename boost::proto::base_expr< \
345 proto_domain \
346 , boost::proto::tag::subscript \
347 , boost::proto::list2< \
348 proto_derived_expr ThisConst() & \
349 , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
350 > \
351 >::type \
352 that_type; \
353 that_type const that = { \
354 *static_cast<proto_derived_expr ThisConst() *>(this) \
355 , boost::proto::as_child<proto_domain>(a) \
356 }; \
357 return proto_generator()(that); \
358 } \
359 /**/
360
361 #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
362 BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
363 BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
364 /**/
365
366 #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
367 BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
368 BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
369 /**/
370
371 #define BOOST_PROTO_EXTENDS_SUBSCRIPT() \
372 BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
373 BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
374 /**/
375
376 /// INTERNAL ONLY
377 ///
378 #define BOOST_PROTO_EXTENDS_FUNCTION_() \
379 template<typename Sig> \
380 struct result \
381 { \
382 typedef \
383 typename BOOST_PROTO_RESULT_OF< \
384 proto_generator( \
385 typename boost::proto::result_of::funop< \
386 Sig \
387 , proto_derived_expr \
388 , proto_domain \
389 >::type \
390 ) \
391 >::type const \
392 type; \
393 }; \
394 /**/
395
396 #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
397 #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
398 BOOST_PROTO_EXTENDS_FUNCTION_() \
399 BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
400 /**/
401
402 #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
403 BOOST_PROTO_EXTENDS_FUNCTION_() \
404 BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
405 /**/
406
407 #define BOOST_PROTO_EXTENDS_FUNCTION() \
408 BOOST_PROTO_EXTENDS_FUNCTION_() \
409 BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
410 BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
411 /**/
412 #else
413 #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
414 BOOST_PROTO_EXTENDS_FUNCTION_() \
415 BOOST_PP_REPEAT_FROM_TO( \
416 0 \
417 , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
418 , BOOST_PROTO_DEFINE_FUN_OP_CONST \
419 , ~ \
420 ) \
421 /**/
422
423 #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
424 BOOST_PROTO_EXTENDS_FUNCTION_() \
425 BOOST_PP_REPEAT_FROM_TO( \
426 0 \
427 , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
428 , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
429 , ~ \
430 ) \
431 /**/
432
433 #define BOOST_PROTO_EXTENDS_FUNCTION() \
434 BOOST_PROTO_EXTENDS_FUNCTION_() \
435 BOOST_PP_REPEAT_FROM_TO( \
436 0 \
437 , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
438 , BOOST_PROTO_DEFINE_FUN_OP \
439 , ~ \
440 ) \
441 /**/
442 #endif
443
444 #define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \
445 BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
446 BOOST_PROTO_EXTENDS_ASSIGN() \
447 BOOST_PROTO_EXTENDS_SUBSCRIPT() \
448 BOOST_PROTO_EXTENDS_FUNCTION() \
449 /**/
450
451 #define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \
452 typedef typename Derived::proto_extends proto_extends; \
453 using proto_extends::operator =; \
454 BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \
455 /**/
456
457 #define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \
458 typedef Derived::proto_extends proto_extends; \
459 using proto_extends::operator =; \
460 BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \
461 /**/
462
463 namespace exprns_
464 {
465 /// \brief Empty type to be used as a dummy template parameter of
466 /// POD expression wrappers. It allows argument-dependent lookup
467 /// to find Proto's operator overloads.
468 ///
469 /// \c proto::is_proto_expr allows argument-dependent lookup
470 /// to find Proto's operator overloads. For example:
471 ///
472 /// \code
473 /// template<typename T, typename Dummy = proto::is_proto_expr>
474 /// struct my_terminal
475 /// {
476 /// BOOST_PROTO_BASIC_EXTENDS(
477 /// typename proto::terminal<T>::type
478 /// , my_terminal<T>
479 /// , default_domain
480 /// )
481 /// };
482 ///
483 /// // ...
484 /// my_terminal<int> _1, _2;
485 /// _1 + _2; // OK, uses proto::operator+
486 /// \endcode
487 ///
488 /// Without the second \c Dummy template parameter, Proto's operator
489 /// overloads would not be considered by name lookup.
490 struct is_proto_expr
491 {};
492
493 /// \brief extends\<\> class template for adding behaviors to a Proto expression template
494 ///
495 template<
496 typename Expr
497 , typename Derived
498 , typename Domain // = proto::default_domain
499 , long Arity // = Expr::proto_arity_c
500 >
501 struct extends
502 {
503 BOOST_FORCEINLINE
504 extends()
505 : proto_expr_()
506 {}
507
508 BOOST_FORCEINLINE
509 extends(extends const &that)
510 : proto_expr_(that.proto_expr_)
511 {}
512
513 BOOST_FORCEINLINE
514 extends(Expr const &expr_)
515 : proto_expr_(expr_)
516 {}
517
518 typedef extends proto_extends;
519 BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
520 BOOST_PROTO_EXTENDS_ASSIGN_CONST_()
521 BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
522
523 // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
524 // nested preprocessor loops, use file iteration here to generate
525 // the operator() overloads, which is more efficient.
526 #include <boost/proto/detail/extends_funop_const.hpp>
527 };
528
529 /// \brief extends\<\> class template for adding behaviors to a Proto expression template
530 ///
531 template<typename Expr, typename Derived, typename Domain>
532 struct extends<Expr, Derived, Domain, 0>
533 {
534 BOOST_FORCEINLINE
535 extends()
536 : proto_expr_()
537 {}
538
539 BOOST_FORCEINLINE
540 extends(extends const &that)
541 : proto_expr_(that.proto_expr_)
542 {}
543
544 BOOST_FORCEINLINE
545 extends(Expr const &expr_)
546 : proto_expr_(expr_)
547 {}
548
549 typedef extends proto_extends;
550 BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
551 BOOST_PROTO_EXTENDS_ASSIGN_()
552 BOOST_PROTO_EXTENDS_SUBSCRIPT()
553
554 // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
555 // nested preprocessor loops, use file iteration here to generate
556 // the operator() overloads, which is more efficient.
557 #include <boost/proto/detail/extends_funop.hpp>
558 };
559
560 /// INTERNAL ONLY
561 ///
562 template<typename This, typename Fun, typename Domain>
563 struct virtual_member
564 {
565 typedef Domain proto_domain;
566 typedef typename Domain::proto_generator proto_generator;
567 typedef virtual_member<This, Fun, Domain> proto_derived_expr;
568 typedef tag::member proto_tag;
569 typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
570 typedef mpl::long_<2> proto_arity;
571 typedef detail::not_a_valid_type proto_address_of_hack_type_;
572 typedef void proto_is_expr_; /**< INTERNAL ONLY */
573 static const long proto_arity_c = 2;
574 typedef boost::proto::tag::proto_expr<proto_tag, Domain> fusion_tag;
575 typedef This &proto_child0;
576 typedef expr<tag::terminal, term<Fun> > const &proto_child1;
577 typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
578 typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
579 typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
580
581 BOOST_PROTO_EXTENDS_ASSIGN_()
582 BOOST_PROTO_EXTENDS_SUBSCRIPT()
583
584 // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
585 // nested preprocessor loops, use file iteration here to generate
586 // the operator() overloads, which is more efficient.
587 #define BOOST_PROTO_NO_WAVE_OUTPUT
588 #include <boost/proto/detail/extends_funop.hpp>
589 #undef BOOST_PROTO_NO_WAVE_OUTPUT
590
591 BOOST_FORCEINLINE
592 proto_base_expr const proto_base() const
593 {
594 proto_base_expr that = {this->child0(), this->child1()};
595 return that;
596 }
597
598 BOOST_FORCEINLINE
599 proto_child0 child0() const
600 {
601 using std::size_t;
602 return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
603 }
604
605 BOOST_FORCEINLINE
606 proto_child1 child1() const
607 {
608 static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
609 return that;
610 }
611 };
612
613 /// INTERNAL ONLY
614 ///
615 #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \
616 boost::proto::exprns_::virtual_member< \
617 proto_derived_expr \
618 , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
619 , DOMAIN \
620 > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
621 /**/
622
623 /// \brief For declaring virtual data members in an extension class.
624 ///
625 #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \
626 union \
627 { \
628 char proto_member_union_start_; \
629 BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \
630 }; \
631 /**/
632
633 /// \brief For declaring virtual data members in an extension class.
634 ///
635 #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
636 BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \
637 /**/
638
639 }
640
641 }}
642
643 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
644 # pragma warning(pop)
645 #endif
646
647 #endif