]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 PHOENIX_STATEMENTS_HPP | |
9 | #define 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 | ||
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 | ////////////////////////////////// | |
56 | template <typename BaseT0, typename BaseT1> | |
57 | inline actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > > | |
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 | ||
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 | ////////////////////////////////// | |
123 | template <typename CondT, typename ThenT> | |
124 | struct 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 | ////////////////////////////////// | |
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 | ||
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 | ////////////////////////////////// | |
168 | template <typename CondT> | |
169 | struct 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 | ////////////////////////////////// | |
194 | template <typename CondT> | |
195 | inline if_gen<CondT> | |
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 | ||
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 | ////////////////////////////////// | |
240 | template <typename CondT> | |
241 | struct 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 | ////////////////////////////////// | |
266 | template <typename CondT> | |
267 | inline while_gen<CondT> | |
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 | ||
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 | //////////////////////////////////// | |
316 | template <typename DoT> | |
317 | struct 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 | //////////////////////////////////// | |
342 | struct 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 | ||
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 | ||
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 | ////////////////////////////////// | |
399 | template <typename InitT, typename CondT, typename StepT> | |
400 | struct 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 | ////////////////////////////////// | |
434 | template <typename InitT, typename CondT, typename StepT> | |
435 | inline for_gen<InitT, CondT, StepT> | |
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 |