You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
317 lines
9.7 KiB
317 lines
9.7 KiB
/*============================================================================= |
|
Copyright (c) 1998-2003 Joel de Guzman |
|
Copyright (c) 2002 Raghavendra Satish |
|
Copyright (c) 2002 Jeff Westfahl |
|
http://spirit.sourceforge.net/ |
|
|
|
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) |
|
=============================================================================*/ |
|
#if !defined(BOOST_SPIRIT_LOOPS_HPP) |
|
#define BOOST_SPIRIT_LOOPS_HPP |
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
#include <boost/spirit/home/classic/namespace.hpp> |
|
#include <boost/spirit/home/classic/core/parser.hpp> |
|
#include <boost/spirit/home/classic/core/composite/composite.hpp> |
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
namespace boost { namespace spirit { |
|
|
|
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
|
|
|
/////////////////////////////////////////////////////////////////////////// |
|
// |
|
// fixed_loop class |
|
// |
|
// This class takes care of the construct: |
|
// |
|
// repeat_p (exact) [p] |
|
// |
|
// where 'p' is a parser and 'exact' is the number of times to |
|
// repeat. The parser iterates over the input exactly 'exact' times. |
|
// The parse function fails if the parser does not match the input |
|
// exactly 'exact' times. |
|
// |
|
// This class is parametizable and can accept constant arguments |
|
// (e.g. repeat_p (5) [p]) as well as references to variables (e.g. |
|
// repeat_p (ref (n)) [p]). |
|
// |
|
/////////////////////////////////////////////////////////////////////////// |
|
template <typename ParserT, typename ExactT> |
|
class fixed_loop |
|
: public unary<ParserT, parser <fixed_loop <ParserT, ExactT> > > |
|
{ |
|
public: |
|
|
|
typedef fixed_loop<ParserT, ExactT> self_t; |
|
typedef unary<ParserT, parser<self_t> > base_t; |
|
|
|
fixed_loop (ParserT const & subject_, ExactT const & exact) |
|
: base_t(subject_), m_exact(exact) {} |
|
|
|
template <typename ScannerT> |
|
typename parser_result <self_t, ScannerT>::type |
|
parse (ScannerT const & scan) const |
|
{ |
|
typedef typename parser_result<self_t, ScannerT>::type result_t; |
|
result_t hit = scan.empty_match(); |
|
std::size_t n = m_exact; |
|
|
|
for (std::size_t i = 0; i < n; ++i) |
|
{ |
|
if (result_t next = this->subject().parse(scan)) |
|
{ |
|
scan.concat_match(hit, next); |
|
} |
|
else |
|
{ |
|
return scan.no_match(); |
|
} |
|
} |
|
|
|
return hit; |
|
} |
|
|
|
template <typename ScannerT> |
|
struct result |
|
{ |
|
typedef typename match_result<ScannerT, nil_t>::type type; |
|
}; |
|
|
|
private: |
|
|
|
ExactT m_exact; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// finite_loop class |
|
// |
|
// This class takes care of the construct: |
|
// |
|
// repeat_p (min, max) [p] |
|
// |
|
// where 'p' is a parser, 'min' and 'max' specifies the minimum and |
|
// maximum iterations over 'p'. The parser iterates over the input |
|
// at least 'min' times and at most 'max' times. The parse function |
|
// fails if the parser does not match the input at least 'min' times |
|
// and at most 'max' times. |
|
// |
|
// This class is parametizable and can accept constant arguments |
|
// (e.g. repeat_p (5, 10) [p]) as well as references to variables |
|
// (e.g. repeat_p (ref (n1), ref (n2)) [p]). |
|
// |
|
/////////////////////////////////////////////////////////////////////////////// |
|
template <typename ParserT, typename MinT, typename MaxT> |
|
class finite_loop |
|
: public unary<ParserT, parser<finite_loop<ParserT, MinT, MaxT> > > |
|
{ |
|
public: |
|
|
|
typedef finite_loop <ParserT, MinT, MaxT> self_t; |
|
typedef unary<ParserT, parser<self_t> > base_t; |
|
|
|
finite_loop (ParserT const & subject_, MinT const & min, MaxT const & max) |
|
: base_t(subject_), m_min(min), m_max(max) {} |
|
|
|
template <typename ScannerT> |
|
typename parser_result <self_t, ScannerT>::type |
|
parse(ScannerT const & scan) const |
|
{ |
|
BOOST_SPIRIT_ASSERT(m_min <= m_max); |
|
typedef typename parser_result<self_t, ScannerT>::type result_t; |
|
result_t hit = scan.empty_match(); |
|
|
|
std::size_t n1 = m_min; |
|
std::size_t n2 = m_max; |
|
|
|
for (std::size_t i = 0; i < n2; ++i) |
|
{ |
|
typename ScannerT::iterator_t save = scan.first; |
|
result_t next = this->subject().parse(scan); |
|
|
|
if (!next) |
|
{ |
|
if (i >= n1) |
|
{ |
|
scan.first = save; |
|
break; |
|
} |
|
else |
|
{ |
|
return scan.no_match(); |
|
} |
|
} |
|
|
|
scan.concat_match(hit, next); |
|
} |
|
|
|
return hit; |
|
} |
|
|
|
template <typename ScannerT> |
|
struct result |
|
{ |
|
typedef typename match_result<ScannerT, nil_t>::type type; |
|
}; |
|
|
|
private: |
|
|
|
MinT m_min; |
|
MaxT m_max; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// infinite_loop class |
|
// |
|
// This class takes care of the construct: |
|
// |
|
// repeat_p (min, more) [p] |
|
// |
|
// where 'p' is a parser, 'min' is the minimum iteration over 'p' |
|
// and more specifies that the iteration should proceed |
|
// indefinitely. The parser iterates over the input at least 'min' |
|
// times and continues indefinitely until 'p' fails or all of the |
|
// input is parsed. The parse function fails if the parser does not |
|
// match the input at least 'min' times. |
|
// |
|
// This class is parametizable and can accept constant arguments |
|
// (e.g. repeat_p (5, more) [p]) as well as references to variables |
|
// (e.g. repeat_p (ref (n), more) [p]). |
|
// |
|
/////////////////////////////////////////////////////////////////////////////// |
|
|
|
struct more_t {}; |
|
more_t const more = more_t (); |
|
|
|
template <typename ParserT, typename MinT> |
|
class infinite_loop |
|
: public unary<ParserT, parser<infinite_loop<ParserT, MinT> > > |
|
{ |
|
public: |
|
|
|
typedef infinite_loop <ParserT, MinT> self_t; |
|
typedef unary<ParserT, parser<self_t> > base_t; |
|
|
|
infinite_loop ( |
|
ParserT const& subject_, |
|
MinT const& min, |
|
more_t const& |
|
) |
|
: base_t(subject_), m_min(min) {} |
|
|
|
template <typename ScannerT> |
|
typename parser_result <self_t, ScannerT>::type |
|
parse(ScannerT const & scan) const |
|
{ |
|
typedef typename parser_result<self_t, ScannerT>::type result_t; |
|
result_t hit = scan.empty_match(); |
|
std::size_t n = m_min; |
|
|
|
for (std::size_t i = 0; ; ++i) |
|
{ |
|
typename ScannerT::iterator_t save = scan.first; |
|
result_t next = this->subject().parse(scan); |
|
|
|
if (!next) |
|
{ |
|
if (i >= n) |
|
{ |
|
scan.first = save; |
|
break; |
|
} |
|
else |
|
{ |
|
return scan.no_match(); |
|
} |
|
} |
|
|
|
scan.concat_match(hit, next); |
|
} |
|
|
|
return hit; |
|
} |
|
|
|
template <typename ScannerT> |
|
struct result |
|
{ |
|
typedef typename match_result<ScannerT, nil_t>::type type; |
|
}; |
|
|
|
private: |
|
|
|
MinT m_min; |
|
}; |
|
|
|
template <typename ExactT> |
|
struct fixed_loop_gen |
|
{ |
|
fixed_loop_gen (ExactT const & exact) |
|
: m_exact (exact) {} |
|
|
|
template <typename ParserT> |
|
fixed_loop <ParserT, ExactT> |
|
operator[](parser <ParserT> const & subject_) const |
|
{ |
|
return fixed_loop <ParserT, ExactT> (subject_.derived (), m_exact); |
|
} |
|
|
|
ExactT m_exact; |
|
}; |
|
|
|
namespace impl { |
|
|
|
template <typename ParserT, typename MinT, typename MaxT> |
|
struct loop_traits |
|
{ |
|
typedef typename mpl::if_< |
|
boost::is_same<MaxT, more_t>, |
|
infinite_loop<ParserT, MinT>, |
|
finite_loop<ParserT, MinT, MaxT> |
|
>::type type; |
|
}; |
|
|
|
} // namespace impl |
|
|
|
template <typename MinT, typename MaxT> |
|
struct nonfixed_loop_gen |
|
{ |
|
nonfixed_loop_gen (MinT min, MaxT max) |
|
: m_min (min), m_max (max) {} |
|
|
|
template <typename ParserT> |
|
typename impl::loop_traits<ParserT, MinT, MaxT>::type |
|
operator[](parser <ParserT> const & subject_) const |
|
{ |
|
typedef typename impl::loop_traits<ParserT, MinT, MaxT>::type ret_t; |
|
return ret_t( |
|
subject_.derived(), |
|
m_min, |
|
m_max); |
|
} |
|
|
|
MinT m_min; |
|
MaxT m_max; |
|
}; |
|
|
|
template <typename ExactT> |
|
fixed_loop_gen <ExactT> |
|
repeat_p(ExactT const & exact) |
|
{ |
|
return fixed_loop_gen <ExactT> (exact); |
|
} |
|
|
|
template <typename MinT, typename MaxT> |
|
nonfixed_loop_gen <MinT, MaxT> |
|
repeat_p(MinT const & min, MaxT const & max) |
|
{ |
|
return nonfixed_loop_gen <MinT, MaxT> (min, max); |
|
} |
|
|
|
BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
|
|
|
}} // namespace BOOST_SPIRIT_CLASSIC_NS |
|
|
|
#endif // #if !defined(BOOST_SPIRIT_LOOPS_HPP)
|
|
|