blob: 00c8c6150637df176cd5821e9c5b6d4c9dc1fc54 (
plain)
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
|
///////////////////////////////////////////////////////////////////////////////
/// \file xpressive_fwd.hpp
/// Forward declarations for all of xpressive's public data types.
//
// Copyright 2008 Eric Niebler. 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_XPRESSIVE_FWD_HPP_EAN_10_04_2005
#define BOOST_XPRESSIVE_XPRESSIVE_FWD_HPP_EAN_10_04_2005
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <string>
#include <boost/config.hpp>
#include <boost/version.hpp>
#include <boost/iterator/iterator_traits.hpp>
#if BOOST_VERSION >= 103500
# define BOOST_PROTO_FUSION_V2
#endif
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# error Sorry, xpressive requires a compiler that supports partial template specialization.
#endif
#if defined(BOOST_NO_STD_LOCALE) & !defined(BOOST_XPRESSIVE_USE_C_TRAITS)
# define BOOST_XPRESSIVE_USE_C_TRAITS
#endif
#if defined(BOOST_NO_CWCHAR) | defined(BOOST_NO_CWCTYPE) | defined(BOOST_NO_STD_WSTRING)
# ifndef BOOST_XPRESSIVE_NO_WREGEX
# define BOOST_XPRESSIVE_NO_WREGEX
# endif
#endif
// Stack protection under MS Windows
// Config logic taken from boost/regex/config.hpp
#ifndef BOOST_XPRESSIVE_HAS_MS_STACK_GUARD
# if (defined(_WIN32) || defined(_WIN64) || defined(_WINCE)) \
&& !defined(__GNUC__) \
&& !(defined(__BORLANDC__) && (__BORLANDC__ >= 0x600)) \
&& !(defined(__MWERKS__) && (__MWERKS__ <= 0x3003))
# define BOOST_XPRESSIVE_HAS_MS_STACK_GUARD 1
# else
# define BOOST_XPRESSIVE_HAS_MS_STACK_GUARD 0
# endif
#endif
#include <boost/proto/proto_fwd.hpp>
namespace boost { namespace xpressive
{
template<typename Char>
struct cpp_regex_traits;
template<typename Char>
struct c_regex_traits;
template<typename Elem>
struct null_regex_traits;
namespace detail
{
template<typename Char>
struct default_regex_traits
{
#ifdef BOOST_XPRESSIVE_USE_C_TRAITS
typedef c_regex_traits<Char> type;
#else
typedef cpp_regex_traits<Char> type;
#endif
};
struct mark_placeholder;
typedef proto::expr<proto::tag::terminal, proto::term<mark_placeholder>, 0> basic_mark_tag;
struct regex_domain;
} // namespace detail
struct mark_tag;
typedef void const *regex_id_type;
struct regex_error;
struct regex_traits_version_1_tag;
struct regex_traits_version_2_tag;
// DEPRECATED
/// INTERNAL ONLY
///
struct regex_traits_version_1_case_fold_tag;
template<typename Trait>
struct has_fold_case;
template<typename BidiIter>
struct basic_regex;
template<typename BidiIter>
struct match_results;
template<typename BidiIter>
struct regex_iterator;
template<typename BidiIter>
struct regex_token_iterator;
template<typename BidiIter>
struct regex_id_filter_predicate;
template<typename BidiIter>
struct sub_match;
template<typename RegexTraits>
struct compiler_traits;
template<typename Char, typename Impl = typename detail::default_regex_traits<Char>::type>
struct regex_traits;
template
<
typename BidiIter
, typename RegexTraits = regex_traits<typename iterator_value<BidiIter>::type>
, typename CompilerTraits = compiler_traits<RegexTraits>
>
struct regex_compiler;
template<typename T>
struct value;
template<typename T>
struct reference;
template<typename T>
struct local;
template<typename T, int I = 0, typename Dummy = proto::is_proto_expr>
struct placeholder;
namespace op
{
struct at;
struct push;
struct push_back;
struct push_front;
struct pop;
struct pop_back;
struct pop_front;
struct front;
struct back;
struct top;
struct first;
struct second;
struct matched;
struct length;
struct str;
struct insert;
struct make_pair;
template<typename T>
struct as;
template<typename T>
struct static_cast_;
template<typename T>
struct dynamic_cast_;
template<typename T>
struct const_cast_;
template<typename T>
struct construct;
template<typename Except>
struct throw_;
struct unwrap_reference;
}
///////////////////////////////////////////////////////////////////////////////
// Common typedefs
//
typedef basic_regex<std::string::const_iterator> sregex;
typedef basic_regex<char const *> cregex;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef basic_regex<std::wstring::const_iterator> wsregex;
typedef basic_regex<wchar_t const *> wcregex;
#endif
typedef sub_match<std::string::const_iterator> ssub_match;
typedef sub_match<char const *> csub_match;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef sub_match<std::wstring::const_iterator> wssub_match;
typedef sub_match<wchar_t const *> wcsub_match;
#endif
typedef regex_compiler<std::string::const_iterator> sregex_compiler;
typedef regex_compiler<char const *> cregex_compiler;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef regex_compiler<std::wstring::const_iterator> wsregex_compiler;
typedef regex_compiler<wchar_t const *> wcregex_compiler;
#endif
typedef regex_iterator<std::string::const_iterator> sregex_iterator;
typedef regex_iterator<char const *> cregex_iterator;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
typedef regex_iterator<wchar_t const *> wcregex_iterator;
#endif
typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
typedef regex_token_iterator<char const *> cregex_token_iterator;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
typedef regex_token_iterator<wchar_t const *> wcregex_token_iterator;
#endif
typedef match_results<std::string::const_iterator> smatch;
typedef match_results<char const *> cmatch;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef match_results<std::wstring::const_iterator> wsmatch;
typedef match_results<wchar_t const *> wcmatch;
#endif
typedef regex_id_filter_predicate<std::string::const_iterator> sregex_id_filter_predicate;
typedef regex_id_filter_predicate<char const *> cregex_id_filter_predicate;
#ifndef BOOST_XPRESSIVE_NO_WREGEX
typedef regex_id_filter_predicate<std::wstring::const_iterator> wsregex_id_filter_predicate;
typedef regex_id_filter_predicate<wchar_t const *> wcregex_id_filter_predicate;
#endif
}} // namespace boost::xpressive
#endif
|
