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///////////////////////////////////////////////////////////////////////////////
15namespace 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///////////////////////////////////////////////////////////////////////////////
33template <typename A0, typename A1>
34struct sequential_composite {
35
36 typedef sequential_composite<A0, A1> self_t;
37
38 template <typename TupleT>
39 struct result { typedef void type; };
40
41 sequential_composite(A0 const& _0, A1 const& _1)
42 : a0(_0), a1(_1) {}
43
44 template <typename TupleT>
45 void
46 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//////////////////////////////////
56template <typename BaseT0, typename BaseT1>
57inline actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > >
58operator,(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///////////////////////////////////////////////////////////////////////////////
93template <typename CondT, typename ThenT, typename ElseT>
94struct 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
104 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>
111 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//////////////////////////////////
123template <typename CondT, typename ThenT>
124struct else_gen {
125
126 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> >
132 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//////////////////////////////////
145template <typename CondT, typename ThenT>
146struct 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
153 if_then_composite(CondT const& cond_, ThenT const& then_)
154 : cond(cond_), then(then_), else_(cond, then) {}
155
156 template <typename TupleT>
157 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//////////////////////////////////
168template <typename CondT>
169struct if_gen {
170
171 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> >
178 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//////////////////////////////////
194template <typename CondT>
195inline if_gen<CondT>
196if_(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///////////////////////////////////////////////////////////////////////////////
217template <typename CondT, typename DoT>
218struct while_composite {
219
220 typedef while_composite<CondT, DoT> self_t;
221
222 template <typename TupleT>
223 struct result { typedef void type; };
224
225 while_composite(CondT const& cond_, DoT const& do__)
226 : cond(cond_), do_(do__) {}
227
228 template <typename TupleT>
229 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//////////////////////////////////
240template <typename CondT>
241struct while_gen {
242
243 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> >
250 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//////////////////////////////////
266template <typename CondT>
267inline while_gen<CondT>
268while_(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///////////////////////////////////////////////////////////////////////////////
292template <typename DoT, typename CondT>
293struct do_composite {
294
295 typedef do_composite<DoT, CondT> self_t;
296
297 template <typename TupleT>
298 struct result { typedef void type; };
299
300 do_composite(DoT const& do__, CondT const& cond_)
301 : do_(do__), cond(cond_) {}
302
303 template <typename TupleT>
304 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////////////////////////////////////
316template <typename DoT>
317struct do_gen2 {
318
319 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> >
326 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////////////////////////////////////
342struct do_gen {
343
344 template <typename DoT>
345 do_gen2<DoT>
346 operator[](DoT const& do_) const
347 {
348 return do_gen2<DoT>(do_);
349 }
350};
351
352do_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///////////////////////////////////////////////////////////////////////////////
372template <typename InitT, typename CondT, typename StepT, typename DoT>
373struct for_composite {
374
375 typedef composite<InitT, CondT, StepT, DoT> self_t;
376
377 template <typename TupleT>
378 struct result { typedef void type; };
379
380 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
389 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//////////////////////////////////
399template <typename InitT, typename CondT, typename StepT>
400struct for_gen {
401
402 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> >
414 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//////////////////////////////////
434template <typename InitT, typename CondT, typename StepT>
435inline for_gen<InitT, CondT, StepT>
436for_(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

source code of boost/libs/spirit/include/boost/spirit/home/classic/phoenix/statements.hpp