1 /*=============================================================================
2 Phoenix V1.2.1
3 Copyright (c) 2001-2002 Joel de Guzman
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_CLASSIC_PHOENIX_STATEMENTS_HPP
9 #define BOOST_SPIRIT_CLASSIC_PHOENIX_STATEMENTS_HPP
10
11 ///////////////////////////////////////////////////////////////////////////////
12 #include <boost/spirit/home/classic/phoenix/composite.hpp>
13
14 ///////////////////////////////////////////////////////////////////////////////
15 namespace phoenix {
16
17 ///////////////////////////////////////////////////////////////////////////////
18 //
19 // sequential_composite
20 //
21 // Two or more actors separated by the comma generates a
22 // sequential_composite which is a composite actor. Example:
23 //
24 // actor,
25 // actor,
26 // actor
27 //
28 // The actors are evaluated sequentially. The result type of this
29 // is void. Note that the last actor should not have a trailing
30 // comma.
31 //
32 ///////////////////////////////////////////////////////////////////////////////
33 template <typename A0, typename A1>
34 struct sequential_composite {
35
36 typedef sequential_composite<A0, A1> self_t;
37
38 template <typename TupleT>
39 struct result { typedef void type; };
40
sequential_compositephoenix::sequential_composite41 sequential_composite(A0 const& _0, A1 const& _1)
42 : a0(_0), a1(_1) {}
43
44 template <typename TupleT>
45 void
evalphoenix::sequential_composite46 eval(TupleT const& args) const
47 {
48 a0.eval(args);
49 a1.eval(args);
50 }
51
52 A0 a0; A1 a1; // actors
53 };
54
55 //////////////////////////////////
56 template <typename BaseT0, typename BaseT1>
57 inline actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > >
operator ,(actor<BaseT0> const & _0,actor<BaseT1> const & _1)58 operator,(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
59 {
60 return sequential_composite<actor<BaseT0>, actor<BaseT1> >(_0, _1);
61 }
62
63 ///////////////////////////////////////////////////////////////////////////////
64 //
65 // if_then_else_composite
66 //
67 // This composite has two (2) forms:
68 //
69 // if_(condition)
70 // [
71 // statement
72 // ]
73 //
74 // and
75 //
76 // if_(condition)
77 // [
78 // true_statement
79 // ]
80 // .else_
81 // [
82 // false_statement
83 // ]
84 //
85 // where condition is an actor that evaluates to bool. If condition
86 // is true, the true_statement (again an actor) is executed
87 // otherwise, the false_statement (another actor) is executed. The
88 // result type of this is void. Note the trailing underscore after
89 // if_ and the leading dot and the trailing underscore before
90 // and after .else_.
91 //
92 ///////////////////////////////////////////////////////////////////////////////
93 template <typename CondT, typename ThenT, typename ElseT>
94 struct if_then_else_composite {
95
96 typedef if_then_else_composite<CondT, ThenT, ElseT> self_t;
97
98 template <typename TupleT>
99 struct result {
100
101 typedef void type;
102 };
103
if_then_else_compositephoenix::if_then_else_composite104 if_then_else_composite(
105 CondT const& cond_,
106 ThenT const& then_,
107 ElseT const& else__)
108 : cond(cond_), then(then_), else_(else__) {}
109
110 template <typename TupleT>
evalphoenix::if_then_else_composite111 void eval(TupleT const& args) const
112 {
113 if (cond.eval(args))
114 then.eval(args);
115 else
116 else_.eval(args);
117 }
118
119 CondT cond; ThenT then; ElseT else_; // actors
120 };
121
122 //////////////////////////////////
123 template <typename CondT, typename ThenT>
124 struct else_gen {
125
else_genphoenix::else_gen126 else_gen(CondT const& cond_, ThenT const& then_)
127 : cond(cond_), then(then_) {}
128
129 template <typename ElseT>
130 actor<if_then_else_composite<CondT, ThenT,
131 typename as_actor<ElseT>::type> >
operator []phoenix::else_gen132 operator[](ElseT const& else_)
133 {
134 typedef if_then_else_composite<CondT, ThenT,
135 typename as_actor<ElseT>::type>
136 result;
137
138 return result(cond, then, as_actor<ElseT>::convert(else_));
139 }
140
141 CondT cond; ThenT then;
142 };
143
144 //////////////////////////////////
145 template <typename CondT, typename ThenT>
146 struct if_then_composite {
147
148 typedef if_then_composite<CondT, ThenT> self_t;
149
150 template <typename TupleT>
151 struct result { typedef void type; };
152
if_then_compositephoenix::if_then_composite153 if_then_composite(CondT const& cond_, ThenT const& then_)
154 : cond(cond_), then(then_), else_(cond, then) {}
155
156 template <typename TupleT>
evalphoenix::if_then_composite157 void eval(TupleT const& args) const
158 {
159 if (cond.eval(args))
160 then.eval(args);
161 }
162
163 CondT cond; ThenT then; // actors
164 else_gen<CondT, ThenT> else_;
165 };
166
167 //////////////////////////////////
168 template <typename CondT>
169 struct if_gen {
170
if_genphoenix::if_gen171 if_gen(CondT const& cond_)
172 : cond(cond_) {}
173
174 template <typename ThenT>
175 actor<if_then_composite<
176 typename as_actor<CondT>::type,
177 typename as_actor<ThenT>::type> >
operator []phoenix::if_gen178 operator[](ThenT const& then) const
179 {
180 typedef if_then_composite<
181 typename as_actor<CondT>::type,
182 typename as_actor<ThenT>::type>
183 result;
184
185 return result(
186 as_actor<CondT>::convert(cond),
187 as_actor<ThenT>::convert(then));
188 }
189
190 CondT cond;
191 };
192
193 //////////////////////////////////
194 template <typename CondT>
195 inline if_gen<CondT>
if_(CondT const & cond)196 if_(CondT const& cond)
197 {
198 return if_gen<CondT>(cond);
199 }
200
201 ///////////////////////////////////////////////////////////////////////////////
202 //
203 // while_composite
204 //
205 // This composite has the form:
206 //
207 // while_(condition)
208 // [
209 // statement
210 // ]
211 //
212 // While the condition (an actor) evaluates to true, statement
213 // (another actor) is executed. The result type of this is void.
214 // Note the trailing underscore after while_.
215 //
216 ///////////////////////////////////////////////////////////////////////////////
217 template <typename CondT, typename DoT>
218 struct while_composite {
219
220 typedef while_composite<CondT, DoT> self_t;
221
222 template <typename TupleT>
223 struct result { typedef void type; };
224
while_compositephoenix::while_composite225 while_composite(CondT const& cond_, DoT const& do__)
226 : cond(cond_), do_(do__) {}
227
228 template <typename TupleT>
evalphoenix::while_composite229 void eval(TupleT const& args) const
230 {
231 while (cond.eval(args))
232 do_.eval(args);
233 }
234
235 CondT cond;
236 DoT do_;
237 };
238
239 //////////////////////////////////
240 template <typename CondT>
241 struct while_gen {
242
while_genphoenix::while_gen243 while_gen(CondT const& cond_)
244 : cond(cond_) {}
245
246 template <typename DoT>
247 actor<while_composite<
248 typename as_actor<CondT>::type,
249 typename as_actor<DoT>::type> >
operator []phoenix::while_gen250 operator[](DoT const& do_) const
251 {
252 typedef while_composite<
253 typename as_actor<CondT>::type,
254 typename as_actor<DoT>::type>
255 result;
256
257 return result(
258 as_actor<CondT>::convert(cond),
259 as_actor<DoT>::convert(do_));
260 }
261
262 CondT cond;
263 };
264
265 //////////////////////////////////
266 template <typename CondT>
267 inline while_gen<CondT>
while_(CondT const & cond)268 while_(CondT const& cond)
269 {
270 return while_gen<CondT>(cond);
271 }
272
273 ///////////////////////////////////////////////////////////////////////////////
274 //
275 // do_composite
276 //
277 // This composite has the form:
278 //
279 // do_
280 // [
281 // statement
282 // ]
283 // .while_(condition)
284 //
285 // While the condition (an actor) evaluates to true, statement
286 // (another actor) is executed. The statement is executed at least
287 // once. The result type of this is void. Note the trailing
288 // underscore after do_ and the leading dot and the trailing
289 // underscore before and after .while_.
290 //
291 ///////////////////////////////////////////////////////////////////////////////
292 template <typename DoT, typename CondT>
293 struct do_composite {
294
295 typedef do_composite<DoT, CondT> self_t;
296
297 template <typename TupleT>
298 struct result { typedef void type; };
299
do_compositephoenix::do_composite300 do_composite(DoT const& do__, CondT const& cond_)
301 : do_(do__), cond(cond_) {}
302
303 template <typename TupleT>
evalphoenix::do_composite304 void eval(TupleT const& args) const
305 {
306 do
307 do_.eval(args);
308 while (cond.eval(args));
309 }
310
311 DoT do_;
312 CondT cond;
313 };
314
315 ////////////////////////////////////
316 template <typename DoT>
317 struct do_gen2 {
318
do_gen2phoenix::do_gen2319 do_gen2(DoT const& do__)
320 : do_(do__) {}
321
322 template <typename CondT>
323 actor<do_composite<
324 typename as_actor<DoT>::type,
325 typename as_actor<CondT>::type> >
while_phoenix::do_gen2326 while_(CondT const& cond) const
327 {
328 typedef do_composite<
329 typename as_actor<DoT>::type,
330 typename as_actor<CondT>::type>
331 result;
332
333 return result(
334 as_actor<DoT>::convert(do_),
335 as_actor<CondT>::convert(cond));
336 }
337
338 DoT do_;
339 };
340
341 ////////////////////////////////////
342 struct do_gen {
343
344 template <typename DoT>
345 do_gen2<DoT>
operator []phoenix::do_gen346 operator[](DoT const& do_) const
347 {
348 return do_gen2<DoT>(do_);
349 }
350 };
351
352 do_gen const do_ = do_gen();
353
354 ///////////////////////////////////////////////////////////////////////////////
355 //
356 // for_composite
357 //
358 // This statement has the form:
359 //
360 // for_(init, condition, step)
361 // [
362 // statement
363 // ]
364 //
365 // Where init, condition, step and statement are all actors. init
366 // is executed once before entering the for-loop. The for-loop
367 // exits once condition evaluates to false. At each loop iteration,
368 // step and statement is called. The result of this statement is
369 // void. Note the trailing underscore after for_.
370 //
371 ///////////////////////////////////////////////////////////////////////////////
372 template <typename InitT, typename CondT, typename StepT, typename DoT>
373 struct for_composite {
374
375 typedef composite<InitT, CondT, StepT, DoT> self_t;
376
377 template <typename TupleT>
378 struct result { typedef void type; };
379
for_compositephoenix::for_composite380 for_composite(
381 InitT const& init_,
382 CondT const& cond_,
383 StepT const& step_,
384 DoT const& do__)
385 : init(init_), cond(cond_), step(step_), do_(do__) {}
386
387 template <typename TupleT>
388 void
evalphoenix::for_composite389 eval(TupleT const& args) const
390 {
391 for (init.eval(args); cond.eval(args); step.eval(args))
392 do_.eval(args);
393 }
394
395 InitT init; CondT cond; StepT step; DoT do_; // actors
396 };
397
398 //////////////////////////////////
399 template <typename InitT, typename CondT, typename StepT>
400 struct for_gen {
401
for_genphoenix::for_gen402 for_gen(
403 InitT const& init_,
404 CondT const& cond_,
405 StepT const& step_)
406 : init(init_), cond(cond_), step(step_) {}
407
408 template <typename DoT>
409 actor<for_composite<
410 typename as_actor<InitT>::type,
411 typename as_actor<CondT>::type,
412 typename as_actor<StepT>::type,
413 typename as_actor<DoT>::type> >
operator []phoenix::for_gen414 operator[](DoT const& do_) const
415 {
416 typedef for_composite<
417 typename as_actor<InitT>::type,
418 typename as_actor<CondT>::type,
419 typename as_actor<StepT>::type,
420 typename as_actor<DoT>::type>
421 result;
422
423 return result(
424 as_actor<InitT>::convert(init),
425 as_actor<CondT>::convert(cond),
426 as_actor<StepT>::convert(step),
427 as_actor<DoT>::convert(do_));
428 }
429
430 InitT init; CondT cond; StepT step;
431 };
432
433 //////////////////////////////////
434 template <typename InitT, typename CondT, typename StepT>
435 inline for_gen<InitT, CondT, StepT>
for_(InitT const & init,CondT const & cond,StepT const & step)436 for_(InitT const& init, CondT const& cond, StepT const& step)
437 {
438 return for_gen<InitT, CondT, StepT>(init, cond, step);
439 }
440
441 } // namespace phoenix
442
443 #endif
444