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
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
|
/*=============================================================================
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Use, modification and distribution is subject to 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)
=============================================================================*/
#if !defined(BOOST_SPIRIT_TRAVERSE_IPP)
#define BOOST_SPIRIT_TRAVERSE_IPP
///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/meta/fundamental.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
template <typename CategoryT>
struct traverse_post_order_return_category;
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
//
// Environment class for post_order_traversal
//
///////////////////////////////////////////////////////////////////////////////
template <int Level, int Node, int Index, int LastLeft>
struct traverse_post_order_env {
BOOST_STATIC_CONSTANT(int, level = Level);
BOOST_STATIC_CONSTANT(int, node = Node);
BOOST_STATIC_CONSTANT(int, index = Index);
BOOST_STATIC_CONSTANT(int, lastleft = LastLeft);
};
///////////////////////////////////////////////////////////////////////////////
//
// traverse_post_order_return template
//
// This template is a helper for dispatching the calculation of a parser
// type result for a traversal level to the corresponding parser_category
// based specialization.
//
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename ParserT, typename EnvT>
struct traverse_post_order_return {
typedef typename ParserT::parser_category_t parser_category_t;
typedef typename impl::traverse_post_order_return_category<parser_category_t>
::template result<MetaT, ParserT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
//
// parser_traversal_..._result templates
//
// These are metafunctions, which calculate the resulting parser type
// for all subparsers and feed these types to the user supplied
// metafunctions to get back the resulting parser type of this traversal
// level.
//
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename ParserT, typename EnvT>
struct parser_traversal_plain_result {
typedef typename MetaT::template plain_result<ParserT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename UnaryT, typename SubjectT, typename EnvT>
struct parser_traversal_unary_result {
typedef typename MetaT
::template unary_result<UnaryT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename ActionT, typename SubjectT, typename EnvT>
struct parser_traversal_action_result {
typedef typename MetaT
::template action_result<ActionT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <
typename MetaT, typename BinaryT, typename LeftT,
typename RightT, typename EnvT
>
struct parser_traversal_binary_result {
BOOST_STATIC_CONSTANT(int,
thisnum = (node_count<BinaryT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int,
leftnum = (node_count<LeftT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int,
leafnum = (leaf_count<LeftT>::value + EnvT::index));
typedef parser_traversal_binary_result self_t;
// left traversal environment and resulting parser type
typedef traverse_post_order_env<
(EnvT::level+1), (self_t::leftnum), (EnvT::index), (EnvT::lastleft)
> left_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, LeftT, left_sub_env_t
>::type
left_t;
// right traversal environment and resulting parser type
typedef traverse_post_order_env<
(EnvT::level+1), (self_t::thisnum-1), (self_t::leafnum), (self_t::leftnum+1)
> right_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, RightT, right_sub_env_t
>::type
right_t;
typedef typename MetaT::template binary_result<
BinaryT, left_t, right_t, EnvT
>::type
type;
};
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
///////////////////////////////////////////////////////////////////////////
//
// Meta functions, which dispatch the calculation of the return type of
// of the post_order traverse function to the result template of the
// corresponding parser_category based metafunction template.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct traverse_post_order_return_category;
template <>
struct traverse_post_order_return_category<plain_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_plain_result<
MetaT, ParserT, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<unary_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_unary_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<action_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_action_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<binary_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_binary_result<
MetaT, ParserT, typename ParserT::left_t,
typename ParserT::right_t, EnvT
>::type
type;
};
};
///////////////////////////////////////////////////////////////////////////
//
// Post-order parser traversal
//
// The following templates contain the parser_category based code for
//
// - calculating the type of the resulting parser, which is to be
// returned from a level of traversal
// - traversing down the composite parser structure, this traversal
// returnes a new parser object
//
// Both tasks are delegated to the MetaT metafunction supplied by the
// user.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct traverse_post_order;
template <>
struct traverse_post_order<plain_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef
typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::type
generate(MetaT const &meta_, ParserT const &parser_, EnvT const &env)
{
return meta_.generate_plain(parser_, env);
}
};
template <>
struct traverse_post_order<unary_parser_category> {
template <
typename MetaT, typename ParserT, typename SubjectT, typename EnvT
>
struct result {
typedef typename parser_traversal_unary_result<
MetaT, ParserT, SubjectT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_unary_result<
MetaT, ParserT,
typename traverse_post_order_return<
MetaT, typename ParserT::subject_t, EnvT
>::type,
EnvT
>::type
generate(MetaT const &meta_, ParserT const &unary_, EnvT const &env)
{
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
return meta_.generate_unary(
unary_,
traverse_post_order<subject_category_t>::generate(meta_,
unary_.subject(),
traverse_post_order_env<
EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft
>()
),
env
);
}
};
template <>
struct traverse_post_order<action_parser_category> {
template <
typename MetaT, typename ParserT, typename SubjectT, typename EnvT
>
struct result {
typedef typename parser_traversal_action_result<
MetaT, ParserT, SubjectT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_action_result<
MetaT, ParserT,
typename traverse_post_order_return<
MetaT, typename ParserT::subject_t, EnvT
>::type,
EnvT
>::type
generate(MetaT const &meta_, ParserT const &action_, EnvT const &env)
{
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
return meta_.generate_action(
action_,
traverse_post_order<subject_category_t>::generate(meta_,
action_.subject(),
traverse_post_order_env<
EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft
>()
),
env
);
}
};
template <>
struct traverse_post_order<binary_parser_category> {
template <
typename MetaT, typename ParserT, typename LeftT,
typename RightT, typename EnvT
>
struct result {
typedef typename parser_traversal_binary_result<
MetaT, ParserT, LeftT, RightT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_binary_result<
MetaT, ParserT,
typename traverse_post_order_return<
MetaT, typename ParserT::left_t, EnvT
>::type,
typename traverse_post_order_return<
MetaT, typename ParserT::right_t, EnvT
>::type,
EnvT
>::type
generate(MetaT const &meta_, ParserT const &binary_, EnvT const& /*env*/)
{
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
enum {
leftnum = (node_count<left_t>::value + EnvT::lastleft-1),
thisnum = (node_count<ParserT>::value + EnvT::lastleft-1),
rightnum = (thisnum-1),
leafnum = (leaf_count<left_t>::value + EnvT::index)
};
return meta_.generate_binary(
binary_,
traverse_post_order<left_category_t>::generate(
meta_, binary_.left(),
traverse_post_order_env<
EnvT::level+1, leftnum, EnvT::index, EnvT::lastleft
>()
),
traverse_post_order<right_category_t>::generate(
meta_, binary_.right(),
traverse_post_order_env<
EnvT::level+1, rightnum, leafnum, leftnum+1
>()
),
traverse_post_order_env<
EnvT::level, thisnum, EnvT::index, EnvT::lastleft
>()
);
}
};
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_TRAVERSE_IPP)
|
