| /*============================================================================= |
| Copyright (c) 2002-2003 Joel de Guzman |
| 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_TRAVERSE_IPP) |
| #define BOOST_SPIRIT_TRAVERSE_IPP |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <boost/spirit/home/classic/meta/fundamental.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace impl |
| { |
| |
| template <typename CategoryT> |
| struct traverse_post_order_return_category; |
| |
| } // namespace impl |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Environment class for post_order_traversal |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| template <int Level, int Node, int Index, int LastLeft> |
| struct traverse_post_order_env { |
| |
| BOOST_STATIC_CONSTANT(int, level = Level); |
| BOOST_STATIC_CONSTANT(int, node = Node); |
| BOOST_STATIC_CONSTANT(int, index = Index); |
| BOOST_STATIC_CONSTANT(int, lastleft = LastLeft); |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // traverse_post_order_return template |
| // |
| // This template is a helper for dispatching the calculation of a parser |
| // type result for a traversal level to the corresponding parser_category |
| // based specialization. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct traverse_post_order_return { |
| |
| typedef typename ParserT::parser_category_t parser_category_t; |
| typedef typename impl::traverse_post_order_return_category<parser_category_t> |
| ::template result<MetaT, ParserT, EnvT>::type type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // parser_traversal_..._result templates |
| // |
| // These are metafunctions, which calculate the resulting parser type |
| // for all subparsers and feed these types to the user supplied |
| // metafunctions to get back the resulting parser type of this traversal |
| // level. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct parser_traversal_plain_result { |
| |
| typedef typename MetaT::template plain_result<ParserT, EnvT>::type type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename MetaT, typename UnaryT, typename SubjectT, typename EnvT> |
| struct parser_traversal_unary_result { |
| |
| typedef typename MetaT |
| ::template unary_result<UnaryT, SubjectT, EnvT>::type type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename MetaT, typename ActionT, typename SubjectT, typename EnvT> |
| struct parser_traversal_action_result { |
| |
| typedef typename MetaT |
| ::template action_result<ActionT, SubjectT, EnvT>::type type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename MetaT, typename BinaryT, typename LeftT, |
| typename RightT, typename EnvT |
| > |
| struct parser_traversal_binary_result { |
| |
| BOOST_STATIC_CONSTANT(int, |
| thisnum = (node_count<BinaryT>::value + EnvT::lastleft-1)); |
| BOOST_STATIC_CONSTANT(int, |
| leftnum = (node_count<LeftT>::value + EnvT::lastleft-1)); |
| BOOST_STATIC_CONSTANT(int, |
| leafnum = (leaf_count<LeftT>::value + EnvT::index)); |
| |
| typedef parser_traversal_binary_result self_t; |
| |
| // left traversal environment and resulting parser type |
| typedef traverse_post_order_env< |
| (EnvT::level+1), (self_t::leftnum), (EnvT::index), (EnvT::lastleft) |
| > left_sub_env_t; |
| typedef typename traverse_post_order_return< |
| MetaT, LeftT, left_sub_env_t |
| >::type |
| left_t; |
| |
| // right traversal environment and resulting parser type |
| typedef traverse_post_order_env< |
| (EnvT::level+1), (self_t::thisnum-1), (self_t::leafnum), (self_t::leftnum+1) |
| > right_sub_env_t; |
| typedef typename traverse_post_order_return< |
| MetaT, RightT, right_sub_env_t |
| >::type |
| right_t; |
| |
| typedef typename MetaT::template binary_result< |
| BinaryT, left_t, right_t, EnvT |
| >::type |
| type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace impl |
| { |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Meta functions, which dispatch the calculation of the return type of |
| // of the post_order traverse function to the result template of the |
| // corresponding parser_category based metafunction template. |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| |
| template <typename CategoryT> |
| struct traverse_post_order_return_category; |
| |
| template <> |
| struct traverse_post_order_return_category<plain_parser_category> { |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct result { |
| |
| typedef typename parser_traversal_plain_result< |
| MetaT, ParserT, EnvT |
| >::type |
| type; |
| }; |
| }; |
| |
| template <> |
| struct traverse_post_order_return_category<unary_parser_category> { |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct result { |
| |
| typedef typename parser_traversal_unary_result< |
| MetaT, ParserT, typename ParserT::subject_t, EnvT |
| >::type |
| type; |
| }; |
| }; |
| |
| template <> |
| struct traverse_post_order_return_category<action_parser_category> { |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct result { |
| |
| typedef typename parser_traversal_action_result< |
| MetaT, ParserT, typename ParserT::subject_t, EnvT |
| >::type |
| type; |
| }; |
| }; |
| |
| template <> |
| struct traverse_post_order_return_category<binary_parser_category> { |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct result { |
| |
| typedef typename parser_traversal_binary_result< |
| MetaT, ParserT, typename ParserT::left_t, |
| typename ParserT::right_t, EnvT |
| >::type |
| type; |
| }; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Post-order parser traversal |
| // |
| // The following templates contain the parser_category based code for |
| // |
| // - calculating the type of the resulting parser, which is to be |
| // returned from a level of traversal |
| // - traversing down the composite parser structure, this traversal |
| // returnes a new parser object |
| // |
| // Both tasks are delegated to the MetaT metafunction supplied by the |
| // user. |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| |
| template <typename CategoryT> |
| struct traverse_post_order; |
| |
| template <> |
| struct traverse_post_order<plain_parser_category> { |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| struct result { |
| |
| typedef |
| typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::type |
| type; |
| }; |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| static |
| typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::type |
| generate(MetaT const &meta_, ParserT const &parser_, EnvT const &env) |
| { |
| return meta_.generate_plain(parser_, env); |
| } |
| }; |
| |
| template <> |
| struct traverse_post_order<unary_parser_category> { |
| |
| template < |
| typename MetaT, typename ParserT, typename SubjectT, typename EnvT |
| > |
| struct result { |
| |
| typedef typename parser_traversal_unary_result< |
| MetaT, ParserT, SubjectT, EnvT |
| >::type |
| type; |
| }; |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| static |
| typename parser_traversal_unary_result< |
| MetaT, ParserT, |
| typename traverse_post_order_return< |
| MetaT, typename ParserT::subject_t, EnvT |
| >::type, |
| EnvT |
| >::type |
| generate(MetaT const &meta_, ParserT const &unary_, EnvT const &env) |
| { |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| return meta_.generate_unary( |
| unary_, |
| traverse_post_order<subject_category_t>::generate(meta_, |
| unary_.subject(), |
| traverse_post_order_env< |
| EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft |
| >() |
| ), |
| env |
| ); |
| } |
| }; |
| |
| template <> |
| struct traverse_post_order<action_parser_category> { |
| |
| template < |
| typename MetaT, typename ParserT, typename SubjectT, typename EnvT |
| > |
| struct result { |
| |
| typedef typename parser_traversal_action_result< |
| MetaT, ParserT, SubjectT, EnvT |
| >::type |
| type; |
| }; |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| static |
| typename parser_traversal_action_result< |
| MetaT, ParserT, |
| typename traverse_post_order_return< |
| MetaT, typename ParserT::subject_t, EnvT |
| >::type, |
| EnvT |
| >::type |
| generate(MetaT const &meta_, ParserT const &action_, EnvT const &env) |
| { |
| typedef typename ParserT::subject_t subject_t; |
| typedef typename subject_t::parser_category_t subject_category_t; |
| |
| return meta_.generate_action( |
| action_, |
| traverse_post_order<subject_category_t>::generate(meta_, |
| action_.subject(), |
| traverse_post_order_env< |
| EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft |
| >() |
| ), |
| env |
| ); |
| } |
| }; |
| |
| template <> |
| struct traverse_post_order<binary_parser_category> { |
| |
| template < |
| typename MetaT, typename ParserT, typename LeftT, |
| typename RightT, typename EnvT |
| > |
| struct result { |
| |
| typedef typename parser_traversal_binary_result< |
| MetaT, ParserT, LeftT, RightT, EnvT |
| >::type |
| type; |
| }; |
| |
| template <typename MetaT, typename ParserT, typename EnvT> |
| static |
| typename parser_traversal_binary_result< |
| MetaT, ParserT, |
| typename traverse_post_order_return< |
| MetaT, typename ParserT::left_t, EnvT |
| >::type, |
| typename traverse_post_order_return< |
| MetaT, typename ParserT::right_t, EnvT |
| >::type, |
| EnvT |
| >::type |
| generate(MetaT const &meta_, ParserT const &binary_, EnvT const& /*env*/) |
| { |
| 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; |
| |
| enum { |
| leftnum = (node_count<left_t>::value + EnvT::lastleft-1), |
| thisnum = (node_count<ParserT>::value + EnvT::lastleft-1), |
| rightnum = (thisnum-1), |
| leafnum = (leaf_count<left_t>::value + EnvT::index) |
| }; |
| |
| return meta_.generate_binary( |
| binary_, |
| traverse_post_order<left_category_t>::generate( |
| meta_, binary_.left(), |
| traverse_post_order_env< |
| EnvT::level+1, leftnum, EnvT::index, EnvT::lastleft |
| >() |
| ), |
| traverse_post_order<right_category_t>::generate( |
| meta_, binary_.right(), |
| traverse_post_order_env< |
| EnvT::level+1, rightnum, leafnum, leftnum+1 |
| >() |
| ), |
| traverse_post_order_env< |
| EnvT::level, thisnum, EnvT::index, EnvT::lastleft |
| >() |
| ); |
| } |
| }; |
| |
| } // namespace impl |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace boost::spirit |
| |
| #endif // !defined(BOOST_SPIRIT_TRAVERSE_IPP) |