Changeset 44649


Ignore:
Timestamp:
Apr 20, 2008, 8:12:12 PM (10 years ago)
Author:
Eric Niebler
Message:

assorted bug fixes and imporovements

Location:
branches/proto/v4/boost/proto
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • branches/proto/v4/boost/proto/detail/as_lvalue.hpp

    r44402 r44649  
    2323            int_(int) {}
    2424        };
    25    
     25
    2626        template<typename T>
    2727        T &as_lvalue(T &t, int = 0)
  • branches/proto/v4/boost/proto/detail/decltype.hpp

    r44402 r44649  
    3737    BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR))                   \
    3838    typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
    39 # endif       
     39# endif
    4040#else
    4141/// INTERNAL ONLY
     
    8383        template<typename T, typename U = T>
    8484        struct result_of_fixup
    85           : mpl::if_<is_function<T>, T *, U>
     85          : mpl::if_c<is_function<T>::value, T *, U>
    8686        {};
    8787
     
    9595          : result_of_fixup<T, U>
    9696        {};
     97
     98        template<typename R, typename T, typename U>
     99        struct result_of_fixup<R T::*, U>
     100        {
     101            typedef R T::*type;
     102        };
    97103
    98104        template<typename T, typename U>
  • branches/proto/v4/boost/proto/extends.hpp

    r44563 r44649  
    106106
    107107    #define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain)                                        \
    108         Expr expr;                                                                                  \
     108        Expr proto_expr_;                                                                           \
    109109                                                                                                    \
    110110        typedef typename Expr::proto_base_expr proto_base_expr;                                     \
     
    126126        proto_base_expr &proto_base()                                                               \
    127127        {                                                                                           \
    128             return this->expr.proto_base();                                                         \
     128            return this->proto_expr_.proto_base();                                                  \
    129129        }                                                                                           \
    130130                                                                                                    \
    131131        proto_base_expr const &proto_base() const                                                   \
    132132        {                                                                                           \
    133             return this->expr.proto_base();                                                         \
     133            return this->proto_expr_.proto_base();                                                  \
    134134        }                                                                                           \
    135135        /**/
     
    375375    {
    376376        extends()
    377           : expr()
     377          : proto_expr_()
    378378        {}
    379379
    380380        extends(extends const &that)
    381           : expr(that.expr)
     381          : proto_expr_(that.proto_expr_)
    382382        {}
    383383
    384384        extends(Expr const &expr_)
    385           : expr(expr_)
     385          : proto_expr_(expr_)
    386386        {}
    387387
     
    413413    {
    414414        extends()
    415           : expr()
     415          : proto_expr_()
    416416        {}
    417417
    418418        extends(extends const &that)
    419           : expr(that.expr)
     419          : proto_expr_(that.proto_expr_)
    420420        {}
    421421
    422422        extends(Expr const &expr_)
    423           : expr(expr_)
     423          : proto_expr_(expr_)
    424424        {}
    425425
  • branches/proto/v4/boost/proto/fusion.hpp

    r44563 r44649  
    399399                }
    400400            };
    401            
     401
    402402            template<typename Iterator>
    403403            struct apply<Iterator, 0>
  • branches/proto/v4/boost/proto/generate.hpp

    r44563 r44649  
    9898        struct default_generator
    9999        {
     100            BOOST_PROTO_CALLABLE()
     101
    100102            template<typename Sig>
    101103            struct result;
     
    127129        struct generator
    128130        {
    129             template<typename Sig>
    130             struct result;
    131 
    132             template<typename This, typename Expr>
    133             struct result<This(Expr)>
     131            BOOST_PROTO_CALLABLE()
     132
     133            template<typename Sig>
     134            struct result;
     135
     136            template<typename This, typename Expr>
     137            struct result<This(Expr)>
     138            {
     139                typedef Extends<Expr> type;
     140            };
     141
     142            template<typename This, typename Expr>
     143            struct result<This(Expr &)>
     144            {
     145                typedef Extends<Expr> type;
     146            };
     147
     148            template<typename This, typename Expr>
     149            struct result<This(Expr const &)>
    134150            {
    135151                typedef Extends<Expr> type;
     
    158174        struct pod_generator
    159175        {
    160             template<typename Sig>
    161             struct result;
    162 
    163             template<typename This, typename Expr>
    164             struct result<This(Expr)>
     176            BOOST_PROTO_CALLABLE()
     177
     178            template<typename Sig>
     179            struct result;
     180
     181            template<typename This, typename Expr>
     182            struct result<This(Expr)>
     183            {
     184                typedef Extends<Expr> type;
     185            };
     186
     187            template<typename This, typename Expr>
     188            struct result<This(Expr &)>
     189            {
     190                typedef Extends<Expr> type;
     191            };
     192
     193            template<typename This, typename Expr>
     194            struct result<This(Expr const &)>
    165195            {
    166196                typedef Extends<Expr> type;
     
    178208
    179209        /// \brief A generator that replaces child nodes held by
    180         /// reference with ones held by value. Use with 
     210        /// reference with ones held by value. Use with
    181211        /// \c compose_generators to forward that result to another
    182212        /// generator.
     
    191221        struct by_value_generator
    192222        {
    193             template<typename Sig>
    194             struct result;
    195 
    196             template<typename This, typename Expr>
    197             struct result<This(Expr)>
     223            BOOST_PROTO_CALLABLE()
     224
     225            template<typename Sig>
     226            struct result;
     227
     228            template<typename This, typename Expr>
     229            struct result<This(Expr)>
     230            {
     231                typedef
     232                    typename detail::by_value_generator_<Expr>::type
     233                type;
     234            };
     235
     236            template<typename This, typename Expr>
     237            struct result<This(Expr &)>
     238            {
     239                typedef
     240                    typename detail::by_value_generator_<Expr>::type
     241                type;
     242            };
     243
     244            template<typename This, typename Expr>
     245            struct result<This(Expr const &)>
    198246            {
    199247                typedef
     
    224272        struct compose_generators
    225273        {
     274            BOOST_PROTO_CALLABLE()
     275
    226276            template<typename Sig>
    227277            struct result;
     
    232282                typedef
    233283                    typename Second::template result<
    234                         typename First::template result<void(Expr)>::type
     284                        void(typename First::template result<void(Expr)>::type)
     285                    >::type
     286                type;
     287            };
     288
     289            template<typename This, typename Expr>
     290            struct result<This(Expr &)>
     291            {
     292                typedef
     293                    typename Second::template result<
     294                        void(typename First::template result<void(Expr)>::type)
     295                    >::type
     296                type;
     297            };
     298
     299            template<typename This, typename Expr>
     300            struct result<This(Expr const &)>
     301            {
     302                typedef
     303                    typename Second::template result<
     304                        void(typename First::template result<void(Expr)>::type)
    235305                    >::type
    236306                type;
     
    247317
    248318        BOOST_PROTO_END_ADL_NAMESPACE(generatorns_)
     319
     320        /// INTERNAL ONLY
     321        template<>
     322        struct is_callable<default_generator>
     323          : mpl::true_
     324        {};
     325
     326        /// INTERNAL ONLY
     327        template<template<typename> class Extends>
     328        struct is_callable<generator<Extends> >
     329          : mpl::true_
     330        {};
     331
     332        /// INTERNAL ONLY
     333        template<template<typename> class Extends>
     334        struct is_callable<pod_generator<Extends> >
     335          : mpl::true_
     336        {};
     337
     338        /// INTERNAL ONLY
     339        template<>
     340        struct is_callable<by_value_generator>
     341          : mpl::true_
     342        {};
     343
     344        /// INTERNAL ONLY
     345        template<typename First, typename Second>
     346        struct is_callable<compose_generators<First, Second> >
     347          : mpl::true_
     348        {};
    249349
    250350    }}
  • branches/proto/v4/boost/proto/make_expr.hpp

    r44402 r44649  
    403403                typedef default_domain type;
    404404            };
    405            
     405
    406406            template<typename Void = void>
    407407            struct deduce_domain0
     
    810810              : functional::make_expr<Tag, Domain>::template result<Sig>
    811811            {};
    812            
     812
    813813            #define M0(Z, N, DATA)                                                                  \
    814814            template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>                                      \
     
    10141014        //   default_domain.
    10151015        // - If S contains only X and default_domain, the deduced domain
    1016         //   is X. 
     1016        //   is X.
    10171017        // - If S contains different domains X and Y, neither of which is
    10181018        //   default_domain, it is an error.
  • branches/proto/v4/boost/proto/matches.hpp

    r44402 r44649  
    642642            {
    643643                typedef if_ proto_base_expr;
    644                
     644
    645645                template<typename Expr, typename State, typename Data>
    646646                struct impl : transform_impl<Expr, State, Data>
  • branches/proto/v4/boost/proto/proto_fwd.hpp

    r44563 r44649  
    407407          , typename Domain = default_domain
    408408          , typename Void = void
    409           #ifdef BOOST_PROTO_BROKEN_PTS 
     409          #ifdef BOOST_PROTO_BROKEN_PTS
    410410          , typename Void2 = void
    411411          #endif
     
    417417          , typename Domain = default_domain
    418418          , typename Void = void
    419           #ifdef BOOST_PROTO_BROKEN_PTS 
     419          #ifdef BOOST_PROTO_BROKEN_PTS
    420420          , typename Void2 = void
    421421          #endif
  • branches/proto/v4/boost/proto/traits.hpp

    r44563 r44649  
    234234              , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
    235235              , typename Void   BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
    236               #ifdef BOOST_PROTO_BROKEN_PTS 
     236              #ifdef BOOST_PROTO_BROKEN_PTS
    237237              , typename Void2  BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
    238238              #endif
     
    298298              , typename T::proto_domain
    299299              , typename T::proto_is_expr_
    300               #ifdef BOOST_PROTO_BROKEN_PTS 
     300              #ifdef BOOST_PROTO_BROKEN_PTS
    301301              , void
    302302              #endif
     
    329329              , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
    330330              , typename Void   BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
    331               #ifdef BOOST_PROTO_BROKEN_PTS 
     331              #ifdef BOOST_PROTO_BROKEN_PTS
    332332              , typename Void2  BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
    333333              #endif
     
    362362              , Domain
    363363              , typename T::proto_is_expr_
    364               #ifdef BOOST_PROTO_BROKEN_PTS 
     364              #ifdef BOOST_PROTO_BROKEN_PTS
    365365              , typename disable_if<is_same<Domain, typename T::proto_domain> >::type
    366366              #endif
     
    394394              , typename T::proto_domain
    395395              , typename T::proto_is_expr_
    396               #ifdef BOOST_PROTO_BROKEN_PTS 
     396              #ifdef BOOST_PROTO_BROKEN_PTS
    397397              , void
    398398              #endif
     
    429429                /// \c Expr. This may be a value or a reference
    430430                typedef typename Expr::proto_child0 value_type;
    431                
     431
    432432                /// The "value" type of the child, suitable for return by value,
    433433                /// computed as follows:
     
    467467                /// \c Expr. This may be a value or a reference
    468468                typedef typename Expr::proto_child0 value_type;
    469                
     469
    470470                /// The "const reference" type of the child, suitable for return by
    471471                /// const reference, computed as follows:
     
    520520                {
    521521                    typedef Expr result_type;
    522                    
     522
    523523                    /// \param expr The current expression
    524524                    /// \pre <tt>matches\<Expr, terminal\<T\> \>::::value</tt> is \c true.
     
    23102310                /// \c Expr. This may be a value or a reference
    23112311                typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
    2312                
     2312
    23132313                /// The "const reference" type of the child, suitable for return by
    23142314                /// const reference, computed as follows:
  • branches/proto/v4/boost/proto/transform/call.hpp

    r44402 r44649  
    247247                }
    248248            };
    249            
     249
    250250                /// Let \c x be <tt>when\<_, A0\>()(expr, state, data)</tt> and \c X
    251251                /// be the type of \c x.
  • branches/proto/v4/boost/proto/transform/default.hpp

    r44403 r44649  
    1717    #include <boost/preprocessor/repetition/enum_shifted.hpp>
    1818    #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
     19    #include <boost/ref.hpp>
     20    #include <boost/utility/enable_if.hpp>
     21    #include <boost/type_traits/is_member_pointer.hpp>
    1922    #include <boost/proto/proto_fwd.hpp>
    2023    #include <boost/proto/traits.hpp>
     
    2629    namespace boost { namespace proto
    2730    {
     31        namespace detail
     32        {
     33            template<typename T>
     34            T &deref(T &t)
     35            {
     36                return t;
     37            }
     38
     39            template<typename T>
     40            T const &deref(T const &t)
     41            {
     42                return t;
     43            }
     44
     45            template<typename T>
     46            T &deref(T *&t)
     47            {
     48                return *t;
     49            }
     50
     51            template<typename T>
     52            T &deref(T *const &t)
     53            {
     54                return *t;
     55            }
     56        }
     57
    2858        template<typename Grammar>
    2959        struct _default
     
    233263            };
    234264
     265            template<typename Expr, typename State, typename Data>
     266            struct impl2<Expr, State, Data, tag::comma, 2>
     267              : transform_impl<Expr, State, Data>
     268            {
     269            private:
     270                typedef typename result_of::child_c<Expr, 0>::type e0;
     271                typedef typename result_of::child_c<Expr, 1>::type e1;
     272                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     273                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     274            public:
     275                typedef typename proto::detail::comma_result<r0, r1>::type result_type;
     276                result_type operator ()(
     277                    typename impl2::expr_param expr
     278                  , typename impl2::state_param state
     279                  , typename impl2::data_param data
     280                ) const
     281                {
     282                    typename Grammar::template impl<e0, State, Data> t0;
     283                    typename Grammar::template impl<e1, State, Data> t1;
     284                    return t0(proto::child_c<0>(expr), state, data)
     285                         , t1(proto::child_c<1>(expr), state, data);
     286                }
     287            };
     288           
    235289            #define EVAL_TYPE(Z, N, DATA)                                                           \
    236290                typedef                                                                             \
     
    284338        {
    285339            BOOST_PP_REPEAT(N, EVAL_TYPE, Expr)
    286        
     340
    287341            typedef
    288                 typename proto::detail::result_of_fixup<e0>::type
     342                typename proto::detail::result_of_fixup<r0>::type
    289343            function_type;
    290344
    291345            typedef
    292346                typename boost::result_of<
    293                     function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, e))
     347                    function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r))
    294348                >::type
    295349            result_type;
    296350
     351            #if N == 1
    297352            result_type operator ()(
    298353                typename impl2::expr_param expr
     
    303358                return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
    304359            }
     360            #else
     361            result_type operator ()(
     362                typename impl2::expr_param expr
     363              , typename impl2::state_param state
     364              , typename impl2::data_param data
     365            ) const
     366            {
     367                return this->invoke(expr, state, data, is_member_pointer<function_type>());
     368            }
     369
     370            result_type invoke(
     371                typename impl2::expr_param expr
     372              , typename impl2::state_param state
     373              , typename impl2::data_param data
     374              , mpl::false_
     375            ) const
     376            {
     377                return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
     378            }
     379
     380            result_type invoke(
     381                typename impl2::expr_param expr
     382              , typename impl2::state_param state
     383              , typename impl2::data_param data
     384              , mpl::true_
     385            ) const
     386            {
     387                #define M0(Z, M, expr) BOOST_PP_COMMA_IF(BOOST_PP_SUB(M, 2)) EVAL(Z, M, expr)
     388                return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr))(
     389                    BOOST_PP_REPEAT_FROM_TO(2, N, M0, expr)
     390                );
     391                #undef M0
     392            }
     393            #endif
    305394        };
    306395
  • branches/proto/v4/boost/proto/transform/fold.hpp

    r44402 r44649  
    227227                    >::type
    228228                result_type;
    229                
     229
    230230                /// Let \c seq be <tt>when\<_, Sequence\>()(expr, state, data)</tt>, let
    231231                /// \c state0 be <tt>when\<_, State0\>()(expr, state, data)</tt>, and
  • branches/proto/v4/boost/proto/transform/make.hpp

    r44402 r44649  
    358358            {
    359359                typedef proto::expr<Tag, Args, Arity> result_type;
    360                
     360
    361361                result_type operator ()(
    362362                    typename impl::expr_param   expr
  • branches/proto/v4/boost/proto/transform/when.hpp

    r44402 r44649  
    163163
    164164                typedef typename which::template impl<Expr, State, Data>::result_type result_type;
    165                
     165
    166166                /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with
    167167                /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on
Note: See TracChangeset for help on using the changeset viewer.