mirror of
https://github.com/vdemydiuk/mtapi.git
synced 2026-08-22 07:08:16 +00:00
Added thirdparty: boost library
This commit is contained in:
Viacheslav Demydiuk
+229
@@ -0,0 +1,229 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2002-2003 Joel de Guzman
|
||||
Copyright (c) 2002 Juan Carlos Arevalo-Baeza
|
||||
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_IF_HPP
|
||||
#define BOOST_SPIRIT_IF_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 {
|
||||
|
||||
//////////////////////////////////
|
||||
// if-else-parser, holds two alternative parsers and a conditional functor
|
||||
// that selects between them.
|
||||
template <typename ParsableTrueT, typename ParsableFalseT, typename CondT>
|
||||
struct if_else_parser
|
||||
: public condition_evaluator<typename as_parser<CondT>::type>
|
||||
, public binary
|
||||
<
|
||||
typename as_parser<ParsableTrueT>::type,
|
||||
typename as_parser<ParsableFalseT>::type,
|
||||
parser< if_else_parser<ParsableTrueT, ParsableFalseT, CondT> >
|
||||
>
|
||||
{
|
||||
typedef if_else_parser<ParsableTrueT, ParsableFalseT, CondT> self_t;
|
||||
|
||||
typedef as_parser<ParsableTrueT> as_parser_true_t;
|
||||
typedef as_parser<ParsableFalseT> as_parser_false_t;
|
||||
typedef typename as_parser_true_t::type parser_true_t;
|
||||
typedef typename as_parser_false_t::type parser_false_t;
|
||||
typedef as_parser<CondT> cond_as_parser_t;
|
||||
typedef typename cond_as_parser_t::type condition_t;
|
||||
|
||||
typedef binary<parser_true_t, parser_false_t, parser<self_t> > base_t;
|
||||
typedef condition_evaluator<condition_t> eval_t;
|
||||
|
||||
if_else_parser
|
||||
(
|
||||
ParsableTrueT const& p_true,
|
||||
ParsableFalseT const& p_false,
|
||||
CondT const& cond_
|
||||
)
|
||||
: eval_t(cond_as_parser_t::convert(cond_))
|
||||
, base_t
|
||||
(
|
||||
as_parser_true_t::convert(p_true),
|
||||
as_parser_false_t::convert(p_false)
|
||||
)
|
||||
{ }
|
||||
|
||||
template <typename ScannerT>
|
||||
struct result
|
||||
{
|
||||
typedef typename match_result<ScannerT, nil_t>::type type;
|
||||
};
|
||||
|
||||
template <typename ScannerT>
|
||||
typename parser_result<self_t, ScannerT>::type
|
||||
parse(ScannerT const& scan) const
|
||||
{
|
||||
typedef typename parser_result
|
||||
<parser_true_t, ScannerT>::type then_result_t;
|
||||
typedef typename parser_result
|
||||
<parser_false_t, ScannerT>::type else_result_t;
|
||||
|
||||
typename ScannerT::iterator_t const save(scan.first);
|
||||
|
||||
std::ptrdiff_t length = this->evaluate(scan);
|
||||
if (length >= 0)
|
||||
{
|
||||
then_result_t then_result(this->left().parse(scan));
|
||||
if (then_result)
|
||||
{
|
||||
length += then_result.length();
|
||||
return scan.create_match(std::size_t(length), nil_t(), save, scan.first);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
else_result_t else_result(this->right().parse(scan));
|
||||
if (else_result)
|
||||
{
|
||||
length = else_result.length();
|
||||
return scan.create_match(std::size_t(length), nil_t(), save, scan.first);
|
||||
}
|
||||
}
|
||||
return scan.no_match();
|
||||
}
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
// if-else-parser generator, takes the false-parser in brackets
|
||||
// and returns the if-else-parser.
|
||||
template <typename ParsableTrueT, typename CondT>
|
||||
struct if_else_parser_gen
|
||||
{
|
||||
if_else_parser_gen(ParsableTrueT const& p_true_, CondT const& cond_)
|
||||
: p_true(p_true_)
|
||||
, cond(cond_) {}
|
||||
|
||||
template <typename ParsableFalseT>
|
||||
if_else_parser
|
||||
<
|
||||
ParsableTrueT,
|
||||
ParsableFalseT,
|
||||
CondT
|
||||
>
|
||||
operator[](ParsableFalseT const& p_false) const
|
||||
{
|
||||
return if_else_parser<ParsableTrueT, ParsableFalseT, CondT>
|
||||
(
|
||||
p_true,
|
||||
p_false,
|
||||
cond
|
||||
);
|
||||
}
|
||||
|
||||
ParsableTrueT const &p_true;
|
||||
CondT const &cond;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
// if-parser, conditionally runs a parser is a functor condition is true.
|
||||
// If the condition is false, it fails the parse.
|
||||
// It can optionally become an if-else-parser through the member else_p.
|
||||
template <typename ParsableT, typename CondT>
|
||||
struct if_parser
|
||||
: public condition_evaluator<typename as_parser<CondT>::type>
|
||||
, public unary
|
||||
<
|
||||
typename as_parser<ParsableT>::type,
|
||||
parser<if_parser<ParsableT, CondT> > >
|
||||
{
|
||||
typedef if_parser<ParsableT, CondT> 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 condition_evaluator<condition_t> eval_t;
|
||||
typedef unary<parser_t, parser<self_t> > base_t;
|
||||
|
||||
if_parser(ParsableT const& p, CondT const& cond_)
|
||||
: eval_t(cond_as_parser_t::convert(cond_))
|
||||
, base_t(as_parser_t::convert(p))
|
||||
, else_p(p, cond_)
|
||||
{}
|
||||
|
||||
template <typename ScannerT>
|
||||
struct result
|
||||
{
|
||||
typedef typename match_result<ScannerT, nil_t>::type type;
|
||||
};
|
||||
|
||||
template <typename ScannerT>
|
||||
typename parser_result<self_t, ScannerT>::type
|
||||
parse(ScannerT const& scan) const
|
||||
{
|
||||
typedef typename parser_result<parser_t, ScannerT>::type t_result_t;
|
||||
typename ScannerT::iterator_t const save(scan.first);
|
||||
|
||||
std::ptrdiff_t length = this->evaluate(scan);
|
||||
if (length >= 0)
|
||||
{
|
||||
t_result_t then_result(this->subject().parse(scan));
|
||||
if (then_result)
|
||||
{
|
||||
length += then_result.length();
|
||||
return scan.create_match(std::size_t(length), nil_t(), save, scan.first);
|
||||
}
|
||||
return scan.no_match();
|
||||
}
|
||||
return scan.empty_match();
|
||||
}
|
||||
|
||||
if_else_parser_gen<ParsableT, CondT> else_p;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
// if-parser generator, takes the true-parser in brackets and returns the
|
||||
// if-parser.
|
||||
template <typename CondT>
|
||||
struct if_parser_gen
|
||||
{
|
||||
if_parser_gen(CondT const& cond_) : cond(cond_) {}
|
||||
|
||||
template <typename ParsableT>
|
||||
if_parser
|
||||
<
|
||||
ParsableT,
|
||||
CondT
|
||||
>
|
||||
operator[](ParsableT const& subject) const
|
||||
{
|
||||
return if_parser<ParsableT, CondT>(subject, cond);
|
||||
}
|
||||
|
||||
CondT const &cond;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
//////////////////////////////////
|
||||
// if_p function, returns "if" parser generator
|
||||
|
||||
template <typename CondT>
|
||||
impl::if_parser_gen<CondT>
|
||||
if_p(CondT const& cond)
|
||||
{
|
||||
return impl::if_parser_gen<CondT>(cond);
|
||||
}
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace BOOST_SPIRIT_CLASSIC_NS
|
||||
|
||||
#endif // BOOST_SPIRIT_IF_HPP
|
||||
Reference in New Issue
Block a user