1/*=============================================================================
2 Copyright (c) 1998-2003 Joel de Guzman
3 Copyright (c) 2002 Raghavendra Satish
4 Copyright (c) 2002 Jeff Westfahl
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_LOOPS_HPP)
11#define BOOST_SPIRIT_LOOPS_HPP
12
13///////////////////////////////////////////////////////////////////////////////
14#include <boost/spirit/home/classic/namespace.hpp>
15#include <boost/spirit/home/classic/core/parser.hpp>
16#include <boost/spirit/home/classic/core/composite/composite.hpp>
17#include <boost/mpl/if.hpp>
18#include <boost/type_traits/is_same.hpp>
19
20///////////////////////////////////////////////////////////////////////////////
21namespace boost { namespace spirit {
22
23BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
24
25 ///////////////////////////////////////////////////////////////////////////
26 //
27 // fixed_loop class
28 //
29 // This class takes care of the construct:
30 //
31 // repeat_p (exact) [p]
32 //
33 // where 'p' is a parser and 'exact' is the number of times to
34 // repeat. The parser iterates over the input exactly 'exact' times.
35 // The parse function fails if the parser does not match the input
36 // exactly 'exact' times.
37 //
38 // This class is parametizable and can accept constant arguments
39 // (e.g. repeat_p (5) [p]) as well as references to variables (e.g.
40 // repeat_p (ref (n)) [p]).
41 //
42 ///////////////////////////////////////////////////////////////////////////
43 template <typename ParserT, typename ExactT>
44 class fixed_loop
45 : public unary<ParserT, parser <fixed_loop <ParserT, ExactT> > >
46 {
47 public:
48
49 typedef fixed_loop<ParserT, ExactT> self_t;
50 typedef unary<ParserT, parser<self_t> > base_t;
51
52 fixed_loop (ParserT const & subject_, ExactT const & exact)
53 : base_t(subject_), m_exact(exact) {}
54
55 template <typename ScannerT>
56 typename parser_result <self_t, ScannerT>::type
57 parse (ScannerT const & scan) const
58 {
59 typedef typename parser_result<self_t, ScannerT>::type result_t;
60 result_t hit = scan.empty_match();
61 std::size_t n = m_exact;
62
63 for (std::size_t i = 0; i < n; ++i)
64 {
65 if (result_t next = this->subject().parse(scan))
66 {
67 scan.concat_match(hit, next);
68 }
69 else
70 {
71 return scan.no_match();
72 }
73 }
74
75 return hit;
76 }
77
78 template <typename ScannerT>
79 struct result
80 {
81 typedef typename match_result<ScannerT, nil_t>::type type;
82 };
83
84 private:
85
86 ExactT m_exact;
87 };
88
89 ///////////////////////////////////////////////////////////////////////////////
90 //
91 // finite_loop class
92 //
93 // This class takes care of the construct:
94 //
95 // repeat_p (min, max) [p]
96 //
97 // where 'p' is a parser, 'min' and 'max' specifies the minimum and
98 // maximum iterations over 'p'. The parser iterates over the input
99 // at least 'min' times and at most 'max' times. The parse function
100 // fails if the parser does not match the input at least 'min' times
101 // and at most 'max' times.
102 //
103 // This class is parametizable and can accept constant arguments
104 // (e.g. repeat_p (5, 10) [p]) as well as references to variables
105 // (e.g. repeat_p (ref (n1), ref (n2)) [p]).
106 //
107 ///////////////////////////////////////////////////////////////////////////////
108 template <typename ParserT, typename MinT, typename MaxT>
109 class finite_loop
110 : public unary<ParserT, parser<finite_loop<ParserT, MinT, MaxT> > >
111 {
112 public:
113
114 typedef finite_loop <ParserT, MinT, MaxT> self_t;
115 typedef unary<ParserT, parser<self_t> > base_t;
116
117 finite_loop (ParserT const & subject_, MinT const & min, MaxT const & max)
118 : base_t(subject_), m_min(min), m_max(max) {}
119
120 template <typename ScannerT>
121 typename parser_result <self_t, ScannerT>::type
122 parse(ScannerT const & scan) const
123 {
124 BOOST_SPIRIT_ASSERT(m_min <= m_max);
125 typedef typename parser_result<self_t, ScannerT>::type result_t;
126 result_t hit = scan.empty_match();
127
128 std::size_t n1 = m_min;
129 std::size_t n2 = m_max;
130
131 for (std::size_t i = 0; i < n2; ++i)
132 {
133 typename ScannerT::iterator_t save = scan.first;
134 result_t next = this->subject().parse(scan);
135
136 if (!next)
137 {
138 if (i >= n1)
139 {
140 scan.first = save;
141 break;
142 }
143 else
144 {
145 return scan.no_match();
146 }
147 }
148
149 scan.concat_match(hit, next);
150 }
151
152 return hit;
153 }
154
155 template <typename ScannerT>
156 struct result
157 {
158 typedef typename match_result<ScannerT, nil_t>::type type;
159 };
160
161 private:
162
163 MinT m_min;
164 MaxT m_max;
165 };
166
167 ///////////////////////////////////////////////////////////////////////////////
168 //
169 // infinite_loop class
170 //
171 // This class takes care of the construct:
172 //
173 // repeat_p (min, more) [p]
174 //
175 // where 'p' is a parser, 'min' is the minimum iteration over 'p'
176 // and more specifies that the iteration should proceed
177 // indefinitely. The parser iterates over the input at least 'min'
178 // times and continues indefinitely until 'p' fails or all of the
179 // input is parsed. The parse function fails if the parser does not
180 // match the input at least 'min' times.
181 //
182 // This class is parametizable and can accept constant arguments
183 // (e.g. repeat_p (5, more) [p]) as well as references to variables
184 // (e.g. repeat_p (ref (n), more) [p]).
185 //
186 ///////////////////////////////////////////////////////////////////////////////
187
188 struct more_t {};
189 more_t const more = more_t ();
190
191 template <typename ParserT, typename MinT>
192 class infinite_loop
193 : public unary<ParserT, parser<infinite_loop<ParserT, MinT> > >
194 {
195 public:
196
197 typedef infinite_loop <ParserT, MinT> self_t;
198 typedef unary<ParserT, parser<self_t> > base_t;
199
200 infinite_loop (
201 ParserT const& subject_,
202 MinT const& min,
203 more_t const&
204 )
205 : base_t(subject_), m_min(min) {}
206
207 template <typename ScannerT>
208 typename parser_result <self_t, ScannerT>::type
209 parse(ScannerT const & scan) const
210 {
211 typedef typename parser_result<self_t, ScannerT>::type result_t;
212 result_t hit = scan.empty_match();
213 std::size_t n = m_min;
214
215 for (std::size_t i = 0; ; ++i)
216 {
217 typename ScannerT::iterator_t save = scan.first;
218 result_t next = this->subject().parse(scan);
219
220 if (!next)
221 {
222 if (i >= n)
223 {
224 scan.first = save;
225 break;
226 }
227 else
228 {
229 return scan.no_match();
230 }
231 }
232
233 scan.concat_match(hit, next);
234 }
235
236 return hit;
237 }
238
239 template <typename ScannerT>
240 struct result
241 {
242 typedef typename match_result<ScannerT, nil_t>::type type;
243 };
244
245 private:
246
247 MinT m_min;
248 };
249
250 template <typename ExactT>
251 struct fixed_loop_gen
252 {
253 fixed_loop_gen (ExactT const & exact)
254 : m_exact (exact) {}
255
256 template <typename ParserT>
257 fixed_loop <ParserT, ExactT>
258 operator[](parser <ParserT> const & subject_) const
259 {
260 return fixed_loop <ParserT, ExactT> (subject_.derived (), m_exact);
261 }
262
263 ExactT m_exact;
264 };
265
266 namespace impl {
267
268 template <typename ParserT, typename MinT, typename MaxT>
269 struct loop_traits
270 {
271 typedef typename mpl::if_<
272 boost::is_same<MaxT, more_t>,
273 infinite_loop<ParserT, MinT>,
274 finite_loop<ParserT, MinT, MaxT>
275 >::type type;
276 };
277
278 } // namespace impl
279
280 template <typename MinT, typename MaxT>
281 struct nonfixed_loop_gen
282 {
283 nonfixed_loop_gen (MinT min, MaxT max)
284 : m_min (min), m_max (max) {}
285
286 template <typename ParserT>
287 typename impl::loop_traits<ParserT, MinT, MaxT>::type
288 operator[](parser <ParserT> const & subject_) const
289 {
290 typedef typename impl::loop_traits<ParserT, MinT, MaxT>::type ret_t;
291 return ret_t(
292 subject_.derived(),
293 m_min,
294 m_max);
295 }
296
297 MinT m_min;
298 MaxT m_max;
299 };
300
301 template <typename ExactT>
302 fixed_loop_gen <ExactT>
303 repeat_p(ExactT const & exact)
304 {
305 return fixed_loop_gen <ExactT> (exact);
306 }
307
308 template <typename MinT, typename MaxT>
309 nonfixed_loop_gen <MinT, MaxT>
310 repeat_p(MinT const & min, MaxT const & max)
311 {
312 return nonfixed_loop_gen <MinT, MaxT> (min, max);
313 }
314
315BOOST_SPIRIT_CLASSIC_NAMESPACE_END
316
317}} // namespace BOOST_SPIRIT_CLASSIC_NS
318
319#endif // #if !defined(BOOST_SPIRIT_LOOPS_HPP)
320

source code of boost/libs/spirit/include/boost/spirit/home/classic/utility/loops.hpp