| /*============================================================================= | |
| Phoenix V1.2.1 | |
| Copyright (c) 2001-2002 Joel de Guzman | |
| 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 PHOENIX_STATEMENTS_HPP | |
| #define PHOENIX_STATEMENTS_HPP | |
| /////////////////////////////////////////////////////////////////////////////// | |
| #include <boost/spirit/home/classic/phoenix/composite.hpp> | |
| /////////////////////////////////////////////////////////////////////////////// | |
| namespace phoenix { | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // sequential_composite | |
| // | |
| // Two or more actors separated by the comma generates a | |
| // sequential_composite which is a composite actor. Example: | |
| // | |
| // actor, | |
| // actor, | |
| // actor | |
| // | |
| // The actors are evaluated sequentially. The result type of this | |
| // is void. Note that the last actor should not have a trailing | |
| // comma. | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| template <typename A0, typename A1> | |
| struct sequential_composite { | |
| typedef sequential_composite<A0, A1> self_t; | |
| template <typename TupleT> | |
| struct result { typedef void type; }; | |
| sequential_composite(A0 const& _0, A1 const& _1) | |
| : a0(_0), a1(_1) {} | |
| template <typename TupleT> | |
| void | |
| eval(TupleT const& args) const | |
| { | |
| a0.eval(args); | |
| a1.eval(args); | |
| } | |
| A0 a0; A1 a1; // actors | |
| }; | |
| ////////////////////////////////// | |
| template <typename BaseT0, typename BaseT1> | |
| inline actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > > | |
| operator,(actor<BaseT0> const& _0, actor<BaseT1> const& _1) | |
| { | |
| return sequential_composite<actor<BaseT0>, actor<BaseT1> >(_0, _1); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // if_then_else_composite | |
| // | |
| // This composite has two (2) forms: | |
| // | |
| // if_(condition) | |
| // [ | |
| // statement | |
| // ] | |
| // | |
| // and | |
| // | |
| // if_(condition) | |
| // [ | |
| // true_statement | |
| // ] | |
| // .else_ | |
| // [ | |
| // false_statement | |
| // ] | |
| // | |
| // where condition is an actor that evaluates to bool. If condition | |
| // is true, the true_statement (again an actor) is executed | |
| // otherwise, the false_statement (another actor) is executed. The | |
| // result type of this is void. Note the trailing underscore after | |
| // if_ and the the leading dot and the trailing underscore before | |
| // and after .else_. | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| template <typename CondT, typename ThenT, typename ElseT> | |
| struct if_then_else_composite { | |
| typedef if_then_else_composite<CondT, ThenT, ElseT> self_t; | |
| template <typename TupleT> | |
| struct result { | |
| typedef void type; | |
| }; | |
| if_then_else_composite( | |
| CondT const& cond_, | |
| ThenT const& then_, | |
| ElseT const& else__) | |
| : cond(cond_), then(then_), else_(else__) {} | |
| template <typename TupleT> | |
| void eval(TupleT const& args) const | |
| { | |
| if (cond.eval(args)) | |
| then.eval(args); | |
| else | |
| else_.eval(args); | |
| } | |
| CondT cond; ThenT then; ElseT else_; // actors | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT, typename ThenT> | |
| struct else_gen { | |
| else_gen(CondT const& cond_, ThenT const& then_) | |
| : cond(cond_), then(then_) {} | |
| template <typename ElseT> | |
| actor<if_then_else_composite<CondT, ThenT, | |
| typename as_actor<ElseT>::type> > | |
| operator[](ElseT const& else_) | |
| { | |
| typedef if_then_else_composite<CondT, ThenT, | |
| typename as_actor<ElseT>::type> | |
| result; | |
| return result(cond, then, as_actor<ElseT>::convert(else_)); | |
| } | |
| CondT cond; ThenT then; | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT, typename ThenT> | |
| struct if_then_composite { | |
| typedef if_then_composite<CondT, ThenT> self_t; | |
| template <typename TupleT> | |
| struct result { typedef void type; }; | |
| if_then_composite(CondT const& cond_, ThenT const& then_) | |
| : cond(cond_), then(then_), else_(cond, then) {} | |
| template <typename TupleT> | |
| void eval(TupleT const& args) const | |
| { | |
| if (cond.eval(args)) | |
| then.eval(args); | |
| } | |
| CondT cond; ThenT then; // actors | |
| else_gen<CondT, ThenT> else_; | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT> | |
| struct if_gen { | |
| if_gen(CondT const& cond_) | |
| : cond(cond_) {} | |
| template <typename ThenT> | |
| actor<if_then_composite< | |
| typename as_actor<CondT>::type, | |
| typename as_actor<ThenT>::type> > | |
| operator[](ThenT const& then) const | |
| { | |
| typedef if_then_composite< | |
| typename as_actor<CondT>::type, | |
| typename as_actor<ThenT>::type> | |
| result; | |
| return result( | |
| as_actor<CondT>::convert(cond), | |
| as_actor<ThenT>::convert(then)); | |
| } | |
| CondT cond; | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT> | |
| inline if_gen<CondT> | |
| if_(CondT const& cond) | |
| { | |
| return if_gen<CondT>(cond); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // while_composite | |
| // | |
| // This composite has the form: | |
| // | |
| // while_(condition) | |
| // [ | |
| // statement | |
| // ] | |
| // | |
| // While the condition (an actor) evaluates to true, statement | |
| // (another actor) is executed. The result type of this is void. | |
| // Note the trailing underscore after while_. | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| template <typename CondT, typename DoT> | |
| struct while_composite { | |
| typedef while_composite<CondT, DoT> self_t; | |
| template <typename TupleT> | |
| struct result { typedef void type; }; | |
| while_composite(CondT const& cond_, DoT const& do__) | |
| : cond(cond_), do_(do__) {} | |
| template <typename TupleT> | |
| void eval(TupleT const& args) const | |
| { | |
| while (cond.eval(args)) | |
| do_.eval(args); | |
| } | |
| CondT cond; | |
| DoT do_; | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT> | |
| struct while_gen { | |
| while_gen(CondT const& cond_) | |
| : cond(cond_) {} | |
| template <typename DoT> | |
| actor<while_composite< | |
| typename as_actor<CondT>::type, | |
| typename as_actor<DoT>::type> > | |
| operator[](DoT const& do_) const | |
| { | |
| typedef while_composite< | |
| typename as_actor<CondT>::type, | |
| typename as_actor<DoT>::type> | |
| result; | |
| return result( | |
| as_actor<CondT>::convert(cond), | |
| as_actor<DoT>::convert(do_)); | |
| } | |
| CondT cond; | |
| }; | |
| ////////////////////////////////// | |
| template <typename CondT> | |
| inline while_gen<CondT> | |
| while_(CondT const& cond) | |
| { | |
| return while_gen<CondT>(cond); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // do_composite | |
| // | |
| // This composite has the form: | |
| // | |
| // do_ | |
| // [ | |
| // statement | |
| // ] | |
| // .while_(condition) | |
| // | |
| // While the condition (an actor) evaluates to true, statement | |
| // (another actor) is executed. The statement is executed at least | |
| // once. The result type of this is void. Note the trailing | |
| // underscore after do_ and the the leading dot and the trailing | |
| // underscore before and after .while_. | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| template <typename DoT, typename CondT> | |
| struct do_composite { | |
| typedef do_composite<DoT, CondT> self_t; | |
| template <typename TupleT> | |
| struct result { typedef void type; }; | |
| do_composite(DoT const& do__, CondT const& cond_) | |
| : do_(do__), cond(cond_) {} | |
| template <typename TupleT> | |
| void eval(TupleT const& args) const | |
| { | |
| do | |
| do_.eval(args); | |
| while (cond.eval(args)); | |
| } | |
| DoT do_; | |
| CondT cond; | |
| }; | |
| //////////////////////////////////// | |
| template <typename DoT> | |
| struct do_gen2 { | |
| do_gen2(DoT const& do__) | |
| : do_(do__) {} | |
| template <typename CondT> | |
| actor<do_composite< | |
| typename as_actor<DoT>::type, | |
| typename as_actor<CondT>::type> > | |
| while_(CondT const& cond) const | |
| { | |
| typedef do_composite< | |
| typename as_actor<DoT>::type, | |
| typename as_actor<CondT>::type> | |
| result; | |
| return result( | |
| as_actor<DoT>::convert(do_), | |
| as_actor<CondT>::convert(cond)); | |
| } | |
| DoT do_; | |
| }; | |
| //////////////////////////////////// | |
| struct do_gen { | |
| template <typename DoT> | |
| do_gen2<DoT> | |
| operator[](DoT const& do_) const | |
| { | |
| return do_gen2<DoT>(do_); | |
| } | |
| }; | |
| do_gen const do_ = do_gen(); | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // for_composite | |
| // | |
| // This statement has the form: | |
| // | |
| // for_(init, condition, step) | |
| // [ | |
| // statement | |
| // ] | |
| // | |
| // Where init, condition, step and statement are all actors. init | |
| // is executed once before entering the for-loop. The for-loop | |
| // exits once condition evaluates to false. At each loop iteration, | |
| // step and statement is called. The result of this statement is | |
| // void. Note the trailing underscore after for_. | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| template <typename InitT, typename CondT, typename StepT, typename DoT> | |
| struct for_composite { | |
| typedef composite<InitT, CondT, StepT, DoT> self_t; | |
| template <typename TupleT> | |
| struct result { typedef void type; }; | |
| for_composite( | |
| InitT const& init_, | |
| CondT const& cond_, | |
| StepT const& step_, | |
| DoT const& do__) | |
| : init(init_), cond(cond_), step(step_), do_(do__) {} | |
| template <typename TupleT> | |
| void | |
| eval(TupleT const& args) const | |
| { | |
| for (init.eval(args); cond.eval(args); step.eval(args)) | |
| do_.eval(args); | |
| } | |
| InitT init; CondT cond; StepT step; DoT do_; // actors | |
| }; | |
| ////////////////////////////////// | |
| template <typename InitT, typename CondT, typename StepT> | |
| struct for_gen { | |
| for_gen( | |
| InitT const& init_, | |
| CondT const& cond_, | |
| StepT const& step_) | |
| : init(init_), cond(cond_), step(step_) {} | |
| template <typename DoT> | |
| actor<for_composite< | |
| typename as_actor<InitT>::type, | |
| typename as_actor<CondT>::type, | |
| typename as_actor<StepT>::type, | |
| typename as_actor<DoT>::type> > | |
| operator[](DoT const& do_) const | |
| { | |
| typedef for_composite< | |
| typename as_actor<InitT>::type, | |
| typename as_actor<CondT>::type, | |
| typename as_actor<StepT>::type, | |
| typename as_actor<DoT>::type> | |
| result; | |
| return result( | |
| as_actor<InitT>::convert(init), | |
| as_actor<CondT>::convert(cond), | |
| as_actor<StepT>::convert(step), | |
| as_actor<DoT>::convert(do_)); | |
| } | |
| InitT init; CondT cond; StepT step; | |
| }; | |
| ////////////////////////////////// | |
| template <typename InitT, typename CondT, typename StepT> | |
| inline for_gen<InitT, CondT, StepT> | |
| for_(InitT const& init, CondT const& cond, StepT const& step) | |
| { | |
| return for_gen<InitT, CondT, StepT>(init, cond, step); | |
| } | |
| } // namespace phoenix | |
| #endif |