]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 2002-2003 Hartmut Kaiser | |
3 | http://spirit.sourceforge.net/ | |
4 | ||
5 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
6 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
7 | =============================================================================*/ | |
8 | #ifndef BOOST_SPIRIT_CONFIX_HPP | |
9 | #define BOOST_SPIRIT_CONFIX_HPP | |
10 | ||
11 | /////////////////////////////////////////////////////////////////////////////// | |
12 | #include <boost/config.hpp> | |
13 | #include <boost/spirit/home/classic/namespace.hpp> | |
14 | #include <boost/spirit/home/classic/meta/as_parser.hpp> | |
15 | #include <boost/spirit/home/classic/core/composite/operators.hpp> | |
16 | ||
17 | #include <boost/spirit/home/classic/utility/confix_fwd.hpp> | |
18 | #include <boost/spirit/home/classic/utility/impl/confix.ipp> | |
19 | ||
20 | /////////////////////////////////////////////////////////////////////////////// | |
21 | namespace boost { namespace spirit { | |
22 | ||
23 | BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
24 | ||
25 | /////////////////////////////////////////////////////////////////////////////// | |
26 | // | |
27 | // confix_parser class | |
28 | // | |
29 | // Parses a sequence of 3 sub-matches. This class may | |
30 | // be used to parse structures, where the opening part is possibly | |
31 | // contained in the expression part and the whole sequence is only | |
32 | // parsed after seeing the closing part matching the first opening | |
33 | // subsequence. Example: C-comments: | |
34 | // | |
35 | // /* This is a C-comment */ | |
36 | // | |
37 | /////////////////////////////////////////////////////////////////////////////// | |
38 | ||
39 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
40 | #pragma warning(push) | |
41 | #pragma warning(disable:4512) //assignment operator could not be generated | |
42 | #endif | |
43 | ||
44 | template<typename NestedT = non_nested, typename LexemeT = non_lexeme> | |
45 | struct confix_parser_gen; | |
46 | ||
47 | template < | |
48 | typename OpenT, typename ExprT, typename CloseT, typename CategoryT, | |
49 | typename NestedT, typename LexemeT | |
50 | > | |
51 | struct confix_parser : | |
52 | public parser< | |
53 | confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT> | |
54 | > | |
55 | { | |
56 | typedef | |
57 | confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT> | |
58 | self_t; | |
59 | ||
60 | confix_parser(OpenT const &open_, ExprT const &expr_, CloseT const &close_) | |
61 | : open(open_), expr(expr_), close(close_) | |
62 | {} | |
63 | ||
64 | template <typename ScannerT> | |
65 | typename parser_result<self_t, ScannerT>::type | |
66 | parse(ScannerT const& scan) const | |
67 | { | |
68 | return impl::confix_parser_type<CategoryT>:: | |
69 | parse(NestedT(), LexemeT(), *this, scan, open, expr, close); | |
70 | } | |
71 | ||
72 | private: | |
73 | ||
74 | typename as_parser<OpenT>::type::embed_t open; | |
75 | typename as_parser<ExprT>::type::embed_t expr; | |
76 | typename as_parser<CloseT>::type::embed_t close; | |
77 | }; | |
78 | ||
79 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
80 | #pragma warning(pop) | |
81 | #endif | |
82 | ||
83 | /////////////////////////////////////////////////////////////////////////////// | |
84 | // | |
85 | // Confix parser generator template | |
86 | // | |
87 | // This is a helper for generating a correct confix_parser<> from | |
88 | // auxiliary parameters. There are the following types supported as | |
89 | // parameters yet: parsers, single characters and strings (see | |
90 | // as_parser). | |
91 | // | |
92 | // If the body parser is an action_parser_category type parser (a parser | |
93 | // with an attached semantic action) we have to do something special. This | |
94 | // happens, if the user wrote something like: | |
95 | // | |
96 | // confix_p(open, body[f], close) | |
97 | // | |
98 | // where 'body' is the parser matching the body of the confix sequence | |
99 | // and 'f' is a functor to be called after matching the body. If we would | |
100 | // do nothing, the resulting code would parse the sequence as follows: | |
101 | // | |
102 | // start >> (body[f] - close) >> close | |
103 | // | |
104 | // what in most cases is not what the user expects. | |
105 | // (If this _is_ what you've expected, then please use the confix_p | |
106 | // generator function 'direct()', which will inhibit | |
107 | // re-attaching the actor to the body parser). | |
108 | // | |
109 | // To make the confix parser behave as expected: | |
110 | // | |
111 | // start >> (body - close)[f] >> close | |
112 | // | |
113 | // the actor attached to the 'body' parser has to be re-attached to the | |
114 | // (body - close) parser construct, which will make the resulting confix | |
115 | // parser 'do the right thing'. This refactoring is done by the help of | |
116 | // the refactoring parsers (see the files refactoring.[hi]pp). | |
117 | // | |
118 | // Additionally special care must be taken, if the body parser is a | |
119 | // unary_parser_category type parser as | |
120 | // | |
121 | // confix_p(open, *anychar_p, close) | |
122 | // | |
123 | // which without any refactoring would result in | |
124 | // | |
125 | // start >> (*anychar_p - close) >> close | |
126 | // | |
127 | // and will not give the expected result (*anychar_p will eat up all the | |
128 | // input up to the end of the input stream). So we have to refactor this | |
129 | // into: | |
130 | // | |
131 | // start >> *(anychar_p - close) >> close | |
132 | // | |
133 | // what will give the correct result. | |
134 | // | |
135 | // The case, where the body parser is a combination of the two mentioned | |
136 | // problems (i.e. the body parser is a unary parser with an attached | |
137 | // action), is handled accordingly too: | |
138 | // | |
139 | // confix_p(start, (*anychar_p)[f], end) | |
140 | // | |
141 | // will be parsed as expected: | |
142 | // | |
143 | // start >> (*(anychar_p - end))[f] >> end. | |
144 | // | |
145 | /////////////////////////////////////////////////////////////////////////////// | |
146 | ||
147 | template<typename NestedT, typename LexemeT> | |
148 | struct confix_parser_gen | |
149 | { | |
150 | // Generic generator function for creation of concrete confix parsers | |
151 | ||
152 | template<typename StartT, typename ExprT, typename EndT> | |
153 | struct paren_op_result_type | |
154 | { | |
155 | typedef confix_parser< | |
156 | typename as_parser<StartT>::type, | |
157 | typename as_parser<ExprT>::type, | |
158 | typename as_parser<EndT>::type, | |
159 | typename as_parser<ExprT>::type::parser_category_t, | |
160 | NestedT, | |
161 | LexemeT | |
162 | > type; | |
163 | }; | |
164 | ||
165 | template<typename StartT, typename ExprT, typename EndT> | |
166 | typename paren_op_result_type<StartT, ExprT, EndT>::type | |
167 | operator()(StartT const &start_, ExprT const &expr_, EndT const &end_) const | |
168 | { | |
169 | typedef typename paren_op_result_type<StartT,ExprT,EndT>::type | |
170 | return_t; | |
171 | ||
172 | return return_t( | |
173 | as_parser<StartT>::convert(start_), | |
174 | as_parser<ExprT>::convert(expr_), | |
175 | as_parser<EndT>::convert(end_) | |
176 | ); | |
177 | } | |
178 | ||
179 | // Generic generator function for creation of concrete confix parsers | |
180 | // which have an action directly attached to the ExprT part of the | |
181 | // parser (see comment above, no automatic refactoring) | |
182 | ||
183 | template<typename StartT, typename ExprT, typename EndT> | |
184 | struct direct_result_type | |
185 | { | |
186 | typedef confix_parser< | |
187 | typename as_parser<StartT>::type, | |
188 | typename as_parser<ExprT>::type, | |
189 | typename as_parser<EndT>::type, | |
190 | plain_parser_category, // do not re-attach action | |
191 | NestedT, | |
192 | LexemeT | |
193 | > type; | |
194 | }; | |
195 | ||
196 | template<typename StartT, typename ExprT, typename EndT> | |
197 | typename direct_result_type<StartT,ExprT,EndT>::type | |
198 | direct(StartT const &start_, ExprT const &expr_, EndT const &end_) const | |
199 | { | |
200 | typedef typename direct_result_type<StartT,ExprT,EndT>::type | |
201 | return_t; | |
202 | ||
203 | return return_t( | |
204 | as_parser<StartT>::convert(start_), | |
205 | as_parser<ExprT>::convert(expr_), | |
206 | as_parser<EndT>::convert(end_) | |
207 | ); | |
208 | } | |
209 | }; | |
210 | ||
211 | /////////////////////////////////////////////////////////////////////////////// | |
212 | // | |
213 | // Predefined non_nested confix parser generators | |
214 | // | |
215 | /////////////////////////////////////////////////////////////////////////////// | |
216 | ||
217 | const confix_parser_gen<non_nested, non_lexeme> confix_p = | |
218 | confix_parser_gen<non_nested, non_lexeme>(); | |
219 | ||
220 | /////////////////////////////////////////////////////////////////////////////// | |
221 | // | |
222 | // Comments are special types of confix parsers | |
223 | // | |
224 | // Comment parser generator template. This is a helper for generating a | |
225 | // correct confix_parser<> from auxiliary parameters, which is able to | |
226 | // parse comment constructs: (StartToken >> Comment text >> EndToken). | |
227 | // | |
228 | // There are the following types supported as parameters yet: parsers, | |
229 | // single characters and strings (see as_parser). | |
230 | // | |
231 | // There are two diffenerent predefined comment parser generators | |
232 | // (comment_p and comment_nest_p, see below), which may be used for | |
233 | // creating special comment parsers in two different ways. | |
234 | // | |
235 | // If these are used with one parameter, a comment starting with the given | |
236 | // first parser parameter up to the end of the line is matched. So for | |
237 | // instance the following parser matches C++ style comments: | |
238 | // | |
239 | // comment_p("//"). | |
240 | // | |
241 | // If these are used with two parameters, a comment starting with the | |
242 | // first parser parameter up to the second parser parameter is matched. | |
243 | // For instance a C style comment parser should be constrcuted as: | |
244 | // | |
245 | // comment_p("/*", "*/"). | |
246 | // | |
247 | // Please note, that a comment is parsed implicitly as if the whole | |
248 | // comment_p(...) statement were embedded into a lexeme_d[] directive. | |
249 | // | |
250 | /////////////////////////////////////////////////////////////////////////////// | |
251 | ||
252 | template<typename NestedT> | |
253 | struct comment_parser_gen | |
254 | { | |
255 | // Generic generator function for creation of concrete comment parsers | |
256 | // from an open token. The newline parser eol_p is used as the | |
257 | // closing token. | |
258 | ||
259 | template<typename StartT> | |
260 | struct paren_op1_result_type | |
261 | { | |
262 | typedef confix_parser< | |
263 | typename as_parser<StartT>::type, | |
264 | kleene_star<anychar_parser>, | |
265 | alternative<eol_parser, end_parser>, | |
266 | unary_parser_category, // there is no action to re-attach | |
267 | NestedT, | |
268 | is_lexeme // insert implicit lexeme_d[] | |
269 | > | |
270 | type; | |
271 | }; | |
272 | ||
273 | template<typename StartT> | |
274 | typename paren_op1_result_type<StartT>::type | |
275 | operator() (StartT const &start_) const | |
276 | { | |
277 | typedef typename paren_op1_result_type<StartT>::type | |
278 | return_t; | |
279 | ||
280 | return return_t( | |
281 | as_parser<StartT>::convert(start_), | |
282 | *anychar_p, | |
283 | eol_p | end_p | |
284 | ); | |
285 | } | |
286 | ||
287 | // Generic generator function for creation of concrete comment parsers | |
288 | // from an open and a close tokens. | |
289 | ||
290 | template<typename StartT, typename EndT> | |
291 | struct paren_op2_result_type | |
292 | { | |
293 | typedef confix_parser< | |
294 | typename as_parser<StartT>::type, | |
295 | kleene_star<anychar_parser>, | |
296 | typename as_parser<EndT>::type, | |
297 | unary_parser_category, // there is no action to re-attach | |
298 | NestedT, | |
299 | is_lexeme // insert implicit lexeme_d[] | |
300 | > type; | |
301 | }; | |
302 | ||
303 | template<typename StartT, typename EndT> | |
304 | typename paren_op2_result_type<StartT,EndT>::type | |
305 | operator() (StartT const &start_, EndT const &end_) const | |
306 | { | |
307 | typedef typename paren_op2_result_type<StartT,EndT>::type | |
308 | return_t; | |
309 | ||
310 | return return_t( | |
311 | as_parser<StartT>::convert(start_), | |
312 | *anychar_p, | |
313 | as_parser<EndT>::convert(end_) | |
314 | ); | |
315 | } | |
316 | }; | |
317 | ||
318 | /////////////////////////////////////////////////////////////////////////////// | |
319 | // | |
320 | // Predefined non_nested comment parser generator | |
321 | // | |
322 | /////////////////////////////////////////////////////////////////////////////// | |
323 | ||
324 | const comment_parser_gen<non_nested> comment_p = | |
325 | comment_parser_gen<non_nested>(); | |
326 | ||
327 | /////////////////////////////////////////////////////////////////////////////// | |
328 | // | |
329 | // comment_nest_parser class | |
330 | // | |
331 | // Parses a nested comments. | |
332 | // Example: nested PASCAL-comments: | |
333 | // | |
334 | // { This is a { nested } PASCAL-comment } | |
335 | // | |
336 | /////////////////////////////////////////////////////////////////////////////// | |
337 | ||
338 | template<typename OpenT, typename CloseT> | |
339 | struct comment_nest_parser: | |
340 | public parser<comment_nest_parser<OpenT, CloseT> > | |
341 | { | |
342 | typedef comment_nest_parser<OpenT, CloseT> self_t; | |
343 | ||
344 | comment_nest_parser(OpenT const &open_, CloseT const &close_): | |
345 | open(open_), close(close_) | |
346 | {} | |
347 | ||
348 | template<typename ScannerT> | |
349 | typename parser_result<self_t, ScannerT>::type | |
350 | parse(ScannerT const &scan) const | |
351 | { | |
352 | return do_parse( | |
353 | open >> *(*this | (anychar_p - close)) >> close, | |
354 | scan); | |
355 | } | |
356 | ||
357 | private: | |
358 | template<typename ParserT, typename ScannerT> | |
359 | typename parser_result<self_t, ScannerT>::type | |
360 | do_parse(ParserT const &p, ScannerT const &scan) const | |
361 | { | |
362 | return | |
363 | impl::contiguous_parser_parse< | |
364 | typename parser_result<ParserT, ScannerT>::type | |
365 | >(p, scan, scan); | |
366 | } | |
367 | ||
368 | typename as_parser<OpenT>::type::embed_t open; | |
369 | typename as_parser<CloseT>::type::embed_t close; | |
370 | }; | |
371 | ||
372 | /////////////////////////////////////////////////////////////////////////////// | |
373 | // | |
374 | // Predefined nested comment parser generator | |
375 | // | |
376 | /////////////////////////////////////////////////////////////////////////////// | |
377 | ||
378 | template<typename OpenT, typename CloseT> | |
379 | struct comment_nest_p_result | |
380 | { | |
381 | typedef comment_nest_parser< | |
382 | typename as_parser<OpenT>::type, | |
383 | typename as_parser<CloseT>::type | |
384 | > type; | |
385 | }; | |
386 | ||
387 | template<typename OpenT, typename CloseT> | |
388 | inline typename comment_nest_p_result<OpenT,CloseT>::type | |
389 | comment_nest_p(OpenT const &open, CloseT const &close) | |
390 | { | |
391 | typedef typename comment_nest_p_result<OpenT,CloseT>::type | |
392 | result_t; | |
393 | ||
394 | return result_t( | |
395 | as_parser<OpenT>::convert(open), | |
396 | as_parser<CloseT>::convert(close) | |
397 | ); | |
398 | } | |
399 | ||
400 | /////////////////////////////////////////////////////////////////////////////// | |
401 | BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
402 | ||
403 | }} // namespace BOOST_SPIRIT_CLASSIC_NS | |
404 | ||
405 | #endif |