/
usr
/
include
/
boost
/
spirit
/
home
/
classic
/
meta
/
impl
/
/usr/include/boost/spirit/home/classic/meta/impl
mkdir
upload
Name
Size
Mode
Actions
fundamental.ipp
5759
0644
edit
dl
rm
parser_traits.ipp
3647
0644
edit
dl
rm
refactoring.ipp
15802
0644
edit
dl
rm
traverse.ipp
13559
0644
edit
dl
rm
Edit:
/usr/include/boost/spirit/home/classic/meta/impl/refactoring.ipp
(15802B)
/*============================================================================= 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) =============================================================================*/ #ifndef BOOST_SPIRIT_REFACTORING_IPP #define BOOST_SPIRIT_REFACTORING_IPP /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN /////////////////////////////////////////////////////////////////////////////// // // The struct 'self_nested_refactoring' is used to indicate, that the // refactoring algorithm should be 'self-nested'. // // The struct 'non_nested_refactoring' is used to indicate, that no nesting // of refactoring algorithms is reqired. // /////////////////////////////////////////////////////////////////////////////// struct non_nested_refactoring { typedef non_nested_refactoring embed_t; }; struct self_nested_refactoring { typedef self_nested_refactoring embed_t; }; /////////////////////////////////////////////////////////////////////////////// namespace impl { /////////////////////////////////////////////////////////////////////////////// // // Helper templates for refactoring parsers // /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // // refactor the left unary operand of a binary parser // // The refactoring should be done only if the left operand is an // unary_parser_category parser. // /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct refactor_unary_nested { template < typename ParserT, typename NestedT, typename ScannerT, typename BinaryT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, NestedT const& /*nested_d*/) { return binary.parse(scan); } }; template <> struct refactor_unary_nested<unary_parser_category> { template < typename ParserT, typename ScannerT, typename BinaryT, typename NestedT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, NestedT const& nested_d) { typedef typename BinaryT::parser_generator_t op_t; typedef typename BinaryT::left_t::parser_generator_t unary_t; return unary_t::generate( nested_d[ op_t::generate(binary.left().subject(), binary.right()) ] ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct refactor_unary_non_nested { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) { return binary.parse(scan); } }; template <> struct refactor_unary_non_nested<unary_parser_category> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) { typedef typename BinaryT::parser_generator_t op_t; typedef typename BinaryT::left_t::parser_generator_t unary_t; return unary_t::generate( op_t::generate(binary.left().subject(), binary.right()) ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename NestedT> struct refactor_unary_type { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, NestedT const& nested_d) { typedef typename BinaryT::left_t::parser_category_t parser_category_t; return refactor_unary_nested<parser_category_t>:: parse(p, scan, binary, nested_d); } }; template <> struct refactor_unary_type<non_nested_refactoring> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, non_nested_refactoring const&) { typedef typename BinaryT::left_t::parser_category_t parser_category_t; return refactor_unary_non_nested<parser_category_t>:: parse(p, scan, binary); } }; template <> struct refactor_unary_type<self_nested_refactoring> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, self_nested_refactoring const &nested_tag) { typedef typename BinaryT::left_t::parser_category_t parser_category_t; typedef typename ParserT::parser_generator_t parser_generator_t; parser_generator_t nested_d(nested_tag); return refactor_unary_nested<parser_category_t>:: parse(p, scan, binary, nested_d); } }; /////////////////////////////////////////////////////////////////////////// // // refactor the action on the left operand of a binary parser // // The refactoring should be done only if the left operand is an // action_parser_category parser. // /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct refactor_action_nested { template < typename ParserT, typename ScannerT, typename BinaryT, typename NestedT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, NestedT const& nested_d) { return nested_d[binary].parse(scan); } }; template <> struct refactor_action_nested<action_parser_category> { template < typename ParserT, typename ScannerT, typename BinaryT, typename NestedT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, NestedT const& nested_d) { typedef typename BinaryT::parser_generator_t binary_gen_t; return ( nested_d[ binary_gen_t::generate( binary.left().subject(), binary.right() ) ][binary.left().predicate()] ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct refactor_action_non_nested { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) { return binary.parse(scan); } }; template <> struct refactor_action_non_nested<action_parser_category> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) { typedef typename BinaryT::parser_generator_t binary_gen_t; return ( binary_gen_t::generate( binary.left().subject(), binary.right() )[binary.left().predicate()] ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename NestedT> struct refactor_action_type { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, NestedT const& nested_d) { typedef typename BinaryT::left_t::parser_category_t parser_category_t; return refactor_action_nested<parser_category_t>:: parse(p, scan, binary, nested_d); } }; template <> struct refactor_action_type<non_nested_refactoring> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, non_nested_refactoring const&) { typedef typename BinaryT::left_t::parser_category_t parser_category_t; return refactor_action_non_nested<parser_category_t>:: parse(p, scan, binary); } }; template <> struct refactor_action_type<self_nested_refactoring> { template <typename ParserT, typename ScannerT, typename BinaryT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, self_nested_refactoring const &nested_tag) { typedef typename ParserT::parser_generator_t parser_generator_t; typedef typename BinaryT::left_t::parser_category_t parser_category_t; parser_generator_t nested_d(nested_tag); return refactor_action_nested<parser_category_t>:: parse(p, scan, binary, nested_d); } }; /////////////////////////////////////////////////////////////////////////// // // refactor the action attached to a binary parser // // The refactoring should be done only if the given parser is an // binary_parser_category parser. // /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct attach_action_nested { template < typename ParserT, typename ScannerT, typename ActionT, typename NestedT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, ActionT const &action, NestedT const& /*nested_d*/) { return action.parse(scan); } }; template <> struct attach_action_nested<binary_parser_category> { template < typename ParserT, typename ScannerT, typename ActionT, typename NestedT > static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, ActionT const &action, NestedT const& nested_d) { typedef typename ActionT::subject_t::parser_generator_t binary_gen_t; return ( binary_gen_t::generate( nested_d[action.subject().left()[action.predicate()]], nested_d[action.subject().right()[action.predicate()]] ) ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename CategoryT> struct attach_action_non_nested { template <typename ParserT, typename ScannerT, typename ActionT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, ActionT const &action) { return action.parse(scan); } }; template <> struct attach_action_non_nested<binary_parser_category> { template <typename ParserT, typename ScannerT, typename ActionT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &, ScannerT const& scan, ActionT const &action) { typedef typename ActionT::subject_t::parser_generator_t binary_gen_t; return ( binary_gen_t::generate( action.subject().left()[action.predicate()], action.subject().right()[action.predicate()] ) ).parse(scan); } }; /////////////////////////////////////////////////////////////////////////// template <typename NestedT> struct attach_action_type { template <typename ParserT, typename ScannerT, typename ActionT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, ActionT const& action, NestedT const& nested_d) { typedef typename ActionT::subject_t::parser_category_t parser_category_t; return attach_action_nested<parser_category_t>:: parse(p, scan, action, nested_d); } }; template <> struct attach_action_type<non_nested_refactoring> { template <typename ParserT, typename ScannerT, typename ActionT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, ActionT const &action, non_nested_refactoring const&) { typedef typename ActionT::subject_t::parser_category_t parser_category_t; return attach_action_non_nested<parser_category_t>:: parse(p, scan, action); } }; template <> struct attach_action_type<self_nested_refactoring> { template <typename ParserT, typename ScannerT, typename ActionT> static typename parser_result<ParserT, ScannerT>::type parse(ParserT const &p, ScannerT const& scan, ActionT const &action, self_nested_refactoring const& nested_tag) { typedef typename ParserT::parser_generator_t parser_generator_t; typedef typename ActionT::subject_t::parser_category_t parser_category_t; parser_generator_t nested_d(nested_tag); return attach_action_nested<parser_category_t>:: parse(p, scan, action, nested_d); } }; } // namespace impl /////////////////////////////////////////////////////////////////////////////// BOOST_SPIRIT_CLASSIC_NAMESPACE_END }} // namespace boost::spirit #endif
Save
cmd:
run