comparison DEPENDENCIES/generic/include/boost/phoenix/scope/let.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 /*==============================================================================
     Copyright (c) 2001-2010 Joel de Guzman
     Copyright (c) 2004 Daniel Wallin
     Copyright (c) 2010 Thomas Heller
+    Copyright (c) 2015 John Fletcher
 
     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 BOOST_PHOENIX_SCOPE_LET_HPP
 #define BOOST_PHOENIX_SCOPE_LET_HPP
 
+//#include <boost/assert.hpp>
+//#include <sstream>
 #include <boost/phoenix/core/limits.hpp>
 #include <boost/fusion/include/transform.hpp>
 #include <boost/fusion/include/as_vector.hpp>
 #include <boost/phoenix/core/call.hpp>
 #include <boost/phoenix/core/expression.hpp>

             typedef
                 typename proto::detail::uncvref<
                     typename proto::result_of::value<Map>::type
                      >::type
                      map_type;
+
+            typedef
+                typename proto::detail::uncvref<Expr>::type
+                     expr_type;
             
-            typedef typename 
+            typedef typename
                 detail::result_of::initialize_locals<
                     vars_type
                   , Context
                 >::type
             locals_type;
 
             typedef typename
                 result_of::eval<
-                    Expr
+                    expr_type
                   , typename result_of::context<
                         scoped_environment<
                             env_type
                           , env_type
                           , locals_type

 
         template <typename Vars, typename Map, typename Expr, typename Context>
         typename result<let_eval(Vars const&, Map const&, Expr const &, Context const &)>::type const
         operator()(Vars const & vars, Map, Expr const & expr, Context const & ctx) const
         {
+            Vars vars_(vars);
+
             typedef
                 typename proto::detail::uncvref<
                     typename result_of::env<Context>::type
                 >::type
                 env_type;

                     vars_type
                   , Context
                 >::type
             locals_type;
 
-            locals_type locals = initialize_locals(proto::value(vars), ctx);
+            locals_type locals = initialize_locals(proto::value(vars_), ctx);
+
+            typedef typename result<let_eval(Vars const&, Map const&, Expr const &, Context const &)>::type result_type;
 
             scoped_environment<
                 env_type
               , env_type
               , locals_type
               , map_type
             >
             env(phoenix::env(ctx), phoenix::env(ctx), locals);
 
-            return eval(expr, phoenix::context(env, phoenix::actions(ctx)));
+            // Fix for bugs (trial)
+            // The idea is to do something which will not be optimised away.
+            //int vsize = boost::fusion::size(vars);
+            //std::stringstream strm;
+            //strm << vsize << std::endl;
+            //int size = strm.str().length();
+            //BOOST_ASSERT(size >= 0);
+            result_type r = eval(expr, phoenix::context(env, phoenix::actions(ctx)));
+            // typedef is_value<result_type> is_val;
+            //if(is_val::value) This seems always to be true
+            //{
+            //   std::cout << "let result has value type" << std::endl;
+            // }
+            //if (is_val(r) ) std::cout << "let returns val" << std::endl;
+            //std::cout << "result is " << r << std::endl;
+            return r;
         }
     };
 
     template <typename Dummy>
     struct default_actions::when<rule::let_, Dummy>

     {};
 
     template <typename Locals, typename Map>
     struct let_actor_gen
     {
-        let_actor_gen(Locals const & locals)
-            : locals(locals)
+        let_actor_gen(Locals const & locals_)
+            : locals(locals_)
         {}
 
         let_actor_gen(let_actor_gen const & o)
             : locals(o.locals)
         {}

           , Map
           , Expr
         >::type const
         operator[](Expr const & expr) const
         {
-            return expression::let_<Locals, Map, Expr>::make(locals, Map(), expr);
+           typedef typename expression::let_<
+              Locals
+            , Map
+            , Expr
+           >::type let_type;
+           //typedef is_value<let_type> is_val;
+
+           let_type let_exp = expression::let_<Locals, Map, Expr>::make(locals, Map(), expr);
+           //if(is_val::value) //This seems always to be true
+           //{
+           //  std::cout << "let has value type" << std::endl;
+           //}
+           return let_exp;
         }
 
         Locals locals;
     };