/*=============================================================================
|
Copyright (c) 2002-2003 Joel de Guzman
|
Copyright (c) 2002-2003 Hartmut Kaiser
|
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_SUBRULE_HPP)
|
#define BOOST_SPIRIT_SUBRULE_HPP
|
|
#include <boost/config.hpp>
|
#include <boost/static_assert.hpp>
|
#include <boost/mpl/if.hpp>
|
#include <boost/mpl/bool.hpp>
|
#include <boost/type_traits/is_same.hpp>
|
|
#include <boost/spirit/home/classic/namespace.hpp>
|
#include <boost/spirit/home/classic/core/parser.hpp>
|
#include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp>
|
|
#include <boost/spirit/home/classic/core/non_terminal/subrule_fwd.hpp>
|
#include <boost/spirit/home/classic/core/non_terminal/impl/subrule.ipp>
|
|
namespace boost { namespace spirit {
|
|
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
|
///////////////////////////////////////////////////////////////////////////
|
//
|
// subrules_scanner class
|
//
|
///////////////////////////////////////////////////////////////////////////
|
template <typename ScannerT, typename ListT>
|
struct subrules_scanner : public ScannerT
|
{
|
typedef ScannerT scanner_t;
|
typedef ListT list_t;
|
typedef subrules_scanner<ScannerT, ListT> self_t;
|
|
subrules_scanner(ScannerT const& scan, ListT const& list_)
|
: ScannerT(scan), list(list_) {}
|
|
template <typename PoliciesT>
|
struct rebind_policies
|
{
|
typedef typename rebind_scanner_policies<ScannerT, PoliciesT>::type
|
rebind_scanner;
|
typedef subrules_scanner<rebind_scanner, ListT> type;
|
};
|
|
template <typename PoliciesT>
|
subrules_scanner<
|
typename rebind_scanner_policies<ScannerT, PoliciesT>::type,
|
ListT>
|
change_policies(PoliciesT const& policies) const
|
{
|
typedef subrules_scanner<
|
BOOST_DEDUCED_TYPENAME
|
rebind_scanner_policies<ScannerT, PoliciesT>::type,
|
ListT>
|
subrules_scanner_t;
|
|
return subrules_scanner_t(
|
ScannerT::change_policies(policies),
|
list);
|
}
|
|
template <typename IteratorT>
|
struct rebind_iterator
|
{
|
typedef typename rebind_scanner_iterator<ScannerT, IteratorT>::type
|
rebind_scanner;
|
typedef subrules_scanner<rebind_scanner, ListT> type;
|
};
|
|
template <typename IteratorT>
|
subrules_scanner<
|
typename rebind_scanner_iterator<ScannerT, IteratorT>::type,
|
ListT>
|
change_iterator(IteratorT const& first, IteratorT const &last) const
|
{
|
typedef subrules_scanner<
|
BOOST_DEDUCED_TYPENAME
|
rebind_scanner_iterator<ScannerT, IteratorT>::type,
|
ListT>
|
subrules_scanner_t;
|
|
return subrules_scanner_t(
|
ScannerT::change_iterator(first, last),
|
list);
|
}
|
|
ListT const& list;
|
};
|
|
///////////////////////////////////////////////////////////////////////////
|
//
|
// subrule_scanner type computer class
|
//
|
// This computer ensures that the scanner will not be recursively
|
// instantiated if it's not needed.
|
//
|
///////////////////////////////////////////////////////////////////////////
|
template <typename ScannerT, typename ListT>
|
struct subrules_scanner_finder
|
{
|
typedef subrules_scanner<ScannerT, ListT> type;
|
};
|
|
template <typename ScannerT, typename ListT>
|
struct subrules_scanner_finder<subrules_scanner<ScannerT, ListT>, ListT>
|
{
|
typedef subrules_scanner<ScannerT, ListT> type;
|
};
|
|
///////////////////////////////////////////////////////////////////////////
|
//
|
// subrule_list class
|
//
|
///////////////////////////////////////////////////////////////////////////
|
template <typename FirstT, typename RestT>
|
struct subrule_list : public parser<subrule_list<FirstT, RestT> >
|
{
|
typedef subrule_list<FirstT, RestT> self_t;
|
typedef FirstT first_t;
|
typedef RestT rest_t;
|
|
subrule_list(FirstT const& first_, RestT const& rest_)
|
: first(first_), rest(rest_) {}
|
|
template <typename ScannerT>
|
struct result
|
{
|
typedef typename parser_result<FirstT, ScannerT>::type type;
|
};
|
|
template <typename ScannerT>
|
typename parser_result<self_t, ScannerT>::type
|
parse(ScannerT const& scan) const
|
{
|
typedef typename subrules_scanner_finder<ScannerT, self_t>::type
|
subrules_scanner_t;
|
subrules_scanner_t g_arg(scan, *this);
|
return first.start.parse(g_arg);
|
}
|
|
template <int ID, typename DefT, typename ContextT>
|
subrule_list<
|
FirstT,
|
subrule_list<
|
subrule_parser<ID, DefT, ContextT>,
|
RestT> >
|
operator,(subrule_parser<ID, DefT, ContextT> const& rhs_)
|
{
|
return subrule_list<
|
FirstT,
|
subrule_list<
|
subrule_parser<ID, DefT, ContextT>,
|
RestT> >(
|
first,
|
subrule_list<
|
subrule_parser<ID, DefT, ContextT>,
|
RestT>(rhs_, rest));
|
}
|
|
FirstT first;
|
RestT rest;
|
};
|
|
///////////////////////////////////////////////////////////////////////////
|
//
|
// subrule_parser class
|
//
|
///////////////////////////////////////////////////////////////////////////
|
template <int ID, typename DefT, typename ContextT>
|
struct subrule_parser
|
: public parser<subrule_parser<ID, DefT, ContextT> >
|
{
|
typedef subrule_parser<ID, DefT, ContextT> self_t;
|
typedef subrule<ID, ContextT> subrule_t;
|
typedef DefT def_t;
|
|
BOOST_STATIC_CONSTANT(int, id = ID);
|
|
template <typename ScannerT>
|
struct result
|
{
|
typedef typename
|
impl::get_subrule_parser_result<
|
DefT, ScannerT, typename subrule_t::attr_t>::type type;
|
};
|
|
subrule_parser(subrule_t const& start_, DefT const& rhs_)
|
: rhs(rhs_), start(start_) {}
|
|
template <typename ScannerT>
|
typename parser_result<self_t, ScannerT>::type
|
parse(ScannerT const& scan) const
|
{
|
// This will only be called when parsing single subrules.
|
typedef subrule_list<self_t, nil_t> list_t;
|
typedef subrules_scanner<ScannerT, list_t> scanner_t;
|
|
list_t list(*this, nil_t());
|
scanner_t g_arg(scan, list);
|
return start.parse(g_arg);
|
}
|
|
template <int ID2, typename DefT2, typename ContextT2>
|
inline subrule_list<
|
self_t,
|
subrule_list<
|
subrule_parser<ID2, DefT2, ContextT2>,
|
nil_t> >
|
operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
|
{
|
return subrule_list<
|
self_t,
|
subrule_list<
|
subrule_parser<ID2, DefT2, ContextT2>,
|
nil_t> >(
|
*this,
|
subrule_list<
|
subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
|
rhs, nil_t()));
|
}
|
|
typename DefT::embed_t rhs;
|
subrule_t const& start;
|
};
|
|
///////////////////////////////////////////////////////////////////////////
|
//
|
// subrule class
|
//
|
///////////////////////////////////////////////////////////////////////////
|
template <int ID, typename ContextT>
|
struct subrule
|
: public parser<subrule<ID, ContextT> >
|
, public ContextT::base_t
|
, public context_aux<ContextT, subrule<ID, ContextT> >
|
{
|
typedef subrule<ID, ContextT> self_t;
|
typedef subrule<ID, ContextT> const& embed_t;
|
|
typedef typename ContextT::context_linker_t context_t;
|
typedef typename context_t::attr_t attr_t;
|
|
BOOST_STATIC_CONSTANT(int, id = ID);
|
|
template <typename ScannerT>
|
struct result
|
{
|
typedef typename
|
impl::get_subrule_result<ID, ScannerT, attr_t>::type type;
|
};
|
|
template <typename ScannerT>
|
typename parser_result<self_t, ScannerT>::type
|
parse_main(ScannerT const& scan) const
|
{
|
typedef typename parser_result<self_t, ScannerT>::type result_t;
|
result_t result_;
|
impl::parse_subrule<result_t, ScannerT, ID>::
|
do_(result_, scan);
|
return result_;
|
}
|
|
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;
|
typedef parser_scanner_linker<ScannerT> scanner_t;
|
BOOST_SPIRIT_CONTEXT_PARSE(
|
scan, *this, scanner_t, context_t, result_t);
|
}
|
|
template <typename DefT>
|
subrule_parser<ID, DefT, ContextT>
|
operator=(parser<DefT> const& rhs) const
|
{
|
return subrule_parser<ID, DefT, ContextT>(*this, rhs.derived());
|
}
|
|
private:
|
|
// assignment of subrules is not allowed. Use subrules
|
// with identical IDs if you want to have aliases.
|
|
subrule& operator=(subrule const&);
|
|
template <int ID2, typename ContextT2>
|
subrule& operator=(subrule<ID2, ContextT2> const&);
|
};
|
|
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
|
}} // namespace BOOST_SPIRIT_CLASSIC_NS
|
|
#endif
|
