1/*=============================================================================
2    Copyright (c) 2002-2003 Hartmut Kaiser
3    http://spirit.sourceforge.net/
4
5    Use, modification and distribution is subject to the Boost Software
6    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
7    http://www.boost.org/LICENSE_1_0.txt)
8=============================================================================*/
9#if !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP)
10#define BOOST_SPIRIT_FUNDAMENTAL_IPP
11
12#include <boost/mpl/int.hpp>
13
14namespace boost { namespace spirit {
15
16BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
17
18namespace impl
19{
20    ///////////////////////////////////////////////////////////////////////////
21    //
22    //  Helper template for counting the number of nodes contained in a
23    //  given parser type.
24    //  All parser_category type parsers are counted as nodes.
25    //
26    ///////////////////////////////////////////////////////////////////////////
27    template <typename CategoryT>
28    struct nodes;
29
30    template <>
31    struct nodes<plain_parser_category> {
32
33        template <typename ParserT, typename LeafCountT>
34        struct count {
35
36            BOOST_STATIC_CONSTANT(int, value = (LeafCountT::value + 1));
37        };
38    };
39
40    template <>
41    struct nodes<unary_parser_category> {
42
43        template <typename ParserT, typename LeafCountT>
44        struct count {
45
46            typedef typename ParserT::subject_t             subject_t;
47            typedef typename subject_t::parser_category_t   subject_category_t;
48
49            BOOST_STATIC_CONSTANT(int, value = (nodes<subject_category_t>
50                ::template count<subject_t, LeafCountT>::value + 1));
51        };
52    };
53
54    template <>
55    struct nodes<action_parser_category> {
56
57        template <typename ParserT, typename LeafCountT>
58        struct count {
59
60            typedef typename ParserT::subject_t             subject_t;
61            typedef typename subject_t::parser_category_t   subject_category_t;
62
63            BOOST_STATIC_CONSTANT(int, value = (nodes<subject_category_t>
64                ::template count<subject_t, LeafCountT>::value + 1));
65        };
66    };
67
68    template <>
69    struct nodes<binary_parser_category> {
70
71        template <typename ParserT, typename LeafCountT>
72        struct count {
73
74            typedef typename ParserT::left_t                left_t;
75            typedef typename ParserT::right_t               right_t;
76            typedef typename left_t::parser_category_t      left_category_t;
77            typedef typename right_t::parser_category_t     right_category_t;
78
79            typedef count self_t;
80
81            BOOST_STATIC_CONSTANT(int,
82                leftcount = (nodes<left_category_t>
83                    ::template count<left_t, LeafCountT>::value));
84            BOOST_STATIC_CONSTANT(int,
85                rightcount = (nodes<right_category_t>
86                    ::template count<right_t, LeafCountT>::value));
87            BOOST_STATIC_CONSTANT(int,
88                value = ((self_t::leftcount) + (self_t::rightcount) + 1));
89        };
90    };
91
92    ///////////////////////////////////////////////////////////////////////////
93    //
94    //  Helper template for counting the number of leaf nodes contained in a
95    //  given parser type.
96    //  Only plain_parser_category type parsers are counted as leaf nodes.
97    //
98    ///////////////////////////////////////////////////////////////////////////
99    template <typename CategoryT>
100    struct leafs;
101
102    template <>
103    struct leafs<plain_parser_category> {
104
105        template <typename ParserT, typename LeafCountT>
106        struct count {
107
108            BOOST_STATIC_CONSTANT(int, value = (LeafCountT::value + 1));
109        };
110    };
111
112    template <>
113    struct leafs<unary_parser_category> {
114
115        template <typename ParserT, typename LeafCountT>
116        struct count {
117
118            typedef typename ParserT::subject_t             subject_t;
119            typedef typename subject_t::parser_category_t   subject_category_t;
120
121            BOOST_STATIC_CONSTANT(int, value = (leafs<subject_category_t>
122                ::template count<subject_t, LeafCountT>::value));
123        };
124    };
125
126    template <>
127    struct leafs<action_parser_category> {
128
129        template <typename ParserT, typename LeafCountT>
130        struct count {
131
132            typedef typename ParserT::subject_t             subject_t;
133            typedef typename subject_t::parser_category_t   subject_category_t;
134
135            BOOST_STATIC_CONSTANT(int, value = (leafs<subject_category_t>
136                ::template count<subject_t, LeafCountT>::value));
137        };
138    };
139
140    template <>
141    struct leafs<binary_parser_category> {
142
143        template <typename ParserT, typename LeafCountT>
144        struct count {
145
146            typedef typename ParserT::left_t                left_t;
147            typedef typename ParserT::right_t               right_t;
148            typedef typename left_t::parser_category_t      left_category_t;
149            typedef typename right_t::parser_category_t     right_category_t;
150
151            typedef count self_t;
152
153            BOOST_STATIC_CONSTANT(int,
154                leftcount = (leafs<left_category_t>
155                    ::template count<left_t, LeafCountT>::value));
156            BOOST_STATIC_CONSTANT(int,
157                rightcount = (leafs<right_category_t>
158                    ::template count<right_t, LeafCountT>::value));
159            BOOST_STATIC_CONSTANT(int,
160                value = (self_t::leftcount + self_t::rightcount));
161        };
162    };
163
164}   // namespace impl
165
166///////////////////////////////////////////////////////////////////////////////
167BOOST_SPIRIT_CLASSIC_NAMESPACE_END
168
169}} // namespace boost::spirit
170
171#endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP)
172