/usr/include/boost/phoenix/scope/dynamic.hpp is in libboost1.54-dev 1.54.0-4ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 164 165 166 167 168 169 170 171 172 173 174 175 176 | /*==============================================================================
Copyright (c) 2001-2010 Joel de Guzman
Copyright (c) 2004 Daniel Wallin
Copyright (c) 2010 Thomas Heller
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_PHOENIX_SCOPE_DYNAMIC_HPP
#define BOOST_PHOENIX_SCOPE_DYNAMIC_HPP
#include <boost/phoenix/core/limits.hpp>
#include <boost/assert.hpp>
#include <boost/noncopyable.hpp>
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/phoenix/core/expression.hpp>
#include <boost/phoenix/core/meta_grammar.hpp>
#include <boost/phoenix/core/call.hpp>
#include <boost/phoenix/support/iterate.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/fold_left.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#define BOOST_PHOENIX_DYNAMIC_TEMPLATE_PARAMS(R, DATA, I, ELEM) \
BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
/**/
#define BOOST_PHOENIX_DYNAMIC_CTOR_INIT(R, DATA, I, ELEM) \
BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2, 1, ELEM)(init<I>(this)) \
/**/
#define BOOST_PHOENIX_DYNAMIC_MEMBER(R, DATA, I, ELEM) \
BOOST_PP_CAT(member, BOOST_PP_INC(I)) BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
/**/
#define BOOST_PHOENIX_DYNAMIC_FILLER_0(X, Y) \
((X, Y)) BOOST_PHOENIX_DYNAMIC_FILLER_1 \
/**/
#define BOOST_PHOENIX_DYNAMIC_FILLER_1(X, Y) \
((X, Y)) BOOST_PHOENIX_DYNAMIC_FILLER_0 \
/**/
#define BOOST_PHOENIX_DYNAMIC_FILLER_0_END
#define BOOST_PHOENIX_DYNAMIC_FILLER_1_END
#define BOOST_PHOENIX_DYNAMIC_BASE(NAME, MEMBER) \
struct NAME \
: ::boost::phoenix::dynamic< \
BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_PHOENIX_DYNAMIC_TEMPLATE_PARAMS \
, _ \
, MEMBER) \
> \
{ \
NAME() \
: BOOST_PP_SEQ_FOR_EACH_I(BOOST_PHOENIX_DYNAMIC_CTOR_INIT, _, MEMBER) \
{} \
\
BOOST_PP_SEQ_FOR_EACH_I(BOOST_PHOENIX_DYNAMIC_MEMBER, _, MEMBER) \
} \
/**/
#define BOOST_PHOENIX_DYNAMIC(NAME, MEMBER) \
BOOST_PHOENIX_DYNAMIC_BASE( \
NAME \
, BOOST_PP_CAT(BOOST_PHOENIX_DYNAMIC_FILLER_0 MEMBER,_END) \
) \
/**/
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(phoenix)(dynamic_member)
, (proto::terminal<proto::_>)
(proto::terminal<proto::_>)
)
namespace boost { namespace phoenix
{
template <typename DynamicScope>
struct dynamic_frame : noncopyable
{
typedef typename DynamicScope::tuple_type tuple_type;
dynamic_frame(DynamicScope const& s)
: tuple()
, save(s.frame)
, scope(s)
{
scope.frame = this;
}
template <typename Tuple>
dynamic_frame(DynamicScope const& s, Tuple const& init)
: tuple(init)
, save(s.frame)
, scope(s)
{
scope.frame = this;
}
~dynamic_frame()
{
scope.frame = save;
}
tuple_type& data() { return tuple; }
tuple_type const& data() const { return tuple; }
private:
tuple_type tuple;
dynamic_frame *save;
DynamicScope const& scope;
};
struct dynamic_member_eval
{
template <typename Sig>
struct result;
template <typename This, typename N, typename Scope, typename Context>
struct result<This(N, Scope, Context)>
{
typedef
typename boost::remove_pointer<
typename proto::detail::uncvref<
typename proto::result_of::value<Scope>::type
>::type
>::type
scope_type;
typedef
typename scope_type::dynamic_frame_type::tuple_type
tuple_type;
typedef
typename fusion::result_of::at_c<
tuple_type
, proto::detail::uncvref<
typename proto::result_of::value<N>::type
>::type::value
>::type
type;
};
template <typename N, typename Scope, typename Context>
typename result<dynamic_member_eval(N, Scope, Context)>::type
operator()(N, Scope s, Context const &) const
{
return
fusion::at_c<
proto::detail::uncvref<
typename proto::result_of::value<N>::type
>::type::value
>(
proto::value(s)->frame->data()
);
}
};
template <typename Dummy>
struct default_actions::when<rule::dynamic_member, Dummy>
: call<dynamic_member_eval>
{};
template <
BOOST_PHOENIX_typename_A_void(BOOST_PHOENIX_DYNAMIC_LIMIT)
, typename Dummy = void
>
struct dynamic;
// Bring in the rest ...
#include <boost/phoenix/scope/detail/dynamic.hpp>
}}
#endif
|