default.hpp

来自「Boost provides free peer-reviewed portab」· HPP 代码 · 共 526 行 · 第 1/2 页

                result_type operator ()(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                ) const
                {
                    typename Grammar::template impl<e0, State, Data> t0;
                    typename Grammar::template impl<e1, State, Data> t1;
                    return t0(proto::child_c<0>(expr), state, data) [
                           t1(proto::child_c<1>(expr), state, data) ];
                }
            };

            template<typename Expr, typename State, typename Data>
            struct impl2<Expr, State, Data, tag::if_else_, 3>
              : transform_impl<Expr, State, Data>
            {
            private:
                typedef typename result_of::child_c<Expr, 0>::type e0;
                typedef typename result_of::child_c<Expr, 1>::type e1;
                typedef typename result_of::child_c<Expr, 2>::type e2;
                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
                typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
            public:
                BOOST_PROTO_DECLTYPE_(
                    proto::detail::make<r0>()
                  ? proto::detail::make<r1>()
                  : proto::detail::make<r2>()
                  , result_type
                )
                result_type operator ()(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                ) const
                {
                    typename Grammar::template impl<e0, State, Data> t0;
                    typename Grammar::template impl<e1, State, Data> t1;
                    typename Grammar::template impl<e2, State, Data> t2;
                    return t0(proto::child_c<0>(expr), state, data)
                         ? t1(proto::child_c<1>(expr), state, data)
                         : t2(proto::child_c<2>(expr), state, data);
                }
            };

            template<typename Expr, typename State, typename Data>
            struct impl2<Expr, State, Data, tag::comma, 2>
              : transform_impl<Expr, State, Data>
            {
            private:
                typedef typename result_of::child_c<Expr, 0>::type e0;
                typedef typename result_of::child_c<Expr, 1>::type e1;
                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
            public:
                typedef typename proto::detail::comma_result<r0, r1>::type result_type;
                result_type operator ()(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                ) const
                {
                    typename Grammar::template impl<e0, State, Data> t0;
                    typename Grammar::template impl<e1, State, Data> t1;
                    return t0(proto::child_c<0>(expr), state, data)
                         , t1(proto::child_c<1>(expr), state, data);
                }
            };

            #define EVAL_TYPE(Z, N, DATA)                                                           \
                typedef                                                                             \
                    typename result_of::child_c<DATA, N>::type                                      \
                BOOST_PP_CAT(e, N);                                                                 \
                typedef                                                                             \
                    typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type   \
                BOOST_PP_CAT(r, N);                                                                 \
                /**/

            #define EVAL(Z, N, DATA)                                                                \
                typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()(                 \
                    proto::child_c<N>(DATA), state, data                                            \
                )                                                                                   \
                /**/

            template<typename Expr, typename State, typename Data>
            struct impl2<Expr, State, Data, tag::function, 1>
              : transform_impl<Expr, State, Data>
            {
                EVAL_TYPE(~, 0, Expr)

                typedef
                    typename proto::detail::result_of_fixup<r0>::type
                function_type;

                typedef
                    typename boost::result_of<function_type()>::type
                result_type;

                result_type operator ()(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                ) const
                {
                    return EVAL(~, 0, expr)();
                }
            };

            template<typename Expr, typename State, typename Data>
            struct impl2<Expr, State, Data, tag::function, 2>
              : transform_impl<Expr, State, Data>
            {
                EVAL_TYPE(~, 0, Expr)
                EVAL_TYPE(~, 1, Expr)

                typedef
                    typename proto::detail::result_of_fixup<r0>::type
                function_type;

                typedef
                    typename detail::result_of_<function_type(r1)>::type
                result_type;

                result_type operator ()(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                ) const
                {
                    return this->invoke(
                        expr
                      , state
                      , data
                      , is_member_function_pointer<function_type>()
                      , is_member_object_pointer<function_type>()
                    );
                }

            private:
                result_type invoke(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                  , mpl::false_
                  , mpl::false_
                ) const
                {
                    return EVAL(~, 0, expr)(EVAL(~, 1, expr));
                }

                result_type invoke(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                  , mpl::true_
                  , mpl::false_
                ) const
                {
                    using namespace detail::get_pointer_;
                    return (get_pointer(EVAL(~, 1, expr)) ->* EVAL(~, 0, expr))();
                }

                result_type invoke(
                    typename impl2::expr_param expr
                  , typename impl2::state_param state
                  , typename impl2::data_param data
                  , mpl::false_
                  , mpl::true_
                ) const
                {
                    using namespace detail::get_pointer_;
                    return (get_pointer(EVAL(~, 1, expr)) ->* EVAL(~, 0, expr));
                }
            };

            #define BOOST_PP_ITERATION_PARAMS_1 (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/default.hpp>))
            #include BOOST_PP_ITERATE()

            #undef EVAL_TYPE
            #undef EVAL

            template<typename Expr, typename State, typename Data>
            struct impl
              : impl2<
                    Expr
                  , State
                  , Data
                  , typename transform_impl<Expr, State, Data>::expr::proto_tag
                  , transform_impl<Expr, State, Data>::expr::proto_arity::value
                >
            {};
        };

        template<typename Grammar>
        struct is_callable<_default<Grammar> >
          : mpl::true_
        {};

    }}

    #endif

#else

    #define N BOOST_PP_ITERATION()

        template<typename Expr, typename State, typename Data>
        struct impl2<Expr, State, Data, tag::function, N>
          : transform_impl<Expr, State, Data>
        {
            BOOST_PP_REPEAT(N, EVAL_TYPE, Expr)

            typedef
                typename proto::detail::result_of_fixup<r0>::type
            function_type;

            typedef
                typename boost::result_of<
                    function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r))
                >::type
            result_type;

            result_type operator ()(
                typename impl2::expr_param expr
              , typename impl2::state_param state
              , typename impl2::data_param data
            ) const
            {
                return this->invoke(expr, state, data, is_member_function_pointer<function_type>());
            }

        private:
            result_type invoke(
                typename impl2::expr_param expr
              , typename impl2::state_param state
              , typename impl2::data_param data
              , mpl::false_
            ) const
            {
                return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
            }

            result_type invoke(
                typename impl2::expr_param expr
              , typename impl2::state_param state
              , typename impl2::data_param data
              , mpl::true_
            ) const
            {
                #define M0(Z, M, expr) BOOST_PP_COMMA_IF(BOOST_PP_SUB(M, 2)) EVAL(Z, M, expr)
                using namespace detail::get_pointer_;
                return (get_pointer(EVAL(~, 1, expr)) ->* EVAL(~, 0, expr))(
                    BOOST_PP_REPEAT_FROM_TO(2, N, M0, expr)
                );
                #undef M0
            }
        };

    #undef N

#endif