diff DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/statements.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/statements.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,443 @@
+/*=============================================================================
+    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