You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
309 lines
10 KiB
309 lines
10 KiB
/*============================================================================= |
|
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)
|
|
|