FM / statement

/usr/include/boost/phoenix/statement

Name	Size	Mode	Actions
detail/	-	0755	rm
do_while.hpp	1996	0644	edit dl rm
for.hpp	2456	0644	edit dl rm
if.hpp	4576	0644	edit dl rm
sequence.hpp	1254	0644	edit dl rm
switch.hpp	8488	0644	edit dl rm
throw.hpp	2790	0644	edit dl rm
try_catch.hpp	16760	0644	edit dl rm
while.hpp	1850	0644	edit dl rm

Edit: /usr/include/boost/phoenix/statement/throw.hpp (2790B)

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_STATEMENT_THROW_HPP
#define BOOST_PHOENIX_STATEMENT_THROW_HPP

#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/core/actor.hpp>
#include <boost/phoenix/core/call.hpp>
#include <boost/phoenix/core/meta_grammar.hpp>
#include <boost/phoenix/core/expression.hpp>
#include <boost/phoenix/core/terminal.hpp>
#include <boost/phoenix/core/value.hpp>

namespace boost { namespace phoenix
{
    namespace tag
    {
        struct throw_ {};
    }

namespace expression
    {
        template <typename A>
        struct throw_
            : expr<tag::throw_, A>
        {};
    }

namespace rule
    {
        struct throw_
            : expression::throw_<meta_grammar>
        {};
    }

template <typename Dummy>
    struct meta_grammar::case_<tag::throw_, Dummy>
        : enable_rule<rule::throw_, Dummy>
    {};

struct throw_eval
    {
        typedef void result_type;

template <typename ThrowExpr, typename Context>
        result_type
        operator()(ThrowExpr const& throw_expr, Context const & ctx) const
        {
            throw boost::phoenix::eval(throw_expr, ctx);
        }
    };
    
    template <typename Dummy>
    struct default_actions::when<rule::throw_, Dummy>
        : call<throw_eval>
    {};

template <typename ThrowExpr>
    inline
    typename expression::throw_<ThrowExpr>::type const
    throw_(ThrowExpr const& throw_expr)
    {
        return expression::throw_<ThrowExpr>::make(throw_expr);
    }
    
    namespace detail
    {
        struct rethrow {};
    }
    
    namespace expression
    {
        struct rethrow
            : expression::value<detail::rethrow>
        {};
    }
    
    template<typename Dummy>
    struct is_custom_terminal<detail::rethrow, Dummy>
      : mpl::true_
    {};

template<typename Dummy>
    struct custom_terminal<detail::rethrow, Dummy>
    {
        typedef void result_type;
      //#ifndef BOOST_PHOENIX_NO_SPECIALIZE_CUSTOM_TERMINAL
        typedef void _is_throw_custom_terminal; // fix for #7730
      //#endif

template <typename Context>
        void operator()(detail::rethrow, Context &) const
        {
            throw;
        }
    };

inline
    expression::rethrow::type const
    throw_()
    {
        return expression::rethrow::make(detail::rethrow());
    }

}}

#endif

/*============================================================================== Copyright (c) 2005-2007 Dan Marsden Copyright (c) 2005-2010 Joel de Guzman Copyright (c) 2010 Thomas Heller 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_STATEMENT_THROW_HPP #define BOOST_PHOENIX_STATEMENT_THROW_HPP #include #include #include #include #include #include #include namespace boost { namespace phoenix { namespace tag { struct throw_ {}; } namespace expression { template struct throw_ : expr {}; } namespace rule { struct throw_ : expression::throw_ {}; } template struct meta_grammar::case_ : enable_rule {}; struct throw_eval { typedef void result_type; template result_type operator()(ThrowExpr const& throw_expr, Context const & ctx) const { throw boost::phoenix::eval(throw_expr, ctx); } }; template struct default_actions::when : call {}; template inline typename expression::throw_::type const throw_(ThrowExpr const& throw_expr) { return expression::throw_::make(throw_expr); } namespace detail { struct rethrow {}; } namespace expression { struct rethrow : expression::value {}; } template struct is_custom_terminal : mpl::true_ {}; template struct custom_terminal { typedef void result_type; //#ifndef BOOST_PHOENIX_NO_SPECIALIZE_CUSTOM_TERMINAL typedef void _is_throw_custom_terminal; // fix for #7730 //#endif template void operator()(detail::rethrow, Context &) const { throw; } }; inline expression::rethrow::type const throw_() { return expression::rethrow::make(detail::rethrow()); } }} #endif