boost/spirit/home/classic/meta/traverse.hpp
/*=============================================================================
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_TRAVERSE_HPP)
#define BOOST_SPIRIT_TRAVERSE_HPP
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/meta/impl/traverse.ipp>
namespace boost { namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////
//
// Post-order traversal of auxilliary parsers.
//
///////////////////////////////////////////////////////////////////////////
struct post_order
{
// Return the parser type, which is generated as the result of the
// traverse function below.
template <typename MetaT, typename ParserT>
struct result
{
typedef typename
traverse_post_order_return<
MetaT
, ParserT
, traverse_post_order_env<0, 0, 0, 0>
>::type
type;
};
// Traverse a given parser and refactor it with the help of the given
// MetaT metafunction template.
template <typename MetaT, typename ParserT>
static typename result<MetaT, ParserT>::type
traverse(MetaT const &meta_, ParserT const &parser_)
{
typedef typename ParserT::parser_category_t parser_category_t;
return impl::traverse_post_order<parser_category_t>::generate(
meta_, parser_, traverse_post_order_env<0, 0, 0, 0>());
}
};
///////////////////////////////////////////////////////////////////////////
//
// Transform policies
//
// The following policy classes could be used to assemble some new
// transformation metafunction which uses identity transformations
// for some parser_category type parsers.
//
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// transform plain parsers
template <typename TransformT>
struct plain_identity_policy
{
template <typename ParserT, typename EnvT>
struct plain_result
{
// plain parsers should be embedded and returned correctly
typedef typename ParserT::embed_t type;
};
template <typename ParserT, typename EnvT>
typename parser_traversal_plain_result<TransformT, ParserT, EnvT>::type
generate_plain(ParserT const &parser_, EnvT const& /*env*/) const
{
return parser_;
}
};
//////////////////////////////////
// transform unary parsers
template <typename UnaryT, typename SubjectT>
struct unary_identity_policy_return
{
typedef typename UnaryT::parser_generator_t parser_generator_t;
typedef typename parser_generator_t
::template result<SubjectT>::type type;
};
template <typename TransformT>
struct unary_identity_policy
{
template <typename UnaryT, typename SubjectT, typename EnvT>
struct unary_result
{
typedef
typename unary_identity_policy_return<UnaryT, SubjectT>::type
type;
};
template <typename UnaryT, typename SubjectT, typename EnvT>
typename parser_traversal_unary_result<
TransformT, UnaryT, SubjectT, EnvT>::type
generate_unary(
UnaryT const &, SubjectT const &subject_, EnvT const& /*env*/) const
{
typedef typename UnaryT::parser_generator_t parser_generator_t;
return parser_generator_t::template generate<SubjectT>(subject_);
}
};
//////////////////////////////////
// transform action parsers
template <typename TransformT>
struct action_identity_policy
{
template <typename ActionT, typename SubjectT, typename EnvT>
struct action_result
{
typedef action<SubjectT, typename ActionT::predicate_t> type;
};
template <typename ActionT, typename SubjectT, typename EnvT>
typename parser_traversal_action_result<
TransformT, ActionT, SubjectT, EnvT
>::type
generate_action(ActionT const &action_, SubjectT const &subject_,
EnvT const& /*env*/) const
{
return subject_[action_.predicate()];
}
};
//////////////////////////////////
// transform binary parsers
template <typename BinaryT, typename LeftT, typename RightT>
struct binary_identity_policy_return
{
typedef typename BinaryT::parser_generator_t parser_generator_t;
typedef typename parser_generator_t
::template result<LeftT, RightT>::type type;
};
template <typename TransformT>
struct binary_identity_policy
{
template <typename BinaryT, typename LeftT
, typename RightT, typename EnvT>
struct binary_result {
typedef typename
binary_identity_policy_return<BinaryT, LeftT, RightT>::type
type;
};
template <typename BinaryT, typename LeftT
, typename RightT, typename EnvT>
typename parser_traversal_binary_result<
TransformT, BinaryT, LeftT, RightT, EnvT
>::type
generate_binary(
BinaryT const &, LeftT const& left_
, RightT const& right_, EnvT const& /*env*/) const
{
typedef typename BinaryT::parser_generator_t parser_generator_t;
return parser_generator_t::
template generate<LeftT, RightT>(left_, right_);
}
};
///////////////////////////////////////////////////////////////////////////
//
// transform_policies template
//
// The transform_policies template metafunction could serve as a
// base class for new metafunctions to be passed to the traverse meta
// template (see above), where only minimal parts have to be
// overwritten.
//
///////////////////////////////////////////////////////////////////////////
template <
typename TransformT,
typename PlainPolicyT = plain_identity_policy<TransformT>,
typename UnaryPolicyT = unary_identity_policy<TransformT>,
typename ActionPolicyT = action_identity_policy<TransformT>,
typename BinaryPolicyT = binary_identity_policy<TransformT>
>
struct transform_policies :
public PlainPolicyT,
public UnaryPolicyT,
public ActionPolicyT,
public BinaryPolicyT
{
};
///////////////////////////////////////////////////////////////////////////
//
// Identity transformation
//
// The identity_transform metafunction supplied to the traverse
// template will generate a new parser, which will be exactly
// identical to the parser given as the parameter to the traverse
// metafunction. I.e. the following conceptual 'equation' will be
// always true:
//
// some_parser ==
// post_order::traverse(identity_transform(), some_parser)
//
///////////////////////////////////////////////////////////////////////////
struct identity_transform : transform_policies<identity_transform> {};
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
}} // namespace BOOST_SPIRIT_CLASSIC_NS
#endif // !defined(BOOST_SPIRIT_TRAVERSE_HPP)
