| /*============================================================================= |
| Copyright (c) 2002-2003 Joel de Guzman |
| Copyright (c) 2002-2003 Hartmut Kaiser |
| Copyright (c) 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) |
| =============================================================================*/ |
| #if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) |
| #define BOOST_SPIRIT_PARSER_TRAITS_HPP |
| |
| #include <boost/type_traits/is_base_and_derived.hpp> |
| #include <boost/static_assert.hpp> |
| |
| #include <boost/spirit/home/classic/namespace.hpp> |
| #include <boost/spirit/home/classic/core/parser.hpp> |
| #include <boost/spirit/home/classic/meta/impl/parser_traits.ipp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Parser traits templates |
| // |
| // Used to determine the type and several other characteristics of a given |
| // parser type. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The is_parser traits template can be used to tell wether a given |
| // class is a parser. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename T> |
| struct is_parser |
| { |
| BOOST_STATIC_CONSTANT(bool, value = |
| (::boost::is_base_and_derived<parser<T>, T>::value)); |
| |
| // [JDG 2/3/03] simplified implementation by |
| // using boost::is_base_and_derived |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The is_unary_composite traits template can be used to tell if a given |
| // parser is a unary parser as for instance kleene_star or optional. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename UnaryT> |
| struct is_unary_composite { |
| |
| BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< |
| typename UnaryT::parser_category_t, unary_parser_category>::value)); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The is_acction_parser traits template can be used to tell if a given |
| // parser is a action parser, i.e. it is a composite consisting of a |
| // auxilliary parser and an attached semantic action. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActionT> |
| struct is_action_parser { |
| |
| BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< |
| typename ActionT::parser_category_t, action_parser_category>::value)); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The is_binary_composite traits template can be used to tell if a given |
| // parser is a binary parser as for instance sequence or difference. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename BinaryT> |
| struct is_binary_composite { |
| |
| BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< |
| typename BinaryT::parser_category_t, binary_parser_category>::value)); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The is_composite_parser traits template can be used to tell if a given |
| // parser is a unary or a binary parser composite type. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename CompositeT> |
| struct is_composite_parser { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<CompositeT>::value || |
| ::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<CompositeT>::value)); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ParserT> |
| struct is_alternative { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_alternative)); |
| }; |
| |
| template <typename ParserT> |
| struct is_sequence { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequence)); |
| }; |
| |
| template <typename ParserT> |
| struct is_sequential_or { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequential_or)); |
| }; |
| |
| template <typename ParserT> |
| struct is_intersection { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_intersection)); |
| }; |
| |
| template <typename ParserT> |
| struct is_difference { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_difference)); |
| }; |
| |
| template <typename ParserT> |
| struct is_exclusive_or { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_exclusive_or)); |
| }; |
| |
| template <typename ParserT> |
| struct is_optional { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_optional)); |
| }; |
| |
| template <typename ParserT> |
| struct is_kleene_star { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_kleene_star)); |
| }; |
| |
| template <typename ParserT> |
| struct is_positive { |
| |
| BOOST_STATIC_CONSTANT(bool, value = ( |
| ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_positive)); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Parser extraction templates |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The unary_subject template can be used to return the type of the |
| // parser used as the subject of an unary parser. |
| // If the parser under inspection is not an unary type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename UnaryT> |
| struct unary_subject { |
| |
| BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value); |
| typedef typename UnaryT::subject_t type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The get_unary_subject template function returns the parser object, which |
| // is used as the subject of an unary parser. |
| // If the parser under inspection is not an unary type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename UnaryT> |
| inline typename unary_subject<UnaryT>::type const & |
| get_unary_subject(UnaryT const &unary_) |
| { |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value); |
| return unary_.subject(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The binary_left_subject and binary_right_subject templates can be used to |
| // return the types of the parsers used as the left and right subject of an |
| // binary parser. |
| // If the parser under inspection is not a binary type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename BinaryT> |
| struct binary_left_subject { |
| |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); |
| typedef typename BinaryT::left_t type; |
| }; |
| |
| template <typename BinaryT> |
| struct binary_right_subject { |
| |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); |
| typedef typename BinaryT::right_t type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The get_binary_left_subject and get_binary_right_subject template functions |
| // return the parser object, which is used as the left or right subject of a |
| // binary parser. |
| // If the parser under inspection is not a binary type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename BinaryT> |
| inline typename binary_left_subject<BinaryT>::type const & |
| get_binary_left_subject(BinaryT const &binary_) |
| { |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); |
| return binary_.left(); |
| } |
| |
| template <typename BinaryT> |
| inline typename binary_right_subject<BinaryT>::type const & |
| get_binary_right_subject(BinaryT const &binary_) |
| { |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value); |
| return binary_.right(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The action_subject template can be used to return the type of the |
| // parser used as the subject of an action parser. |
| // If the parser under inspection is not an action type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActionT> |
| struct action_subject { |
| |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); |
| typedef typename ActionT::subject_t type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The get_action_subject template function returns the parser object, which |
| // is used as the subject of an action parser. |
| // If the parser under inspection is not an action type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActionT> |
| inline typename action_subject<ActionT>::type const & |
| get_action_subject(ActionT const &action_) |
| { |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); |
| return action_.subject(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The semantic_action template can be used to return the type of the |
| // attached semantic action of an action parser. |
| // If the parser under inspection is not an action type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActionT> |
| struct semantic_action { |
| |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); |
| typedef typename ActionT::predicate_t type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The get_semantic_action template function returns the attached semantic |
| // action of an action parser. |
| // If the parser under inspection is not an action type parser the compilation |
| // will fail. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActionT> |
| inline typename semantic_action<ActionT>::type const & |
| get_semantic_action(ActionT const &action_) |
| { |
| BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value); |
| return action_.predicate(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace BOOST_SPIRIT_CLASSIC_NS |
| |
| #endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) |