← Back to branch summary

~ubuntu-branches/debian/sid/boost1.49/sid

« back to all changes in this revision

Viewing changes to boost/spirit/home/classic/meta/impl/refactoring.ipp

  • Committer: Package Import Robot
  • Author(s): Steve M. Robbins
  • Date: 2012-02-26 00:31:44 UTC
  • Revision ID: package-import@ubuntu.com-20120226003144-eaytp12cbf6ubpms
Tags: upstream-1.49.0
Import upstream version 1.49.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/spirit/home/classic/meta/impl/refactoring.ipp
 
1
/*=============================================================================
 
2
    Copyright (c) 2002-2003 Hartmut Kaiser
 
3
    http://spirit.sourceforge.net/
 
4
 
 
5
    Use, modification and distribution is subject to the Boost Software
 
6
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 
7
    http://www.boost.org/LICENSE_1_0.txt)
 
8
=============================================================================*/
 
9
#ifndef BOOST_SPIRIT_REFACTORING_IPP
 
10
#define BOOST_SPIRIT_REFACTORING_IPP
 
11
 
 
12
///////////////////////////////////////////////////////////////////////////////
 
13
namespace boost { namespace spirit {
 
14
 
 
15
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
16
 
 
17
///////////////////////////////////////////////////////////////////////////////
 
18
//
 
19
//  The struct 'self_nested_refactoring' is used to indicate, that the
 
20
//  refactoring algorithm should be 'self-nested'.
 
21
//
 
22
//  The struct 'non_nested_refactoring' is used to indicate, that no nesting
 
23
//  of refactoring algorithms is reqired.
 
24
//
 
25
///////////////////////////////////////////////////////////////////////////////
 
26
 
 
27
struct non_nested_refactoring { typedef non_nested_refactoring embed_t; };
 
28
struct self_nested_refactoring { typedef self_nested_refactoring embed_t; };
 
29
 
 
30
///////////////////////////////////////////////////////////////////////////////
 
31
namespace impl {
 
32
 
 
33
///////////////////////////////////////////////////////////////////////////////
 
34
//
 
35
//  Helper templates for refactoring parsers
 
36
//
 
37
///////////////////////////////////////////////////////////////////////////////
 
38
 
 
39
    ///////////////////////////////////////////////////////////////////////////
 
40
    //
 
41
    //  refactor the left unary operand of a binary parser
 
42
    //
 
43
    //      The refactoring should be done only if the left operand is an
 
44
    //      unary_parser_category parser.
 
45
    //
 
46
    ///////////////////////////////////////////////////////////////////////////
 
47
 
 
48
    ///////////////////////////////////////////////////////////////////////////
 
49
    template <typename CategoryT>
 
50
    struct refactor_unary_nested {
 
51
 
 
52
        template <
 
53
            typename ParserT, typename NestedT,
 
54
            typename ScannerT, typename BinaryT
 
55
        >
 
56
        static typename parser_result<ParserT, ScannerT>::type
 
57
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
 
58
            NestedT const& /*nested_d*/)
 
59
        {
 
60
            return binary.parse(scan);
 
61
        }
 
62
    };
 
63
 
 
64
    template <>
 
65
    struct refactor_unary_nested<unary_parser_category> {
 
66
 
 
67
        template <
 
68
            typename ParserT, typename ScannerT, typename BinaryT,
 
69
            typename NestedT
 
70
        >
 
71
        static typename parser_result<ParserT, ScannerT>::type
 
72
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
 
73
            NestedT const& nested_d)
 
74
        {
 
75
            typedef typename BinaryT::parser_generator_t op_t;
 
76
            typedef
 
77
                typename BinaryT::left_t::parser_generator_t
 
78
                unary_t;
 
79
 
 
80
            return
 
81
                unary_t::generate(
 
82
                    nested_d[
 
83
                        op_t::generate(binary.left().subject(), binary.right())
 
84
                    ]
 
85
                ).parse(scan);
 
86
        }
 
87
    };
 
88
 
 
89
    ///////////////////////////////////////////////////////////////////////////
 
90
    template <typename CategoryT>
 
91
    struct refactor_unary_non_nested {
 
92
 
 
93
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
94
        static typename parser_result<ParserT, ScannerT>::type
 
95
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
 
96
        {
 
97
            return binary.parse(scan);
 
98
        }
 
99
    };
 
100
 
 
101
    template <>
 
102
    struct refactor_unary_non_nested<unary_parser_category> {
 
103
 
 
104
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
105
        static typename parser_result<ParserT, ScannerT>::type
 
106
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
 
107
        {
 
108
            typedef typename BinaryT::parser_generator_t op_t;
 
109
            typedef
 
110
                typename BinaryT::left_t::parser_generator_t
 
111
                unary_t;
 
112
 
 
113
            return unary_t::generate(
 
114
                op_t::generate(binary.left().subject(), binary.right())
 
115
            ).parse(scan);
 
116
        }
 
117
    };
 
118
 
 
119
    ///////////////////////////////////////////////////////////////////////////
 
120
    template <typename NestedT>
 
121
    struct refactor_unary_type {
 
122
 
 
123
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
124
        static typename parser_result<ParserT, ScannerT>::type
 
125
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
126
            NestedT const& nested_d)
 
127
        {
 
128
            typedef
 
129
                typename BinaryT::left_t::parser_category_t
 
130
                parser_category_t;
 
131
 
 
132
            return refactor_unary_nested<parser_category_t>::
 
133
                    parse(p, scan, binary, nested_d);
 
134
        }
 
135
    };
 
136
 
 
137
    template <>
 
138
    struct refactor_unary_type<non_nested_refactoring> {
 
139
 
 
140
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
141
        static typename parser_result<ParserT, ScannerT>::type
 
142
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
143
            non_nested_refactoring const&)
 
144
        {
 
145
            typedef
 
146
                typename BinaryT::left_t::parser_category_t
 
147
                parser_category_t;
 
148
 
 
149
            return refactor_unary_non_nested<parser_category_t>::
 
150
                    parse(p, scan, binary);
 
151
        }
 
152
 
 
153
    };
 
154
 
 
155
    template <>
 
156
    struct refactor_unary_type<self_nested_refactoring> {
 
157
 
 
158
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
159
        static typename parser_result<ParserT, ScannerT>::type
 
160
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
161
            self_nested_refactoring const &nested_tag)
 
162
        {
 
163
            typedef
 
164
                typename BinaryT::left_t::parser_category_t
 
165
                parser_category_t;
 
166
            typedef typename ParserT::parser_generator_t parser_generator_t;
 
167
 
 
168
            parser_generator_t nested_d(nested_tag);
 
169
            return refactor_unary_nested<parser_category_t>::
 
170
                    parse(p, scan, binary, nested_d);
 
171
        }
 
172
 
 
173
    };
 
174
 
 
175
    ///////////////////////////////////////////////////////////////////////////
 
176
    //
 
177
    //  refactor the action on the left operand of a binary parser
 
178
    //
 
179
    //      The refactoring should be done only if the left operand is an
 
180
    //      action_parser_category parser.
 
181
    //
 
182
    ///////////////////////////////////////////////////////////////////////////
 
183
 
 
184
    ///////////////////////////////////////////////////////////////////////////
 
185
    template <typename CategoryT>
 
186
    struct refactor_action_nested {
 
187
 
 
188
        template <
 
189
            typename ParserT, typename ScannerT, typename BinaryT,
 
190
            typename NestedT
 
191
        >
 
192
        static typename parser_result<ParserT, ScannerT>::type
 
193
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
 
194
            NestedT const& nested_d)
 
195
        {
 
196
            return nested_d[binary].parse(scan);
 
197
        }
 
198
    };
 
199
 
 
200
    template <>
 
201
    struct refactor_action_nested<action_parser_category> {
 
202
 
 
203
        template <
 
204
            typename ParserT, typename ScannerT, typename BinaryT,
 
205
            typename NestedT
 
206
        >
 
207
        static typename parser_result<ParserT, ScannerT>::type
 
208
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
 
209
            NestedT const& nested_d)
 
210
        {
 
211
            typedef typename BinaryT::parser_generator_t binary_gen_t;
 
212
 
 
213
            return (
 
214
                nested_d[
 
215
                    binary_gen_t::generate(
 
216
                        binary.left().subject(),
 
217
                        binary.right()
 
218
                    )
 
219
                ][binary.left().predicate()]
 
220
            ).parse(scan);
 
221
        }
 
222
    };
 
223
 
 
224
    ///////////////////////////////////////////////////////////////////////////
 
225
    template <typename CategoryT>
 
226
    struct refactor_action_non_nested {
 
227
 
 
228
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
229
        static typename parser_result<ParserT, ScannerT>::type
 
230
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
 
231
        {
 
232
            return binary.parse(scan);
 
233
        }
 
234
    };
 
235
 
 
236
    template <>
 
237
    struct refactor_action_non_nested<action_parser_category> {
 
238
 
 
239
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
240
        static typename parser_result<ParserT, ScannerT>::type
 
241
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
 
242
        {
 
243
            typedef typename BinaryT::parser_generator_t binary_gen_t;
 
244
 
 
245
            return (
 
246
                binary_gen_t::generate(
 
247
                    binary.left().subject(),
 
248
                    binary.right()
 
249
                )[binary.left().predicate()]
 
250
            ).parse(scan);
 
251
        }
 
252
    };
 
253
 
 
254
    ///////////////////////////////////////////////////////////////////////////
 
255
    template <typename NestedT>
 
256
    struct refactor_action_type {
 
257
 
 
258
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
259
        static typename parser_result<ParserT, ScannerT>::type
 
260
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
261
            NestedT const& nested_d)
 
262
        {
 
263
            typedef
 
264
                typename BinaryT::left_t::parser_category_t
 
265
                parser_category_t;
 
266
 
 
267
            return refactor_action_nested<parser_category_t>::
 
268
                    parse(p, scan, binary, nested_d);
 
269
        }
 
270
    };
 
271
 
 
272
    template <>
 
273
    struct refactor_action_type<non_nested_refactoring> {
 
274
 
 
275
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
276
        static typename parser_result<ParserT, ScannerT>::type
 
277
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
278
            non_nested_refactoring const&)
 
279
        {
 
280
            typedef
 
281
                typename BinaryT::left_t::parser_category_t
 
282
                parser_category_t;
 
283
 
 
284
            return refactor_action_non_nested<parser_category_t>::
 
285
                parse(p, scan, binary);
 
286
        }
 
287
    };
 
288
 
 
289
    template <>
 
290
    struct refactor_action_type<self_nested_refactoring> {
 
291
 
 
292
        template <typename ParserT, typename ScannerT, typename BinaryT>
 
293
        static typename parser_result<ParserT, ScannerT>::type
 
294
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
 
295
            self_nested_refactoring const &nested_tag)
 
296
        {
 
297
            typedef typename ParserT::parser_generator_t parser_generator_t;
 
298
            typedef
 
299
                typename BinaryT::left_t::parser_category_t
 
300
                parser_category_t;
 
301
 
 
302
            parser_generator_t nested_d(nested_tag);
 
303
            return refactor_action_nested<parser_category_t>::
 
304
                    parse(p, scan, binary, nested_d);
 
305
        }
 
306
    };
 
307
 
 
308
    ///////////////////////////////////////////////////////////////////////////
 
309
    //
 
310
    //  refactor the action attached to a binary parser
 
311
    //
 
312
    //      The refactoring should be done only if the given parser is an
 
313
    //      binary_parser_category parser.
 
314
    //
 
315
    ///////////////////////////////////////////////////////////////////////////
 
316
 
 
317
    ///////////////////////////////////////////////////////////////////////////
 
318
    template <typename CategoryT>
 
319
    struct attach_action_nested {
 
320
 
 
321
        template <
 
322
            typename ParserT, typename ScannerT, typename ActionT,
 
323
            typename NestedT
 
324
        >
 
325
        static typename parser_result<ParserT, ScannerT>::type
 
326
        parse(ParserT const &, ScannerT const& scan, ActionT const &action,
 
327
            NestedT const& nested_d)
 
328
        {
 
329
            return action.parse(scan);
 
330
        }
 
331
    };
 
332
 
 
333
    template <>
 
334
    struct attach_action_nested<binary_parser_category> {
 
335
 
 
336
        template <
 
337
            typename ParserT, typename ScannerT, typename ActionT,
 
338
            typename NestedT
 
339
        >
 
340
        static typename parser_result<ParserT, ScannerT>::type
 
341
        parse(ParserT const &, ScannerT const& scan, ActionT const &action,
 
342
            NestedT const& nested_d)
 
343
        {
 
344
            typedef
 
345
                typename ActionT::subject_t::parser_generator_t
 
346
                binary_gen_t;
 
347
 
 
348
            return (
 
349
                binary_gen_t::generate(
 
350
                    nested_d[action.subject().left()[action.predicate()]],
 
351
                    nested_d[action.subject().right()[action.predicate()]]
 
352
                )
 
353
            ).parse(scan);
 
354
        }
 
355
    };
 
356
 
 
357
    ///////////////////////////////////////////////////////////////////////////
 
358
    template <typename CategoryT>
 
359
    struct attach_action_non_nested {
 
360
 
 
361
        template <typename ParserT, typename ScannerT, typename ActionT>
 
362
        static typename parser_result<ParserT, ScannerT>::type
 
363
        parse(ParserT const &, ScannerT const& scan, ActionT const &action)
 
364
        {
 
365
            return action.parse(scan);
 
366
        }
 
367
    };
 
368
 
 
369
    template <>
 
370
    struct attach_action_non_nested<binary_parser_category> {
 
371
 
 
372
        template <typename ParserT, typename ScannerT, typename ActionT>
 
373
        static typename parser_result<ParserT, ScannerT>::type
 
374
        parse(ParserT const &, ScannerT const& scan, ActionT const &action)
 
375
        {
 
376
            typedef
 
377
                typename ActionT::subject_t::parser_generator_t
 
378
                binary_gen_t;
 
379
 
 
380
            return (
 
381
                binary_gen_t::generate(
 
382
                    action.subject().left()[action.predicate()],
 
383
                    action.subject().right()[action.predicate()]
 
384
                )
 
385
            ).parse(scan);
 
386
        }
 
387
    };
 
388
 
 
389
    ///////////////////////////////////////////////////////////////////////////
 
390
    template <typename NestedT>
 
391
    struct attach_action_type {
 
392
 
 
393
        template <typename ParserT, typename ScannerT, typename ActionT>
 
394
        static typename parser_result<ParserT, ScannerT>::type
 
395
        parse(ParserT const &p, ScannerT const& scan, ActionT const& action,
 
396
            NestedT const& nested_d)
 
397
        {
 
398
            typedef
 
399
                typename ActionT::subject_t::parser_category_t
 
400
                parser_category_t;
 
401
 
 
402
            return attach_action_nested<parser_category_t>::
 
403
                    parse(p, scan, action, nested_d);
 
404
        }
 
405
    };
 
406
 
 
407
    template <>
 
408
    struct attach_action_type<non_nested_refactoring> {
 
409
 
 
410
        template <typename ParserT, typename ScannerT, typename ActionT>
 
411
        static typename parser_result<ParserT, ScannerT>::type
 
412
        parse(ParserT const &p, ScannerT const& scan, ActionT const &action,
 
413
            non_nested_refactoring const&)
 
414
        {
 
415
            typedef
 
416
                typename ActionT::subject_t::parser_category_t
 
417
                parser_category_t;
 
418
 
 
419
            return attach_action_non_nested<parser_category_t>::
 
420
                parse(p, scan, action);
 
421
        }
 
422
    };
 
423
 
 
424
    template <>
 
425
    struct attach_action_type<self_nested_refactoring> {
 
426
 
 
427
        template <typename ParserT, typename ScannerT, typename ActionT>
 
428
        static typename parser_result<ParserT, ScannerT>::type
 
429
        parse(ParserT const &p, ScannerT const& scan, ActionT const &action,
 
430
            self_nested_refactoring const& nested_tag)
 
431
        {
 
432
            typedef typename ParserT::parser_generator_t parser_generator_t;
 
433
            typedef
 
434
                typename ActionT::subject_t::parser_category_t
 
435
                parser_category_t;
 
436
 
 
437
            parser_generator_t nested_d(nested_tag);
 
438
            return attach_action_nested<parser_category_t>::
 
439
                    parse(p, scan, action, nested_d);
 
440
        }
 
441
    };
 
442
 
 
443
}   // namespace impl
 
444
 
 
445
///////////////////////////////////////////////////////////////////////////////
 
446
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 
447
 
 
448
}} // namespace boost::spirit
 
449
 
 
450
#endif
 
451