1///////////////////////////////////////////////////////////////////////////////
2/// \file generate.hpp
3/// Contains definition of generate\<\> class template, which end users can
4/// specialize for generating domain-specific expression wrappers.
5//
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)
9
10#ifndef BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
11#define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
12
13#include <boost/config.hpp>
14#include <boost/version.hpp>
15#include <boost/preprocessor/cat.hpp>
16#include <boost/preprocessor/iteration/iterate.hpp>
17#include <boost/preprocessor/facilities/intercept.hpp>
18#include <boost/preprocessor/repetition/enum_params.hpp>
19#include <boost/preprocessor/repetition/enum_binary_params.hpp>
20#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
21#include <boost/mpl/bool.hpp>
22#include <boost/utility/enable_if.hpp>
23#include <boost/utility/result_of.hpp>
24#include <boost/proto/proto_fwd.hpp>
25#include <boost/proto/args.hpp>
26
27#if defined(_MSC_VER)
28# pragma warning(push)
29# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
30#endif
31
32namespace boost { namespace proto
33{
34
35 namespace detail
36 {
37 template<typename Expr>
38 struct by_value_generator_;
39
40 template<typename Tag, typename Arg>
41 struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> >
42 {
43 typedef
44 proto::expr<
45 Tag
46 , term<typename detail::term_traits<Arg>::value_type>
47 , 0
48 >
49 type;
50
51 BOOST_FORCEINLINE
52 static type const call(proto::expr<Tag, term<Arg>, 0> const &e)
53 {
54 type that = {e.child0};
55 return that;
56 }
57 };
58
59 template<typename Tag, typename Arg>
60 struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> >
61 {
62 typedef
63 proto::basic_expr<
64 Tag
65 , term<typename detail::term_traits<Arg>::value_type>
66 , 0
67 >
68 type;
69
70 BOOST_FORCEINLINE
71 static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e)
72 {
73 type that = {e.child0};
74 return that;
75 }
76 };
77
78 // Include the other specializations of by_value_generator_
79 #include <boost/proto/detail/generate_by_value.hpp>
80 }
81
82 /// \brief Annotate a generator to indicate that it would
83 /// prefer to be passed instances of \c proto::basic_expr\<\> rather
84 /// than \c proto::expr\<\>. <tt>use_basic_expr\<Generator\></tt> is
85 /// itself a generator.
86 ///
87 template<typename Generator>
88 struct use_basic_expr
89 : Generator
90 {
91 BOOST_PROTO_USE_BASIC_EXPR()
92 };
93
94 /// \brief A simple generator that passes an expression
95 /// through unchanged.
96 ///
97 /// Generators are intended for use as the first template parameter
98 /// to the \c domain\<\> class template and control if and how
99 /// expressions within that domain are to be customized.
100 /// The \c default_generator makes no modifications to the expressions
101 /// passed to it.
102 struct default_generator
103 {
104 BOOST_PROTO_CALLABLE()
105
106 template<typename Sig>
107 struct result;
108
109 template<typename This, typename Expr>
110 struct result<This(Expr)>
111 {
112 typedef Expr type;
113 };
114
115 /// \param expr A Proto expression
116 /// \return expr
117 template<typename Expr>
118 BOOST_FORCEINLINE
119 BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(Expr, Expr const &)
120 operator ()(Expr const &e) const
121 {
122 return e;
123 }
124 };
125
126 /// \brief A simple generator that passes an expression
127 /// through unchanged and specifies a preference for
128 /// \c proto::basic_expr\<\> over \c proto::expr\<\>.
129 ///
130 /// Generators are intended for use as the first template parameter
131 /// to the \c domain\<\> class template and control if and how
132 /// expressions within that domain are to be customized.
133 /// The \c default_generator makes no modifications to the expressions
134 /// passed to it.
135 struct basic_default_generator
136 : proto::use_basic_expr<default_generator>
137 {};
138
139 /// \brief A generator that wraps expressions passed
140 /// to it in the specified extension wrapper.
141 ///
142 /// Generators are intended for use as the first template parameter
143 /// to the \c domain\<\> class template and control if and how
144 /// expressions within that domain are to be customized.
145 /// \c generator\<\> wraps each expression passed to it in
146 /// the \c Extends\<\> wrapper.
147 template<template<typename> class Extends>
148 struct generator
149 {
150 BOOST_PROTO_CALLABLE()
151 BOOST_PROTO_USE_BASIC_EXPR()
152
153 template<typename Sig>
154 struct result;
155
156 template<typename This, typename Expr>
157 struct result<This(Expr)>
158 {
159 typedef Extends<Expr> type;
160 };
161
162 template<typename This, typename Expr>
163 struct result<This(Expr &)>
164 {
165 typedef Extends<Expr> type;
166 };
167
168 template<typename This, typename Expr>
169 struct result<This(Expr const &)>
170 {
171 typedef Extends<Expr> type;
172 };
173
174 /// \param expr A Proto expression
175 /// \return Extends<Expr>(expr)
176 template<typename Expr>
177 BOOST_FORCEINLINE
178 Extends<Expr> operator ()(Expr const &e) const
179 {
180 return Extends<Expr>(e);
181 }
182 };
183
184 /// \brief A generator that wraps expressions passed
185 /// to it in the specified extension wrapper and uses
186 /// aggregate initialization for the wrapper.
187 ///
188 /// Generators are intended for use as the first template parameter
189 /// to the \c domain\<\> class template and control if and how
190 /// expressions within that domain are to be customized.
191 /// \c pod_generator\<\> wraps each expression passed to it in
192 /// the \c Extends\<\> wrapper, and uses aggregate initialzation
193 /// for the wrapped object.
194 template<template<typename> class Extends>
195 struct pod_generator
196 {
197 BOOST_PROTO_CALLABLE()
198 BOOST_PROTO_USE_BASIC_EXPR()
199
200 template<typename Sig>
201 struct result;
202
203 template<typename This, typename Expr>
204 struct result<This(Expr)>
205 {
206 typedef Extends<Expr> type;
207 };
208
209 template<typename This, typename Expr>
210 struct result<This(Expr &)>
211 {
212 typedef Extends<Expr> type;
213 };
214
215 template<typename This, typename Expr>
216 struct result<This(Expr const &)>
217 {
218 typedef Extends<Expr> type;
219 };
220
221 /// \param expr The expression to wrap
222 /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
223 template<typename Expr>
224 BOOST_FORCEINLINE
225 Extends<Expr> operator ()(Expr const &e) const
226 {
227 Extends<Expr> that = {e};
228 return that;
229 }
230
231 // Work-around for:
232 // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct
233 #if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
234 template<typename Class, typename Member>
235 BOOST_FORCEINLINE
236 Extends<expr<tag::terminal, proto::term<Member Class::*> > > operator ()(expr<tag::terminal, proto::term<Member Class::*> > const &e) const
237 {
238 Extends<expr<tag::terminal, proto::term<Member Class::*> > > that;
239 proto::value(that.proto_expr_) = proto::value(e);
240 return that;
241 }
242
243 template<typename Class, typename Member>
244 BOOST_FORCEINLINE
245 Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > operator ()(basic_expr<tag::terminal, proto::term<Member Class::*> > const &e) const
246 {
247 Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > that;
248 proto::value(that.proto_expr_) = proto::value(e);
249 return that;
250 }
251 #endif
252 };
253
254 /// \brief A generator that replaces child nodes held by
255 /// reference with ones held by value. Use with
256 /// \c compose_generators to forward that result to another
257 /// generator.
258 ///
259 /// Generators are intended for use as the first template parameter
260 /// to the \c domain\<\> class template and control if and how
261 /// expressions within that domain are to be customized.
262 /// \c by_value_generator ensures all child nodes are
263 /// held by value. This generator is typically composed with a
264 /// second generator for further processing, as
265 /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
266 struct by_value_generator
267 {
268 BOOST_PROTO_CALLABLE()
269
270 template<typename Sig>
271 struct result;
272
273 template<typename This, typename Expr>
274 struct result<This(Expr)>
275 {
276 typedef
277 typename detail::by_value_generator_<Expr>::type
278 type;
279 };
280
281 template<typename This, typename Expr>
282 struct result<This(Expr &)>
283 {
284 typedef
285 typename detail::by_value_generator_<Expr>::type
286 type;
287 };
288
289 template<typename This, typename Expr>
290 struct result<This(Expr const &)>
291 {
292 typedef
293 typename detail::by_value_generator_<Expr>::type
294 type;
295 };
296
297 /// \param expr The expression to modify.
298 /// \return <tt>deep_copy(expr)</tt>
299 template<typename Expr>
300 BOOST_FORCEINLINE
301 typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
302 {
303 return detail::by_value_generator_<Expr>::call(e);
304 }
305 };
306
307 /// \brief A composite generator that first applies one
308 /// transform to an expression and then forwards the result
309 /// on to another generator for further transformation.
310 ///
311 /// Generators are intended for use as the first template parameter
312 /// to the \c domain\<\> class template and control if and how
313 /// expressions within that domain are to be customized.
314 /// \c compose_generators\<\> is a composite generator that first
315 /// applies one transform to an expression and then forwards the
316 /// result on to another generator for further transformation.
317 template<typename First, typename Second>
318 struct compose_generators
319 {
320 BOOST_PROTO_CALLABLE()
321
322 template<typename Sig>
323 struct result;
324
325 template<typename This, typename Expr>
326 struct result<This(Expr)>
327 {
328 typedef
329 typename Second::template result<
330 Second(typename First::template result<First(Expr)>::type)
331 >::type
332 type;
333 };
334
335 template<typename This, typename Expr>
336 struct result<This(Expr &)>
337 {
338 typedef
339 typename Second::template result<
340 Second(typename First::template result<First(Expr)>::type)
341 >::type
342 type;
343 };
344
345 template<typename This, typename Expr>
346 struct result<This(Expr const &)>
347 {
348 typedef
349 typename Second::template result<
350 Second(typename First::template result<First(Expr)>::type)
351 >::type
352 type;
353 };
354
355 /// \param expr The expression to modify.
356 /// \return Second()(First()(expr))
357 template<typename Expr>
358 BOOST_FORCEINLINE
359 typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
360 {
361 return Second()(First()(e));
362 }
363 };
364
365 /// \brief Tests a generator to see whether it would prefer
366 /// to be passed instances of \c proto::basic_expr\<\> rather than
367 /// \c proto::expr\<\>.
368 ///
369 template<typename Generator, typename Void>
370 struct wants_basic_expr
371 : mpl::false_
372 {};
373
374 template<typename Generator>
375 struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_>
376 : mpl::true_
377 {};
378
379 /// INTERNAL ONLY
380 template<>
381 struct is_callable<default_generator>
382 : mpl::true_
383 {};
384
385 /// INTERNAL ONLY
386 template<template<typename> class Extends>
387 struct is_callable<generator<Extends> >
388 : mpl::true_
389 {};
390
391 /// INTERNAL ONLY
392 template<template<typename> class Extends>
393 struct is_callable<pod_generator<Extends> >
394 : mpl::true_
395 {};
396
397 /// INTERNAL ONLY
398 template<>
399 struct is_callable<by_value_generator>
400 : mpl::true_
401 {};
402
403 /// INTERNAL ONLY
404 template<typename First, typename Second>
405 struct is_callable<compose_generators<First, Second> >
406 : mpl::true_
407 {};
408
409}}
410
411// Specializations of boost::result_of and boost::tr1_result_of to eliminate
412// some unnecessary template instantiations
413namespace boost
414{
415 template<typename Expr>
416 struct result_of<proto::default_domain(Expr)>
417 {
418 typedef Expr type;
419 };
420
421 template<typename Expr>
422 struct result_of<proto::basic_default_domain(Expr)>
423 {
424 typedef Expr type;
425 };
426
427 template<typename Expr>
428 struct result_of<proto::default_generator(Expr)>
429 {
430 typedef Expr type;
431 };
432
433 template<typename Expr>
434 struct result_of<proto::basic_default_generator(Expr)>
435 {
436 typedef Expr type;
437 };
438
439 #if BOOST_VERSION >= 104400
440 template<typename Expr>
441 struct tr1_result_of<proto::default_domain(Expr)>
442 {
443 typedef Expr type;
444 };
445
446 template<typename Expr>
447 struct tr1_result_of<proto::basic_default_domain(Expr)>
448 {
449 typedef Expr type;
450 };
451
452 template<typename Expr>
453 struct tr1_result_of<proto::default_generator(Expr)>
454 {
455 typedef Expr type;
456 };
457
458 template<typename Expr>
459 struct tr1_result_of<proto::basic_default_generator(Expr)>
460 {
461 typedef Expr type;
462 };
463 #endif
464}
465
466#if defined(_MSC_VER)
467# pragma warning(pop)
468#endif
469
470#endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
471