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
163
|
///////////////////////////////////////////////////////////////////////////////
/// \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/facilities/intercept.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)
# 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
# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
#endif
namespace boost { namespace proto
{
namespace detail
{
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>
BOOST_FORCEINLINE
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>
BOOST_FORCEINLINE
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>
BOOST_FORCEINLINE
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;
}
// Work-around for:
// https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700))
template<typename T, typename Expr, typename C, typename U>
BOOST_FORCEINLINE
Expr make_terminal(T &t, Expr *, proto::term<U C::*> *)
{
Expr that;
that.child0 = t;
return that;
}
#endif
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;
#include <boost/proto/detail/funop.hpp>
}
namespace exprns_
{
// This is where the basic_expr specializations are
// actually defined:
#include <boost/proto/detail/basic_expr.hpp>
// This is where the expr specialization are
// actually defined:
#include <boost/proto/detail/expr.hpp>
}
/// \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()
BOOST_FORCEINLINE
explicit unexpr(Expr const &e)
: Expr(e)
{}
using Expr::operator =;
};
}}
#if defined(_MSC_VER)
# pragma warning(pop)
#endif
#endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
|
Swift