← Back to branch summary

~ai.tron/armagetronad/0.4-winlibs-updated

« back to all changes in this revision

Viewing changes to boost/includes/boost/xpressive/detail/core/linker.hpp

  • Committer: Manuel Moos
  • Date: 2013-08-10 16:21:05 UTC
  • mfrom: (118.1.64 winlibs-refactor)
  • Revision ID: z-man@users.sf.net-20130810162105-e6v55tas5si5gb3e
Updating boost to 1.53

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/includes/boost/xpressive/detail/core/linker.hpp
 
1
///////////////////////////////////////////////////////////////////////////////
 
2
// linker.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_CORE_LINKER_HPP_EAN_10_04_2005
 
9
#define BOOST_XPRESSIVE_DETAIL_CORE_LINKER_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 <boost/config.hpp>
 
17
#ifndef BOOST_NO_STD_LOCALE
 
18
# include <locale>
 
19
#endif
 
20
#include <stack>
 
21
#include <limits>
 
22
#include <typeinfo>
 
23
#include <boost/shared_ptr.hpp>
 
24
#include <boost/type_traits/is_same.hpp>
 
25
#include <boost/version.hpp>
 
26
 
 
27
#if BOOST_VERSION >= 103500
 
28
# include <boost/fusion/include/for_each.hpp>
 
29
#else
 
30
# include <boost/spirit/fusion/algorithm/for_each.hpp>
 
31
#endif
 
32
 
 
33
#include <boost/xpressive/detail/detail_fwd.hpp>
 
34
#include <boost/xpressive/detail/dynamic/matchable.hpp>
 
35
#include <boost/xpressive/detail/core/matchers.hpp>
 
36
#include <boost/xpressive/detail/core/peeker.hpp>
 
37
#include <boost/xpressive/detail/utility/never_true.hpp>
 
38
 
 
39
namespace boost { namespace xpressive { namespace detail
 
40
{
 
41
 
 
42
///////////////////////////////////////////////////////////////////////////////
 
43
// icase_modifier
 
44
//
 
45
//   wrapped by the modifier<> template and inserted into the xpression
 
46
//   template with the icase() helper function. icase_modifier morphs
 
47
//   a case-sensitive visitor into a case-insensitive visitor, which
 
48
//   causes all matchers visited to become case-insensitive.
 
49
//
 
50
struct icase_modifier
 
51
{
 
52
    template<typename Visitor>
 
53
    struct apply {};
 
54
 
 
55
    template<typename BidiIter, typename ICase, typename Traits>
 
56
    struct apply<xpression_visitor<BidiIter, ICase, Traits> >
 
57
    {
 
58
        typedef xpression_visitor<BidiIter, mpl::true_, Traits> type;
 
59
    };
 
60
 
 
61
    template<typename Visitor>
 
62
    static typename apply<Visitor>::type
 
63
    call(Visitor &visitor)
 
64
    {
 
65
        return typename apply<Visitor>::type(visitor.traits(), visitor.self());
 
66
    }
 
67
};
 
68
 
 
69
///////////////////////////////////////////////////////////////////////////////
 
70
// regex_traits_type : wrap a locale in the appropriate regex_traits
 
71
//
 
72
template<typename Locale, typename BidiIter>
 
73
struct regex_traits_type
 
74
{
 
75
#ifndef BOOST_NO_STD_LOCALE
 
76
 
 
77
    typedef typename iterator_value<BidiIter>::type char_type;
 
78
 
 
79
    // if Locale is std::locale, wrap it in a cpp_regex_traits<Char>
 
80
    typedef typename mpl::if_c
 
81
    <
 
82
        is_same<Locale, std::locale>::value
 
83
      , cpp_regex_traits<char_type>
 
84
      , Locale
 
85
    >::type type;
 
86
 
 
87
#else
 
88
 
 
89
    typedef Locale type;
 
90
 
 
91
#endif
 
92
};
 
93
 
 
94
///////////////////////////////////////////////////////////////////////////////
 
95
// locale_modifier
 
96
//
 
97
//   wrapped by the modifier<> template and inserted into the xpression
 
98
//   template with the imbue() helper function. Causes a sub-xpression to
 
99
//   use the specified Locale
 
100
//
 
101
template<typename Locale>
 
102
struct locale_modifier
 
103
{
 
104
    typedef Locale locale_type;
 
105
 
 
106
    locale_modifier(Locale const &loc)
 
107
      : loc_(loc)
 
108
    {
 
109
    }
 
110
 
 
111
    template<typename Visitor>
 
112
    struct apply {};
 
113
 
 
114
    template<typename BidiIter, typename ICase, typename OtherTraits>
 
115
    struct apply<xpression_visitor<BidiIter, ICase, OtherTraits> >
 
116
    {
 
117
        typedef typename regex_traits_type<Locale, BidiIter>::type traits_type;
 
118
        typedef xpression_visitor<BidiIter, ICase, traits_type> type;
 
119
    };
 
120
 
 
121
    template<typename Visitor>
 
122
    typename apply<Visitor>::type
 
123
    call(Visitor &visitor) const
 
124
    {
 
125
        return typename apply<Visitor>::type(this->loc_, visitor.self());
 
126
    }
 
127
 
 
128
    Locale getloc() const
 
129
    {
 
130
        return this->loc_;
 
131
    }
 
132
 
 
133
private:
 
134
    Locale loc_;
 
135
};
 
136
 
 
137
///////////////////////////////////////////////////////////////////////////////
 
138
// xpression_linker
 
139
//
 
140
template<typename Char>
 
141
struct xpression_linker
 
142
{
 
143
    template<typename Traits>
 
144
    explicit xpression_linker(Traits const &tr)
 
145
      : back_stack_()
 
146
      , traits_(&tr)
 
147
      , traits_type_(&typeid(Traits))
 
148
      , has_backrefs_(false)
 
149
    {
 
150
    }
 
151
 
 
152
    template<typename Matcher>
 
153
    void accept(Matcher const &, void const *)
 
154
    {
 
155
        // no-op
 
156
    }
 
157
 
 
158
    template<typename Traits, typename ICase>
 
159
    void accept(mark_matcher<Traits, ICase> const &, void const *)
 
160
    {
 
161
        this->has_backrefs_ = true;
 
162
    }
 
163
 
 
164
    template<typename Action>
 
165
    void accept(action_matcher<Action> const &, void const *)
 
166
    {
 
167
        this->has_backrefs_ = true;
 
168
    }
 
169
 
 
170
    template<typename Predicate>
 
171
    void accept(predicate_matcher<Predicate> const &, void const *)
 
172
    {
 
173
        this->has_backrefs_ = true;
 
174
    }
 
175
 
 
176
    void accept(repeat_begin_matcher const &, void const *next)
 
177
    {
 
178
        this->back_stack_.push(next);
 
179
    }
 
180
 
 
181
    template<typename Greedy>
 
182
    void accept(repeat_end_matcher<Greedy> const &matcher, void const *)
 
183
    {
 
184
        matcher.back_ = this->back_stack_.top();
 
185
        this->back_stack_.pop();
 
186
    }
 
187
 
 
188
    template<typename Alternates, typename Traits>
 
189
    void accept(alternate_matcher<Alternates, Traits> const &matcher, void const *next)
 
190
    {
 
191
        xpression_peeker<Char> peeker(matcher.bset_, this->get_traits<Traits>());
 
192
        this->alt_link(matcher.alternates_, next, &peeker);
 
193
    }
 
194
 
 
195
    void accept(alternate_end_matcher const &matcher, void const *)
 
196
    {
 
197
        matcher.back_ = this->back_stack_.top();
 
198
        this->back_stack_.pop();
 
199
    }
 
200
 
 
201
    template<typename Xpr, typename Greedy>
 
202
    void accept(optional_matcher<Xpr, Greedy> const &matcher, void const *next)
 
203
    {
 
204
        this->back_stack_.push(next);
 
205
        matcher.xpr_.link(*this);
 
206
    }
 
207
 
 
208
    template<typename Xpr, typename Greedy>
 
209
    void accept(optional_mark_matcher<Xpr, Greedy> const &matcher, void const *next)
 
210
    {
 
211
        this->back_stack_.push(next);
 
212
        matcher.xpr_.link(*this);
 
213
    }
 
214
 
 
215
    template<typename Xpr>
 
216
    void accept(keeper_matcher<Xpr> const &matcher, void const *)
 
217
    {
 
218
        matcher.xpr_.link(*this);
 
219
    }
 
220
 
 
221
    template<typename Xpr>
 
222
    void accept(lookahead_matcher<Xpr> const &matcher, void const *)
 
223
    {
 
224
        matcher.xpr_.link(*this);
 
225
    }
 
226
 
 
227
    template<typename Xpr>
 
228
    void accept(lookbehind_matcher<Xpr> const &matcher, void const *)
 
229
    {
 
230
        matcher.xpr_.link(*this);
 
231
    }
 
232
 
 
233
    template<typename Xpr, typename Greedy>
 
234
    void accept(simple_repeat_matcher<Xpr, Greedy> const &matcher, void const *)
 
235
    {
 
236
        matcher.xpr_.link(*this);
 
237
    }
 
238
 
 
239
    // accessors
 
240
    bool has_backrefs() const
 
241
    {
 
242
        return this->has_backrefs_;
 
243
    }
 
244
 
 
245
    // for use by alt_link_pred below
 
246
    template<typename Xpr>
 
247
    void alt_branch_link(Xpr const &xpr, void const *next, xpression_peeker<Char> *peeker)
 
248
    {
 
249
        this->back_stack_.push(next);
 
250
        xpr.link(*this);
 
251
        xpr.peek(*peeker);
 
252
    }
 
253
 
 
254
private:
 
255
 
 
256
    ///////////////////////////////////////////////////////////////////////////////
 
257
    // alt_link_pred
 
258
    //
 
259
    struct alt_link_pred
 
260
    {
 
261
        xpression_linker<Char> *linker_;
 
262
        xpression_peeker<Char> *peeker_;
 
263
        void const *next_;
 
264
 
 
265
        alt_link_pred
 
266
        (
 
267
            xpression_linker<Char> *linker
 
268
          , xpression_peeker<Char> *peeker
 
269
          , void const *next
 
270
        )
 
271
          : linker_(linker)
 
272
          , peeker_(peeker)
 
273
          , next_(next)
 
274
        {
 
275
        }
 
276
 
 
277
        template<typename Xpr>
 
278
        void operator ()(Xpr const &xpr) const
 
279
        {
 
280
            this->linker_->alt_branch_link(xpr, this->next_, this->peeker_);
 
281
        }
 
282
    };
 
283
 
 
284
    template<typename BidiIter>
 
285
    void alt_link
 
286
    (
 
287
        alternates_vector<BidiIter> const &alternates
 
288
      , void const *next
 
289
      , xpression_peeker<Char> *peeker
 
290
    )
 
291
    {
 
292
        std::for_each(alternates.begin(), alternates.end(), alt_link_pred(this, peeker, next));
 
293
    }
 
294
 
 
295
    template<typename Alternates>
 
296
    void alt_link
 
297
    (
 
298
        fusion::sequence_base<Alternates> const &alternates
 
299
      , void const *next
 
300
      , xpression_peeker<Char> *peeker
 
301
    )
 
302
    {
 
303
#if BOOST_VERSION >= 103500
 
304
        fusion::for_each(alternates.derived(), alt_link_pred(this, peeker, next));
 
305
#else
 
306
        fusion::for_each(alternates.cast(), alt_link_pred(this, peeker, next));
 
307
#endif
 
308
    }
 
309
 
 
310
    template<typename Traits>
 
311
    Traits const &get_traits() const
 
312
    {
 
313
        BOOST_ASSERT(*this->traits_type_ == typeid(Traits));
 
314
        return *static_cast<Traits const *>(this->traits_);
 
315
    }
 
316
 
 
317
    std::stack<void const *> back_stack_;
 
318
    void const *traits_;
 
319
    std::type_info const *traits_type_;
 
320
    bool has_backrefs_;
 
321
};
 
322
 
 
323
}}} // namespace boost::xpressive::detail
 
324
 
 
325
#endif