← Back to branch summary

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

« back to all changes in this revision

Viewing changes to boost/xpressive/detail/detail_fwd.hpp

  • 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/xpressive/detail/detail_fwd.hpp
 
1
///////////////////////////////////////////////////////////////////////////////
 
2
// detail_fwd.hpp
 
3
//
 
4
//  Copyright 2008 Eric Niebler. Distributed under the Boost
 
5
//  Software License, Version 1.0. (See accompanying file
 
6
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
7
 
 
8
#ifndef BOOST_XPRESSIVE_DETAIL_DETAIL_FWD_HPP_EAN_10_04_2005
 
9
#define BOOST_XPRESSIVE_DETAIL_DETAIL_FWD_HPP_EAN_10_04_2005
 
10
 
 
11
// MS compatible compilers support #pragma once
 
12
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
 
13
# pragma once
 
14
#endif
 
15
 
 
16
#include <map>
 
17
#include <string>
 
18
#include <vector>
 
19
#include <climits> // for INT_MAX
 
20
#include <typeinfo>
 
21
#include <boost/mpl/bool.hpp>
 
22
#include <boost/mpl/size_t.hpp>
 
23
#include <boost/shared_ptr.hpp>
 
24
#include <boost/xpressive/xpressive_fwd.hpp>
 
25
 
 
26
namespace boost { namespace xpressive { namespace detail
 
27
{
 
28
    typedef unsigned int uint_t;
 
29
 
 
30
    template<uint_t Min, uint_t Max = Min>
 
31
    struct generic_quant_tag;
 
32
 
 
33
    struct modifier_tag;
 
34
 
 
35
    struct check_tag;
 
36
 
 
37
    typedef mpl::size_t<INT_MAX / 2 - 1> unknown_width;
 
38
 
 
39
    struct type_info_less;
 
40
 
 
41
    typedef std::map<std::type_info const *, void *, type_info_less> action_args_type;
 
42
 
 
43
    struct action_context;
 
44
 
 
45
    struct ReplaceAlgo;
 
46
 
 
47
    ///////////////////////////////////////////////////////////////////////////////
 
48
    // placeholders
 
49
    //
 
50
    struct mark_placeholder;
 
51
 
 
52
    struct posix_charset_placeholder;
 
53
 
 
54
    template<typename Cond>
 
55
    struct assert_word_placeholder;
 
56
 
 
57
    template<typename Char>
 
58
    struct range_placeholder;
 
59
 
 
60
    struct assert_bol_placeholder;
 
61
 
 
62
    struct assert_eol_placeholder;
 
63
 
 
64
    struct logical_newline_placeholder;
 
65
 
 
66
    struct self_placeholder;
 
67
 
 
68
    template<typename Nbr>
 
69
    struct attribute_placeholder;
 
70
 
 
71
    ///////////////////////////////////////////////////////////////////////////////
 
72
    // matchers
 
73
    //
 
74
    struct end_matcher;
 
75
 
 
76
    struct independent_end_matcher;
 
77
 
 
78
    struct assert_bos_matcher;
 
79
 
 
80
    struct assert_eos_matcher;
 
81
 
 
82
    template<typename Traits>
 
83
    struct assert_bol_matcher;
 
84
 
 
85
    template<typename Traits>
 
86
    struct assert_eol_matcher;
 
87
 
 
88
    template<typename Cond, typename Traits>
 
89
    struct assert_word_matcher;
 
90
 
 
91
    struct true_matcher;
 
92
 
 
93
    template<typename Alternates, typename Traits>
 
94
    struct alternate_matcher;
 
95
 
 
96
    struct alternate_end_matcher;
 
97
 
 
98
    template<typename Traits>
 
99
    struct posix_charset_matcher;
 
100
 
 
101
    template<typename BidiIter>
 
102
    struct sequence;
 
103
 
 
104
    template<typename Traits, typename ICase>
 
105
    struct mark_matcher;
 
106
 
 
107
    struct mark_begin_matcher;
 
108
 
 
109
    struct mark_end_matcher;
 
110
 
 
111
    template<typename BidiIter>
 
112
    struct regex_matcher;
 
113
 
 
114
    template<typename BidiIter>
 
115
    struct regex_byref_matcher;
 
116
 
 
117
    template<typename Traits>
 
118
    struct compound_charset;
 
119
 
 
120
    template<typename Traits, typename ICase, typename CharSet = compound_charset<Traits> >
 
121
    struct charset_matcher;
 
122
 
 
123
    template<typename Traits, typename ICase>
 
124
    struct range_matcher;
 
125
 
 
126
    template<typename Traits, typename Size>
 
127
    struct set_matcher;
 
128
 
 
129
    template<typename Xpr, typename Greedy>
 
130
    struct simple_repeat_matcher;
 
131
 
 
132
    struct repeat_begin_matcher;
 
133
 
 
134
    template<typename Greedy>
 
135
    struct repeat_end_matcher;
 
136
 
 
137
    template<typename Traits, typename ICase, typename Not>
 
138
    struct literal_matcher;
 
139
 
 
140
    template<typename Traits, typename ICase>
 
141
    struct string_matcher;
 
142
 
 
143
    template<typename Actor>
 
144
    struct action_matcher;
 
145
 
 
146
    template<typename Predicate>
 
147
    struct predicate_matcher;
 
148
 
 
149
    template<typename Xpr, typename Greedy>
 
150
    struct optional_matcher;
 
151
 
 
152
    template<typename Xpr, typename Greedy>
 
153
    struct optional_mark_matcher;
 
154
 
 
155
    template<typename Matcher, typename Traits, typename ICase>
 
156
    struct attr_matcher;
 
157
 
 
158
    template<typename Nbr>
 
159
    struct attr_begin_matcher;
 
160
 
 
161
    struct attr_end_matcher;
 
162
 
 
163
    template<typename Xpr>
 
164
    struct is_modifiable;
 
165
 
 
166
    template<typename Head, typename Tail>
 
167
    struct alternates_list;
 
168
 
 
169
    template<typename Modifier>
 
170
    struct modifier_op;
 
171
 
 
172
    struct icase_modifier;
 
173
 
 
174
    template<typename BidiIter, typename ICase, typename Traits>
 
175
    struct xpression_visitor;
 
176
 
 
177
    template<typename BidiIter>
 
178
    struct regex_impl;
 
179
 
 
180
    struct epsilon_matcher;
 
181
 
 
182
    template<typename BidiIter>
 
183
    struct nested_results;
 
184
 
 
185
    template<typename BidiIter>
 
186
    struct regex_id_filter_predicate;
 
187
 
 
188
    template<typename Xpr>
 
189
    struct keeper_matcher;
 
190
 
 
191
    template<typename Xpr>
 
192
    struct lookahead_matcher;
 
193
 
 
194
    template<typename Xpr>
 
195
    struct lookbehind_matcher;
 
196
 
 
197
    template<typename IsBoundary>
 
198
    struct word_boundary;
 
199
 
 
200
    template<typename BidiIter, typename Matcher>
 
201
    sequence<BidiIter> make_dynamic(Matcher const &matcher);
 
202
 
 
203
    template<typename Char>
 
204
    struct xpression_linker;
 
205
 
 
206
    template<typename Char>
 
207
    struct xpression_peeker;
 
208
 
 
209
    struct any_matcher;
 
210
 
 
211
    template<typename Traits>
 
212
    struct logical_newline_matcher;
 
213
 
 
214
    typedef proto::expr<proto::tag::terminal, proto::term<logical_newline_placeholder>, 0> logical_newline_xpression;
 
215
 
 
216
    struct set_initializer;
 
217
 
 
218
    typedef proto::expr<proto::tag::terminal, proto::term<set_initializer>, 0> set_initializer_type;
 
219
 
 
220
    struct lookahead_tag;
 
221
 
 
222
    struct lookbehind_tag;
 
223
 
 
224
    struct keeper_tag;
 
225
 
 
226
    template<typename Locale>
 
227
    struct locale_modifier;
 
228
 
 
229
    template<typename Matcher>
 
230
    struct matcher_wrapper;
 
231
 
 
232
    template<typename Locale, typename BidiIter>
 
233
    struct regex_traits_type;
 
234
 
 
235
    template<typename Expr>
 
236
    struct let_;
 
237
 
 
238
    template<typename Args, typename BidiIter>
 
239
    void bind_args(let_<Args> const &, match_results<BidiIter> &);
 
240
 
 
241
    ///////////////////////////////////////////////////////////////////////////////
 
242
    // Misc.
 
243
    struct no_next;
 
244
 
 
245
    template<typename BidiIter>
 
246
    struct core_access;
 
247
 
 
248
    template<typename BidiIter>
 
249
    struct match_state;
 
250
 
 
251
    template<typename BidiIter>
 
252
    struct matchable;
 
253
 
 
254
    template<typename BidiIter>
 
255
    struct matchable_ex;
 
256
 
 
257
    template<typename Matcher, typename BidiIter>
 
258
    struct dynamic_xpression;
 
259
 
 
260
    template<typename BidiIter>
 
261
    struct shared_matchable;
 
262
 
 
263
    template<typename BidiIter>
 
264
    struct alternates_vector;
 
265
 
 
266
    template<typename Matcher, typename Next>
 
267
    struct static_xpression;
 
268
 
 
269
    typedef static_xpression<end_matcher, no_next> end_xpression;
 
270
 
 
271
    typedef static_xpression<alternate_end_matcher, no_next> alternate_end_xpression;
 
272
 
 
273
    typedef static_xpression<independent_end_matcher, no_next> independent_end_xpression;
 
274
 
 
275
    typedef static_xpression<true_matcher, no_next> true_xpression;
 
276
 
 
277
    template<typename Matcher, typename Next = end_xpression>
 
278
    struct static_xpression;
 
279
 
 
280
    template<typename Top, typename Next>
 
281
    struct stacked_xpression;
 
282
 
 
283
    template<typename Xpr>
 
284
    struct is_static_xpression;
 
285
 
 
286
    template<typename BidiIter>
 
287
    struct sub_match_impl;
 
288
 
 
289
    template<typename T>
 
290
    struct list;
 
291
 
 
292
    template<typename BidiIter>
 
293
    struct results_cache;
 
294
 
 
295
    template<typename T>
 
296
    struct sequence_stack;
 
297
 
 
298
    template<typename BidiIter>
 
299
    struct results_extras;
 
300
 
 
301
    template<typename BidiIter>
 
302
    struct match_context;
 
303
 
 
304
    template<typename BidiIter>
 
305
    struct sub_match_vector;
 
306
 
 
307
    template<typename T, typename U>
 
308
    struct action_arg;
 
309
 
 
310
    struct actionable;
 
311
 
 
312
    template<typename Char>
 
313
    struct traits;
 
314
 
 
315
    template<typename Traits, typename BidiIter>
 
316
    Traits const &traits_cast(match_state<BidiIter> const &state);
 
317
 
 
318
    template<typename Char>
 
319
    struct basic_chset;
 
320
 
 
321
    template<typename Char>
 
322
    struct named_mark;
 
323
 
 
324
    template<typename BidiIter>
 
325
    struct memento;
 
326
 
 
327
    template<typename Char, typename Traits>
 
328
    void set_char(compound_charset<Traits> &chset, Char ch, Traits const &tr, bool icase);
 
329
 
 
330
    template<typename Char, typename Traits>
 
331
    void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &tr, bool icase);
 
332
 
 
333
    template<typename Traits>
 
334
    void set_class(compound_charset<Traits> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);
 
335
 
 
336
    template<typename Char, typename Traits>
 
337
    void set_char(basic_chset<Char> &chset, Char ch, Traits const &tr, bool icase);
 
338
 
 
339
    template<typename Char, typename Traits>
 
340
    void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &tr, bool icase);
 
341
 
 
342
    template<typename Char, typename Traits>
 
343
    void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);
 
344
 
 
345
    template<typename Matcher>
 
346
    static_xpression<Matcher> const
 
347
    make_static(Matcher const &matcher);
 
348
 
 
349
    template<typename Matcher, typename Next>
 
350
    static_xpression<Matcher, Next> const
 
351
    make_static(Matcher const &matcher, Next const &next);
 
352
 
 
353
    int get_mark_number(basic_mark_tag const &);
 
354
 
 
355
    template<typename Xpr, typename BidiIter>
 
356
    void static_compile(Xpr const &xpr, shared_ptr<regex_impl<BidiIter> > const &impl);
 
357
 
 
358
    struct quant_spec;
 
359
 
 
360
    template<typename BidiIter, typename Xpr>
 
361
    void make_simple_repeat(quant_spec const &spec, sequence<BidiIter> &seq, Xpr const &xpr);
 
362
 
 
363
    template<typename BidiIter>
 
364
    void make_simple_repeat(quant_spec const &spec, sequence<BidiIter> &seq);
 
365
 
 
366
    template<typename BidiIter>
 
367
    void make_repeat(quant_spec const &spec, sequence<BidiIter> &seq, int mark_nbr);
 
368
 
 
369
    template<typename BidiIter>
 
370
    void make_repeat(quant_spec const &spec, sequence<BidiIter> &seq);
 
371
 
 
372
    template<typename BidiIter>
 
373
    void make_optional(quant_spec const &spec, sequence<BidiIter> &seq);
 
374
 
 
375
    template<typename BidiIter>
 
376
    void make_optional(quant_spec const &spec, sequence<BidiIter> &seq, int mark_nbr);
 
377
 
 
378
    template<typename Char>
 
379
    struct string_type
 
380
    {
 
381
        typedef std::vector<Char> type;
 
382
    };
 
383
 
 
384
    template<>
 
385
    struct string_type<char>
 
386
    {
 
387
        typedef std::string type;
 
388
    };
 
389
 
 
390
    #ifndef BOOST_XPRESSIVE_NO_WREGEX
 
391
    template<>
 
392
    struct string_type<wchar_t>
 
393
    {
 
394
        typedef std::wstring type;
 
395
    };
 
396
    #endif
 
397
 
 
398
}}} // namespace boost::xpressive::detail
 
399
 
 
400
namespace boost { namespace xpressive { namespace grammar_detail
 
401
{
 
402
    using proto::_;
 
403
    using proto::or_;
 
404
    using proto::if_;
 
405
    using proto::call;
 
406
    using proto::when;
 
407
    using proto::otherwise;
 
408
    using proto::switch_;
 
409
    using proto::make;
 
410
    using proto::_child;
 
411
    using proto::_value;
 
412
    using proto::_left;
 
413
    using proto::_right;
 
414
    using proto::not_;
 
415
    using proto::_state;
 
416
    using proto::_data;
 
417
    using proto::callable;
 
418
    using proto::transform;
 
419
    using proto::fold;
 
420
    using proto::reverse_fold;
 
421
    using proto::fold_tree;
 
422
    using proto::reverse_fold_tree;
 
423
    using proto::terminal;
 
424
    using proto::shift_right;
 
425
    using proto::bitwise_or;
 
426
    using proto::logical_not;
 
427
    using proto::dereference;
 
428
    using proto::unary_plus;
 
429
    using proto::negate;
 
430
    using proto::complement;
 
431
    using proto::comma;
 
432
    using proto::assign;
 
433
    using proto::subscript;
 
434
    using proto::nary_expr;
 
435
    using proto::unary_expr;
 
436
    using proto::binary_expr;
 
437
    using proto::_deep_copy;
 
438
    using proto::vararg;
 
439
    namespace tag = proto::tag;
 
440
}}}
 
441
 
 
442
namespace boost { namespace xpressive { namespace op
 
443
{
 
444
    struct push;
 
445
    struct push_back;
 
446
    struct pop;
 
447
    struct push_front;
 
448
    struct pop_back;
 
449
    struct pop_front;
 
450
    struct back;
 
451
    struct front;
 
452
    struct top;
 
453
    struct first;
 
454
    struct second;
 
455
    struct matched;
 
456
    struct length;
 
457
    struct str;
 
458
    struct insert;
 
459
    struct make_pair;
 
460
 
 
461
    template<typename T>
 
462
    struct as;
 
463
    template<typename T>
 
464
    struct static_cast_;
 
465
    template<typename T>
 
466
    struct dynamic_cast_;
 
467
    template<typename T>
 
468
    struct const_cast_;
 
469
    template<typename T>
 
470
    struct construct;
 
471
    template<typename T>
 
472
    struct throw_;
 
473
}}} // namespace boost::xpressive::op
 
474
 
 
475
/// INTERNAL ONLY
 
476
namespace boost { namespace xpressive
 
477
{
 
478
 
 
479
    /// INTERNAL ONLY
 
480
    template<typename Traits, std::size_t N>
 
481
    typename Traits::char_class_type
 
482
    lookup_classname(Traits const &traits, char const (&cname)[N], bool icase = false);
 
483
 
 
484
}} // namespace boost::xpressive
 
485
 
 
486
#endif