1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
///////////////////////////////////////////////////////////////////////////////
/// \file expr.hpp
/// Contains definition of expr\<\> class template.
//
// Copyright 2008 Eric Niebler. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
#define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/selection/max.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum_trailing.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/utility/addressof.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/traits.hpp>
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma warning(push)
# pragma warning(disable : 4510) // default constructor could not be generated
# pragma warning(disable : 4512) // assignment operator could not be generated
# pragma warning(disable : 4610) // user defined constructor required
#endif
namespace boost { namespace proto
{
namespace detail
{
/// INTERNAL ONLY
///
#define BOOST_PROTO_CHILD(Z, N, DATA) \
typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \
BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \
/**< INTERNAL ONLY */
/// INTERNAL ONLY
///
#define BOOST_PROTO_VOID(Z, N, DATA) \
typedef void BOOST_PP_CAT(proto_child, N); \
/**< INTERNAL ONLY */
struct not_a_valid_type
{
private:
not_a_valid_type()
{}
};
template<typename Tag, typename Arg>
struct address_of_hack
{
typedef not_a_valid_type type;
};
template<typename Expr>
struct address_of_hack<proto::tag::address_of, Expr &>
{
typedef Expr *type;
};
template<typename T, typename Expr, typename Arg0>
Expr make_terminal(T &t, Expr *, proto::term<Arg0> *)
{
Expr that = {t};
return that;
}
template<typename T, typename Expr, typename Arg0, std::size_t N>
Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *)
{
Expr that;
for(std::size_t i = 0; i < N; ++i)
{
that.child0[i] = t[i];
}
return that;
}
template<typename T, typename Expr, typename Arg0, std::size_t N>
Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *)
{
Expr that;
for(std::size_t i = 0; i < N; ++i)
{
that.child0[i] = t[i];
}
return that;
}
template<typename T, typename U>
struct same_cv
{
typedef U type;
};
template<typename T, typename U>
struct same_cv<T const, U>
{
typedef U const type;
};
}
namespace result_of
{
/// \brief A helper metafunction for computing the
/// return type of \c proto::expr\<\>::operator().
template<typename Sig, typename This, typename Domain>
struct funop;
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/funop.hpp>))
#include BOOST_PP_ITERATE()
}
namespace exprns_
{
// The expr<> specializations are actually defined here.
#define BOOST_PROTO_DEFINE_TERMINAL
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr0.hpp>))
#include BOOST_PP_ITERATE()
#undef BOOST_PROTO_DEFINE_TERMINAL
#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr0.hpp>))
#include BOOST_PP_ITERATE()
}
#undef BOOST_PROTO_CHILD
#undef BOOST_PROTO_VOID
/// \brief Lets you inherit the interface of an expression
/// while hiding from Proto the fact that the type is a Proto
/// expression.
template<typename Expr>
struct unexpr
: Expr
{
BOOST_PROTO_UNEXPR()
explicit unexpr(Expr const &e)
: Expr(e)
{}
using Expr::operator =;
};
}}
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma warning(pop)
#endif
#endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
|
Swift