boost/spirit/home/classic/dynamic/while.hpp
/*=============================================================================
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
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)
=============================================================================*/
#ifndef BOOST_SPIRIT_WHILE_HPP
#define BOOST_SPIRIT_WHILE_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>
#include <boost/spirit/home/classic/dynamic/impl/conditions.ipp>
////////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
namespace impl {
//////////////////////////////////
// while parser
// object are created by while_parser_gen and do_parser_gen
template <typename ParsableT, typename CondT, bool is_do_parser>
struct while_parser
: public condition_evaluator< typename as_parser<CondT>::type >
, public unary // the parent stores a copy of the body parser
<
typename as_parser<ParsableT>::type,
parser<while_parser<ParsableT, CondT, is_do_parser> >
>
{
typedef while_parser<ParsableT, CondT, is_do_parser> self_t;
typedef as_parser<ParsableT> as_parser_t;
typedef typename as_parser_t::type parser_t;
typedef as_parser<CondT> cond_as_parser_t;
typedef typename cond_as_parser_t::type condition_t;
typedef unary<parser_t, parser<self_t> > base_t;
typedef condition_evaluator<condition_t> eval_t;
//////////////////////////////
// constructor, saves condition and body parser
while_parser(ParsableT const &body, CondT const &cond)
: eval_t(cond_as_parser_t::convert(cond))
, base_t(as_parser_t::convert(body))
{}
//////////////////////////////
// result type computer.
template <typename ScannerT>
struct result
{
typedef typename match_result
<ScannerT, nil_t>::type type;
};
//////////////////////////////
// parse member function
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<parser_t, ScannerT>::type sresult_t;
typedef typename ScannerT::iterator_t iterator_t;
iterator_t save(scan.first);
std::size_t length = 0;
int eval_length = 0;
bool dont_check_condition = is_do_parser;
while (dont_check_condition || (eval_length=this->evaluate(scan))>=0)
{
dont_check_condition = false;
length += eval_length;
sresult_t tmp(this->subject().parse(scan));
if (tmp)
{
length+=tmp.length();
}
else
{
return scan.no_match();
}
}
return scan.create_match(length, nil_t(), save, scan.first);
}
};
//////////////////////////////////
// while-parser generator, takes the body-parser in brackets
// and returns the actual while-parser.
template <typename CondT>
struct while_parser_gen
{
//////////////////////////////
// constructor, saves the condition for use by operator[]
while_parser_gen(CondT const& cond_) : cond(cond_) {}
//////////////////////////////
// operator[] returns the actual while-parser object
template <typename ParsableT>
while_parser<ParsableT, CondT, false>
operator[](ParsableT const &subject) const
{
return while_parser<ParsableT, CondT, false>(subject, cond);
}
private:
//////////////////////////////
// the condition is stored by reference here.
// this should not cause any harm since object of type
// while_parser_gen<> are only used as temporaries
// the while-parser object constructed by the operator[]
// stores a copy of the condition.
CondT const &cond;
};
//////////////////////////////////
// do-while-parser generator, takes the condition as
// parameter to while_p member function and returns the
// actual do-while-parser.
template <typename ParsableT>
struct do_while_parser_gen
{
//////////////////////////////
// constructor. saves the body parser for use by while_p.
explicit do_while_parser_gen(ParsableT const &body_parser)
: body(body_parser)
{}
//////////////////////////////
// while_p returns the actual while-parser object
template <typename CondT>
while_parser<ParsableT, CondT, true>
while_p(CondT cond) const
{
return while_parser<ParsableT, CondT, true>(body, cond);
}
private:
//////////////////////////////
// the body is stored by reference here
// this should not cause any harm since object of type
// do_while_parser_gen<> are only used as temporaries
// the while-parser object constructed by the while_p
// member function stores a copy of the body parser.
ParsableT const &body;
};
struct do_parser_gen
{
inline do_parser_gen() {}
template <typename ParsableT>
impl::do_while_parser_gen<ParsableT>
operator[](ParsableT const& body) const
{
return impl::do_while_parser_gen<ParsableT>(body);
}
};
} // namespace impl
//////////////////////////////////
// while_p function, while-parser generator
// Usage: spirit::while_p(Condition)[Body]
template <typename CondT>
impl::while_parser_gen<CondT>
while_p(CondT const& cond)
{
return impl::while_parser_gen<CondT>(cond);
}
//////////////////////////////////
// do_p functor, do-while-parser generator
// Usage: spirit::do_p[Body].while_p(Condition)
impl::do_parser_gen const do_p = impl::do_parser_gen();
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
}} // namespace BOOST_SPIRIT_CLASSIC_NS
#endif // BOOST_SPIRIT_WHILE_HPP
