boost/proto/transform/when.hpp
/////////////////////////////////////////////////////////////////////////////// /// \file when.hpp /// Definition of when transform. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 #define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/call.hpp> #include <boost/proto/transform/make.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/env.hpp> #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename Grammar, typename R, typename Fun> struct when_impl : transform<when<Grammar, Fun> > { typedef Grammar first; typedef Fun second; typedef typename Grammar::proto_grammar proto_grammar; // Note: do not evaluate is_callable<R> in this scope. // R may be an incomplete type at this point. template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { // OK to evaluate is_callable<R> here. R should be compete by now. typedef typename mpl::if_c< is_callable<R>::value , proto::call<Fun> // "R" is a function to call , proto::make<Fun> // "R" is an object to construct >::type which; typedef typename which::template impl<Expr, State, Data>::result_type result_type; /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on /// whether <tt>is_callable\<R\>::value</tt> is \c true or /// \c false. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true /// \return <tt>which()(e, s, d)</tt> BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return typename which::template impl<Expr, State, Data>()(e, s, d); } }; }; } /// \brief A grammar element and a PrimitiveTransform that associates /// a transform with the grammar. /// /// Use <tt>when\<\></tt> to override a grammar's default transform /// with a custom transform. It is for used when composing larger /// transforms by associating smaller transforms with individual /// rules in your grammar, as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode /// /// In <tt>when\<G, T\></tt>, when \c T is a class type it is a /// PrimitiveTransform and the following equivalencies hold: /// /// <tt>boost::result_of\<when\<G,T\>(E,S,V)\>::type</tt> is the same as /// <tt>boost::result_of\<T(E,S,V)\>::type</tt>. /// /// <tt>when\<G,T\>()(e,s,d)</tt> is the same as /// <tt>T()(e,s,d)</tt>. template<typename Grammar, typename PrimitiveTransform /*= Grammar*/> struct when : PrimitiveTransform { typedef Grammar first; typedef PrimitiveTransform second; typedef typename Grammar::proto_grammar proto_grammar; }; /// \brief A specialization that treats function pointer Transforms as /// if they were function type Transforms. /// /// This specialization requires that \c Fun is actually a function type. /// /// This specialization is required for nested transforms such as /// <tt>when\<G, T0(T1(_))\></tt>. In C++, functions that are used as /// parameters to other functions automatically decay to funtion /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization /// is required to handle these nested function pointer type transforms /// properly. template<typename Grammar, typename Fun> struct when<Grammar, Fun *> : when<Grammar, Fun> {}; /// \brief Syntactic sugar for <tt>when\<_, Fun\></tt>, for use /// in grammars to handle all the cases not yet handled. /// /// Use <tt>otherwise\<T\></tt> in your grammars as a synonym for /// <tt>when\<_, T\></tt> as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode template<typename Fun> struct otherwise : when<_, Fun> {}; namespace envns_ { // Define the transforms global BOOST_PROTO_DEFINE_ENV_VAR(transforms_type, transforms); } using envns_::transforms; /// \brief This specialization uses the Data parameter as a collection /// of transforms that can be indexed by the specified rule. /// /// Use <tt>when\<T, external_transform\></tt> in your code when you would like /// to define a grammar once and use it to evaluate expressions with /// many different sets of transforms. The transforms are found by /// using the Data parameter as a map from rules to transforms. /// /// See \c action_map for an example. template<typename Grammar> struct when<Grammar, external_transform> : proto::transform<when<Grammar, external_transform> > { typedef Grammar first; typedef external_transform second; typedef typename Grammar::proto_grammar proto_grammar; template<typename Expr, typename State, typename Data> struct impl : remove_reference< typename mpl::eval_if_c< proto::result_of::has_env_var<Data, transforms_type>::value , proto::result_of::env_var<Data, transforms_type> , proto::result_of::env_var<Data, data_type> >::type >::type::template when<Grammar>::template impl<Expr, State, Data> {}; }; /// \brief For defining a map of Rule/Transform pairs for use with /// <tt>when\<T, external_transform\></tt> to make transforms external to the grammar /// /// The following code defines a grammar with a couple of external transforms. /// It also defines an action_map that maps from rules to transforms. It then /// passes that transforms map at the Data parameter to the grammar. In this way, /// the behavior of the grammar can be modified post-hoc by passing a different /// action_map. /// /// \code /// struct int_terminal /// : proto::terminal<int> /// {}; /// /// struct char_terminal /// : proto::terminal<char> /// {}; /// /// struct my_grammar /// : proto::or_< /// proto::when< int_terminal, proto::external_transform > /// , proto::when< char_terminal, proto::external_transform > /// , proto::when< /// proto::plus< my_grammar, my_grammar > /// , proto::fold< _, int(), my_grammar > /// > /// > /// {}; /// /// struct my_transforms /// : proto::external_transforms< /// proto::when<int_terminal, print(proto::_value)> /// , proto::when<char_terminal, print(proto::_value)> /// > /// {}; /// /// proto::literal<int> i(1); /// proto::literal<char> c('a'); /// my_transforms trx; /// /// // Evaluate "i+c" using my_grammar with the specified transforms: /// my_grammar()(i + c, 0, trx); /// \endcode template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)> struct external_transforms { typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type; template<typename Rule> struct when : proto::when<_, typename mpl::at<map_type, Rule>::type> {}; }; // Other specializations of proto::when are generated by the preprocessor... #include <boost/proto/transform/detail/when.hpp> /// INTERNAL ONLY /// template<typename Grammar, typename Transform> struct is_callable<when<Grammar, Transform> > : mpl::true_ {}; }} // namespace boost::proto #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma warning(pop) #endif #endif