| /*============================================================================= |
| Copyright (c) 2002-2003 Hartmut Kaiser |
| http://spirit.sourceforge.net/ |
| |
| Use, modification and distribution is subject to 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_FUNDAMENTAL_IPP) |
| #define BOOST_SPIRIT_FUNDAMENTAL_IPP |
| |
| #include <boost/mpl/int.hpp> |
| |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) |
| BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(count_wrapper, count); |
| #endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) |
| |
| namespace impl |
| { |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Helper template for counting the number of nodes contained in a |
| // given parser type. |
| // All parser_category type parsers are counted as nodes. |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template <typename CategoryT> |
| struct nodes; |
| |
| template <> |
| struct nodes<plain_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (LeafCountT::value + 1) }; |
| }; |
| }; |
| |
| #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) |
| |
| template <> |
| struct nodes<unary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| typedef nodes<subject_category_t> nodes_t; |
| typedef typename count_wrapper<nodes_t> |
| ::template result_<subject_t, LeafCountT> count_t; |
| |
| BOOST_STATIC_CONSTANT(int, value = count_t::value + 1); |
| }; |
| }; |
| |
| template <> |
| struct nodes<action_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| typedef nodes<subject_category_t> nodes_t; |
| typedef typename count_wrapper<nodes_t> |
| ::template result_<subject_t, LeafCountT> count_t; |
| |
| BOOST_STATIC_CONSTANT(int, value = count_t::value + 1); |
| }; |
| }; |
| |
| template <> |
| struct nodes<binary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::left_t left_t; |
| typedef typename ParserT::right_t right_t; |
| typedef typename left_t::parser_category_t left_category_t; |
| typedef typename right_t::parser_category_t right_category_t; |
| |
| typedef nodes<left_category_t> left_nodes_t; |
| typedef typename count_wrapper<left_nodes_t> |
| ::template result_<left_t, LeafCountT> left_count_t; |
| |
| typedef nodes<right_category_t> right_nodes_t; |
| typedef typename count_wrapper<right_nodes_t> |
| ::template result_<right_t, LeafCountT> right_count_t; |
| |
| BOOST_STATIC_CONSTANT(int, |
| value = (left_count_t::value + right_count_t::value + 1)); |
| }; |
| }; |
| |
| #else |
| |
| template <> |
| struct nodes<unary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (nodes<subject_category_t> |
| ::template count<subject_t, LeafCountT>::value + 1) }; |
| }; |
| }; |
| |
| template <> |
| struct nodes<action_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (nodes<subject_category_t> |
| ::template count<subject_t, LeafCountT>::value + 1) }; |
| }; |
| }; |
| |
| template <> |
| struct nodes<binary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::left_t left_t; |
| typedef typename ParserT::right_t right_t; |
| typedef typename left_t::parser_category_t left_category_t; |
| typedef typename right_t::parser_category_t right_category_t; |
| |
| typedef count self_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { |
| leftcount = (nodes<left_category_t> |
| ::template count<left_t, LeafCountT>::value), |
| rightcount = (nodes<right_category_t> |
| ::template count<right_t, LeafCountT>::value), |
| value = ((self_t::leftcount) + (self_t::rightcount) + 1) |
| }; |
| }; |
| }; |
| |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Helper template for counting the number of leaf nodes contained in a |
| // given parser type. |
| // Only plain_parser_category type parsers are counted as leaf nodes. |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template <typename CategoryT> |
| struct leafs; |
| |
| template <> |
| struct leafs<plain_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (LeafCountT::value + 1) }; |
| }; |
| }; |
| |
| #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) |
| |
| template <> |
| struct leafs<unary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| typedef leafs<subject_category_t> nodes_t; |
| typedef typename count_wrapper<nodes_t> |
| ::template result_<subject_t, LeafCountT> count_t; |
| |
| BOOST_STATIC_CONSTANT(int, value = count_t::value); |
| }; |
| }; |
| |
| template <> |
| struct leafs<action_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| typedef leafs<subject_category_t> nodes_t; |
| typedef typename count_wrapper<nodes_t> |
| ::template result_<subject_t, LeafCountT> count_t; |
| |
| BOOST_STATIC_CONSTANT(int, value = count_t::value); |
| }; |
| }; |
| |
| template <> |
| struct leafs<binary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::left_t left_t; |
| typedef typename ParserT::right_t right_t; |
| typedef typename left_t::parser_category_t left_category_t; |
| typedef typename right_t::parser_category_t right_category_t; |
| |
| typedef leafs<left_category_t> left_nodes_t; |
| typedef typename count_wrapper<left_nodes_t> |
| ::template result_<left_t, LeafCountT> left_count_t; |
| |
| typedef leafs<right_category_t> right_nodes_t; |
| typedef typename count_wrapper<right_nodes_t> |
| ::template result_<right_t, LeafCountT> right_count_t; |
| |
| BOOST_STATIC_CONSTANT(int, |
| value = (left_count_t::value + right_count_t::value)); |
| }; |
| }; |
| |
| #else |
| |
| template <> |
| struct leafs<unary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (leafs<subject_category_t> |
| ::template count<subject_t, LeafCountT>::value) }; |
| }; |
| }; |
| |
| template <> |
| struct leafs<action_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { value = (leafs<subject_category_t> |
| ::template count<subject_t, LeafCountT>::value) }; |
| }; |
| }; |
| |
| template <> |
| struct leafs<binary_parser_category> { |
| |
| template <typename ParserT, typename LeafCountT> |
| struct count { |
| |
| typedef typename ParserT::left_t left_t; |
| typedef typename ParserT::right_t right_t; |
| typedef typename left_t::parser_category_t left_category_t; |
| typedef typename right_t::parser_category_t right_category_t; |
| |
| typedef count self_t; |
| |
| // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT |
| enum { |
| leftcount = (leafs<left_category_t> |
| ::template count<left_t, LeafCountT>::value), |
| rightcount = (leafs<right_category_t> |
| ::template count<right_t, LeafCountT>::value), |
| value = (self_t::leftcount + self_t::rightcount) |
| }; |
| }; |
| }; |
| |
| #endif |
| |
| } // namespace impl |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace boost::spirit |
| |
| #endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP) |