1 #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) 2 3 #include <boost/proto/detail/preprocessed/traits.hpp> 4 5 #elif !defined(BOOST_PP_IS_ITERATING) 6 7 #define BOOST_PROTO_CHILD(Z, N, DATA) \ 8 /** INTERNAL ONLY */ \ 9 typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N); \ 10 /**/ 11 12 #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) 13 #pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp") 14 #endif 15 16 /////////////////////////////////////////////////////////////////////////////// 17 /// \file traits.hpp 18 /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c 19 // 20 // Copyright 2008 Eric Niebler. Distributed under the Boost 21 // Software License, Version 1.0. (See accompanying file 22 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 23 24 #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) 25 #pragma wave option(preserve: 1) 26 #endif 27 28 #define BOOST_PP_ITERATION_PARAMS_1 \ 29 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/traits.hpp>)) 30 #include BOOST_PP_ITERATE() 31 32 #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) 33 #pragma wave option(output: null) 34 #endif 35 36 #undef BOOST_PROTO_CHILD 37 38 #else // BOOST_PP_IS_ITERATING 39 40 #define N BOOST_PP_ITERATION() 41 42 #if N > 0 43 /// \brief A metafunction for generating function-call expression types, 44 /// a grammar element for matching function-call expressions, and a 45 /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> 46 /// transform. 47 template<BOOST_PP_ENUM_PARAMS(N, typename A)> 48 struct function 49 #if N != BOOST_PROTO_MAX_ARITY 50 < 51 BOOST_PP_ENUM_PARAMS(N, A) 52 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) 53 > 54 #endif 55 : proto::transform< 56 function< 57 BOOST_PP_ENUM_PARAMS(N, A) 58 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) 59 > 60 , int 61 > 62 { 63 typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; 64 typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; 65 66 template<typename Expr, typename State, typename Data> 67 struct impl 68 : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> 69 {}; 70 71 /// INTERNAL ONLY 72 typedef proto::tag::function proto_tag; 73 BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) 74 BOOST_PP_REPEAT_FROM_TO( 75 N 76 , BOOST_PROTO_MAX_ARITY 77 , BOOST_PROTO_CHILD 78 , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT 79 ) 80 }; 81 82 /// \brief A metafunction for generating n-ary expression types with a 83 /// specified tag type, 84 /// a grammar element for matching n-ary expressions, and a 85 /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> 86 /// transform. 87 /// 88 /// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any 89 /// n-ary expression; that is, any non-terminal. 90 template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> 91 struct nary_expr 92 #if N != BOOST_PROTO_MAX_ARITY 93 < 94 Tag 95 BOOST_PP_ENUM_TRAILING_PARAMS(N, A) 96 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) 97 > 98 #endif 99 : proto::transform< 100 nary_expr< 101 Tag 102 BOOST_PP_ENUM_TRAILING_PARAMS(N, A) 103 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) 104 > 105 , int 106 > 107 { 108 typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; 109 typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; 110 111 template<typename Expr, typename State, typename Data> 112 struct impl 113 : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> 114 {}; 115 116 /// INTERNAL ONLY 117 typedef Tag proto_tag; 118 BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) 119 BOOST_PP_REPEAT_FROM_TO( 120 N 121 , BOOST_PROTO_MAX_ARITY 122 , BOOST_PROTO_CHILD 123 , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT 124 ) 125 }; 126 127 namespace detail 128 { 129 template< 130 template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T 131 , BOOST_PP_ENUM_PARAMS(N, typename A) 132 > 133 struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)> 134 : is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable> 135 {}; 136 } 137 138 #endif 139 140 namespace result_of 141 { 142 /// \brief A metafunction that returns the type of the Nth child 143 /// of a Proto expression. 144 /// 145 /// A metafunction that returns the type of the Nth child 146 /// of a Proto expression. \c N must be less than 147 /// \c Expr::proto_arity::value. 148 template<typename Expr> 149 struct child_c<Expr, N> 150 { 151 /// Verify that we are not operating on a terminal 152 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); 153 154 /// The raw type of the Nth child as it is stored within 155 /// \c Expr. This may be a value or a reference 156 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; 157 158 /// The "value" type of the child, suitable for return by value, 159 /// computed as follows: 160 /// \li <tt>T const &</tt> becomes <tt>T</tt> 161 /// \li <tt>T &</tt> becomes <tt>T</tt> 162 /// \li <tt>T</tt> becomes <tt>T</tt> 163 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type; 164 }; 165 166 template<typename Expr> 167 struct child_c<Expr &, N> 168 { 169 /// Verify that we are not operating on a terminal 170 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); 171 172 /// The raw type of the Nth child as it is stored within 173 /// \c Expr. This may be a value or a reference 174 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; 175 176 /// The "reference" type of the child, suitable for return by 177 /// reference, computed as follows: 178 /// \li <tt>T const &</tt> becomes <tt>T const &</tt> 179 /// \li <tt>T &</tt> becomes <tt>T &</tt> 180 /// \li <tt>T</tt> becomes <tt>T &</tt> 181 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type; 182 183 /// INTERNAL ONLY 184 /// 185 BOOST_FORCEINLINE callresult_of::child_c186 static type call(Expr &e) 187 { 188 return e.proto_base().BOOST_PP_CAT(child, N); 189 } 190 }; 191 192 template<typename Expr> 193 struct child_c<Expr const &, N> 194 { 195 /// Verify that we are not operating on a terminal 196 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); 197 198 /// The raw type of the Nth child as it is stored within 199 /// \c Expr. This may be a value or a reference 200 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; 201 202 /// The "const reference" type of the child, suitable for return by 203 /// const reference, computed as follows: 204 /// \li <tt>T const &</tt> becomes <tt>T const &</tt> 205 /// \li <tt>T &</tt> becomes <tt>T &</tt> 206 /// \li <tt>T</tt> becomes <tt>T const &</tt> 207 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type; 208 209 /// INTERNAL ONLY 210 /// 211 BOOST_FORCEINLINE callresult_of::child_c212 static type call(Expr const &e) 213 { 214 return e.proto_base().BOOST_PP_CAT(child, N); 215 } 216 }; 217 } 218 219 #undef N 220 221 #endif 222