← Back
Editing: try_catch.hpp
/*============================================================================== 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_TRY_CATCH_HPP #define BOOST_PHOENIX_STATEMENT_TRY_CATCH_HPP #include <boost/phoenix/config.hpp> #include <boost/phoenix/core/limits.hpp> #include <boost/phoenix/core/call.hpp> #include <boost/phoenix/core/expression.hpp> #include <boost/phoenix/core/meta_grammar.hpp> #include <boost/phoenix/core/is_nullary.hpp> #include <boost/phoenix/scope/local_variable.hpp> #include <boost/phoenix/scope/scoped_environment.hpp> #include <boost/proto/functional/fusion/pop_front.hpp> #include <boost/core/enable_if.hpp> #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable: 4355) // 'this' : used in base member initializer list #endif namespace boost { namespace phoenix { template <typename Expr> struct try_catch_actor; template <typename Exception> struct catch_exception { typedef Exception type; }; namespace tag { struct try_catch {}; struct catch_ {}; struct catch_all {}; } namespace expression { template < typename Try , BOOST_PHOENIX_typename_A_void(BOOST_PHOENIX_CATCH_LIMIT) , typename Dummy = void > struct try_catch; // bring in the expression definitions #include <boost/phoenix/statement/detail/try_catch_expression.hpp> template <typename A0, typename A1, typename A2 = void> struct catch_ : proto::nary_expr<tag::catch_, A0, A1, A2> {}; template <typename A0, typename A1> struct catch_<A0, A1, void> : proto::binary_expr<tag::catch_, A0, A1> {}; template <typename A0> struct catch_all : proto::unary_expr<tag::catch_all, A0> {}; } namespace rule { typedef expression::catch_< proto::terminal<catch_exception<proto::_> > , local_variable , meta_grammar > captured_catch; typedef expression::catch_< proto::terminal<catch_exception<proto::_> > , meta_grammar > non_captured_catch; struct catch_ : proto::or_< captured_catch , non_captured_catch > {}; struct catch_all : expression::catch_all< meta_grammar > {}; struct try_catch : proto::or_< expression::try_catch< meta_grammar , proto::vararg<rule::catch_> > , expression::try_catch< meta_grammar , rule::catch_all > , expression::try_catch< meta_grammar , proto::vararg<rule::catch_> , rule::catch_all > > {}; } template <typename Dummy> struct meta_grammar::case_<tag::try_catch, Dummy> : enable_rule<rule::try_catch, Dummy> {}; struct try_catch_eval { typedef void result_type; template <typename Try, typename Context> void operator()(Try const &, Context const &) const {} template <typename Catch, typename Exception, typename Context> typename enable_if<proto::matches<Catch, rule::non_captured_catch> >::type eval_catch_body(Catch const &c, Exception & /*unused*/, Context const &ctx BOOST_PHOENIX_SFINAE_AND_OVERLOADS) const { phoenix::eval(proto::child_c<1>(c), ctx); } template <typename Catch, typename Exception, typename Context> typename enable_if<proto::matches<Catch, rule::captured_catch> >::type eval_catch_body(Catch const &c, Exception &e, Context const &ctx) const { typedef typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c<Catch, 1>::type >::type >::type capture_type; typedef typename proto::detail::uncvref< typename result_of::env<Context>::type >::type env_type; typedef vector1<Exception &> local_type; typedef detail::map_local_index_to_tuple<capture_type> map_type; typedef phoenix::scoped_environment< env_type , env_type , local_type , map_type > scoped_env_tpe; local_type local = {e}; scoped_env_tpe env(phoenix::env(ctx), phoenix::env(ctx), local); phoenix::eval(proto::child_c<2>(c), phoenix::context(env, phoenix::actions(ctx))); } // bring in the operator overloads #include <boost/phoenix/statement/detail/try_catch_eval.hpp> }; template <typename Dummy> struct default_actions::when<rule::try_catch, Dummy> : call<try_catch_eval, Dummy> {}; namespace detail { struct try_catch_is_nullary : proto::or_< proto::when< phoenix::rule::catch_all , proto::call< evaluator( proto::_child_c<0> , proto::_data , proto::make<proto::empty_env()> ) > > , proto::when< phoenix::rule::catch_ , proto::or_< proto::when< phoenix::rule::captured_catch , proto::call< evaluator( proto::_child_c<2> , proto::call< phoenix::functional::context( proto::make<mpl::true_()> , proto::make<detail::scope_is_nullary_actions()> ) > , proto::make<proto::empty_env()> ) > > , proto::otherwise< proto::call< evaluator( proto::_child_c<1> , proto::_data , proto::make<proto::empty_env()> ) > > > > , proto::when< phoenix::rule::try_catch , proto::make< mpl::and_< proto::call< evaluator( proto::_child_c<0> , proto::_data , proto::make<proto::empty_env()> ) > , proto::fold< proto::call< proto::functional::pop_front(proto::_) > , proto::make<mpl::true_()> , proto::make< mpl::and_< proto::_state , proto::call< try_catch_is_nullary( proto::_ , proto::make<proto::empty_env()> , proto::_data ) > >() > > >() > > > {}; template < typename TryCatch , typename Exception , typename Capture , typename Expr , long Arity = proto::arity_of<TryCatch>::value > struct catch_push_back; template <typename TryCatch, typename Exception, typename Capture, typename Expr> struct catch_push_back<TryCatch, Exception, Capture, Expr, 1> { typedef typename proto::result_of::make_expr< phoenix::tag::catch_ , proto::basic_default_domain , catch_exception<Exception> , Capture , Expr >::type catch_expr; typedef phoenix::expression::try_catch< TryCatch , catch_expr > gen_type; typedef typename gen_type::type type; static type make(TryCatch const & try_catch, Capture const & capture, Expr const & catch_) { return gen_type::make( try_catch , proto::make_expr< phoenix::tag::catch_ , proto::basic_default_domain >(catch_exception<Exception>(), capture, catch_) ); } }; template <typename TryCatch, typename Exception, typename Expr> struct catch_push_back<TryCatch, Exception, void, Expr, 1> { typedef typename proto::result_of::make_expr< phoenix::tag::catch_ , proto::basic_default_domain , catch_exception<Exception> , Expr >::type catch_expr; typedef phoenix::expression::try_catch< TryCatch , catch_expr > gen_type; typedef typename gen_type::type type; static type make(TryCatch const & try_catch, Expr const & catch_) { return gen_type::make( try_catch , proto::make_expr< phoenix::tag::catch_ , proto::basic_default_domain >(catch_exception<Exception>(), catch_) ); } }; template < typename TryCatch , typename Expr , long Arity = proto::arity_of<TryCatch>::value > struct catch_all_push_back; template <typename TryCatch, typename Expr> struct catch_all_push_back<TryCatch, Expr, 1> { typedef typename proto::result_of::make_expr< phoenix::tag::catch_all , proto::basic_default_domain , Expr >::type catch_expr; typedef phoenix::expression::try_catch< TryCatch , catch_expr > gen_type; typedef typename gen_type::type type; static type make(TryCatch const& try_catch, Expr const& catch_) { return gen_type::make( try_catch , proto::make_expr< phoenix::tag::catch_all , proto::basic_default_domain >(catch_) ); } }; #include <boost/phoenix/statement/detail/catch_push_back.hpp> } template <typename Dummy> struct is_nullary::when<rule::try_catch, Dummy> : proto::call< detail::try_catch_is_nullary( proto::_ , proto::make<proto::empty_env()> , _context ) > {}; template <typename TryCatch, typename Exception, typename Capture = void> struct catch_gen { catch_gen(TryCatch const& try_catch_, Capture const& capture) : try_catch(try_catch_) , capture(capture) {} template <typename Expr> typename boost::disable_if< proto::matches< typename proto::result_of::child_c< TryCatch , proto::arity_of<TryCatch>::value - 1 >::type , rule::catch_all > , typename detail::catch_push_back<TryCatch, Exception, Capture, Expr>::type >::type operator[](Expr const& expr) const { return detail::catch_push_back<TryCatch, Exception, Capture, Expr>::make( try_catch, capture, expr ); } TryCatch try_catch; Capture capture; }; template <typename TryCatch, typename Exception> struct catch_gen<TryCatch, Exception, void> { catch_gen(TryCatch const& try_catch_) : try_catch(try_catch_) {} template <typename Expr> typename boost::disable_if< proto::matches< typename proto::result_of::child_c< TryCatch , proto::arity_of<TryCatch>::value - 1 >::type , rule::catch_all > , typename detail::catch_push_back<TryCatch, Exception, void, Expr>::type >::type operator[](Expr const& expr) const { return detail::catch_push_back<TryCatch, Exception, void, Expr>::make( try_catch, expr ); } TryCatch try_catch; }; template <typename TryCatch> struct catch_all_gen { catch_all_gen(TryCatch const& try_catch_) : try_catch(try_catch_) {} template <typename Expr> typename boost::disable_if< proto::matches< typename proto::result_of::child_c< TryCatch , proto::arity_of<TryCatch>::value - 1 >::type , rule::catch_all > , typename detail::catch_all_push_back<TryCatch, Expr>::type >::type operator[](Expr const& expr) const { return detail::catch_all_push_back<TryCatch, Expr>::make( try_catch, expr ); } TryCatch try_catch; }; template < typename Expr > struct try_catch_actor; template <typename Expr> struct try_catch_actor : actor<Expr> { typedef actor<Expr> base_type; try_catch_actor(base_type const& expr) : base_type(expr) , catch_all(*this) { } template <typename Exception> catch_gen<base_type, Exception> const catch_() const { return catch_gen<base_type, Exception>(*this); } template <typename Exception, typename Capture> catch_gen<base_type, Exception, Capture> const catch_(Capture const &expr) const { return catch_gen<base_type, Exception, Capture>(*this, expr); } catch_all_gen<base_type> const catch_all; }; template <typename Expr> struct is_actor<try_catch_actor<Expr> > : mpl::true_ {}; struct try_gen { template <typename Try> typename expression::try_catch<Try>::type const operator[](Try const & try_) const { return expression::try_catch<Try>::make(try_); } }; #ifndef BOOST_PHOENIX_NO_PREDEFINED_TERMINALS try_gen const try_ = {}; #endif }} #ifdef _MSC_VER #pragma warning(pop) #endif #endif
Save File
Cancel