1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*==============================================================================
Copyright (c) 2001-2010 Joel de Guzman
Copyright (c) 2010 Eric Niebler
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PHOENIX_STATEMENT_IF_HPP
#define BOOST_PHOENIX_STATEMENT_IF_HPP
#include <boost/config.hpp>
#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/core/actor.hpp>
#include <boost/phoenix/core/call.hpp>
#include <boost/phoenix/core/expression.hpp>
#include <boost/phoenix/core/meta_grammar.hpp>
#include <boost/phoenix/core/is_actor.hpp>
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable: 4355) // 'this' used in base member initializer list
#endif
namespace boost { namespace phoenix
{
template <typename> struct if_actor;
}}
BOOST_PHOENIX_DEFINE_EXPRESSION_EXT(
if_actor
, (boost)(phoenix)(if_)
, (meta_grammar) // Cond
(meta_grammar) // Then
)
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(phoenix)(if_else_statement)
, (meta_grammar) // Cond
(meta_grammar) // Then
(meta_grammar) // Else
)
namespace boost { namespace phoenix
{
////////////////////////////////////////////////////////////////////////////
// If-Else statements
////////////////////////////////////////////////////////////////////////////
// Function for evaluating lambdas like:
// if_( foo )[ bar ]
// and
// if_( foo )[ bar ].else_[ baz ]
struct if_else_eval
{
typedef void result_type;
template<typename Cond, typename Then, typename Context>
result_type
operator()(Cond const & cond, Then const & then, Context const & ctx) const
{
if(boost::phoenix::eval(cond, ctx))
boost::phoenix::eval(then, ctx);
}
template<typename Cond, typename Then, typename Else, typename Context>
result_type
operator()(
Cond const & cond
, Then const & then
, Else const & else_
, Context const & ctx
) const
{
if(boost::phoenix::eval(cond, ctx))
boost::phoenix::eval(then, ctx);
else
boost::phoenix::eval(else_, ctx);
}
};
template <typename Dummy>
struct default_actions::when<rule::if_, Dummy>
: call<if_else_eval, Dummy>
{};
template <typename Dummy>
struct default_actions::when<rule::if_else_statement, Dummy>
: call<if_else_eval, Dummy>
{};
// Generator for .else_[ expr ] branch.
template<typename Cond, typename Then>
struct else_gen
{
else_gen(Cond const & cond_, Then const & then_)
: cond(cond_)
, then(then_) {}
template<typename Else>
typename expression::if_else_statement<Cond, Then, Else>::type const
operator[](Else const & else_) const
{
return expression::if_else_statement<Cond, Then, Else>::make(cond, then, else_);
}
Cond cond;
Then then;
};
// We subclass actor so we can provide the member else_ (which is an
// else_gen responsible for the .else_[ expr ] branch).
template<typename Expr>
struct if_actor : actor<Expr>
{
typedef actor<Expr> base_type;
if_actor(base_type const & base)
: base_type(base)
, else_(proto::child_c<0>(*this), proto::child_c<1>(*this))
{}
typedef typename proto::result_of::child_c<Expr, 0>::type cond_type;
typedef typename proto::result_of::child_c<Expr, 1>::type then_type;
else_gen<cond_type, then_type> else_;
};
template <typename Expr>
struct is_actor<if_actor<Expr> >
: mpl::true_
{};
// Generator for if( cond )[ then ] branch.
template<typename Cond>
struct if_gen
{
if_gen(Cond const & cond_)
: cond(cond_) {}
template<typename Then>
typename expression::if_<Cond, Then>::type const
operator[](Then const & then) const
{
return expression::if_<Cond, Then>::make(cond, then);
}
Cond cond;
};
template<typename Cond>
inline
if_gen<Cond> const
if_(Cond const & cond)
{
return if_gen<Cond>(cond);
}
}}
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#endif
|
