Changeset 44712


Ignore:
Timestamp:
Apr 22, 2008, 6:47:13 AM (10 years ago)
Author:
Eric Niebler
Message:

loosen const-correctness in return type calculation of _default and default_context

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

Legend:

Unmodified
Added
Removed
  • branches/proto/v4/boost/proto/context/default.hpp

    r44402 r44712  
    2121    #include <boost/type_traits/is_function.hpp>
    2222    #include <boost/type_traits/remove_reference.hpp>
     23    #include <boost/type_traits/is_member_pointer.hpp>
    2324    #include <boost/proto/proto_fwd.hpp>
    2425    #include <boost/proto/tags.hpp>
     
    4748            /// INTERNAL ONLY
    4849            ///
    49         #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG)                                                \
     50        #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG, MAKE)                                          \
    5051            template<typename Expr, typename Context>                                               \
    5152            struct default_eval<Expr, Context, TAG, 1>                                              \
     
    5556                typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;               \
    5657            public:                                                                                 \
    57                 BOOST_PROTO_DECLTYPE_(OP proto::detail::make<r0>(), result_type)                    \
     58                BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type)                    \
    5859                result_type operator ()(Expr &expr, Context &ctx) const                             \
    5960                {                                                                                   \
     
    6566            /// INTERNAL ONLY
    6667            ///
    67         #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG)                                               \
     68        #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG, LMAKE, RMAKE)                                 \
    6869            template<typename Expr, typename Context>                                               \
    6970            struct default_eval<Expr, Context, TAG, 2>                                              \
     
    7677            public:                                                                                 \
    7778                BOOST_PROTO_DECLTYPE_(                                                              \
    78                     proto::detail::make<r0>() OP proto::detail::make<r1>()                          \
     79                    proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>()                        \
    7980                  , result_type                                                                     \
    8081                )                                                                                   \
     
    8990            /**/
    9091
    91             BOOST_PROTO_UNARY_OP_RESULT(+, proto::tag::unary_plus)
    92             BOOST_PROTO_UNARY_OP_RESULT(-, proto::tag::negate)
    93             BOOST_PROTO_UNARY_OP_RESULT(*, proto::tag::dereference)
    94             BOOST_PROTO_UNARY_OP_RESULT(~, proto::tag::complement)
    95             BOOST_PROTO_UNARY_OP_RESULT(&, proto::tag::address_of)
    96             BOOST_PROTO_UNARY_OP_RESULT(!, proto::tag::logical_not)
    97             BOOST_PROTO_UNARY_OP_RESULT(++, proto::tag::pre_inc)
    98             BOOST_PROTO_UNARY_OP_RESULT(--, proto::tag::pre_dec)
    99 
    100             BOOST_PROTO_BINARY_OP_RESULT(<<, proto::tag::shift_left)
    101             BOOST_PROTO_BINARY_OP_RESULT(>>, proto::tag::shift_right)
    102             BOOST_PROTO_BINARY_OP_RESULT(*, proto::tag::multiplies)
    103             BOOST_PROTO_BINARY_OP_RESULT(/, proto::tag::divides)
    104             BOOST_PROTO_BINARY_OP_RESULT(%, proto::tag::modulus)
    105             BOOST_PROTO_BINARY_OP_RESULT(+, proto::tag::plus)
    106             BOOST_PROTO_BINARY_OP_RESULT(-, proto::tag::minus)
    107             BOOST_PROTO_BINARY_OP_RESULT(<, proto::tag::less)
    108             BOOST_PROTO_BINARY_OP_RESULT(>, proto::tag::greater)
    109             BOOST_PROTO_BINARY_OP_RESULT(<=, proto::tag::less_equal)
    110             BOOST_PROTO_BINARY_OP_RESULT(>=, proto::tag::greater_equal)
    111             BOOST_PROTO_BINARY_OP_RESULT(==, proto::tag::equal_to)
    112             BOOST_PROTO_BINARY_OP_RESULT(!=, proto::tag::not_equal_to)
    113             BOOST_PROTO_BINARY_OP_RESULT(||, proto::tag::logical_or)
    114             BOOST_PROTO_BINARY_OP_RESULT(&&, proto::tag::logical_and)
    115             BOOST_PROTO_BINARY_OP_RESULT(&, proto::tag::bitwise_and)
    116             BOOST_PROTO_BINARY_OP_RESULT(|, proto::tag::bitwise_or)
    117             BOOST_PROTO_BINARY_OP_RESULT(^, proto::tag::bitwise_xor)
    118             BOOST_PROTO_BINARY_OP_RESULT(->*, proto::tag::mem_ptr)
    119 
    120             BOOST_PROTO_BINARY_OP_RESULT(=, proto::tag::assign)
    121             BOOST_PROTO_BINARY_OP_RESULT(<<=, proto::tag::shift_left_assign)
    122             BOOST_PROTO_BINARY_OP_RESULT(>>=, proto::tag::shift_right_assign)
    123             BOOST_PROTO_BINARY_OP_RESULT(*=, proto::tag::multiplies_assign)
    124             BOOST_PROTO_BINARY_OP_RESULT(/=, proto::tag::divides_assign)
    125             BOOST_PROTO_BINARY_OP_RESULT(%=, proto::tag::modulus_assign)
    126             BOOST_PROTO_BINARY_OP_RESULT(+=, proto::tag::plus_assign)
    127             BOOST_PROTO_BINARY_OP_RESULT(-=, proto::tag::minus_assign)
    128             BOOST_PROTO_BINARY_OP_RESULT(&=, proto::tag::bitwise_and_assign)
    129             BOOST_PROTO_BINARY_OP_RESULT(|=, proto::tag::bitwise_or_assign)
    130             BOOST_PROTO_BINARY_OP_RESULT(^=, proto::tag::bitwise_xor_assign)
     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            BOOST_PROTO_BINARY_OP_RESULT(->*, proto::tag::mem_ptr, make_mutable, make)
     120
     121            BOOST_PROTO_BINARY_OP_RESULT(=, proto::tag::assign, make_mutable, make)
     122            BOOST_PROTO_BINARY_OP_RESULT(<<=, proto::tag::shift_left_assign, make_mutable, make)
     123            BOOST_PROTO_BINARY_OP_RESULT(>>=, proto::tag::shift_right_assign, make_mutable, make)
     124            BOOST_PROTO_BINARY_OP_RESULT(*=, proto::tag::multiplies_assign, make_mutable, make)
     125            BOOST_PROTO_BINARY_OP_RESULT(/=, proto::tag::divides_assign, make_mutable, make)
     126            BOOST_PROTO_BINARY_OP_RESULT(%=, proto::tag::modulus_assign, make_mutable, make)
     127            BOOST_PROTO_BINARY_OP_RESULT(+=, proto::tag::plus_assign, make_mutable, make)
     128            BOOST_PROTO_BINARY_OP_RESULT(-=, proto::tag::minus_assign, make_mutable, make)
     129            BOOST_PROTO_BINARY_OP_RESULT(&=, proto::tag::bitwise_and_assign, make_mutable, make)
     130            BOOST_PROTO_BINARY_OP_RESULT(|=, proto::tag::bitwise_or_assign, make_mutable, make)
     131            BOOST_PROTO_BINARY_OP_RESULT(^=, proto::tag::bitwise_xor_assign, make_mutable, make)
    131132
    132133        #undef BOOST_PROTO_UNARY_OP_RESULT
     
    154155                typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
    155156            public:
    156                 BOOST_PROTO_DECLTYPE_(proto::detail::make<r0>() ++, result_type)
     157                BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
    157158                result_type operator ()(Expr &expr, Context &ctx) const
    158159                {
     
    169170                typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
    170171            public:
    171                 BOOST_PROTO_DECLTYPE_(proto::detail::make<r0>() --, result_type)
     172                BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
    172173                result_type operator ()(Expr &expr, Context &ctx) const
    173174                {
     
    289290            result_type;
    290291
     292            #if N == 1
    291293            result_type operator ()(Expr &expr, Context &context) const
    292294            {
    293295                return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
    294296            }
     297            #else
     298            result_type operator ()(Expr &expr, Context &context) const
     299            {
     300                return this->invoke(expr, context, is_member_pointer<function_type>());
     301            }
     302
     303            result_type invoke(Expr &expr, Context &context, mpl::false_) const
     304            {
     305                return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
     306            }
     307
     308            result_type invoke(Expr &expr, Context &context, mpl::true_) const
     309            {
     310                #define M0(Z, M, expr) BOOST_PP_COMMA_IF(BOOST_PP_SUB(M, 2)) EVAL(Z, M, expr)
     311                return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr))(
     312                    BOOST_PP_REPEAT_FROM_TO(2, N, M0, expr)
     313                );
     314                #undef M0
     315            }
     316            #endif
    295317        };
    296318
  • branches/proto/v4/boost/proto/detail/decltype.hpp

    r44702 r44712  
    5151        ////////////////////////////////////////////////////////////////////////////////////////////
    5252        template<typename T>
     53        struct as_mutable
     54        {
     55            typedef T &type;
     56        };
     57
     58        template<typename T>
     59        struct as_mutable<T &>
     60        {
     61            typedef T &type;
     62        };
     63
     64        template<typename T>
     65        struct as_mutable<T const &>
     66        {
     67            typedef T &type;
     68        };
     69
     70        ////////////////////////////////////////////////////////////////////////////////////////////
     71        template<typename T>
    5372        T make();
     73
     74        ////////////////////////////////////////////////////////////////////////////////////////////
     75        template<typename T>
     76        typename as_mutable<T>::type make_mutable();
    5477
    5578        ////////////////////////////////////////////////////////////////////////////////////////////
     
    5982        template<typename T>
    6083        char (&check_reference(T const &))[2];
     84
     85        ////////////////////////////////////////////////////////////////////////////////////////////
     86        template<typename T>
     87        T &deref(T &t)
     88        {
     89            return t;
     90        }
     91
     92        template<typename T>
     93        T const &deref(T const &t)
     94        {
     95            return t;
     96        }
     97
     98        template<typename T>
     99        T &deref(T *&t)
     100        {
     101            return *t;
     102        }
     103
     104        template<typename T>
     105        T &deref(T *const &t)
     106        {
     107            return *t;
     108        }
    61109
    62110        ////////////////////////////////////////////////////////////////////////////////////////////
  • branches/proto/v4/boost/proto/transform/default.hpp

    r44649 r44712  
    2929    namespace boost { namespace proto
    3030    {
    31         namespace detail
    32         {
    33             template<typename T>
    34             T &deref(T &t)
    35             {
    36                 return t;
    37             }
    38 
    39             template<typename T>
    40             T const &deref(T const &t)
    41             {
    42                 return t;
    43             }
    44 
    45             template<typename T>
    46             T &deref(T *&t)
    47             {
    48                 return *t;
    49             }
    50 
    51             template<typename T>
    52             T &deref(T *const &t)
    53             {
    54                 return *t;
    55             }
    56         }
    57 
    5831        template<typename Grammar>
    5932        struct _default
     
    6841            {};
    6942
    70             #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG)                                            \
     43            #define BOOST_PROTO_UNARY_OP_RESULT(OP, TAG, MAKE)                                      \
    7144            template<typename Expr, typename State, typename Data>                                  \
    7245            struct impl2<Expr, State, Data, TAG, 1>                                                 \
     
    7750                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;           \
    7851            public:                                                                                 \
    79                 BOOST_PROTO_DECLTYPE_(OP proto::detail::make<r0>(), result_type)                    \
     52                BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type)                    \
    8053                result_type operator ()(                                                            \
    8154                    typename impl2::expr_param expr                                                 \
     
    9063            /**/
    9164
    92             #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG)                                           \
     65            #define BOOST_PROTO_BINARY_OP_RESULT(OP, TAG, LMAKE, RMAKE)                             \
    9366            template<typename Expr, typename State, typename Data>                                  \
    9467            struct impl2<Expr, State, Data, TAG, 2>                                                 \
     
    10275            public:                                                                                 \
    10376                BOOST_PROTO_DECLTYPE_(                                                              \
    104                     proto::detail::make<r0>() OP proto::detail::make<r1>()                          \
     77                    proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>()                        \
    10578                  , result_type                                                                     \
    10679                )                                                                                   \
     
    11992            /**/
    12093
    121             BOOST_PROTO_UNARY_OP_RESULT(+, tag::unary_plus)
    122             BOOST_PROTO_UNARY_OP_RESULT(-, tag::negate)
    123             BOOST_PROTO_UNARY_OP_RESULT(*, tag::dereference)
    124             BOOST_PROTO_UNARY_OP_RESULT(~, tag::complement)
    125             BOOST_PROTO_UNARY_OP_RESULT(&, tag::address_of)
    126             BOOST_PROTO_UNARY_OP_RESULT(!, tag::logical_not)
    127             BOOST_PROTO_UNARY_OP_RESULT(++, tag::pre_inc)
    128             BOOST_PROTO_UNARY_OP_RESULT(--, tag::pre_dec)
    129 
    130             BOOST_PROTO_BINARY_OP_RESULT(<<, tag::shift_left)
    131             BOOST_PROTO_BINARY_OP_RESULT(>>, tag::shift_right)
    132             BOOST_PROTO_BINARY_OP_RESULT(*, tag::multiplies)
    133             BOOST_PROTO_BINARY_OP_RESULT(/, tag::divides)
    134             BOOST_PROTO_BINARY_OP_RESULT(%, tag::modulus)
    135             BOOST_PROTO_BINARY_OP_RESULT(+, tag::plus)
    136             BOOST_PROTO_BINARY_OP_RESULT(-, tag::minus)
    137             BOOST_PROTO_BINARY_OP_RESULT(<, tag::less)
    138             BOOST_PROTO_BINARY_OP_RESULT(>, tag::greater)
    139             BOOST_PROTO_BINARY_OP_RESULT(<=, tag::less_equal)
    140             BOOST_PROTO_BINARY_OP_RESULT(>=, tag::greater_equal)
    141             BOOST_PROTO_BINARY_OP_RESULT(==, tag::equal_to)
    142             BOOST_PROTO_BINARY_OP_RESULT(!=, tag::not_equal_to)
    143             BOOST_PROTO_BINARY_OP_RESULT(||, tag::logical_or)
    144             BOOST_PROTO_BINARY_OP_RESULT(&&, tag::logical_and)
    145             BOOST_PROTO_BINARY_OP_RESULT(&, tag::bitwise_and)
    146             BOOST_PROTO_BINARY_OP_RESULT(|, tag::bitwise_or)
    147             BOOST_PROTO_BINARY_OP_RESULT(^, tag::bitwise_xor)
    148             BOOST_PROTO_BINARY_OP_RESULT(->*, tag::mem_ptr)
    149 
    150             BOOST_PROTO_BINARY_OP_RESULT(=, tag::assign)
    151             BOOST_PROTO_BINARY_OP_RESULT(<<=, tag::shift_left_assign)
    152             BOOST_PROTO_BINARY_OP_RESULT(>>=, tag::shift_right_assign)
    153             BOOST_PROTO_BINARY_OP_RESULT(*=, tag::multiplies_assign)
    154             BOOST_PROTO_BINARY_OP_RESULT(/=, tag::divides_assign)
    155             BOOST_PROTO_BINARY_OP_RESULT(%=, tag::modulus_assign)
    156             BOOST_PROTO_BINARY_OP_RESULT(+=, tag::plus_assign)
    157             BOOST_PROTO_BINARY_OP_RESULT(-=, tag::minus_assign)
    158             BOOST_PROTO_BINARY_OP_RESULT(&=, tag::bitwise_and_assign)
    159             BOOST_PROTO_BINARY_OP_RESULT(|=, tag::bitwise_or_assign)
    160             BOOST_PROTO_BINARY_OP_RESULT(^=, tag::bitwise_xor_assign)
     94            BOOST_PROTO_UNARY_OP_RESULT(+, tag::unary_plus, make)
     95            BOOST_PROTO_UNARY_OP_RESULT(-, tag::negate, make)
     96            BOOST_PROTO_UNARY_OP_RESULT(*, tag::dereference, make)
     97            BOOST_PROTO_UNARY_OP_RESULT(~, tag::complement, make)
     98            BOOST_PROTO_UNARY_OP_RESULT(&, tag::address_of, make)
     99            BOOST_PROTO_UNARY_OP_RESULT(!, tag::logical_not, make)
     100            BOOST_PROTO_UNARY_OP_RESULT(++, tag::pre_inc, make_mutable)
     101            BOOST_PROTO_UNARY_OP_RESULT(--, tag::pre_dec, make_mutable)
     102
     103            BOOST_PROTO_BINARY_OP_RESULT(<<, tag::shift_left, make_mutable, make)
     104            BOOST_PROTO_BINARY_OP_RESULT(>>, tag::shift_right, make_mutable, make)
     105            BOOST_PROTO_BINARY_OP_RESULT(*, tag::multiplies, make, make)
     106            BOOST_PROTO_BINARY_OP_RESULT(/, tag::divides, make, make)
     107            BOOST_PROTO_BINARY_OP_RESULT(%, tag::modulus, make, make)
     108            BOOST_PROTO_BINARY_OP_RESULT(+, tag::plus, make, make)
     109            BOOST_PROTO_BINARY_OP_RESULT(-, tag::minus, make, make)
     110            BOOST_PROTO_BINARY_OP_RESULT(<, tag::less, make, make)
     111            BOOST_PROTO_BINARY_OP_RESULT(>, tag::greater, make, make)
     112            BOOST_PROTO_BINARY_OP_RESULT(<=, tag::less_equal, make, make)
     113            BOOST_PROTO_BINARY_OP_RESULT(>=, tag::greater_equal, make, make)
     114            BOOST_PROTO_BINARY_OP_RESULT(==, tag::equal_to, make, make)
     115            BOOST_PROTO_BINARY_OP_RESULT(!=, tag::not_equal_to, make, make)
     116            BOOST_PROTO_BINARY_OP_RESULT(||, tag::logical_or, make, make)
     117            BOOST_PROTO_BINARY_OP_RESULT(&&, tag::logical_and, make, make)
     118            BOOST_PROTO_BINARY_OP_RESULT(&, tag::bitwise_and, make, make)
     119            BOOST_PROTO_BINARY_OP_RESULT(|, tag::bitwise_or, make, make)
     120            BOOST_PROTO_BINARY_OP_RESULT(^, tag::bitwise_xor, make, make)
     121            BOOST_PROTO_BINARY_OP_RESULT(->*, tag::mem_ptr, make_mutable, 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)
    161134
    162135            #undef BOOST_PROTO_UNARY_OP_RESULT
     
    171144                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    172145            public:
    173                 BOOST_PROTO_DECLTYPE_(proto::detail::make<r0>() ++, result_type)
     146                BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
    174147                result_type operator ()(
    175148                    typename impl2::expr_param expr
     
    191164                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
    192165            public:
    193                 BOOST_PROTO_DECLTYPE_(proto::detail::make<r0>() --, result_type)
     166                BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
    194167                result_type operator ()(
    195168                    typename impl2::expr_param expr
Note: See TracChangeset for help on using the changeset viewer.