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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
|
///////////////////////////////////////////////////////////////////////////////
// as_action.hpp
//
// Copyright 2008 Eric Niebler.
// Copyright 2008 David Jenkins.
//
// 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_XPRESSIVE_DETAIL_STATIC_TRANSFORMS_AS_ACTION_HPP_EAN_04_05_2007
#define BOOST_XPRESSIVE_DETAIL_STATIC_TRANSFORMS_AS_ACTION_HPP_EAN_04_05_2007
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/mpl/sizeof.hpp>
#include <boost/mpl/min_max.hpp>
#include <boost/mpl/apply_wrap.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/core/matcher/attr_end_matcher.hpp>
#include <boost/xpressive/detail/static/static.hpp>
#include <boost/xpressive/detail/static/transforms/as_quantifier.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/transform/arg.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/when.hpp>
#include <boost/proto/transform/fold.hpp>
#include <boost/proto/transform/fold_tree.hpp>
namespace boost { namespace xpressive { namespace detail
{
///////////////////////////////////////////////////////////////////////////////
// read_attr
// Placeholder that knows the slot number of an attribute as well as the type
// of the object stored in it.
template<typename Nbr, typename Matcher>
struct read_attr
{
typedef Nbr nbr_type;
typedef Matcher matcher_type;
static Nbr nbr() { return Nbr(); }
};
template<typename Nbr, typename Matcher>
struct read_attr<Nbr, Matcher &>
{
typedef Nbr nbr_type;
typedef Matcher matcher_type;
};
}}}
namespace boost { namespace xpressive { namespace grammar_detail
{
///////////////////////////////////////////////////////////////////////////////
// FindAttr
// Look for patterns like (a1= terminal<RHS>) and return the type of the RHS.
template<typename Nbr>
struct FindAttr
: or_<
// Ignore nested actions, because attributes are scoped
when< subscript<_, _>, _state >
, when< terminal<_>, _state >
, when< proto::assign<terminal<detail::attribute_placeholder<Nbr> >, _>, call<_value(_right)> >
, otherwise< fold<_, _state, FindAttr<Nbr> > >
>
{};
///////////////////////////////////////////////////////////////////////////////
// as_read_attr
// For patterns like (a1 = RHS)[ref(i) = a1], transform to
// (a1 = RHS)[ref(i) = read_attr<1, RHS>] so that when reading the attribute
// we know what type is stored in the attribute slot.
struct as_read_attr : proto::transform<as_read_attr>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef typename impl::expr expr_type;
typedef
typename FindAttr<typename expr_type::proto_child0::nbr_type>::template impl<
State
, mpl::void_
, int
>::result_type
attr_type;
typedef
typename proto::terminal<
detail::read_attr<
typename expr_type::proto_child0::nbr_type
, BOOST_PROTO_UNCVREF(attr_type)
>
>::type
result_type;
result_type operator ()(proto::ignore, proto::ignore, proto::ignore) const
{
result_type that = {{}};
return that;
}
};
};
///////////////////////////////////////////////////////////////////////////////
// DeepCopy
// Turn all refs into values, and also bind all attribute placeholders with
// the types from which they are being assigned.
struct DeepCopy
: or_<
when< terminal<detail::attribute_placeholder<_> >, as_read_attr>
, when< terminal<_>, proto::_deep_copy>
, otherwise< nary_expr<_, vararg<DeepCopy> > >
>
{};
///////////////////////////////////////////////////////////////////////////////
// attr_nbr
// For an attribute placeholder, return the attribute's slot number.
struct attr_nbr : proto::transform<attr_nbr>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef typename impl::expr expr_type;
typedef typename expr_type::proto_child0::nbr_type::type result_type;
};
};
struct max_attr;
///////////////////////////////////////////////////////////////////////////////
// MaxAttr
// In an action (rx)[act], find the largest attribute slot being used.
struct MaxAttr
: or_<
when< terminal<detail::attribute_placeholder<_> >, attr_nbr>
, when< terminal<_>, make<mpl::int_<0> > >
// Ignore nested actions, because attributes are scoped:
, when< subscript<_, _>, make<mpl::int_<0> > >
, otherwise< fold<_, make<mpl::int_<0> >, max_attr> >
>
{};
///////////////////////////////////////////////////////////////////////////////
// max_attr
// Take the maximum of the current attr slot number and the state.
struct max_attr : proto::transform<max_attr>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef
typename mpl::max<
typename impl::state
, typename MaxAttr::template impl<Expr, State, Data>::result_type
>::type
result_type;
};
};
///////////////////////////////////////////////////////////////////////////////
// as_attr_matcher
// turn a1=matcher into attr_matcher<Matcher>(1)
struct as_attr_matcher : proto::transform<as_attr_matcher>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef typename impl::expr expr_type;
typedef typename impl::data data_type;
typedef
detail::attr_matcher<
typename proto::result_of::value<typename expr_type::proto_child1>::type
, typename data_type::traits_type
, typename data_type::icase_type
>
result_type;
result_type operator ()(
typename impl::expr_param expr
, typename impl::state_param
, typename impl::data_param data
) const
{
return result_type(
proto::value(proto::left(expr)).nbr()
, proto::value(proto::right(expr))
, data.traits()
);
}
};
};
///////////////////////////////////////////////////////////////////////////////
// add_attrs
// Wrap an expression in attr_begin_matcher/attr_end_matcher pair
struct add_attrs : proto::transform<add_attrs>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef
detail::attr_begin_matcher<
typename MaxAttr::template impl<Expr, mpl::int_<0>, int>::result_type
>
begin_type;
typedef typename impl::expr expr_type;
typedef
typename shift_right<
typename terminal<begin_type>::type
, typename shift_right<
Expr
, terminal<detail::attr_end_matcher>::type
>::type
>::type
result_type;
result_type operator ()(
typename impl::expr_param expr
, typename impl::state_param
, typename impl::data_param
) const
{
begin_type begin;
detail::attr_end_matcher end;
result_type that = {{begin}, {expr, {end}}};
return that;
}
};
};
///////////////////////////////////////////////////////////////////////////////
// InsertAttrs
struct InsertAttrs
: if_<MaxAttr, add_attrs, _>
{};
///////////////////////////////////////////////////////////////////////////////
// CheckAssertion
struct CheckAssertion
: proto::function<terminal<detail::check_tag>, _>
{};
///////////////////////////////////////////////////////////////////////////////
// action_transform
// Turn A[B] into (mark_begin(n) >> A >> mark_end(n) >> action_matcher<B>(n))
// If A and B use attributes, wrap the above expression in
// a attr_begin_matcher<Count> / attr_end_matcher pair, where Count is
// the number of attribute slots used by the pattern/action.
struct as_action : proto::transform<as_action>
{
template<typename Expr, typename State, typename Data>
struct impl : proto::transform_impl<Expr, State, Data>
{
typedef typename proto::result_of::left<Expr>::type expr_type;
typedef typename proto::result_of::right<Expr>::type action_type;
typedef
typename DeepCopy::impl<action_type, expr_type, int>::result_type
action_copy_type;
typedef
typename InsertMark::impl<expr_type, State, Data>::result_type
marked_expr_type;
typedef
typename mpl::if_c<
proto::matches<action_type, CheckAssertion>::value
, detail::predicate_matcher<action_copy_type>
, detail::action_matcher<action_copy_type>
>::type
matcher_type;
typedef
typename proto::shift_right<
marked_expr_type
, typename proto::terminal<matcher_type>::type
>::type
no_attr_type;
typedef
typename InsertAttrs::impl<no_attr_type, State, Data>::result_type
result_type;
result_type operator ()(
typename impl::expr_param expr
, typename impl::state_param state
, typename impl::data_param data
) const
{
int dummy = 0;
marked_expr_type marked_expr =
InsertMark::impl<expr_type, State, Data>()(proto::left(expr), state, data);
no_attr_type that = {
marked_expr
, {
matcher_type(
DeepCopy::impl<action_type, expr_type, int>()(
proto::right(expr)
, proto::left(expr)
, dummy
)
, proto::value(proto::left(marked_expr)).mark_number_
)
}
};
return InsertAttrs::impl<no_attr_type, State, Data>()(that, state, data);
}
};
};
}}}
#endif
|
