Changeset 44563


Ignore:
Timestamp:
Apr 19, 2008, 12:16:05 AM (10 years ago)
Author:
Eric Niebler
Message:

eliminate need for child_traits, handle function references as terminals correctly

Location:
branches/proto/v4
Files:
1 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • branches/proto/v4/boost/proto/args.hpp

    r44447 r44563  
    2020    #include <boost/preprocessor/repetition/repeat.hpp>
    2121    #include <boost/preprocessor/repetition/repeat_from_to.hpp>
     22    #include <boost/type_traits/is_function.hpp>
     23    #include <boost/mpl/if.hpp>
    2224    #include <boost/mpl/void.hpp>
    2325    #include <boost/proto/proto_fwd.hpp>
     
    4850            typedef typename Expr::proto_arity proto_arity;
    4951            typedef typename Expr::proto_domain proto_domain;
     52            typedef proto_derived_expr value_type;
     53            typedef Expr &reference;
     54            typedef Expr const &const_reference;
    5055        };
    5156
     
    6065            typedef typename Expr::proto_arity proto_arity;
    6166            typedef typename Expr::proto_domain proto_domain;
     67            typedef proto_derived_expr value_type;
     68            typedef Expr &reference;
     69            typedef Expr &const_reference;
    6270        };
    63        
     71
    6472        /// INTERNAL ONLY
    6573        template<typename T>
    6674        struct term_ref
    6775        {
    68             typedef T type;
     76            typedef T value_type;
     77            typedef T &reference;
     78            typedef T const &const_reference;
    6979        };
    7080
     
    7383        struct term_ref<T &>
    7484        {
    75             typedef T type;
     85            typedef typename mpl::if_c<is_function<T>::value, T &, T>::type value_type;
     86            typedef T &reference;
     87            typedef T &const_reference;
    7688        };
    7789
     
    8092        struct term_ref<T const &>
    8193        {
    82             typedef T type;
     94            typedef T value_type;
     95            typedef T const &reference;
     96            typedef T const &const_reference;
     97        };
     98
     99        /// INTERNAL ONLY
     100        template<typename T, std::size_t N>
     101        struct term_ref<T (&)[N]>
     102        {
     103            typedef T (&value_type)[N];
     104            typedef T (&reference)[N];
     105            typedef T (&const_reference)[N];
     106        };
     107
     108        /// INTERNAL ONLY
     109        template<typename T, std::size_t N>
     110        struct term_ref<T const (&)[N]>
     111        {
     112            typedef T const (&value_type)[N];
     113            typedef T const (&reference)[N];
     114            typedef T const (&const_reference)[N];
     115        };
     116
     117        /// INTERNAL ONLY
     118        template<typename T, std::size_t N>
     119        struct term_ref<T[N]>
     120        {
     121            typedef T (&value_type)[N];
     122            typedef T (&reference)[N];
     123            typedef T const (&const_reference)[N];
     124        };
     125
     126        /// INTERNAL ONLY
     127        template<typename T, std::size_t N>
     128        struct term_ref<T const[N]>
     129        {
     130            typedef T const (&value_type)[N];
     131            typedef T const (&reference)[N];
     132            typedef T const (&const_reference)[N];
    83133        };
    84134
  • branches/proto/v4/boost/proto/context/callable.hpp

    r44402 r44563  
    4949            template<typename Expr, typename Context, long Arity = Expr::proto_arity::value>
    5050            struct is_expr_handled;
     51
     52            template<typename Expr, typename Context>
     53            struct is_expr_handled<Expr, Context, 0>
     54            {
     55                static callable_context_wrapper<Context, 1> &sctx_;
     56                static Expr &sexpr_;
     57                static typename Expr::proto_tag &stag_;
     58
     59                BOOST_STATIC_CONSTANT(bool, value =
     60                (
     61                    sizeof(yes_type) ==
     62                    sizeof(
     63                        detail::check_is_expr_handled(
     64                            (sctx_(stag_, proto::value(sexpr_)), 0)
     65                        )
     66                )));
     67
     68                typedef mpl::bool_<value> type;
     69            };
    5170        }
    5271
     
    7291            struct callable_eval
    7392            {};
     93
     94            /// \brief A BinaryFunction that accepts a Proto expression and a
     95            /// callable context and calls the context with the expression tag
     96            /// and children as arguments, effectively fanning the expression
     97            /// out.
     98            ///
     99            /// <tt>callable_eval\<\></tt> requires that \c Context is a
     100            /// PolymorphicFunctionObject that can be invoked with \c Expr's
     101            /// tag and children as expressions, as follows:
     102            ///
     103            /// \code
     104            /// context(Expr::proto_tag(), value(expr))
     105            /// \endcode
     106            template<typename Expr, typename Context>
     107            struct callable_eval<Expr, Context, 0>
     108            {
     109                typedef typename proto::result_of::value<Expr const &>::type value_type;
     110
     111                typedef
     112                    typename boost::result_of<
     113                        Context(typename Expr::proto_tag, value_type)
     114                    >::type
     115                result_type;
     116
     117                /// \param expr The current expression
     118                /// \param context The callable evaluation context
     119                /// \return <tt>context(Expr::proto_tag(), value(expr))</tt>
     120                result_type operator ()(Expr &expr, Context &context) const
     121                {
     122                    return context(typename Expr::proto_tag(), proto::value(expr));
     123                }
     124            };
    74125
    75126            /// \brief An evaluation context adaptor that makes authoring a
     
    177228
    178229    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
    179         (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/context/callable.hpp>))                         \
     230        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/callable.hpp>))                         \
    180231        /**/
    181232
     
    192243
    193244    #define N BOOST_PP_ITERATION()
    194     #define ARG_COUNT BOOST_PP_MAX(1, N)
    195245
    196246        namespace detail
    197247        {
    198             #if N > 0
    199248            template<typename Context>
    200249            struct callable_context_wrapper<Context, N>
     
    205254                    private_type_ const &fun_type(
    206255                        BOOST_PP_ENUM_PARAMS(
    207                             BOOST_PP_INC(ARG_COUNT)
     256                            BOOST_PP_INC(N)
    208257                          , detail::dont_care BOOST_PP_INTERCEPT
    209258                        )
     
    211260                operator fun_type *() const;
    212261            };
    213             #endif
    214262
    215263            template<typename Expr, typename Context>
    216264            struct is_expr_handled<Expr, Context, N>
    217265            {
    218                 static callable_context_wrapper<Context, ARG_COUNT> &sctx_;
     266                static callable_context_wrapper<Context, N> &sctx_;
    219267                static Expr &sexpr_;
    220268                static typename Expr::proto_tag &stag_;
     
    227275                            (sctx_(
    228276                                stag_
    229                                 BOOST_PP_ENUM_TRAILING(ARG_COUNT, BOOST_PROTO_CHILD_N, sexpr_)
     277                                BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, sexpr_)
    230278                            ), 0)
    231279                        )
     
    253301            struct callable_eval<Expr, Context, N>
    254302            {
    255                 BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD_N_TYPE, Expr)
     303                BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD_N_TYPE, Expr)
    256304
    257305                typedef
     
    259307                        Context(
    260308                            typename Expr::proto_tag
    261                             BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, child)
     309                            BOOST_PP_ENUM_TRAILING_PARAMS(N, child)
    262310                        )
    263311                    >::type
     
    271319                    return context(
    272320                        typename Expr::proto_tag()
    273                         BOOST_PP_ENUM_TRAILING(ARG_COUNT, BOOST_PROTO_CHILD_N, expr)
     321                        BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, expr)
    274322                    );
    275323                }
     
    278326
    279327    #undef N
    280     #undef ARG_COUNT
    281328
    282329#endif
  • branches/proto/v4/boost/proto/expr.hpp

    r44402 r44563  
    2727    #include <boost/proto/args.hpp>
    2828    #include <boost/proto/traits.hpp>
    29     #include <boost/proto/detail/child_traits.hpp>
    3029    #include <boost/proto/detail/suffix.hpp>
    3130
     
    5756            /**/
    5857
    59         /// INTERNAL ONLY
    60         ///
    61         #define BOOST_PROTO_UNREF_CHILD_TYPE(Z, N, DATA)                                            \
    62             typename detail::child_traits<typename Args::BOOST_PP_CAT(child, N)>::const_reference   \
    63             /**/
    64 
    65         /// INTERNAL ONLY
    66         ///
    67         #define BOOST_PROTO_UNREF_CHILD(Z, N, DATA)                                                 \
    68             this->BOOST_PP_CAT(child, N)                                                            \
    69             /**/
    70 
    7158            template<typename Tag, typename Arg>
    7259            struct address_of_hack
     
    120107        #undef BOOST_PROTO_CHILD
    121108        #undef BOOST_PROTO_VOID
    122         #undef BOOST_PROTO_UNREF_CHILD_TYPE
    123         #undef BOOST_PROTO_UNREF_CHILD
    124109    }}
    125110
  • branches/proto/v4/boost/proto/extends.hpp

    r44402 r44563  
    100100            typename proto_base_expr::BOOST_PP_CAT(proto_child, N)                                  \
    101101        BOOST_PP_CAT(proto_child, N);                                                               \
     102        typedef                                                                                     \
     103            typename proto_base_expr::BOOST_PP_CAT(proto_child_ref, N)                              \
     104        BOOST_PP_CAT(proto_child_ref, N);                                                           \
    102105        /**/
    103106
  • branches/proto/v4/boost/proto/fusion.hpp

    r44402 r44563  
    6868        {
    6969            typedef Expr expr_type;
     70            typedef typename Expr::proto_tag proto_tag;
    7071            BOOST_STATIC_CONSTANT(long, index = Pos);
    7172            BOOST_PROTO_FUSION_DEFINE_CATEGORY(fusion::random_access_traversal_tag)
     
    339340        struct value_of_impl<proto::tag::proto_expr_iterator>
    340341        {
    341             template<typename Iterator>
     342            template<
     343                typename Iterator
     344              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
     345            >
    342346            struct apply
    343347            {
     
    349353                type;
    350354            };
     355
     356            template<typename Iterator>
     357            struct apply<Iterator, 0>
     358            {
     359                typedef
     360                    typename proto::result_of::value<
     361                        typename Iterator::expr_type
     362                    >::value_type
     363                type;
     364            };
    351365        };
    352366
     
    367381        struct deref_impl<proto::tag::proto_expr_iterator>
    368382        {
    369             template<typename Iterator>
     383            template<
     384                typename Iterator
     385              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
     386            >
    370387            struct apply
    371388            {
    372389                typedef
    373390                    typename proto::result_of::child_c<
    374                         typename Iterator::expr_type const
     391                        typename Iterator::expr_type const &
    375392                      , Iterator::index
    376                     >::type const &
     393                    >::type
    377394                type;
    378395
     
    382399                }
    383400            };
     401           
     402            template<typename Iterator>
     403            struct apply<Iterator, 0>
     404            {
     405                typedef
     406                    typename proto::result_of::value<
     407                        typename Iterator::expr_type const &
     408                    >::type
     409                type;
     410
     411                static type call(Iterator const &iter)
     412                {
     413                    return proto::value(iter.expr);
     414                }
     415            };
    384416        };
    385417
     
    517549        struct value_at_impl<proto::tag::proto_expr>
    518550        {
    519             template<typename Sequence, typename Index>
     551            template<
     552                typename Sequence
     553              , typename Index
     554              , long Arity = proto::arity_of<Sequence>::value
     555            >
    520556            struct apply
    521557            {
     
    527563                type;
    528564            };
     565
     566            template<typename Sequence, typename Index>
     567            struct apply<Sequence, Index, 0>
     568            {
     569                typedef
     570                    typename proto::result_of::value<
     571                        Sequence
     572                    >::value_type
     573                type;
     574            };
    529575        };
    530576
     
    535581        struct at_impl<proto::tag::proto_expr>
    536582        {
    537             template<typename Sequence, typename Index>
     583            template<
     584                typename Sequence
     585              , typename Index
     586              , long Arity = proto::arity_of<Sequence>::value
     587            >
    538588            struct apply
    539589            {
     
    552602
    553603            template<typename Sequence, typename Index>
    554             struct apply<Sequence const, Index>
    555             {
    556                 typedef
    557                     typename proto::result_of::child_c<
    558                         Sequence const &
    559                       , Index::value
     604            struct apply<Sequence, Index, 0>
     605            {
     606                typedef
     607                    typename proto::result_of::value<
     608                        Sequence &
    560609                    >::type
    561610                type;
    562611
    563                 static type call(Sequence const &seq)
     612                static type call(Sequence &seq)
    564613                {
    565                     return proto::child_c<Index::value>(seq);
     614                    return proto::value(seq);
    566615                }
    567616            };
  • branches/proto/v4/boost/proto/generate.hpp

    r44402 r44563  
    5656
    5757        #define BOOST_PROTO_DEFINE_BY_VALUE_TYPE(Z, N, Expr)                                        \
    58             typename detail::child_traits<                                                          \
    59                 typename expr_traits<Expr>::args::BOOST_PP_CAT(child, N)                            \
    60             >::value_type                                                                           \
     58            typename expr_traits<Expr>::args::BOOST_PP_CAT(child_ref, N)::proto_derived_expr        \
    6159            /**/
    6260
     
    7068                typedef proto::expr<
    7169                    tag::terminal
    72                   , term<BOOST_PROTO_DEFINE_BY_VALUE_TYPE(~, 0, Expr) >
     70                  , term<typename expr_traits<Expr>::args::child_ref0::value_type>
    7371                > type;
    7472
     
    264262                    typename expr_traits<Expr>::tag
    265263                  , BOOST_PP_CAT(list, N)<
    266                         // typename detail::child_traits<typename expr_traits<Expr>::args::child0>::value_type, ...
     264                        // typename expr_traits<Expr>::args::child_ref0::proto_derived_expr, ...
    267265                        BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_BY_VALUE_TYPE, Expr)
    268266                    >
  • branches/proto/v4/boost/proto/literal.hpp

    r44402 r44563  
    4444
    4545        public:
    46             typedef typename proto::detail::child_traits<T>::value_type value_type;
    47             typedef typename proto::detail::child_traits<T>::reference reference;
    48             typedef typename proto::detail::child_traits<T>::const_reference const_reference;
     46            typedef typename terminal_type::proto_child_ref0::value_type value_type;
     47            typedef typename terminal_type::proto_child_ref0::reference reference;
     48            typedef typename terminal_type::proto_child_ref0::const_reference const_reference;
    4949
    5050            template<typename U>
  • branches/proto/v4/boost/proto/proto_fwd.hpp

    r44521 r44563  
    746746    struct _data;
    747747
     748    struct _value;
     749
    748750    template<int I>
    749751    struct _child_c;
     
    752754    typedef _child_c<1> _child1;
    753755    typedef _child0     _child;
    754     typedef _child0     _value;
    755756    typedef _child0     _left;
    756757    typedef _child1     _right;
  • branches/proto/v4/boost/proto/traits.hpp

    r44521 r44563  
    4444    #include <boost/proto/args.hpp>
    4545    #include <boost/proto/tags.hpp>
    46     #include <boost/proto/detail/child_traits.hpp>
    4746    #include <boost/proto/transform/pass_through.hpp>
    4847    #include <boost/proto/detail/suffix.hpp>
     
    426425            template<typename Expr>
    427426            struct value
    428               : child_c<Expr, 0>
    429             {};
     427            {
     428                /// The raw type of the Nth child as it is stored within
     429                /// \c Expr. This may be a value or a reference
     430                typedef typename Expr::proto_child0 value_type;
     431               
     432                /// The "value" type of the child, suitable for return by value,
     433                /// computed as follows:
     434                /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
     435                /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt>
     436                /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
     437                /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
     438                /// \li <tt>T const &</tt> becomes <tt>T</tt>
     439                /// \li <tt>T &</tt> becomes <tt>T</tt>
     440                /// \li <tt>T</tt> becomes <tt>T</tt>
     441                typedef typename Expr::proto_child_ref0::value_type type;
     442            };
     443
     444            template<typename Expr>
     445            struct value<Expr &>
     446            {
     447                /// The raw type of the Nth child as it is stored within
     448                /// \c Expr. This may be a value or a reference
     449                typedef typename Expr::proto_child0 value_type;
     450
     451                /// The "reference" type of the child, suitable for return by
     452                /// reference, computed as follows:
     453                /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
     454                /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt>
     455                /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
     456                /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
     457                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
     458                /// \li <tt>T &</tt> becomes <tt>T &</tt>
     459                /// \li <tt>T</tt> becomes <tt>T &</tt>
     460                typedef typename Expr::proto_child_ref0::reference type;
     461            };
     462
     463            template<typename Expr>
     464            struct value<Expr const &>
     465            {
     466                /// The raw type of the Nth child as it is stored within
     467                /// \c Expr. This may be a value or a reference
     468                typedef typename Expr::proto_child0 value_type;
     469               
     470                /// The "const reference" type of the child, suitable for return by
     471                /// const reference, computed as follows:
     472                /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
     473                /// \li <tt>T[N]</tt> becomes <tt>T const(&)[N]</tt>
     474                /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
     475                /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
     476                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
     477                /// \li <tt>T &</tt> becomes <tt>T &</tt>
     478                /// \li <tt>T</tt> becomes <tt>T const &</tt>
     479                typedef typename Expr::proto_child_ref0::const_reference type;
     480            };
    430481
    431482            // TODO left<> and right<> force the instantiation of Expr.
     
    19542005        ///
    19552006        template<typename Expr2>
    1956         typename detail::child_traits<typename Expr2::proto_base_expr::proto_child0>::reference
     2007        typename Expr2::proto_base_expr::proto_child_ref0::reference
    19572008        child(Expr2 &expr2 BOOST_PROTO_DISABLE_IF_IS_CONST(Expr2))
    19582009        {
     
    19632014        ///
    19642015        template<typename Expr2>
    1965         typename detail::child_traits<typename Expr2::proto_base_expr::proto_child0>::const_reference
     2016        typename Expr2::proto_base_expr::proto_child_ref0::const_reference
    19662017        child(Expr2 const &expr2)
    19672018        {
     
    22252276                /// The "value" type of the child, suitable for return by value,
    22262277                /// computed as follows:
    2227                 /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
    2228                 /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt>
    2229                 /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
    2230                 /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
    22312278                /// \li <tt>T const &</tt> becomes <tt>T</tt>
    22322279                /// \li <tt>T &</tt> becomes <tt>T</tt>
    22332280                /// \li <tt>T</tt> becomes <tt>T</tt>
    2234                 typedef typename detail::child_traits<value_type>::value_type type;
    2235             };
    2236            
     2281                typedef typename Expr::BOOST_PP_CAT(proto_child_ref, N)::value_type type;
     2282            };
     2283
    22372284            template<typename Expr>
    22382285            struct child_c<Expr &, N>
     
    22442291                /// The "reference" type of the child, suitable for return by
    22452292                /// reference, computed as follows:
    2246                 /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
    2247                 /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt>
    2248                 /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
    2249                 /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
    22502293                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
    22512294                /// \li <tt>T &</tt> becomes <tt>T &</tt>
    22522295                /// \li <tt>T</tt> becomes <tt>T &</tt>
    2253                 typedef typename detail::child_traits<value_type>::reference type;
    2254                
     2296                typedef typename Expr::BOOST_PP_CAT(proto_child_ref, N)::reference type;
     2297
    22552298                /// INTERNAL ONLY
    22562299                ///
     
    22602303                }
    22612304            };
    2262            
     2305
    22632306            template<typename Expr>
    22642307            struct child_c<Expr const &, N>
     
    22702313                /// The "const reference" type of the child, suitable for return by
    22712314                /// const reference, computed as follows:
    2272                 /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt>
    2273                 /// \li <tt>T[N]</tt> becomes <tt>T const(&)[N]</tt>
    2274                 /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt>
    2275                 /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt>
    22762315                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
    22772316                /// \li <tt>T &</tt> becomes <tt>T &</tt>
    22782317                /// \li <tt>T</tt> becomes <tt>T const &</tt>
    2279                 typedef typename detail::child_traits<value_type>::const_reference type;
     2318                typedef typename Expr::BOOST_PP_CAT(proto_child_ref, N)::const_reference type;
    22802319
    22812320                /// INTERNAL ONLY
  • branches/proto/v4/boost/proto/transform/arg.hpp

    r44402 r44563  
    115115    };
    116116
     117    /// \brief A PrimitiveTransform that returns the value of the
     118    /// current terminal expression.
     119    struct _value : transform<_value>
     120    {
     121        template<typename Expr, typename State, typename Data>
     122        struct impl : transform_impl<Expr, State, Data>
     123        {
     124            typedef
     125                typename result_of::value<Expr>::type
     126            result_type;
     127
     128            /// \param expr The current expression.
     129            /// \return <tt>proto::value(expr)</tt>
     130            /// \throw nothrow
     131            typename result_of::value<typename impl::expr_param>::type
     132            operator ()(
     133                typename impl::expr_param expr
     134              , typename impl::state_param
     135              , typename impl::data_param
     136            ) const
     137            {
     138                return proto::value(expr);
     139            }
     140        };
     141    };
     142
    117143    /// \brief A unary CallableTransform that wraps its argument
    118144    /// in a \c boost::reference_wrapper\<\>.
     
    224250    ///
    225251    template<>
     252    struct is_callable<_value>
     253      : mpl::true_
     254    {};
     255
     256    /// INTERNAL ONLY
     257    ///
     258    template<>
    226259    struct is_callable<_byref>
    227260      : mpl::true_
  • branches/proto/v4/boost/xpressive/detail/static/transforms/as_action.hpp

    r44402 r44563  
    2525#include <boost/xpressive/detail/static/transforms/as_quantifier.hpp>
    2626#include <boost/proto/core.hpp>
    27 #include <boost/proto/transform.hpp>
     27#include <boost/proto/transform/arg.hpp>
     28#include <boost/proto/transform/call.hpp>
     29#include <boost/proto/transform/make.hpp>
     30#include <boost/proto/transform/when.hpp>
     31#include <boost/proto/transform/fold.hpp>
     32#include <boost/proto/transform/fold_tree.hpp>
    2833
    2934namespace boost { namespace xpressive { namespace detail
  • branches/proto/v4/boost/xpressive/detail/static/transforms/as_independent.hpp

    r44402 r44563  
    1818#include <boost/xpressive/detail/static/static.hpp>
    1919#include <boost/proto/core.hpp>
    20 #include <boost/proto/transform.hpp>
     20#include <boost/proto/transform/arg.hpp>
     21#include <boost/proto/transform/when.hpp>
     22#include <boost/proto/transform/fold.hpp>
     23#include <boost/proto/transform/fold_tree.hpp>
    2124
    2225namespace boost { namespace xpressive { namespace detail
  • branches/proto/v4/boost/xpressive/regex_actions.hpp

    r44402 r44563  
    4141// Doxygen can't handle proto :-(
    4242#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
    43 # include <boost/proto/transform.hpp>
     43# include <boost/proto/transform/arg.hpp>
     44# include <boost/proto/transform/when.hpp>
    4445# include <boost/xpressive/detail/core/matcher/action_matcher.hpp>
    4546#endif
  • branches/proto/v4/boost/xpressive/regex_primitives.hpp

    r44402 r44563  
    2525#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
    2626# include <boost/proto/core.hpp>
    27 # include <boost/proto/transform.hpp>
     27# include <boost/proto/transform/arg.hpp>
     28# include <boost/proto/transform/when.hpp>
    2829# include <boost/xpressive/detail/core/icase.hpp>
    2930# include <boost/xpressive/detail/static/compile.hpp>
  • branches/proto/v4/libs/proto/test/toy_spirit2.cpp

    r44402 r44563  
    207207        struct SpiritTerminal
    208208          : or_<
    209                 when< AnyChar,          _child >
     209                when< AnyChar,          _value >
    210210              , when< CharLiteral,      if_<_icase, ichar(_value), _value> >
    211211              , when< CharParser,       if_<_icase, ichar(_value(_child1)), _value(_child1)> >  // char_('a')
Note: See TracChangeset for help on using the changeset viewer.