Changeset 62138


Ignore:
Timestamp:
May 22, 2010, 6:17:55 AM (8 years ago)
Author:
Eric Niebler
Message:

Merged revisions 61076,61547,61675-61677,61750,61782,61788,61859 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........

r61076 | eric_niebler | 2010-04-05 12:15:49 -0700 (Mon, 05 Apr 2010) | 1 line


code clean-up

........

r61547 | eric_niebler | 2010-04-24 12:50:15 -0700 (Sat, 24 Apr 2010) | 1 line


when using proto::and_ as a transform, apply *all* transforms but only return the result of applying the last

........

r61675 | eric_niebler | 2010-04-29 06:59:12 -0700 (Thu, 29 Apr 2010) | 1 line


allow virtual members to be in a different domain than their enclosing class

........

r61676 | eric_niebler | 2010-04-29 08:08:18 -0700 (Thu, 29 Apr 2010) | 1 line


const-correctness fixes when invoking proto domains

........

r61677 | eric_niebler | 2010-04-29 08:18:21 -0700 (Thu, 29 Apr 2010) | 1 line


more const-correctness fixes when invoking proto domains

........

r61750 | eric_niebler | 2010-05-03 18:19:53 -0700 (Mon, 03 May 2010) | 1 line


_default transform is also a grammar that matches the expressions the transform knows how to handle

........

r61782 | eric_niebler | 2010-05-04 17:19:22 -0700 (Tue, 04 May 2010) | 1 line


pass_through transform doesn't strip expression wrappers

........

r61788 | eric_niebler | 2010-05-05 09:02:34 -0700 (Wed, 05 May 2010) | 1 line


fix broken proto

........

r61859 | eric_niebler | 2010-05-08 15:27:39 -0700 (Sat, 08 May 2010) | 1 line


add partial support for sub-domains. Full support (on compilers supporting Boost.TypeOf?) to come

........

Location:
branches/release
Files:
148 edited

Legend:

Unmodified
Added
Removed
  • branches/release

  • branches/release/INSTALL

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/LICENSE_1_0.txt

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost

  • branches/release/boost-build.jam

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost.css

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost.png

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/algorithm/string

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/archive

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/array.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/bimap

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/config

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/config/compiler

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/detail

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/filesystem

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/functional/hash

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/fusion

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/gil

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/graph

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/integer

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/interprocess

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/intrusive

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/iostreams

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/numeric/ublas

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/program_options

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/property_tree

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/proto/context/default.hpp

    r58336 r62138  
    1414
    1515    #include <boost/config.hpp>
     16    #include <boost/preprocessor/arithmetic/add.hpp>
     17    #include <boost/preprocessor/arithmetic/sub.hpp>
    1618    #include <boost/preprocessor/iteration/iterate.hpp>
     19    #include <boost/preprocessor/repetition/enum.hpp>
    1720    #include <boost/preprocessor/repetition/enum_shifted.hpp>
    1821    #include <boost/utility/result_of.hpp>
     
    4649            {};
    4750
     51            template<typename Expr, typename Context>
     52            struct default_eval<Expr, Context, tag::terminal, 0>
     53            {
     54                typedef
     55                    typename proto::result_of::value<Expr &>::type
     56                result_type;
     57
     58                result_type operator ()(Expr &expr, Context &) const
     59                {
     60                    return proto::value(expr);
     61                }
     62            };
     63
    4864            /// INTERNAL ONLY
    4965            ///
    50         #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG, MAKE)                                          \
     66        #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE)                                       \
    5167            template<typename Expr, typename Context>                                               \
    5268            struct default_eval<Expr, Context, TAG, 1>                                              \
     
    6682            /// INTERNAL ONLY
    6783            ///
    68         #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG, LMAKE, RMAKE)                                 \
     84        #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE)                              \
    6985            template<typename Expr, typename Context>                                               \
    7086            struct default_eval<Expr, Context, TAG, 2>                                              \
     
    90106            /**/
    91107
    92             BOOST_PROTO_UNARY_OP_RESULT(+, proto::tag::unary_plus, make)
    93             BOOST_PROTO_UNARY_OP_RESULT(-, proto::tag::negate, make)
    94             BOOST_PROTO_UNARY_OP_RESULT(*, proto::tag::dereference, make)
    95             BOOST_PROTO_UNARY_OP_RESULT(~, proto::tag::complement, make)
    96             BOOST_PROTO_UNARY_OP_RESULT(&, proto::tag::address_of, make)
    97             BOOST_PROTO_UNARY_OP_RESULT(!, proto::tag::logical_not, make)
    98             BOOST_PROTO_UNARY_OP_RESULT(++, proto::tag::pre_inc, make_mutable)
    99             BOOST_PROTO_UNARY_OP_RESULT(--, proto::tag::pre_dec, make_mutable)
    100 
    101             BOOST_PROTO_BINARY_OP_RESULT(<<, proto::tag::shift_left, make_mutable, make)
    102             BOOST_PROTO_BINARY_OP_RESULT(>>, proto::tag::shift_right, make_mutable, make)
    103             BOOST_PROTO_BINARY_OP_RESULT(*, proto::tag::multiplies, make, make)
    104             BOOST_PROTO_BINARY_OP_RESULT(/, proto::tag::divides, make, make)
    105             BOOST_PROTO_BINARY_OP_RESULT(%, proto::tag::modulus, make, make)
    106             BOOST_PROTO_BINARY_OP_RESULT(+, proto::tag::plus, make, make)
    107             BOOST_PROTO_BINARY_OP_RESULT(-, proto::tag::minus, make, make)
    108             BOOST_PROTO_BINARY_OP_RESULT(<, proto::tag::less, make, make)
    109             BOOST_PROTO_BINARY_OP_RESULT(>, proto::tag::greater, make, make)
    110             BOOST_PROTO_BINARY_OP_RESULT(<=, proto::tag::less_equal, make, make)
    111             BOOST_PROTO_BINARY_OP_RESULT(>=, proto::tag::greater_equal, make, make)
    112             BOOST_PROTO_BINARY_OP_RESULT(==, proto::tag::equal_to, make, make)
    113             BOOST_PROTO_BINARY_OP_RESULT(!=, proto::tag::not_equal_to, make, make)
    114             BOOST_PROTO_BINARY_OP_RESULT(||, proto::tag::logical_or, make, make)
    115             BOOST_PROTO_BINARY_OP_RESULT(&&, proto::tag::logical_and, make, make)
    116             BOOST_PROTO_BINARY_OP_RESULT(&, proto::tag::bitwise_and, make, make)
    117             BOOST_PROTO_BINARY_OP_RESULT(|, proto::tag::bitwise_or, make, make)
    118             BOOST_PROTO_BINARY_OP_RESULT(^, proto::tag::bitwise_xor, make, make)
    119 
    120             BOOST_PROTO_BINARY_OP_RESULT(=, proto::tag::assign, make_mutable, make)
    121             BOOST_PROTO_BINARY_OP_RESULT(<<=, proto::tag::shift_left_assign, make_mutable, make)
    122             BOOST_PROTO_BINARY_OP_RESULT(>>=, proto::tag::shift_right_assign, make_mutable, make)
    123             BOOST_PROTO_BINARY_OP_RESULT(*=, proto::tag::multiplies_assign, make_mutable, make)
    124             BOOST_PROTO_BINARY_OP_RESULT(/=, proto::tag::divides_assign, make_mutable, make)
    125             BOOST_PROTO_BINARY_OP_RESULT(%=, proto::tag::modulus_assign, make_mutable, make)
    126             BOOST_PROTO_BINARY_OP_RESULT(+=, proto::tag::plus_assign, make_mutable, make)
    127             BOOST_PROTO_BINARY_OP_RESULT(-=, proto::tag::minus_assign, make_mutable, make)
    128             BOOST_PROTO_BINARY_OP_RESULT(&=, proto::tag::bitwise_and_assign, make_mutable, make)
    129             BOOST_PROTO_BINARY_OP_RESULT(|=, proto::tag::bitwise_or_assign, make_mutable, make)
    130             BOOST_PROTO_BINARY_OP_RESULT(^=, proto::tag::bitwise_xor_assign, make_mutable, make)
    131 
    132         #undef BOOST_PROTO_UNARY_OP_RESULT
    133         #undef BOOST_PROTO_BINARY_OP_RESULT
     108            BOOST_PROTO_UNARY_DEFAULT_EVAL(+, proto::tag::unary_plus, make)
     109            BOOST_PROTO_UNARY_DEFAULT_EVAL(-, proto::tag::negate, make)
     110            BOOST_PROTO_UNARY_DEFAULT_EVAL(*, proto::tag::dereference, make)
     111            BOOST_PROTO_UNARY_DEFAULT_EVAL(~, proto::tag::complement, make)
     112            BOOST_PROTO_UNARY_DEFAULT_EVAL(&, proto::tag::address_of, make)
     113            BOOST_PROTO_UNARY_DEFAULT_EVAL(!, proto::tag::logical_not, make)
     114            BOOST_PROTO_UNARY_DEFAULT_EVAL(++, proto::tag::pre_inc, make_mutable)
     115            BOOST_PROTO_UNARY_DEFAULT_EVAL(--, proto::tag::pre_dec, make_mutable)
     116
     117            BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, proto::tag::shift_left, make_mutable, make)
     118            BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, proto::tag::shift_right, make_mutable, make)
     119            BOOST_PROTO_BINARY_DEFAULT_EVAL(*, proto::tag::multiplies, make, make)
     120            BOOST_PROTO_BINARY_DEFAULT_EVAL(/, proto::tag::divides, make, make)
     121            BOOST_PROTO_BINARY_DEFAULT_EVAL(%, proto::tag::modulus, make, make)
     122            BOOST_PROTO_BINARY_DEFAULT_EVAL(+, proto::tag::plus, make, make)
     123            BOOST_PROTO_BINARY_DEFAULT_EVAL(-, proto::tag::minus, make, make)
     124            BOOST_PROTO_BINARY_DEFAULT_EVAL(<, proto::tag::less, make, make)
     125            BOOST_PROTO_BINARY_DEFAULT_EVAL(>, proto::tag::greater, make, make)
     126            BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, proto::tag::less_equal, make, make)
     127            BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, proto::tag::greater_equal, make, make)
     128            BOOST_PROTO_BINARY_DEFAULT_EVAL(==, proto::tag::equal_to, make, make)
     129            BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, proto::tag::not_equal_to, make, make)
     130            BOOST_PROTO_BINARY_DEFAULT_EVAL(||, proto::tag::logical_or, make, make)
     131            BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, proto::tag::logical_and, make, make)
     132            BOOST_PROTO_BINARY_DEFAULT_EVAL(&, proto::tag::bitwise_and, make, make)
     133            BOOST_PROTO_BINARY_DEFAULT_EVAL(|, proto::tag::bitwise_or, make, make)
     134            BOOST_PROTO_BINARY_DEFAULT_EVAL(^, proto::tag::bitwise_xor, make, make)
     135
     136            BOOST_PROTO_BINARY_DEFAULT_EVAL(=, proto::tag::assign, make_mutable, make)
     137            BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, proto::tag::shift_left_assign, make_mutable, make)
     138            BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, proto::tag::shift_right_assign, make_mutable, make)
     139            BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, proto::tag::multiplies_assign, make_mutable, make)
     140            BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, proto::tag::divides_assign, make_mutable, make)
     141            BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, proto::tag::modulus_assign, make_mutable, make)
     142            BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, proto::tag::plus_assign, make_mutable, make)
     143            BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, proto::tag::minus_assign, make_mutable, make)
     144            BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, proto::tag::bitwise_and_assign, make_mutable, make)
     145            BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, proto::tag::bitwise_or_assign, make_mutable, make)
     146            BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, proto::tag::bitwise_xor_assign, make_mutable, make)
     147
     148        #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
     149        #undef BOOST_PROTO_BINARY_DEFAULT_EVAL
    134150
    135151            /// INTERNAL ONLY
     
    195211            {};
    196212
    197             template<typename Expr, typename Context, typename Tag>
    198             struct default_eval<Expr, Context, Tag, 0>
    199             {
    200                 typedef
    201                     typename proto::result_of::value<Expr &>::type
    202                 result_type;
    203 
    204                 result_type operator ()(Expr &expr, Context &) const
    205                 {
    206                     return proto::value(expr);
    207                 }
    208             };
    209 
    210213            // Handle post-increment specially.
    211214            template<typename Expr, typename Context>
     
    299302
    300303            // Handle function specially
    301             #define EVAL_TYPE(Z, N, DATA)                                                           \
     304            #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA)                                       \
    302305                typename proto::result_of::eval<                                                    \
    303306                    typename remove_reference<                                                      \
     
    308311                /**/
    309312
    310             #define EVAL(Z, N, DATA)                                                                \
     313            #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA)                                            \
    311314                proto::eval(proto::child_c<N>(DATA), context)                                       \
    312315                /**/
     
    316319            {
    317320                typedef
    318                     typename proto::detail::result_of_fixup<EVAL_TYPE(~, 0, Expr)>::type
     321                    typename proto::detail::result_of_fixup<
     322                        BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
     323                    >::type
    319324                function_type;
    320325
     
    325330                result_type operator ()(Expr &expr, Context &context) const
    326331                {
    327                     return EVAL(~, 0, expr)();
     332                    return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)();
    328333                }
    329334            };
     
    333338            {
    334339                typedef
    335                     typename proto::detail::result_of_fixup<EVAL_TYPE(~, 0, Expr)>::type
     340                    typename proto::detail::result_of_fixup<
     341                        BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
     342                    >::type
    336343                function_type;
    337344
    338345                typedef
    339                     typename detail::result_of_<function_type(EVAL_TYPE(~, 1, Expr))>::type
     346                    typename detail::result_of_<
     347                        function_type(BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr))
     348                    >::type
    340349                result_type;
    341350
     
    353362                result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const
    354363                {
    355                     return EVAL(~, 0, expr)(EVAL(~, 1, expr));
     364                    return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(BOOST_PROTO_DEFAULT_EVAL(~, 1, expr));
    356365                }
    357366
     
    360369                    BOOST_PROTO_USE_GET_POINTER();
    361370                    typedef typename detail::classtypeof<function_type>::type class_type;
    362                     return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, expr)) ->* EVAL(~, 0, expr))();
     371                    return (
     372                        BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
     373                        BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
     374                    )();
    363375                }
    364376
     
    367379                    BOOST_PROTO_USE_GET_POINTER();
    368380                    typedef typename detail::classtypeof<function_type>::type class_type;
    369                     return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, expr)) ->* EVAL(~, 0, expr));
     381                    return (
     382                        BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
     383                        BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
     384                    );
    370385                }
    371386            };
     
    374389            #include BOOST_PP_ITERATE()
    375390
    376             #undef EVAL_TYPE
    377             #undef EVAL
     391            #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
     392            #undef BOOST_PROTO_DEFAULT_EVAL
    378393
    379394            /// default_context
     
    405420        {
    406421            typedef
    407                 typename proto::detail::result_of_fixup<EVAL_TYPE(~, 0, Expr)>::type
     422                typename proto::detail::result_of_fixup<
     423                    BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
     424                >::type
    408425            function_type;
    409426
    410427            typedef
    411428                typename boost::result_of<
    412                     function_type(BOOST_PP_ENUM_SHIFTED(N, EVAL_TYPE, Expr))
     429                    function_type(BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr))
    413430                >::type
    414431            result_type;
     
    422439            result_type invoke(Expr &expr, Context &context, mpl::false_) const
    423440            {
    424                 return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
     441                return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(
     442                    BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, expr)
     443                );
    425444            }
    426445
    427446            result_type invoke(Expr &expr, Context &context, mpl::true_) const
    428447            {
    429                 #define M0(Z, M, expr) BOOST_PP_COMMA_IF(BOOST_PP_SUB(M, 2)) EVAL(Z, M, expr)
     448                #define M0(Z, M, DATA)                                                              \
     449                    BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)                           \
     450                    /**/
     451
    430452                BOOST_PROTO_USE_GET_POINTER();
    431453                typedef typename detail::classtypeof<function_type>::type class_type;
    432                 return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, expr)) ->* EVAL(~, 0, expr))(
    433                     BOOST_PP_REPEAT_FROM_TO(2, N, M0, expr)
    434                 );
     454                return (
     455                    BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
     456                    BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
     457                )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), M0, expr));
     458
    435459                #undef M0
    436460            }
  • branches/release/boost/proto/deep_copy.hpp

    r58336 r62138  
    205205                result_type operator()(Expr2 const &e, S const &, D const &) const
    206206                {
    207                     expr_type that = {
     207                    expr_type const that = {
    208208                        BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~)
    209209                    };
  • branches/release/boost/proto/domain.hpp

    r60505 r62138  
    1 ///////////////////////////////////////////////////////////////////////////////
    2 /// \file domain.hpp
    3 /// Contains definition of domain\<\> class template and helpers for
    4 /// defining domains with a generator and a grammar for controlling
    5 /// operator overloading.
    6 //
    7 //  Copyright 2008 Eric Niebler. Distributed under the Boost
    8 //  Software License, Version 1.0. (See accompanying file
    9 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    10 
    11 #ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
    12 #define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
    13 
    14 #include <boost/ref.hpp>
    15 #include <boost/mpl/bool.hpp>
    16 #include <boost/proto/proto_fwd.hpp>
    17 #include <boost/proto/generate.hpp>
    18 
    19 namespace boost { namespace proto
    20 {
    21 
    22     namespace detail
     1#ifndef BOOST_PP_IS_ITERATING
     2    ///////////////////////////////////////////////////////////////////////////////
     3    /// \file domain.hpp
     4    /// Contains definition of domain\<\> class template and helpers for
     5    /// defining domains with a generator and a grammar for controlling
     6    /// operator overloading.
     7    //
     8    //  Copyright 2008 Eric Niebler. Distributed under the Boost
     9    //  Software License, Version 1.0. (See accompanying file
     10    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
     11
     12    #ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
     13    #define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
     14
     15    #include <boost/ref.hpp>
     16    #include <boost/mpl/bool.hpp>
     17    #include <boost/mpl/assert.hpp>
     18    #include <boost/preprocessor/cat.hpp>
     19    #include <boost/preprocessor/facilities/intercept.hpp>
     20    #include <boost/preprocessor/iteration/iterate.hpp>
     21    #include <boost/preprocessor/repetition/repeat.hpp>
     22    #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
     23    #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
     24    #include <boost/preprocessor/repetition/enum_params.hpp>
     25    #include <boost/preprocessor/arithmetic/inc.hpp>
     26    #include <boost/preprocessor/arithmetic/dec.hpp>
     27    #include <boost/preprocessor/arithmetic/add.hpp>
     28    #include <boost/preprocessor/control/expr_if.hpp>
     29    #include <boost/proto/proto_fwd.hpp>
     30    #include <boost/proto/generate.hpp>
     31
     32    #ifdef _MSC_VER
     33    #define BOOST_PROTO_DISABLE_MSVC_C4584 __pragma(warning(disable: 4584))
     34    #else
     35    #define BOOST_PROTO_DISABLE_MSVC_C4584
     36    #endif
     37
     38    namespace boost { namespace proto
    2339    {
    24         struct not_a_generator
    25         {};
    26 
    27         struct not_a_grammar
    28         {};
    29     }
    30 
    31     namespace domainns_
    32     {
    33         /// \brief For use in defining domain tags to be used
    34         /// with \c proto::extends\<\>. A \e Domain associates
    35         /// an expression type with a \e Generator, and optionally
    36         /// a \e Grammar.
    37         ///
    38         /// The Generator determines how new expressions in the
    39         /// domain are constructed. Typically, a generator wraps
    40         /// all new expressions in a wrapper that imparts
    41         /// domain-specific behaviors to expressions within its
    42         /// domain. (See \c proto::extends\<\>.)
    43         ///
    44         /// The Grammar determines whether a given expression is
    45         /// valid within the domain, and automatically disables
    46         /// any operator overloads which would cause an invalid
    47         /// expression to be created. By default, the Grammar
    48         /// parameter defaults to the wildcard, \c proto::_, which
    49         /// makes all expressions valid within the domain.
    50         ///
    51         /// Example:
    52         /// \code
    53         /// template<typename Expr>
    54         /// struct MyExpr;
    55         ///
    56         /// struct MyGrammar
    57         ///   : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
    58         /// {};
    59         ///
    60         /// // Define MyDomain, in which all expressions are
    61         /// // wrapped in MyExpr<> and only expressions that
    62         /// // conform to MyGrammar are allowed.
    63         /// struct MyDomain
    64         ///   : domain<generator<MyExpr>, MyGrammar>
    65         /// {};
    66         ///
    67         /// // Use MyDomain to define MyExpr
    68         /// template<typename Expr>
    69         /// struct MyExpr
    70         ///   : extends<Expr, MyExpr<Expr>, MyDomain>
    71         /// {
    72         ///     // ...
    73         /// };
    74         /// \endcode
    75         ///
    76         template<
    77             typename Generator // = default_generator
    78           , typename Grammar   // = proto::_
    79         >
    80         struct domain
    81           : Generator
     40
     41        namespace detail
    8242        {
    83             typedef Generator proto_generator;
    84             typedef Grammar proto_grammar;
    85 
    86             /// INTERNAL ONLY
    87             typedef void proto_is_domain_;
    88         };
    89 
    90         /// \brief The domain expressions have by default, if
    91         /// \c proto::extends\<\> has not been used to associate
    92         /// a domain with an expression.
    93         ///
    94         struct default_domain
    95           : domain<>
    96         {};
    97 
    98         /// \brief A pseudo-domain for use in functions and
    99         /// metafunctions that require a domain parameter. It
    100         /// indicates that the domain of the parent node should
    101         /// be inferred from the domains of the child nodes.
    102         ///
    103         /// \attention \c deduce_domain is not itself a valid domain.
    104         ///
    105         struct deduce_domain
    106           : domain<detail::not_a_generator, detail::not_a_grammar>
    107         {};
    108     }
    109 
    110     namespace result_of
    111     {
    112         /// A metafunction that returns \c mpl::true_
    113         /// if the type \c T is the type of a Proto domain;
    114         /// \c mpl::false_ otherwise. If \c T inherits from
    115         /// \c proto::domain\<\>, \c is_domain\<T\> is
    116         /// \c mpl::true_.
    117         template<typename T, typename Void  /* = void*/>
    118         struct is_domain
    119           : mpl::false_
    120         {};
    121 
    122         /// INTERNAL ONLY
    123         ///
    124         template<typename T>
    125         struct is_domain<T, typename T::proto_is_domain_>
    126           : mpl::true_
    127         {};
    128 
    129         /// A metafunction that returns the domain of
    130         /// a given type. If \c T is a Proto expression
    131         /// type, it returns that expression's associated
    132         /// domain. If not, it returns
    133         /// \c proto::default_domain.
    134         template<typename T, typename Void /* = void*/>
    135         struct domain_of
     43            struct not_a_generator
     44            {};
     45
     46            struct not_a_grammar
     47            {};
     48
     49            struct not_a_domain
     50            {};
     51
     52            template<typename Super>
     53            struct super_domain : super_domain<typename Super::super>
     54            {
     55                typedef Super super;
     56                using super_domain<typename Super::super>::test;
     57                super_domain test(super_domain);
     58                super_domain test(super_domain<default_domain> const &);
     59                super *& get_super();
     60            };
     61
     62            template<>
     63            struct super_domain<not_a_domain>
     64            {
     65                typedef not_a_domain super;
     66                super_domain test(...);
     67                super *& get_super();
     68            };
     69
     70            template<>
     71            struct super_domain<default_domain>
     72            {
     73                typedef default_domain super;
     74                template<typename T> T test(T);
     75                super *& get_super();
     76            };
     77
     78            template<typename T, int N> char (&select_domain(T*&))[N];
     79            template<typename T, int N> char (&select_domain(...))[1];
     80
     81            template<
     82                int Index
     83                BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
     84                    BOOST_PROTO_MAX_ARITY
     85                  , typename D
     86                  , = void BOOST_PP_INTERCEPT
     87                )
     88            >
     89            struct select_nth
     90            {
     91                BOOST_MPL_ASSERT_MSG((false), PROTO_DOMAIN_MISMATCH, (select_nth));
     92                typedef not_a_domain type;
     93            };
     94
     95            template<typename Void = void>
     96            struct deduce_domain0
     97            {
     98                typedef default_domain type;
     99            };
     100
     101            #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/domain.hpp>))
     102            #include BOOST_PP_ITERATE()
     103        }
     104
     105        namespace domainns_
    136106        {
    137             typedef default_domain type;
    138         };
    139 
    140         /// INTERNAL ONLY
    141         ///
    142         template<typename T>
    143         struct domain_of<T, typename T::proto_is_expr_>
     107            /// \brief For use in defining domain tags to be used
     108            /// with \c proto::extends\<\>. A \e Domain associates
     109            /// an expression type with a \e Generator, and optionally
     110            /// a \e Grammar.
     111            ///
     112            /// The Generator determines how new expressions in the
     113            /// domain are constructed. Typically, a generator wraps
     114            /// all new expressions in a wrapper that imparts
     115            /// domain-specific behaviors to expressions within its
     116            /// domain. (See \c proto::extends\<\>.)
     117            ///
     118            /// The Grammar determines whether a given expression is
     119            /// valid within the domain, and automatically disables
     120            /// any operator overloads which would cause an invalid
     121            /// expression to be created. By default, the Grammar
     122            /// parameter defaults to the wildcard, \c proto::_, which
     123            /// makes all expressions valid within the domain.
     124            ///
     125            /// Example:
     126            /// \code
     127            /// template<typename Expr>
     128            /// struct MyExpr;
     129            ///
     130            /// struct MyGrammar
     131            ///   : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
     132            /// {};
     133            ///
     134            /// // Define MyDomain, in which all expressions are
     135            /// // wrapped in MyExpr<> and only expressions that
     136            /// // conform to MyGrammar are allowed.
     137            /// struct MyDomain
     138            ///   : domain<generator<MyExpr>, MyGrammar>
     139            /// {};
     140            ///
     141            /// // Use MyDomain to define MyExpr
     142            /// template<typename Expr>
     143            /// struct MyExpr
     144            ///   : extends<Expr, MyExpr<Expr>, MyDomain>
     145            /// {
     146            ///     // ...
     147            /// };
     148            /// \endcode
     149            ///
     150            BOOST_PROTO_DISABLE_MSVC_C4584
     151            template<
     152                typename Generator // = default_generator
     153              , typename Grammar   // = proto::_
     154              , typename Super     // = detail::not_a_domain
     155            >
     156            struct domain
     157              : detail::super_domain<Super>
     158              , Generator
     159            {
     160                typedef Generator proto_generator;
     161                typedef Grammar proto_grammar;
     162
     163                /// INTERNAL ONLY
     164                typedef void proto_is_domain_;
     165            };
     166
     167            /// \brief The domain expressions have by default, if
     168            /// \c proto::extends\<\> has not been used to associate
     169            /// a domain with an expression.
     170            ///
     171            struct default_domain
     172              : domain<>
     173            {};
     174
     175            /// \brief A pseudo-domain for use in functions and
     176            /// metafunctions that require a domain parameter. It
     177            /// indicates that the domain of the parent node should
     178            /// be inferred from the domains of the child nodes.
     179            ///
     180            /// \attention \c deduce_domain is not itself a valid domain.
     181            ///
     182            struct deduce_domain
     183              : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain>
     184            {};
     185        }
     186
     187        namespace result_of
    144188        {
    145             typedef typename T::proto_domain type;
    146         };
    147 
    148         /// INTERNAL ONLY
    149         ///
    150         template<typename T>
    151         struct domain_of<T &, void>
    152         {
    153             typedef typename domain_of<T>::type type;
    154         };
    155 
    156         /// INTERNAL ONLY
    157         ///
    158         template<typename T>
    159         struct domain_of<boost::reference_wrapper<T>, void>
    160         {
    161             typedef typename domain_of<T>::type type;
    162         };
    163 
    164         /// INTERNAL ONLY
    165         ///
    166         template<typename T>
    167         struct domain_of<boost::reference_wrapper<T> const, void>
    168         {
    169             typedef typename domain_of<T>::type type;
    170         };
    171     }
    172 }}
     189            /// A metafunction that returns \c mpl::true_
     190            /// if the type \c T is the type of a Proto domain;
     191            /// \c mpl::false_ otherwise. If \c T inherits from
     192            /// \c proto::domain\<\>, \c is_domain\<T\> is
     193            /// \c mpl::true_.
     194            template<typename T, typename Void  /* = void*/>
     195            struct is_domain
     196              : mpl::false_
     197            {};
     198
     199            /// INTERNAL ONLY
     200            ///
     201            template<typename T>
     202            struct is_domain<T, typename T::proto_is_domain_>
     203              : mpl::true_
     204            {};
     205
     206            /// A metafunction that returns the domain of
     207            /// a given type. If \c T is a Proto expression
     208            /// type, it returns that expression's associated
     209            /// domain. If not, it returns
     210            /// \c proto::default_domain.
     211            template<typename T, typename Void /* = void*/>
     212            struct domain_of
     213            {
     214                typedef default_domain type;
     215            };
     216
     217            /// INTERNAL ONLY
     218            ///
     219            template<typename T>
     220            struct domain_of<T, typename T::proto_is_expr_>
     221            {
     222                typedef typename T::proto_domain type;
     223            };
     224
     225            /// INTERNAL ONLY
     226            ///
     227            template<typename T>
     228            struct domain_of<T &, void>
     229            {
     230                typedef typename domain_of<T>::type type;
     231            };
     232
     233            /// INTERNAL ONLY
     234            ///
     235            template<typename T>
     236            struct domain_of<boost::reference_wrapper<T>, void>
     237            {
     238                typedef typename domain_of<T>::type type;
     239            };
     240
     241            /// INTERNAL ONLY
     242            ///
     243            template<typename T>
     244            struct domain_of<boost::reference_wrapper<T> const, void>
     245            {
     246                typedef typename domain_of<T>::type type;
     247            };
     248        }
     249    }}
     250
     251    #endif
     252
     253#else
     254
     255    #define N BOOST_PP_ITERATION()
     256
     257            template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename T)>
     258            struct select_nth<BOOST_PP_DEC(N), BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, T)>
     259            {
     260                typedef BOOST_PP_CAT(T, BOOST_PP_DEC(N)) type;
     261            };
     262
     263            template<BOOST_PP_ENUM_PARAMS(N, typename D)>
     264            struct BOOST_PP_CAT(common_domain, N)
     265            {
     266                #define M0(Z, M, DATA)                                                              \
     267                static detail::super_domain<BOOST_PP_CAT(D, M)> & BOOST_PP_CAT(d, M);               \
     268                /**/
     269                BOOST_PP_REPEAT(N, M0, ~)
     270                #undef M0
     271
     272                enum e
     273                {
     274                    value0 = 0
     275                    #define M0(Z, M, DATA)                                                          \
     276                        BOOST_PP_EXPR_IF(M, .test)(BOOST_PP_CAT(d, M))                              \
     277                    /**/
     278                    #define M1(Z, M, DATA)                                                          \
     279                      , BOOST_PP_CAT(value, BOOST_PP_INC(M)) =                                      \
     280                        BOOST_PP_CAT(value, M) ?                                                    \
     281                        BOOST_PP_CAT(value, M) :                                                    \
     282                        sizeof(detail::select_domain<BOOST_PP_CAT(D, M), BOOST_PP_ADD(M, 2)>(       \
     283                            BOOST_PP_REPEAT_ ## Z(N, M0, ~).get_super()                             \
     284                        )) - 1                                                                      \
     285                    /**/
     286                    BOOST_PP_REPEAT(N, M1, ~)
     287                    #undef M1
     288                    #undef M0
     289                  , value = BOOST_PP_CAT(value, N) - 1
     290                };
     291
     292                typedef typename select_nth<value BOOST_PP_ENUM_TRAILING_PARAMS(N, D)>::type type;
     293                //typedef BOOST_TYPEOF_TPL(d0.test(d1).test(d2).base()) type;
     294            };
     295
     296            template<BOOST_PP_ENUM_PARAMS(N, typename E)>
     297            struct BOOST_PP_CAT(deduce_domain, N)
     298              : BOOST_PP_CAT(common_domain, N)<
     299                    BOOST_PP_ENUM_BINARY_PARAMS(N, typename domain_of<E, >::type BOOST_PP_INTERCEPT)
     300                >
     301            {};
     302
     303    #undef N
    173304
    174305#endif
  • branches/release/boost/proto/extends.hpp

    r61073 r62138  
    223223              , 2                                                                                   \
    224224            > that_type;                                                                            \
    225             that_type that = {                                                                      \
     225            that_type const that = {                                                                \
    226226                *this                                                                               \
    227227              , a                                                                                   \
     
    246246        /// INTERNAL ONLY
    247247        ///
    248     #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(Const)                                                 \
     248    #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst)                                  \
    249249        template<typename A>                                                                        \
    250250        typename boost::result_of<                                                                  \
     
    253253                    boost::proto::tag::assign                                                       \
    254254                  , boost::proto::list2<                                                            \
    255                         proto_derived_expr Const() &                                                \
    256                       , typename boost::proto::result_of::as_child<A, proto_domain>::type          \
     255                        proto_derived_expr ThisConst() &                                            \
     256                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
    257257                    >                                                                               \
    258258                  , 2                                                                               \
     
    260260            )                                                                                       \
    261261        >::type const                                                                               \
    262         operator =(A &a) Const()                                                                    \
     262        operator =(A ThatConst() &a) ThisConst()                                                    \
    263263        {                                                                                           \
    264264            typedef boost::proto::expr<                                                             \
    265265                boost::proto::tag::assign                                                           \
    266266              , boost::proto::list2<                                                                \
    267                     proto_derived_expr Const() &                                                    \
    268                   , typename boost::proto::result_of::as_child<A, proto_domain>::type               \
     267                    proto_derived_expr ThisConst() &                                                \
     268                  , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type   \
    269269                >                                                                                   \
    270270              , 2                                                                                   \
    271271            > that_type;                                                                            \
    272             that_type that = {                                                                      \
    273                 *static_cast<proto_derived_expr Const() *>(this)                                    \
     272            that_type const that = {                                                                \
     273                *static_cast<proto_derived_expr ThisConst() *>(this)                                \
    274274              , boost::proto::as_child<proto_domain>(a)                                             \
    275275            };                                                                                      \
    276276            return proto_domain()(that);                                                            \
    277277        }                                                                                           \
    278                                                                                                     \
    279         template<typename A>                                                                        \
    280         typename boost::result_of<                                                                  \
    281             proto_domain(                                                                           \
    282                 boost::proto::expr<                                                                 \
    283                     boost::proto::tag::assign                                                       \
    284                   , boost::proto::list2<                                                            \
    285                         proto_derived_expr Const() &                                                \
    286                       , typename boost::proto::result_of::as_child<A const, proto_domain>::type     \
    287                     >                                                                               \
    288                   , 2                                                                               \
    289                 >                                                                                   \
    290             )                                                                                       \
    291         >::type const                                                                               \
    292         operator =(A const &a) Const()                                                              \
    293         {                                                                                           \
    294             typedef boost::proto::expr<                                                             \
    295                 boost::proto::tag::assign                                                           \
    296               , boost::proto::list2<                                                                \
    297                     proto_derived_expr Const() &                                                    \
    298                   , typename boost::proto::result_of::as_child<A const, proto_domain>::type         \
    299                 >                                                                                   \
    300               , 2                                                                                   \
    301             > that_type;                                                                            \
    302             that_type that = {                                                                      \
    303                 *static_cast<proto_derived_expr Const() *>(this)                                    \
    304               , boost::proto::as_child<proto_domain>(a)                                             \
    305             };                                                                                      \
    306             return proto_domain()(that);                                                            \
    307         }                                                                                           \
    308278        /**/
    309279
    310280    #define BOOST_PROTO_EXTENDS_ASSIGN_CONST_()                                                     \
    311         BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST)                                         \
     281        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY)                         \
     282        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST)                      \
    312283        /**/
    313284
    314285    #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_()                                                 \
    315         BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY)                                            \
     286        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY)                            \
     287        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST)                         \
    316288        /**/
    317289
    318290    #define BOOST_PROTO_EXTENDS_ASSIGN_()                                                           \
    319         BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY)                                            \
    320         BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST)                                         \
     291        BOOST_PROTO_EXTENDS_ASSIGN_CONST_()                                                         \
     292        BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_()                                                     \
    321293        /**/
    322294
     
    338310        /// INTERNAL ONLY
    339311        ///
    340     #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(Const)                                              \
     312    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst)                               \
    341313        template<typename A>                                                                        \
    342314        typename boost::result_of<                                                                  \
     
    345317                    boost::proto::tag::subscript                                                    \
    346318                  , boost::proto::list2<                                                            \
    347                         proto_derived_expr Const() &                                                \
    348                       , typename boost::proto::result_of::as_child<A, proto_domain>::type          \
     319                        proto_derived_expr ThisConst() &                                            \
     320                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
    349321                    >                                                                               \
    350322                  , 2                                                                               \
     
    352324            )                                                                                       \
    353325        >::type const                                                                               \
    354         operator [](A &a) Const()                                                                   \
     326        operator [](A ThatConst() &a) ThisConst()                                                   \
    355327        {                                                                                           \
    356328            typedef boost::proto::expr<                                                             \
    357329                boost::proto::tag::subscript                                                        \
    358330              , boost::proto::list2<                                                                \
    359                     proto_derived_expr Const() &                                                    \
    360                   , typename boost::proto::result_of::as_child<A, proto_domain>::type               \
     331                    proto_derived_expr ThisConst() &                                                \
     332                  , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type   \
    361333                >                                                                                   \
    362334              , 2                                                                                   \
    363335            > that_type;                                                                            \
    364             that_type that = {                                                                      \
    365                 *static_cast<proto_derived_expr Const() *>(this)                                    \
     336            that_type const that = {                                                                \
     337                *static_cast<proto_derived_expr ThisConst() *>(this)                                \
    366338              , boost::proto::as_child<proto_domain>(a)                                             \
    367339            };                                                                                      \
    368340            return proto_domain()(that);                                                            \
    369341        }                                                                                           \
    370                                                                                                     \
    371         template<typename A>                                                                        \
    372         typename boost::result_of<                                                                  \
    373             proto_domain(                                                                           \
    374                 boost::proto::expr<                                                                 \
    375                     boost::proto::tag::subscript                                                    \
    376                   , boost::proto::list2<                                                            \
    377                         proto_derived_expr Const() &                                                \
    378                       , typename boost::proto::result_of::as_child<A const, proto_domain>::type     \
    379                     >                                                                               \
    380                   , 2                                                                               \
    381                 >                                                                                   \
    382             )                                                                                       \
    383         >::type const                                                                               \
    384         operator [](A const &a) Const()                                                             \
    385         {                                                                                           \
    386             typedef boost::proto::expr<                                                             \
    387                 boost::proto::tag::subscript                                                        \
    388               , boost::proto::list2<                                                                \
    389                     proto_derived_expr Const() &                                                    \
    390                   , typename boost::proto::result_of::as_child<A const, proto_domain>::type         \
    391                 >                                                                                   \
    392               , 2                                                                                   \
    393             > that_type;                                                                            \
    394             that_type that = {                                                                      \
    395                 *static_cast<proto_derived_expr Const() *>(this)                                    \
    396               , boost::proto::as_child<proto_domain>(a)                                             \
    397             };                                                                                      \
    398             return proto_domain()(that);                                                            \
    399         }                                                                                           \
    400342        /**/
    401343
    402344    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()                                                   \
    403         BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST)                                      \
     345        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY)                      \
     346        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST)                   \
    404347        /**/
    405348
    406349    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST()                                               \
    407         BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY)                                         \
     350        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY)                         \
     351        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST)                      \
    408352        /**/
    409353
     
    669613        /// INTERNAL ONLY
    670614        ///
    671         #define BOOST_PROTO_EXTENDS_MEMBER_(R, DATA, ELEM)                                              \
     615        #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM)                                            \
    672616            boost::proto::exprns_::virtual_member<                                                      \
    673617                proto_derived_expr                                                                      \
    674618              , BOOST_PP_TUPLE_ELEM(2, 0, ELEM)                                                         \
    675               , proto_domain                                                                            \
     619              , DOMAIN                                                                                  \
    676620            > BOOST_PP_TUPLE_ELEM(2, 1, ELEM);                                                          \
    677621            /**/
     
    679623        /// \brief For declaring virtual data members in an extension class.
    680624        ///
    681         #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ)                                                        \
     625        #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN)                                    \
    682626            union                                                                                       \
    683627            {                                                                                           \
    684628                char proto_member_union_start_;                                                         \
    685                 BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, ~, SEQ)                              \
     629                BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ)                         \
    686630            };                                                                                          \
    687631            /**/
    688632
     633        /// \brief For declaring virtual data members in an extension class.
     634        ///
     635        #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ)                                                        \
     636            BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain)                                  \
     637            /**/
     638
    689639    }
    690640
  • branches/release/boost/proto/make_expr.hpp

    r60789 r62138  
    9292    ///
    9393    #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA)                                       \
    94         typedef typename fusion::result_of::next<                                \
     94        typedef typename fusion::result_of::next<                                                   \
    9595            BOOST_PP_CAT(fusion_iterator, N)>::type                                                 \
    9696                BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N));                                     \
     
    101101    #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N)                                                    \
    102102        typedef                                                                                     \
    103             typename fusion::result_of::begin<Sequence const>::type              \
     103            typename fusion::result_of::begin<Sequence const>::type                                 \
    104104        fusion_iterator0;                                                                           \
    105105        BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator)    \
     
    110110    #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA)                                                  \
    111111        typename add_const<                                                                         \
    112             typename fusion::result_of::value_of<                                \
     112            typename fusion::result_of::value_of<                                                   \
    113113                BOOST_PP_CAT(fusion_iterator, N)                                                    \
    114114            >::type                                                                                 \
     
    192192                    return functional::as_child<Domain>()(t);
    193193                }
    194             };
    195 
    196             template<
    197                 int Index
    198                 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
    199                     BOOST_PROTO_MAX_ARITY
    200                   , typename D
    201                   , = void BOOST_PP_INTERCEPT
    202                 )
    203             >
    204             struct select_nth
    205             {
    206                 BOOST_MPL_ASSERT_MSG((false), PROTO_DOMAIN_MISMATCH, (select_nth));
    207                 typedef default_domain type;
    208             };
    209 
    210             template<typename Void = void>
    211             struct deduce_domain0
    212             {
    213                 typedef default_domain type;
    214             };
    215 
    216             template<int I>
    217             struct sized
    218             {
    219                 char buffer[I];
    220             };
    221 
    222             template<typename T>
    223             struct nondeduced_domain
    224             {
    225                 typedef nondeduced_domain type;
    226                 nondeduced_domain(T);
    227                 nondeduced_domain(default_domain);
    228             };
    229 
    230             template<>
    231             struct nondeduced_domain<default_domain>
    232             {
    233                 typedef nondeduced_domain type;
    234                 nondeduced_domain(default_domain);
    235194            };
    236195
     
    900859    #endif
    901860
    902         template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename T)>
    903         struct select_nth<BOOST_PP_DEC(N), BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, T)>
    904         {
    905             typedef BOOST_PP_CAT(T, BOOST_PP_DEC(N)) type;
    906         };
    907 
    908         // Use function overloading as an efficient mechanism for
    909         // calculating the domain shared by a bunch of proto expressions
    910         // (or non-expressions, assumed to be in the default_domain).
    911         // The domain of a set of domains S is deduced as follows:
    912         // - If S contains only default_domain, the deduced domain is
    913         //   default_domain.
    914         // - If S contains only X and default_domain, the deduced domain
    915         //   is X.
    916         // - If S contains different domains X and Y, neither of which is
    917         //   default_domain, it is an error.
    918         template<BOOST_PP_ENUM_PARAMS(N, typename A)>
    919         struct BOOST_PP_CAT(deduce_domain, N)
    920         {
    921             #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
    922             // The function overloading trick doesn't work on MSVC-7.1, so
    923             // do it the hard (expensive) way.
    924             typedef
    925                 typename mpl::eval_if_c<
    926                     is_same<typename domain_of<A0>::type, default_domain>::value
    927                   , BOOST_PP_CAT(deduce_domain, BOOST_PP_DEC(N))<BOOST_PP_ENUM_SHIFTED_PARAMS(N, A)>
    928                   , domain_of<A0>
    929                 >::type
    930             type;
    931             #else
    932             #define M0(N, F) char (&F)[BOOST_PP_INC(N)]
    933             static M0(BOOST_PROTO_MAX_ARITY, deducer(...));
    934             #define M1(Z, X, DATA)                                                                  \
    935             typedef typename domain_of<BOOST_PP_CAT(A, X)>::type BOOST_PP_CAT(D, X);                \
    936             static BOOST_PP_CAT(D, X) &BOOST_PP_CAT(d, X);                                          \
    937             template<typename T>                                                                    \
    938             static M0(X, deducer(                                                                   \
    939                 BOOST_PP_ENUM_PARAMS_Z(Z, X, default_domain BOOST_PP_INTERCEPT)                     \
    940                 BOOST_PP_COMMA_IF(X) T                                                              \
    941                 BOOST_PP_ENUM_TRAILING_PARAMS_Z(                                                    \
    942                     Z                                                                               \
    943                   , BOOST_PP_DEC(BOOST_PP_SUB(N, X))                                                \
    944                   , typename nondeduced_domain<T>::type BOOST_PP_INTERCEPT                          \
    945                 )                                                                                   \
    946             ));
    947             BOOST_PP_REPEAT(N, M1, ~)
    948             #undef M0
    949             #undef M1
    950             BOOST_STATIC_CONSTANT(int, value = sizeof(deducer(BOOST_PP_ENUM_PARAMS(N, d))) - 1);
    951             typedef typename select_nth<value, BOOST_PP_ENUM_PARAMS(N, D)>::type type;
    952             #endif
    953         };
    954 
    955861        template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
    956862        struct make_expr_<Tag, Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
     
    967873            result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
    968874            {
    969                 expr_type that = {
     875                expr_type const that = {
    970876                    BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain))
    971877                };
     
    1002908            {
    1003909                BOOST_PROTO_FUSION_ITERATORS(N)
    1004                 expr_type that = {
     910                expr_type const that = {
    1005911                    BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~)
    1006912                };
  • branches/release/boost/proto/matches.hpp

    r60505 r62138  
    1717    #include <boost/preprocessor/arithmetic/dec.hpp>
    1818    #include <boost/preprocessor/arithmetic/sub.hpp>
    19     #include <boost/preprocessor/repetition/enum.hpp>
    2019    #include <boost/preprocessor/iteration/iterate.hpp>
    2120    #include <boost/preprocessor/facilities/intercept.hpp>
    2221    #include <boost/preprocessor/punctuation/comma_if.hpp>
     22    #include <boost/preprocessor/repetition/enum.hpp>
    2323    #include <boost/preprocessor/repetition/enum_params.hpp>
    2424    #include <boost/preprocessor/repetition/enum_shifted.hpp>
     25    #include <boost/preprocessor/repetition/enum_binary_params.hpp>
    2526    #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
    2627    #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
    2728    #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
     29    #include <boost/preprocessor/repetition/repeat.hpp>
    2830    #include <boost/config.hpp>
    2931    #include <boost/mpl/logical.hpp>
     
    7274            struct and_2;
    7375
    74             template<typename And>
    75             struct last;
    76 
    77             template<>
    78             struct last<proto::and_<> >
    79             {
    80                 typedef proto::_ type;
    81             };
    82 
    83             template<typename G0>
    84             struct last<proto::and_<G0> >
    85             {
    86                 typedef G0 type;
    87             };
     76            template<typename And, typename Expr, typename State, typename Data>
     77            struct _and_impl;
    8878
    8979            template<typename T, typename U>
     
    588578        }
    589579
     580        namespace detail
     581        {
     582            template<typename Expr, typename State, typename Data>
     583            struct _and_impl<proto::and_<>, Expr, State, Data>
     584              : proto::_::impl<Expr, State, Data>
     585            {};
     586
     587            template<typename G0, typename Expr, typename State, typename Data>
     588            struct _and_impl<proto::and_<G0>, Expr, State, Data>
     589              : proto::when<proto::_, G0>::template impl<Expr, State, Data>
     590            {};
     591        }
     592
    590593        namespace control
    591594        {
     
    755758
    756759            /// \brief For matching all of a set of grammars. When used as a
    757             /// transform, \c and_\<\> applies the transform associated with
    758             /// the last grammar in the set.
     760            /// transform, \c and_\<\> applies the transforms associated with
     761            /// the each grammar in the set, and returns the result of the last.
    759762            ///
    760763            /// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
     
    763766            /// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an
    764767            /// expression \c e, state \c s and data \c d, it is
    765             /// equivalent to <tt>Bn()(e, s, d)</tt>.
     768            /// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>.
    766769            template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
    767770            struct and_ : transform<and_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> >
     
    771774                template<typename Expr, typename State, typename Data>
    772775                struct impl
    773                   : detail::last<and_>::type::template impl<Expr, State, Data>
    774                 {
    775                     /// \param e An expression
    776                     /// \param s The current state
    777                     /// \param d A data of arbitrary type
    778                     /// \pre <tt>matches\<Expr,and_\>::::value</tt> is \c true.
    779                     /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is
    780                     /// the last non-void sub-grammar in the <tt>and_\<\></tt>.
    781                 };
     776                  : detail::_and_impl<and_, Expr, State, Data>
     777                {};
    782778            };
    783779
     
    948944
    949945        #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY
    950             template<BOOST_PP_ENUM_PARAMS(N, typename G)>
    951             struct last<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> >
    952             {
    953                 typedef BOOST_PP_CAT(G, BOOST_PP_DEC(N)) type;
     946            template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data>
     947            struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data>
     948              : proto::transform_impl<Expr, State, Data>
     949            {
     950                #define M0(Z, N, DATA)                                                            \
     951                typedef                                                                           \
     952                    typename proto::when<proto::_, BOOST_PP_CAT(G, N)>                            \
     953                        ::template impl<Expr, State, Data>                                        \
     954                BOOST_PP_CAT(Gimpl, N);                                                           \
     955                /**/
     956                BOOST_PP_REPEAT(N, M0, ~)
     957
     958                typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type;
     959
     960                result_type operator()(
     961                    typename _and_impl::expr_param e
     962                  , typename _and_impl::state_param s
     963                  , typename _and_impl::data_param d
     964                ) const
     965                {
     966                    // expands to (G0()(e,s,d),G1()(e,s,d),...);
     967                    return (BOOST_PP_ENUM_BINARY_PARAMS(N, Gimpl, ()(e,s,d) BOOST_PP_INTERCEPT));
     968                }
     969
     970                #undef M0
    954971            };
    955972
  • branches/release/boost/proto/operators.hpp

    r58336 r62138  
    1919#include <boost/proto/tags.hpp>
    2020#include <boost/proto/expr.hpp>
     21#include <boost/proto/domain.hpp>
    2122#include <boost/proto/matches.hpp>
    2223#include <boost/proto/generate.hpp>
     
    2728    namespace detail
    2829    {
    29         template<typename Domain1, typename Domain2>
    30         struct choose_domain2
    31         {
    32             BOOST_MPL_ASSERT((boost::is_same<Domain1, Domain2>));
    33             typedef Domain1 type;
    34         };
    35 
    36         template<typename Domain1>
    37         struct choose_domain2<Domain1, proto::default_domain>
    38         {
    39             typedef Domain1 type;
    40         };
    41 
    42         template<typename Domain2>
    43         struct choose_domain2<proto::default_domain, Domain2>
    44         {
    45             typedef Domain2 type;
    46         };
    47 
    48         template<>
    49         struct choose_domain2<proto::default_domain, proto::default_domain>
    50         {
    51             typedef proto::default_domain type;
    52         };
    53 
    5430        template<typename Domain, typename Expr, typename EnableIf = void>
    5531        struct generate_if
     
    12197            make(Left &left, Right &right)
    12298            {
    123                 term_type term = {right};
    124                 expr_type that = {left, proto_domain()(term)};
     99                term_type const term = {right};
     100                expr_type const that = {left, proto_domain()(term)};
    125101                return proto_domain()(that);
    126102            }
     
    143119            make(Left &left, Right &right)
    144120            {
    145                 term_type term = {left};
    146                 expr_type that = {proto_domain()(term), right};
     121                term_type const term = {left};
     122                expr_type const that = {proto_domain()(term), right};
    147123                return proto_domain()(that);
    148124            }
     
    157133        struct as_expr_if<Tag, Left, Right, typename Left::proto_is_expr_, typename Right::proto_is_expr_>
    158134          : generate_if<
    159                 typename choose_domain2<typename Left::proto_domain, typename Right::proto_domain>::type
     135                typename common_domain2<typename Left::proto_domain, typename Right::proto_domain>::type
    160136              , proto::expr<Tag, list2<Left &, Right &>, 2>
    161137            >
    162138        {
    163139            typedef proto::expr<Tag, list2<Left &, Right &>, 2> expr_type;
    164             typedef typename choose_domain2<typename Left::proto_domain, typename Right::proto_domain>::type proto_domain;
     140            typedef typename common_domain2<typename Left::proto_domain, typename Right::proto_domain>::type proto_domain;
    165141
    166142            static typename proto_domain::template result<proto_domain(expr_type)>::type
    167143            make(Left &left, Right &right)
    168144            {
    169                 expr_type that = {left, right};
     145                expr_type const that = {left, right};
    170146                return proto_domain()(that);
    171147            }
     
    253229    {                                                                                               \
    254230        typedef proto::expr<TAG, list1<Arg &>, 1> that_type;                                        \
    255         that_type that = {arg};                                                                     \
     231        that_type const that = {arg};                                                               \
    256232        return typename Arg::proto_domain()(that);                                                  \
    257233    }                                                                                               \
     
    265241    {                                                                                               \
    266242        typedef proto::expr<TAG, list1<Arg const &>, 1> that_type;                                  \
    267         that_type that = {arg};                                                                     \
     243        that_type const that = {arg};                                                               \
    268244        return typename Arg::proto_domain()(that);                                                  \
    269245    }                                                                                               \
  • branches/release/boost/proto/proto_fwd.hpp

    r58697 r62138  
    139139
    140140        struct _default;
     141
     142        struct not_a_domain;
     143        struct not_a_grammar;
     144        struct not_a_generator;
    141145    }
    142146
     
    256260    namespace domainns_
    257261    {
    258         template<typename Generator = default_generator, typename Grammar = proto::_>
     262        template<
     263            typename Generator  = default_generator
     264          , typename Grammar    = proto::_
     265          , typename Super      = detail::not_a_domain
     266        >
    259267        struct domain;
    260268
     
    718726    struct _value;
    719727
     728    struct _void;
     729
    720730    template<int I>
    721731    struct _child_c;
  • branches/release/boost/proto/proto_typeof.hpp

    r58336 r62138  
    6868BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::utility::literal, (typename)(typename))
    6969
     70BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_generator)
     71BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_grammar)
     72BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_domain)
     73BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::domainns_::domain, 3)
     74
    7075BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::argsns_::term, 1)
    7176BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::argsns_::list1, 1)
  • branches/release/boost/proto/transform/arg.hpp

    r60505 r62138  
    211211    };
    212212
     213    /// \brief A PrimitiveTransform that does nothing
     214    /// and returns void.
     215    struct _void : transform<_void>
     216    {
     217        template<typename Expr, typename State, typename Data>
     218        struct impl : transform_impl<Expr, State, Data>
     219        {
     220            typedef void result_type;
     221
     222            /// Does nothing and returns void
     223            void operator ()(
     224                typename impl::expr_param
     225              , typename impl::state_param
     226              , typename impl::data_param
     227            ) const
     228            {}
     229        };
     230    };
     231
    213232    /// \brief A unary CallableTransform that wraps its argument
    214233    /// in a \c boost::reference_wrapper\<\>.
  • branches/release/boost/proto/transform/default.hpp

    r58336 r62138  
    1414    #include <boost/preprocessor/iteration/iterate.hpp>
    1515    #include <boost/preprocessor/repetition/repeat.hpp>
     16    #include <boost/preprocessor/arithmetic/add.hpp>
     17    #include <boost/preprocessor/arithmetic/sub.hpp>
     18    #include <boost/preprocessor/repetition/enum.hpp>
    1619    #include <boost/preprocessor/repetition/enum_shifted.hpp>
    1720    #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
     
    3033    namespace boost { namespace proto
    3134    {
    32         template<typename Grammar /*= detail::_default*/>
    33         struct _default
    34           : transform<_default<Grammar> >
     35        namespace detail
    3536        {
    36             template<typename Expr, typename State, typename Data, typename Tag, long Arity>
    37             struct impl2;
    38 
    39             template<typename Expr, typename State, typename Data, typename Tag>
    40             struct impl2<Expr, State, Data, Tag, 0>
    41               : _value::impl<Expr, State, Data>
    42             {};
    43 
    44             #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG, MAKE)                                      \
    45             template<typename Expr, typename State, typename Data>                                  \
    46             struct impl2<Expr, State, Data, TAG, 1>                                                 \
    47               : transform_impl<Expr, State, Data>                                                   \
    48             {                                                                                       \
    49             private:                                                                                \
    50                 typedef typename result_of::child_c<Expr, 0>::type e0;                              \
    51                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;           \
    52             public:                                                                                 \
    53                 BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type)                    \
    54                 result_type operator ()(                                                            \
    55                     typename impl2::expr_param e                                                    \
    56                   , typename impl2::state_param s                                                   \
    57                   , typename impl2::data_param d                                                    \
    58                 ) const                                                                             \
    59                 {                                                                                   \
    60                     typename Grammar::template impl<e0, State, Data> t0;                            \
    61                     return OP t0(proto::child_c<0>(e), s, d);                                       \
    62                 }                                                                                   \
    63             };                                                                                      \
     37            template<typename Grammar, typename Tag>
     38            struct default_case
     39              : not_<_>
     40            {};
     41
     42            template<typename Grammar>
     43            struct default_case<Grammar, tag::terminal>
     44              : when<terminal<_>, _value>
     45            {};
     46
     47            template<typename Grammar>
     48            struct default_cases
     49            {
     50                template<typename Tag>
     51                struct case_
     52                  : default_case<Grammar, Tag>
     53                {};
     54            };
     55
     56            #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE)                                       \
     57            template<typename Grammar>                                                                  \
     58            struct BOOST_PP_CAT(default_, TAG)                                                          \
     59              : transform<BOOST_PP_CAT(default_, TAG)<Grammar> >                                        \
     60            {                                                                                           \
     61                template<typename Expr, typename State, typename Data>                                  \
     62                struct impl                                                                             \
     63                  : transform_impl<Expr, State, Data>                                                   \
     64                {                                                                                       \
     65                private:                                                                                \
     66                    typedef typename result_of::child_c<Expr, 0>::type e0;                              \
     67                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;           \
     68                public:                                                                                 \
     69                    BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type)                    \
     70                    result_type operator ()(                                                            \
     71                        typename impl::expr_param e                                                     \
     72                      , typename impl::state_param s                                                    \
     73                      , typename impl::data_param d                                                     \
     74                    ) const                                                                             \
     75                    {                                                                                   \
     76                        typename Grammar::template impl<e0, State, Data> t0;                            \
     77                        return OP t0(proto::child_c<0>(e), s, d);                                       \
     78                    }                                                                                   \
     79                };                                                                                      \
     80            };                                                                                          \
     81                                                                                                        \
     82            template<typename Grammar>                                                                  \
     83            struct default_case<Grammar, tag::TAG>                                                      \
     84            : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> >                \
     85            {};                                                                                         \
    6486            /**/
    6587
    66             #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG, LMAKE, RMAKE)                             \
    67             template<typename Expr, typename State, typename Data>                                  \
    68             struct impl2<Expr, State, Data, TAG, 2>                                                 \
    69               : transform_impl<Expr, State, Data>                                                   \
    70             {                                                                                       \
    71             private:                                                                                \
    72                 typedef typename result_of::child_c<Expr, 0>::type e0;                              \
    73                 typedef typename result_of::child_c<Expr, 1>::type e1;                              \
    74                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;           \
    75                 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;           \
    76             public:                                                                                 \
    77                 BOOST_PROTO_DECLTYPE_(                                                              \
    78                     proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>()                        \
    79                   , result_type                                                                     \
    80                 )                                                                                   \
    81                 result_type operator ()(                                                            \
    82                     typename impl2::expr_param e                                                    \
    83                   , typename impl2::state_param s                                                   \
    84                   , typename impl2::data_param d                                                    \
    85                 ) const                                                                             \
    86                 {                                                                                   \
    87                     typename Grammar::template impl<e0, State, Data> t0;                            \
    88                     typename Grammar::template impl<e1, State, Data> t1;                            \
    89                     return t0(proto::child_c<0>(e), s, d)                                           \
    90                         OP t1(proto::child_c<1>(e), s, d);                                          \
    91                 }                                                                                   \
    92             };                                                                                      \
     88            #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE)                              \
     89            template<typename Grammar>                                                                  \
     90            struct BOOST_PP_CAT(default_, TAG)                                                          \
     91              : transform<BOOST_PP_CAT(default_, TAG)<Grammar> >                                        \
     92            {                                                                                           \
     93                template<typename Expr, typename State, typename Data>                                  \
     94                struct impl                                                                             \
     95                  : transform_impl<Expr, State, Data>                                                   \
     96                {                                                                                       \
     97                private:                                                                                \
     98                    typedef typename result_of::child_c<Expr, 0>::type e0;                              \
     99                    typedef typename result_of::child_c<Expr, 1>::type e1;                              \
     100                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;           \
     101                    typedef typename Grammar::template impl<e1, State, Data>::result_type r1;           \
     102                public:                                                                                 \
     103                    BOOST_PROTO_DECLTYPE_(                                                              \
     104                        proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>()                        \
     105                      , result_type                                                                     \
     106                    )                                                                                   \
     107                    result_type operator ()(                                                            \
     108                        typename impl::expr_param e                                                     \
     109                      , typename impl::state_param s                                                    \
     110                      , typename impl::data_param d                                                     \
     111                    ) const                                                                             \
     112                    {                                                                                   \
     113                        typename Grammar::template impl<e0, State, Data> t0;                            \
     114                        typename Grammar::template impl<e1, State, Data> t1;                            \
     115                        return t0(proto::child_c<0>(e), s, d)                                           \
     116                            OP t1(proto::child_c<1>(e), s, d);                                          \
     117                    }                                                                                   \
     118                };                                                                                      \
     119            };                                                                                          \
     120                                                                                                        \
     121            template<typename Grammar>                                                                  \
     122            struct default_case<Grammar, tag::TAG>                                                      \
     123              : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> >    \
     124            {};                                                                                         \
    93125            /**/
    94126
    95             BOOST_PROTO_UNARY_OP_RESULT(+, tag::unary_plus, make)
    96             BOOST_PROTO_UNARY_OP_RESULT(-, tag::negate, make)
    97             BOOST_PROTO_UNARY_OP_RESULT(*, tag::dereference, make)
    98             BOOST_PROTO_UNARY_OP_RESULT(~, tag::complement, make)
    99             BOOST_PROTO_UNARY_OP_RESULT(&, tag::address_of, make)
    100             BOOST_PROTO_UNARY_OP_RESULT(!, tag::logical_not, make)
    101             BOOST_PROTO_UNARY_OP_RESULT(++, tag::pre_inc, make_mutable)
    102             BOOST_PROTO_UNARY_OP_RESULT(--, tag::pre_dec, make_mutable)
    103 
    104             BOOST_PROTO_BINARY_OP_RESULT(<<, tag::shift_left, make_mutable, make)
    105             BOOST_PROTO_BINARY_OP_RESULT(>>, tag::shift_right, make_mutable, make_mutable)
    106             BOOST_PROTO_BINARY_OP_RESULT(*, tag::multiplies, make, make)
    107             BOOST_PROTO_BINARY_OP_RESULT(/, tag::divides, make, make)
    108             BOOST_PROTO_BINARY_OP_RESULT(%, tag::modulus, make, make)
    109             BOOST_PROTO_BINARY_OP_RESULT(+, tag::plus, make, make)
    110             BOOST_PROTO_BINARY_OP_RESULT(-, tag::minus, make, make)
    111             BOOST_PROTO_BINARY_OP_RESULT(<, tag::less, make, make)
    112             BOOST_PROTO_BINARY_OP_RESULT(>, tag::greater, make, make)
    113             BOOST_PROTO_BINARY_OP_RESULT(<=, tag::less_equal, make, make)
    114             BOOST_PROTO_BINARY_OP_RESULT(>=, tag::greater_equal, make, make)
    115             BOOST_PROTO_BINARY_OP_RESULT(==, tag::equal_to, make, make)
    116             BOOST_PROTO_BINARY_OP_RESULT(!=, tag::not_equal_to, make, make)
    117             BOOST_PROTO_BINARY_OP_RESULT(||, tag::logical_or, make, make)
    118             BOOST_PROTO_BINARY_OP_RESULT(&&, tag::logical_and, make, make)
    119             BOOST_PROTO_BINARY_OP_RESULT(&, tag::bitwise_and, make, make)
    120             BOOST_PROTO_BINARY_OP_RESULT(|, tag::bitwise_or, make, make)
    121             BOOST_PROTO_BINARY_OP_RESULT(^, tag::bitwise_xor, make, make)
    122 
    123             BOOST_PROTO_BINARY_OP_RESULT(=, tag::assign, make_mutable, make)
    124             BOOST_PROTO_BINARY_OP_RESULT(<<=, tag::shift_left_assign, make_mutable, make)
    125             BOOST_PROTO_BINARY_OP_RESULT(>>=, tag::shift_right_assign, make_mutable, make)
    126             BOOST_PROTO_BINARY_OP_RESULT(*=, tag::multiplies_assign, make_mutable, make)
    127             BOOST_PROTO_BINARY_OP_RESULT(/=, tag::divides_assign, make_mutable, make)
    128             BOOST_PROTO_BINARY_OP_RESULT(%=, tag::modulus_assign, make_mutable, make)
    129             BOOST_PROTO_BINARY_OP_RESULT(+=, tag::plus_assign, make_mutable, make)
    130             BOOST_PROTO_BINARY_OP_RESULT(-=, tag::minus_assign, make_mutable, make)
    131             BOOST_PROTO_BINARY_OP_RESULT(&=, tag::bitwise_and_assign, make_mutable, make)
    132             BOOST_PROTO_BINARY_OP_RESULT(|=, tag::bitwise_or_assign, make_mutable, make)
    133             BOOST_PROTO_BINARY_OP_RESULT(^=, tag::bitwise_xor_assign, make_mutable, make)
    134 
    135             #undef BOOST_PROTO_UNARY_OP_RESULT
    136             #undef BOOST_PROTO_BINARY_OP_RESULT
     127            BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make)
     128            BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make)
     129            BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make)
     130            BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make)
     131            BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make)
     132            BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make)
     133            BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable)
     134            BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable)
     135
     136            BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make)
     137            BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable)
     138            BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make)
     139            BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make)
     140            BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make)
     141            BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make)
     142            BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make)
     143            BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make)
     144            BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make)
     145            BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make)
     146            BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make)
     147            BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make)
     148            BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make)
     149            BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make)
     150            BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make)
     151            BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make)
     152            BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make)
     153            BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make)
     154
     155            BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make)
     156            BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make)
     157            BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make)
     158            BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make)
     159            BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make)
     160            BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make)
     161            BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make)
     162            BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make)
     163            BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make)
     164            BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make)
     165            BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make)
     166
     167            #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
     168            #undef BOOST_PROTO_BINARY_DEFAULT_EVAL
    137169
    138170            /// INTERNAL ONLY
    139             template<typename Expr, typename State, typename Data>
     171            template<typename Grammar, typename Expr, typename State, typename Data>
    140172            struct is_member_function_invocation
    141173              : is_member_function_pointer<
     
    153185
    154186            /// INTERNAL ONLY
    155             template<typename Expr, typename State, typename Data, bool IsMemFunCall>
    156             struct memfun_impl
     187            template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall>
     188            struct default_mem_ptr_impl
    157189              : transform_impl<Expr, State, Data>
    158190            {
     
    165197                typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
    166198                result_type operator ()(
    167                     typename memfun_impl::expr_param e
    168                   , typename memfun_impl::state_param s
    169                   , typename memfun_impl::data_param d
     199                    typename default_mem_ptr_impl::expr_param e
     200                  , typename default_mem_ptr_impl::state_param s
     201                  , typename default_mem_ptr_impl::data_param d
    170202                ) const
    171203                {
     
    180212
    181213            /// INTERNAL ONLY
    182             template<typename Expr, typename State, typename Data>
    183             struct memfun_impl<Expr, State, Data, true>
     214            template<typename Grammar, typename Expr, typename State, typename Data>
     215            struct default_mem_ptr_impl<Grammar, Expr, State, Data, true>
    184216              : transform_impl<Expr, State, Data>
    185217            {
     
    192224                typedef detail::memfun<r0, r1> result_type;
    193225                result_type const operator ()(
    194                     typename memfun_impl::expr_param e
    195                   , typename memfun_impl::state_param s
    196                   , typename memfun_impl::data_param d
     226                    typename default_mem_ptr_impl::expr_param e
     227                  , typename default_mem_ptr_impl::state_param s
     228                  , typename default_mem_ptr_impl::data_param d
    197229                ) const
    198230                {
     
    206238            };
    207239
    208             template<typename Expr, typename State, typename Data>
    209             struct impl2<Expr, State, Data, tag::mem_ptr, 2>
    210               : memfun_impl<Expr, State, Data, is_member_function_invocation<Expr, State, Data>::value>
    211             {};
    212 
    213             template<typename Expr, typename State, typename Data>
    214             struct impl2<Expr, State, Data, tag::post_inc, 1>
    215               : transform_impl<Expr, State, Data>
    216             {
    217             private:
    218                 typedef typename result_of::child_c<Expr, 0>::type e0;
    219                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    220             public:
    221                 BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
    222                 result_type operator ()(
    223                     typename impl2::expr_param e
    224                   , typename impl2::state_param s
    225                   , typename impl2::data_param d
    226                 ) const
    227                 {
    228                     typename Grammar::template impl<e0, State, Data> t0;
    229                     return t0(proto::child_c<0>(e), s, d) ++;
    230                 }
    231             };
    232 
    233             template<typename Expr, typename State, typename Data>
    234             struct impl2<Expr, State, Data, tag::post_dec, 1>
    235               : transform_impl<Expr, State, Data>
    236             {
    237             private:
    238                 typedef typename result_of::child_c<Expr, 0>::type e0;
    239                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    240             public:
    241                 BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
    242                 result_type operator ()(
    243                     typename impl2::expr_param e
    244                   , typename impl2::state_param s
    245                   , typename impl2::data_param d
    246                 ) const
    247                 {
    248                     typename Grammar::template impl<e0, State, Data> t0;
    249                     return t0(proto::child_c<0>(e), s, d) --;
    250                 }
    251             };
    252 
    253             template<typename Expr, typename State, typename Data>
    254             struct impl2<Expr, State, Data, tag::subscript, 2>
    255               : transform_impl<Expr, State, Data>
    256             {
    257             private:
    258                 typedef typename result_of::child_c<Expr, 0>::type e0;
    259                 typedef typename result_of::child_c<Expr, 1>::type e1;
    260                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    261                 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
    262             public:
    263                 BOOST_PROTO_DECLTYPE_(
    264                     proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]
    265                   , result_type
    266                 )
    267                 result_type operator ()(
    268                     typename impl2::expr_param e
    269                   , typename impl2::state_param s
    270                   , typename impl2::data_param d
    271                 ) const
    272                 {
    273                     typename Grammar::template impl<e0, State, Data> t0;
    274                     typename Grammar::template impl<e1, State, Data> t1;
    275                     return t0(proto::child_c<0>(e), s, d) [
    276                            t1(proto::child_c<1>(e), s, d) ];
    277                 }
    278             };
    279 
    280             template<typename Expr, typename State, typename Data>
    281             struct impl2<Expr, State, Data, tag::if_else_, 3>
    282               : transform_impl<Expr, State, Data>
    283             {
    284             private:
    285                 typedef typename result_of::child_c<Expr, 0>::type e0;
    286                 typedef typename result_of::child_c<Expr, 1>::type e1;
    287                 typedef typename result_of::child_c<Expr, 2>::type e2;
    288                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    289                 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
    290                 typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
    291             public:
    292                 BOOST_PROTO_DECLTYPE_(
    293                     proto::detail::make<r0>()
    294                   ? proto::detail::make<r1>()
    295                   : proto::detail::make<r2>()
    296                   , result_type
    297                 )
    298                 result_type operator ()(
    299                     typename impl2::expr_param e
    300                   , typename impl2::state_param s
    301                   , typename impl2::data_param d
    302                 ) const
    303                 {
    304                     typename Grammar::template impl<e0, State, Data> t0;
    305                     typename Grammar::template impl<e1, State, Data> t1;
    306                     typename Grammar::template impl<e2, State, Data> t2;
    307                     return t0(proto::child_c<0>(e), s, d)
    308                          ? t1(proto::child_c<1>(e), s, d)
    309                          : t2(proto::child_c<2>(e), s, d);
    310                 }
    311             };
    312 
    313             template<typename Expr, typename State, typename Data>
    314             struct impl2<Expr, State, Data, tag::comma, 2>
    315               : transform_impl<Expr, State, Data>
    316             {
    317             private:
    318                 typedef typename result_of::child_c<Expr, 0>::type e0;
    319                 typedef typename result_of::child_c<Expr, 1>::type e1;
    320                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    321                 typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
    322             public:
    323                 typedef typename proto::detail::comma_result<r0, r1>::type result_type;
    324                 result_type operator ()(
    325                     typename impl2::expr_param e
    326                   , typename impl2::state_param s
    327                   , typename impl2::data_param d
    328                 ) const
    329                 {
    330                     typename Grammar::template impl<e0, State, Data> t0;
    331                     typename Grammar::template impl<e1, State, Data> t1;
    332                     return t0(proto::child_c<0>(e), s, d)
    333                          , t1(proto::child_c<1>(e), s, d);
    334                 }
    335             };
    336 
    337             #define EVAL_TYPE(Z, N, DATA)                                                           \
     240            template<typename Grammar>
     241            struct default_mem_ptr
     242              : transform<default_mem_ptr<Grammar> >
     243            {
     244                template<typename Expr, typename State, typename Data>
     245                struct impl
     246                  : default_mem_ptr_impl<
     247                        Grammar
     248                      , Expr
     249                      , State
     250                      , Data
     251                      , is_member_function_invocation<Grammar, Expr, State, Data>::value
     252                    >
     253                {};
     254            };
     255
     256            template<typename Grammar>
     257            struct default_case<Grammar, tag::mem_ptr>
     258              : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> >
     259            {};
     260
     261            template<typename Grammar>
     262            struct default_post_inc
     263              : transform<default_post_inc<Grammar> >
     264            {
     265                template<typename Expr, typename State, typename Data>
     266                struct impl
     267                  : transform_impl<Expr, State, Data>
     268                {
     269                private:
     270                    typedef typename result_of::child_c<Expr, 0>::type e0;
     271                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     272                public:
     273                    BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
     274                    result_type operator ()(
     275                        typename impl::expr_param e
     276                      , typename impl::state_param s
     277                      , typename impl::data_param d
     278                    ) const
     279                    {
     280                        typename Grammar::template impl<e0, State, Data> t0;
     281                        return t0(proto::child_c<0>(e), s, d) ++;
     282                    }
     283                };
     284            };
     285
     286            template<typename Grammar>
     287            struct default_case<Grammar, tag::post_inc>
     288              : when<post_inc<Grammar>, default_post_inc<Grammar> >
     289            {};
     290
     291            template<typename Grammar>
     292            struct default_post_dec
     293              : transform<default_post_dec<Grammar> >
     294            {
     295                template<typename Expr, typename State, typename Data>
     296                struct impl
     297                  : transform_impl<Expr, State, Data>
     298                {
     299                private:
     300                    typedef typename result_of::child_c<Expr, 0>::type e0;
     301                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     302                public:
     303                    BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
     304                    result_type operator ()(
     305                        typename impl::expr_param e
     306                      , typename impl::state_param s
     307                      , typename impl::data_param d
     308                    ) const
     309                    {
     310                        typename Grammar::template impl<e0, State, Data> t0;
     311                        return t0(proto::child_c<0>(e), s, d) --;
     312                    }
     313                };
     314            };
     315
     316            template<typename Grammar>
     317            struct default_case<Grammar, tag::post_dec>
     318              : when<post_dec<Grammar>, default_post_dec<Grammar> >
     319            {};
     320
     321            template<typename Grammar>
     322            struct default_subscript
     323              : transform<default_subscript<Grammar> >
     324            {
     325                template<typename Expr, typename State, typename Data>
     326                struct impl
     327                  : transform_impl<Expr, State, Data>
     328                {
     329                private:
     330                    typedef typename result_of::child_c<Expr, 0>::type e0;
     331                    typedef typename result_of::child_c<Expr, 1>::type e1;
     332                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     333                    typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     334                public:
     335                    BOOST_PROTO_DECLTYPE_(
     336                        proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]
     337                      , result_type
     338                    )
     339                    result_type operator ()(
     340                        typename impl::expr_param e
     341                      , typename impl::state_param s
     342                      , typename impl::data_param d
     343                    ) const
     344                    {
     345                        typename Grammar::template impl<e0, State, Data> t0;
     346                        typename Grammar::template impl<e1, State, Data> t1;
     347                        return t0(proto::child_c<0>(e), s, d) [
     348                               t1(proto::child_c<1>(e), s, d) ];
     349                    }
     350                };
     351            };
     352
     353            template<typename Grammar>
     354            struct default_case<Grammar, tag::subscript>
     355              : when<subscript<Grammar, Grammar>, default_subscript<Grammar> >
     356            {};
     357
     358            template<typename Grammar>
     359            struct default_if_else_
     360            {
     361                template<typename Expr, typename State, typename Data>
     362                struct impl
     363                  : transform_impl<Expr, State, Data>
     364                {
     365                private:
     366                    typedef typename result_of::child_c<Expr, 0>::type e0;
     367                    typedef typename result_of::child_c<Expr, 1>::type e1;
     368                    typedef typename result_of::child_c<Expr, 2>::type e2;
     369                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     370                    typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     371                    typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
     372                public:
     373                    BOOST_PROTO_DECLTYPE_(
     374                        proto::detail::make<r0>()
     375                      ? proto::detail::make<r1>()
     376                      : proto::detail::make<r2>()
     377                      , result_type
     378                    )
     379                    result_type operator ()(
     380                        typename impl::expr_param e
     381                      , typename impl::state_param s
     382                      , typename impl::data_param d
     383                    ) const
     384                    {
     385                        typename Grammar::template impl<e0, State, Data> t0;
     386                        typename Grammar::template impl<e1, State, Data> t1;
     387                        typename Grammar::template impl<e2, State, Data> t2;
     388                        return t0(proto::child_c<0>(e), s, d)
     389                             ? t1(proto::child_c<1>(e), s, d)
     390                             : t2(proto::child_c<2>(e), s, d);
     391                    }
     392                };
     393            };
     394
     395            template<typename Grammar>
     396            struct default_case<Grammar, tag::if_else_>
     397              : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> >
     398            {};
     399
     400            template<typename Grammar>
     401            struct default_comma
     402              : transform<default_comma<Grammar> >
     403            {
     404                template<typename Expr, typename State, typename Data>
     405                struct impl
     406                  : transform_impl<Expr, State, Data>
     407                {
     408                private:
     409                    typedef typename result_of::child_c<Expr, 0>::type e0;
     410                    typedef typename result_of::child_c<Expr, 1>::type e1;
     411                    typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     412                    typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     413                public:
     414                    typedef typename proto::detail::comma_result<r0, r1>::type result_type;
     415                    result_type operator ()(
     416                        typename impl::expr_param e
     417                      , typename impl::state_param s
     418                      , typename impl::data_param d
     419                    ) const
     420                    {
     421                        typename Grammar::template impl<e0, State, Data> t0;
     422                        typename Grammar::template impl<e1, State, Data> t1;
     423                        return t0(proto::child_c<0>(e), s, d)
     424                             , t1(proto::child_c<1>(e), s, d);
     425                    }
     426                };
     427            };
     428
     429            template<typename Grammar>
     430            struct default_case<Grammar, tag::comma>
     431              : when<comma<Grammar, Grammar>, default_comma<Grammar> >
     432            {};
     433
     434            template<typename Grammar, typename Expr, typename State, typename Data, long Arity>
     435            struct default_function_impl;
     436
     437            template<typename Grammar>
     438            struct default_function
     439              : transform<default_function<Grammar> >
     440            {
     441                template<typename Expr, typename State, typename Data>
     442                struct impl
     443                  : default_function_impl<
     444                        Grammar
     445                      , Expr
     446                      , State
     447                      , Data
     448                      , transform_impl<Expr, State, Data>::expr::proto_arity_c
     449                    >
     450                {};
     451            };
     452
     453            template<typename Grammar>
     454            struct default_case<Grammar, tag::function>
     455              : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> >
     456            {};
     457
     458            #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA)                                       \
    338459                typedef                                                                             \
    339460                    typename result_of::child_c<DATA, N>::type                                      \
    340461                BOOST_PP_CAT(e, N);                                                                 \
     462                                                                                                    \
    341463                typedef                                                                             \
    342464                    typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type   \
     
    344466                /**/
    345467
    346             #define EVAL(Z, N, DATA)                                                                \
     468            #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA)                                            \
    347469                typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()(                 \
    348                     proto::child_c<N>(DATA), s, d                                            \
     470                    proto::child_c<N>(DATA), s, d                                                   \
    349471                )                                                                                   \
    350472                /**/
    351473
    352             template<typename Expr, typename State, typename Data>
    353             struct impl2<Expr, State, Data, tag::function, 1>
     474            template<typename Grammar, typename Expr, typename State, typename Data>
     475            struct default_function_impl<Grammar, Expr, State, Data, 1>
    354476              : transform_impl<Expr, State, Data>
    355477            {
    356                 EVAL_TYPE(~, 0, Expr)
     478                BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
    357479
    358480                typedef
     
    365487
    366488                result_type operator ()(
    367                     typename impl2::expr_param e
    368                   , typename impl2::state_param s
    369                   , typename impl2::data_param d
     489                    typename default_function_impl::expr_param e
     490                  , typename default_function_impl::state_param s
     491                  , typename default_function_impl::data_param d
    370492                ) const
    371493                {
    372                     return EVAL(~, 0, e)();
     494                    return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)();
    373495                }
    374496            };
    375497
    376             template<typename Expr, typename State, typename Data>
    377             struct impl2<Expr, State, Data, tag::function, 2>
     498            template<typename Grammar, typename Expr, typename State, typename Data>
     499            struct default_function_impl<Grammar, Expr, State, Data, 2>
    378500              : transform_impl<Expr, State, Data>
    379501            {
    380                 EVAL_TYPE(~, 0, Expr)
    381                 EVAL_TYPE(~, 1, Expr)
     502                BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
     503                BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)
    382504
    383505                typedef
     
    390512
    391513                result_type operator ()(
    392                     typename impl2::expr_param e
    393                   , typename impl2::state_param s
    394                   , typename impl2::data_param d
     514                    typename default_function_impl::expr_param e
     515                  , typename default_function_impl::state_param s
     516                  , typename default_function_impl::data_param d
    395517                ) const
    396518                {
     
    406528            private:
    407529                result_type invoke(
    408                     typename impl2::expr_param e
    409                   , typename impl2::state_param s
    410                   , typename impl2::data_param d
     530                    typename default_function_impl::expr_param e
     531                  , typename default_function_impl::state_param s
     532                  , typename default_function_impl::data_param d
    411533                  , mpl::false_
    412534                  , mpl::false_
    413535                ) const
    414536                {
    415                     return EVAL(~, 0, e)(EVAL(~, 1, e));
     537                    return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e));
    416538                }
    417539
    418540                result_type invoke(
    419                     typename impl2::expr_param e
    420                   , typename impl2::state_param s
    421                   , typename impl2::data_param d
     541                    typename default_function_impl::expr_param e
     542                  , typename default_function_impl::state_param s
     543                  , typename default_function_impl::data_param d
    422544                  , mpl::true_
    423545                  , mpl::false_
     
    426548                    BOOST_PROTO_USE_GET_POINTER();
    427549                    typedef typename detail::classtypeof<function_type>::type class_type;
    428                     return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, e)) ->* EVAL(~, 0, e))();
     550                    return (
     551                        BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
     552                        BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
     553                    )();
    429554                }
    430555
    431556                result_type invoke(
    432                     typename impl2::expr_param e
    433                   , typename impl2::state_param s
    434                   , typename impl2::data_param d
     557                    typename default_function_impl::expr_param e
     558                  , typename default_function_impl::state_param s
     559                  , typename default_function_impl::data_param d
    435560                  , mpl::false_
    436561                  , mpl::true_
     
    439564                    BOOST_PROTO_USE_GET_POINTER();
    440565                    typedef typename detail::classtypeof<function_type>::type class_type;
    441                     return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, e)) ->* EVAL(~, 0, e));
     566                    return (
     567                        BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
     568                        BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
     569                    );
    442570                }
    443571            };
     
    446574            #include BOOST_PP_ITERATE()
    447575
    448             #undef EVAL_TYPE
    449             #undef EVAL
    450 
    451             template<typename Expr, typename State, typename Data>
    452             struct impl
    453               : impl2<
    454                     Expr
    455                   , State
    456                   , Data
    457                   , typename transform_impl<Expr, State, Data>::expr::proto_tag
    458                   , transform_impl<Expr, State, Data>::expr::proto_arity_c
    459                 >
    460             {};
    461         };
     576            #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
     577            #undef BOOST_PROTO_DEFAULT_EVAL
     578        }
     579
     580        template<typename Grammar /*= detail::_default*/>
     581        struct _default
     582          : switch_<detail::default_cases<Grammar> >
     583        {};
    462584
    463585        template<typename Grammar>
     
    483605    #define N BOOST_PP_ITERATION()
    484606
    485         template<typename Expr, typename State, typename Data>
    486         struct impl2<Expr, State, Data, tag::function, N>
     607        template<typename Grammar, typename Expr, typename State, typename Data>
     608        struct default_function_impl<Grammar, Expr, State, Data, N>
    487609          : transform_impl<Expr, State, Data>
    488610        {
    489             BOOST_PP_REPEAT(N, EVAL_TYPE, Expr)
     611            BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)
    490612
    491613            typedef
     
    500622
    501623            result_type operator ()(
    502                 typename impl2::expr_param e
    503               , typename impl2::state_param s
    504               , typename impl2::data_param d
     624                typename default_function_impl::expr_param e
     625              , typename default_function_impl::state_param s
     626              , typename default_function_impl::data_param d
    505627            ) const
    506628            {
     
    510632        private:
    511633            result_type invoke(
    512                 typename impl2::expr_param e
    513               , typename impl2::state_param s
    514               , typename impl2::data_param d
     634                typename default_function_impl::expr_param e
     635              , typename default_function_impl::state_param s
     636              , typename default_function_impl::data_param d
    515637              , mpl::false_
    516638            ) const
    517639            {
    518                 return EVAL(~, 0, e)(BOOST_PP_ENUM_SHIFTED(N, EVAL, e));
     640                return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(
     641                    BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e)
     642                );
    519643            }
    520644
    521645            result_type invoke(
    522                 typename impl2::expr_param e
    523               , typename impl2::state_param s
    524               , typename impl2::data_param d
     646                typename default_function_impl::expr_param e
     647              , typename default_function_impl::state_param s
     648              , typename default_function_impl::data_param d
    525649              , mpl::true_
    526650            ) const
    527651            {
    528                 #define M0(Z, M, e) BOOST_PP_COMMA_IF(BOOST_PP_SUB(M, 2)) EVAL(Z, M, e)
     652                #define M0(Z, M, DATA) BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)
    529653                BOOST_PROTO_USE_GET_POINTER();
    530654                typedef typename detail::classtypeof<function_type>::type class_type;
    531                 return (BOOST_PROTO_GET_POINTER(class_type, EVAL(~, 1, e)) ->* EVAL(~, 0, e))(
    532                     BOOST_PP_REPEAT_FROM_TO(2, N, M0, e)
    533                 );
     655                return (
     656                    BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
     657                    BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
     658                )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), M0, e));
    534659                #undef M0
    535660            }
  • branches/release/boost/proto/transform/pass_through.hpp

    r60505 r62138  
    4242                  , State                                                                           \
    4343                  , Data                                                                            \
    44                 >::result_type
     44                >::result_type                                                                      \
     45                /**/
    4546
    4647            #define BOOST_PROTO_DEFINE_TRANSFORM(Z, N, DATA)                                        \
     
    5051                  , Data                                                                            \
    5152                >()(                                                                                \
    52                     e.proto_base().BOOST_PP_CAT(child, N), s, d                           \
    53                 )
     53                    e.proto_base().BOOST_PP_CAT(child, N), s, d                                     \
     54                )                                                                                   \
     55                /**/
    5456
    5557            #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/pass_through.hpp>))
     
    7173                result_type
    7274                #else
    73                 typename pass_through_impl::expr_param 
     75                typename pass_through_impl::expr_param
    7476                #endif
    7577                operator()(
     
    164166              : transform_impl<Expr, State, Data>
    165167            {
     168                typedef typename pass_through_impl::expr unref_expr;
     169
    166170                typedef proto::expr<
    167                     typename remove_reference<Expr>::type::proto_tag
     171                    typename unref_expr::proto_tag
    168172                  , BOOST_PP_CAT(list, N)<
    169173                        BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM_TYPE, ~)
    170174                    >
    171175                  , N
    172                 > result_type;
    173 
    174                 result_type operator ()(
     176                > expr_type;
     177
     178                typedef typename unref_expr::proto_domain proto_domain;
     179                typedef typename boost::result_of<proto_domain(expr_type)>::type result_type;
     180
     181                result_type const operator ()(
    175182                    typename pass_through_impl::expr_param e
    176183                  , typename pass_through_impl::state_param s
     
    178185                ) const
    179186                {
    180                     result_type that = {
     187                    expr_type const that = {
    181188                        BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM, ~)
    182189                    };
     
    187194                    &that;
    188195                    #endif
    189                     return that;
     196                    return proto_domain()(that);
    190197                }
    191198            };
  • branches/release/boost/python

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/range

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/regex

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/serialization

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/serialization/factory.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/signals

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/signals2

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/spirit

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/spirit/home

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/spirit/home/karma

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/spirit/home/support/attributes.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/statechart

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/system

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/thread

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/thread.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/tr1

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/type_traits

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/unordered

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/utility

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/utility/value_init.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/uuid

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/variant

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/boost/wave

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/bootstrap.bat

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/bootstrap.sh

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/index.htm

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs

  • branches/release/libs/array/doc/array.xml

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/array/test/array0.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/bimap

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/config

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/config/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/filesystem

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/functional/hash

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/fusion

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/graph_parallel

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/integer

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/interprocess

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/intrusive

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/iostreams

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/libraries.htm

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/maintainers.txt

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/broken-compiler-workarounds.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/categorized-index-concepts.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/cfg-no-preprocessed-headers.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/composition-and-argument-binding.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/data-types-concepts.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/data-types-miscellaneous.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/extensible-associative-sequence.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/inserter-class.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/tag-dispatched-metafunction.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/refmanual/trivial-metafunctions-summary.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/mpl/doc/src/refmanual/Iterators-Iterator.rst

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/numeric/ublas

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/numeric/ublas/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/property_tree

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/proto/doc/back_end.qbk

    r51586 r62138  
    12491249       the given expression and apply its associated transform.]]
    12501250 [[_and_]
    1251       [For the given set of sub-grammars, take the /last/ sub-grammar and apply its
    1252        associated transform.]]
     1251      [For the given set of sub-grammars, apply all the associated transforms and
     1252       return the result of the last.]]
    12531253 [[_not_]
    12541254      [Return the current expression unmodified.]]
  • branches/release/libs/proto/doc/reference.xml

    r60672 r62138  
    4949        <computeroutput>
    5050          <classname alt="boost::proto::_value">proto::_value</classname>
     51        </computeroutput>
     52      </listitem>
     53      <listitem>
     54        <computeroutput>
     55          <classname alt="boost::proto::_void">proto::_void</classname>
    5156        </computeroutput>
    5257      </listitem>
  • branches/release/libs/proto/doc/reference/matches.xml

    r58393 r62138  
    359359        <purpose>For matching all of a set of grammars. When used as a transform,
    360360          <computeroutput>proto::and_&lt;&gt;</computeroutput> applies the transform associated
    361           with the <emphasis>last</emphasis> grammar in the set.</purpose>
     361          with each grammar in the set and returns the result of the last.</purpose>
    362362        <description>
    363363          <para>
     
    372372            as a transform with an expression <computeroutput>e</computeroutput>, state
    373373            <computeroutput>s</computeroutput> and data <computeroutput>d</computeroutput>, it is equivalent
    374             to <computeroutput>G<subscript>n</subscript>()(e, s, d)</computeroutput>.
     374            to <computeroutput>(G<subscript>0</subscript>()(e, s, d),G<subscript>1</subscript>()(e, s, d),...G<subscript>n</subscript>()(e, s, d))</computeroutput>.
    375375          </para>
    376376          <para>
     
    413413              <returns>
    414414                <para>
    415                   <computeroutput>G<subscript>n</subscript>()(expr, state, data)</computeroutput>
     415                  <computeroutput>(G<subscript>0</subscript>()(expr, state, data),G<subscript>1</subscript>()(expr, state, data),...G<subscript>n</subscript>()(expr, state, data))</computeroutput>
    416416                </para>
    417417              </returns>
  • branches/release/libs/proto/doc/reference/transform/arg.xml

    r50279 r62138  
    282282                </para>
    283283              </returns>
     284              <throws>
     285                <simpara>Will not throw.</simpara>
     286              </throws>
     287            </method>
     288          </method-group>
     289        </struct>
     290      </struct>
     291
     292      <struct name="_void">
     293        <inherit><classname>proto::transform</classname>&lt; _void &gt;</inherit>
     294        <purpose>A <conceptname>PrimitiveTransform</conceptname> that does nothing and returns void. </purpose>
     295        <struct name="impl">
     296          <template>
     297            <template-type-parameter name="Expr"/>
     298            <template-type-parameter name="State"/>
     299            <template-type-parameter name="Data"/>
     300          </template>
     301          <inherit><classname>proto::transform_impl</classname>&lt; Expr, State, Data &gt;</inherit>
     302          <typedef name="result_type">
     303            <type>void</type>
     304          </typedef>
     305          <method-group name="public member functions">
     306            <method name="operator()" cv="const">
     307              <type>void</type>
     308              <parameter name="">
     309                <paramtype>typename impl::expr_param</paramtype>
     310              </parameter>
     311              <parameter name="">
     312                <paramtype>typename impl::state_param</paramtype>
     313              </parameter>
     314              <parameter name="">
     315                <paramtype>typename impl::data_param</paramtype>
     316              </parameter>
     317              <description>
     318                <para>
     319                  Does nothing.
     320                </para>
     321              </description>
    284322              <throws>
    285323                <simpara>Will not throw.</simpara>
  • branches/release/libs/proto/doc/reference/transform/pass_through.xml

    r57440 r62138  
    101101            <type>typename Expr::proto_tag</type>
    102102          </typedef>
     103          <typedef name="D">
     104            <purpose>For exposition only</purpose>
     105            <type>typename Expr::proto_domain</type>
     106          </typedef>
     107          <typedef name="expr_type">
     108            <purpose>For exposition only</purpose>
     109            <type><classname>proto::expr</classname>&lt;T, <classname>proto::listN</classname>&lt;R0,...RN&gt; &gt;</type>
     110          </typedef>
    103111          <typedef name="result_type">
    104             <type><classname>proto::expr</classname>&lt;T, <classname>proto::listN</classname>&lt;R0,...RN&gt; &gt;</type>
     112            <type>typename boost::result_of&lt;D(expr_type)&gt;::type</type>
    105113          </typedef>
    106114          <method-group name="public member functions">
     
    125133              <returns>
    126134                <para>
    127                   <programlisting>result_type::make(
     135                  <programlisting>D()(expr_type::make(
    128136  G0()(<functionname>proto::child_c</functionname>&lt;0&gt;(expr), state, data),
    129137  ...
    130138  GN()(<functionname>proto::child_c</functionname>&lt;N&gt;(expr), state, data)
    131 )</programlisting>
     139))</programlisting>
    132140                </para>
    133141              </returns>
  • branches/release/libs/proto/doc/release_notes.qbk

    r60789 r62138  
    77
    88[section:release_notes Appendix A: Release Notes]
     9
     10[/=================]
     11[heading Boost 1.44]
     12[/=================]
     13
     14In Boost 1.44, the behavior of _and_ as a transform changed. Previously, it only
     15applied the transform associated with the last grammar in the set. Now, it applies
     16all the transforms but only returns the result of the last. That makes it behave
     17like C++'s comma operator. For example, a grammar such as:
     18
     19  proto::and_< G0, G1, G2 >
     20
     21when evaluated with an expression `e` now behaves like this:
     22
     23  (G0()(e), G1()(e), G2()(e))
    924
    1025[/=================]
  • branches/release/libs/python

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/range

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/range/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/regex

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/regex/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/serialization

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/signals

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/signals2

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/classic/example

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/doc

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/example

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/phoenix

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/test

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/spirit/test/qi/optional.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/statechart

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/static_assert

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/system

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/thread

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/timer

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/tr1

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/type_traits

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/unordered

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/utility

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/utility/swap.html

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/utility/swap/test/std_bitset.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/utility/value_init.htm

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/utility/value_init_test.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/uuid

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/libs/wave

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/more

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/people

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/rst.css

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/status

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/status/Jamfile.v2

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/bcp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/boostbook

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/build/v2

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/build/v2/tools

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/inspect

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/jam

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/quickbook

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/regression

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/release

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/tools/wave

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/release/wiki

    • Property svn:mergeinfo changed (with no actual effect on merging)
Note: See TracChangeset for help on using the changeset viewer.