]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 2002-2003 Joel de Guzman | |
3 | Copyright (c) 2002-2003 Hartmut Kaiser | |
4 | Copyright (c) 2003 Martin Wille | |
5 | http://spirit.sourceforge.net/ | |
6 | ||
7 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
8 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
9 | =============================================================================*/ | |
10 | #if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) | |
11 | #define BOOST_SPIRIT_PARSER_TRAITS_HPP | |
12 | ||
13 | #include <boost/type_traits/is_base_and_derived.hpp> | |
14 | #include <boost/static_assert.hpp> | |
15 | ||
16 | #include <boost/spirit/home/classic/namespace.hpp> | |
17 | #include <boost/spirit/home/classic/core/parser.hpp> | |
18 | #include <boost/spirit/home/classic/meta/impl/parser_traits.ipp> | |
19 | ||
20 | /////////////////////////////////////////////////////////////////////////////// | |
21 | namespace boost { namespace spirit { | |
22 | ||
23 | BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
24 | ||
25 | /////////////////////////////////////////////////////////////////////////////// | |
26 | // | |
27 | // Parser traits templates | |
28 | // | |
29 | // Used to determine the type and several other characteristics of a given | |
30 | // parser type. | |
31 | // | |
32 | /////////////////////////////////////////////////////////////////////////////// | |
33 | ||
34 | /////////////////////////////////////////////////////////////////////////////// | |
35 | // | |
36 | // The is_parser traits template can be used to tell wether a given | |
37 | // class is a parser. | |
38 | // | |
39 | /////////////////////////////////////////////////////////////////////////////// | |
40 | template <typename T> | |
41 | struct is_parser | |
42 | { | |
43 | BOOST_STATIC_CONSTANT(bool, value = | |
44 | (::boost::is_base_and_derived<parser<T>, T>::value)); | |
45 | ||
46 | // [JDG 2/3/03] simplified implementation by | |
47 | // using boost::is_base_and_derived | |
48 | }; | |
49 | ||
50 | /////////////////////////////////////////////////////////////////////////////// | |
51 | // | |
52 | // The is_unary_composite traits template can be used to tell if a given | |
53 | // parser is a unary parser as for instance kleene_star or optional. | |
54 | // | |
55 | /////////////////////////////////////////////////////////////////////////////// | |
56 | template <typename UnaryT> | |
57 | struct is_unary_composite { | |
58 | ||
59 | BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< | |
60 | typename UnaryT::parser_category_t, unary_parser_category>::value)); | |
61 | }; | |
62 | ||
63 | /////////////////////////////////////////////////////////////////////////////// | |
64 | // | |
65 | // The is_acction_parser traits template can be used to tell if a given | |
66 | // parser is a action parser, i.e. it is a composite consisting of a | |
67 | // auxilliary parser and an attached semantic action. | |
68 | // | |
69 | /////////////////////////////////////////////////////////////////////////////// | |
70 | template <typename ActionT> | |
71 | struct is_action_parser { | |
72 | ||
73 | BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< | |
74 | typename ActionT::parser_category_t, action_parser_category>::value)); | |
75 | }; | |
76 | ||
77 | /////////////////////////////////////////////////////////////////////////////// | |
78 | // | |
79 | // The is_binary_composite traits template can be used to tell if a given | |
80 | // parser is a binary parser as for instance sequence or difference. | |
81 | // | |
82 | /////////////////////////////////////////////////////////////////////////////// | |
83 | template <typename BinaryT> | |
84 | struct is_binary_composite { | |
85 | ||
86 | BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< | |
87 | typename BinaryT::parser_category_t, binary_parser_category>::value)); | |
88 | }; | |
89 | ||
90 | /////////////////////////////////////////////////////////////////////////////// | |
91 | // | |
92 | // The is_composite_parser traits template can be used to tell if a given | |
93 | // parser is a unary or a binary parser composite type. | |
94 | // | |
95 | /////////////////////////////////////////////////////////////////////////////// | |
96 | template <typename CompositeT> | |
97 | struct is_composite_parser { | |
98 | ||
99 | BOOST_STATIC_CONSTANT(bool, value = ( | |
100 | ::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<CompositeT>::value || | |
101 | ::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<CompositeT>::value)); | |
102 | }; | |
103 | ||
104 | /////////////////////////////////////////////////////////////////////////////// | |
105 | template <typename ParserT> | |
106 | struct is_alternative { | |
107 | ||
108 | BOOST_STATIC_CONSTANT(bool, value = ( | |
109 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_alternative)); | |
110 | }; | |
111 | ||
112 | template <typename ParserT> | |
113 | struct is_sequence { | |
114 | ||
115 | BOOST_STATIC_CONSTANT(bool, value = ( | |
116 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequence)); | |
117 | }; | |
118 | ||
119 | template <typename ParserT> | |
120 | struct is_sequential_or { | |
121 | ||
122 | BOOST_STATIC_CONSTANT(bool, value = ( | |
123 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequential_or)); | |
124 | }; | |
125 | ||
126 | template <typename ParserT> | |
127 | struct is_intersection { | |
128 | ||
129 | BOOST_STATIC_CONSTANT(bool, value = ( | |
130 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_intersection)); | |
131 | }; | |
132 | ||
133 | template <typename ParserT> | |
134 | struct is_difference { | |
135 | ||
136 | BOOST_STATIC_CONSTANT(bool, value = ( | |
137 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_difference)); | |
138 | }; | |
139 | ||
140 | template <typename ParserT> | |
141 | struct is_exclusive_or { | |
142 | ||
143 | BOOST_STATIC_CONSTANT(bool, value = ( | |
144 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_exclusive_or)); | |
145 | }; | |
146 | ||
147 | template <typename ParserT> | |
148 | struct is_optional { | |
149 | ||
150 | BOOST_STATIC_CONSTANT(bool, value = ( | |
151 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_optional)); | |
152 | }; | |
153 | ||
154 | template <typename ParserT> | |
155 | struct is_kleene_star { | |
156 | ||
157 | BOOST_STATIC_CONSTANT(bool, value = ( | |
158 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_kleene_star)); | |
159 | }; | |
160 | ||
161 | template <typename ParserT> | |
162 | struct is_positive { | |
163 | ||
164 | BOOST_STATIC_CONSTANT(bool, value = ( | |
165 | ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_positive)); | |
166 | }; | |
167 | ||
168 | /////////////////////////////////////////////////////////////////////////////// | |
169 | // | |
170 | // Parser extraction templates | |
171 | // | |
172 | /////////////////////////////////////////////////////////////////////////////// | |
173 | ||
174 | /////////////////////////////////////////////////////////////////////////////// | |
175 | // | |
176 | // The unary_subject template can be used to return the type of the | |
177 | // parser used as the subject of an unary parser. | |
178 | // If the parser under inspection is not an unary type parser the compilation | |
179 | // will fail. | |
180 | // | |
181 | /////////////////////////////////////////////////////////////////////////////// | |
182 | template <typename UnaryT> | |
183 | struct unary_subject { | |
184 | ||
185 | BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value); | |
186 | typedef typename UnaryT::subject_t type; | |
187 | }; | |
188 | ||
189 | /////////////////////////////////////////////////////////////////////////////// | |
190 | // | |
191 | // The get_unary_subject template function returns the parser object, which | |
192 | // is used as the subject of an unary parser. | |
193 | // If the parser under inspection is not an unary type parser the compilation | |
194 | // will fail. | |
195 | // | |
196 | /////////////////////////////////////////////////////////////////////////////// | |
197 | template <typename UnaryT> | |
198 | inline typename unary_subject<UnaryT>::type const & | |
199 | get_unary_subject(UnaryT const &unary_) | |
200 | { | |
201 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value); | |
202 | return unary_.subject(); | |
203 | } | |
204 | ||
205 | /////////////////////////////////////////////////////////////////////////////// | |
206 | // | |
207 | // The binary_left_subject and binary_right_subject templates can be used to | |
208 | // return the types of the parsers used as the left and right subject of an | |
209 | // binary parser. | |
210 | // If the parser under inspection is not a binary type parser the compilation | |
211 | // will fail. | |
212 | // | |
213 | /////////////////////////////////////////////////////////////////////////////// | |
214 | template <typename BinaryT> | |
215 | struct binary_left_subject { | |
216 | ||
217 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); | |
218 | typedef typename BinaryT::left_t type; | |
219 | }; | |
220 | ||
221 | template <typename BinaryT> | |
222 | struct binary_right_subject { | |
223 | ||
224 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); | |
225 | typedef typename BinaryT::right_t type; | |
226 | }; | |
227 | ||
228 | /////////////////////////////////////////////////////////////////////////////// | |
229 | // | |
230 | // The get_binary_left_subject and get_binary_right_subject template functions | |
231 | // return the parser object, which is used as the left or right subject of a | |
232 | // binary parser. | |
233 | // If the parser under inspection is not a binary type parser the compilation | |
234 | // will fail. | |
235 | // | |
236 | /////////////////////////////////////////////////////////////////////////////// | |
237 | template <typename BinaryT> | |
238 | inline typename binary_left_subject<BinaryT>::type const & | |
239 | get_binary_left_subject(BinaryT const &binary_) | |
240 | { | |
241 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); | |
242 | return binary_.left(); | |
243 | } | |
244 | ||
245 | template <typename BinaryT> | |
246 | inline typename binary_right_subject<BinaryT>::type const & | |
247 | get_binary_right_subject(BinaryT const &binary_) | |
248 | { | |
249 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); | |
250 | return binary_.right(); | |
251 | } | |
252 | ||
253 | /////////////////////////////////////////////////////////////////////////////// | |
254 | // | |
255 | // The action_subject template can be used to return the type of the | |
256 | // parser used as the subject of an action parser. | |
257 | // If the parser under inspection is not an action type parser the compilation | |
258 | // will fail. | |
259 | // | |
260 | /////////////////////////////////////////////////////////////////////////////// | |
261 | template <typename ActionT> | |
262 | struct action_subject { | |
263 | ||
264 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); | |
265 | typedef typename ActionT::subject_t type; | |
266 | }; | |
267 | ||
268 | /////////////////////////////////////////////////////////////////////////////// | |
269 | // | |
270 | // The get_action_subject template function returns the parser object, which | |
271 | // is used as the subject of an action parser. | |
272 | // If the parser under inspection is not an action type parser the compilation | |
273 | // will fail. | |
274 | // | |
275 | /////////////////////////////////////////////////////////////////////////////// | |
276 | template <typename ActionT> | |
277 | inline typename action_subject<ActionT>::type const & | |
278 | get_action_subject(ActionT const &action_) | |
279 | { | |
280 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); | |
281 | return action_.subject(); | |
282 | } | |
283 | ||
284 | /////////////////////////////////////////////////////////////////////////////// | |
285 | // | |
286 | // The semantic_action template can be used to return the type of the | |
287 | // attached semantic action of an action parser. | |
288 | // If the parser under inspection is not an action type parser the compilation | |
289 | // will fail. | |
290 | // | |
291 | /////////////////////////////////////////////////////////////////////////////// | |
292 | template <typename ActionT> | |
293 | struct semantic_action { | |
294 | ||
295 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); | |
296 | typedef typename ActionT::predicate_t type; | |
297 | }; | |
298 | ||
299 | /////////////////////////////////////////////////////////////////////////////// | |
300 | // | |
301 | // The get_semantic_action template function returns the attached semantic | |
302 | // action of an action parser. | |
303 | // If the parser under inspection is not an action type parser the compilation | |
304 | // will fail. | |
305 | // | |
306 | /////////////////////////////////////////////////////////////////////////////// | |
307 | template <typename ActionT> | |
308 | inline typename semantic_action<ActionT>::type const & | |
309 | get_semantic_action(ActionT const &action_) | |
310 | { | |
311 | BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); | |
312 | return action_.predicate(); | |
313 | } | |
314 | ||
315 | /////////////////////////////////////////////////////////////////////////////// | |
316 | BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
317 | ||
318 | }} // namespace BOOST_SPIRIT_CLASSIC_NS | |
319 | ||
320 | #endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) |