| /*============================================================================= | |
| 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_CONFIX_IPP | |
| #define BOOST_SPIRIT_CONFIX_IPP | |
| /////////////////////////////////////////////////////////////////////////////// | |
| #include <boost/spirit/home/classic/meta/refactoring.hpp> | |
| #include <boost/spirit/home/classic/core/composite/impl/directives.ipp> | |
| /////////////////////////////////////////////////////////////////////////////// | |
| namespace boost { namespace spirit { | |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // Types to distinguish nested and non-nested confix parsers | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| struct is_nested {}; | |
| struct non_nested {}; | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // Types to distinguish between confix parsers, which are implicitly lexems | |
| // and without this behaviour | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| struct is_lexeme {}; | |
| struct non_lexeme {}; | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // confix_parser_type class implementation | |
| // | |
| /////////////////////////////////////////////////////////////////////////////// | |
| namespace impl { | |
| /////////////////////////////////////////////////////////////////////////// | |
| // implicitly insert a lexeme_d into the parsing process | |
| template <typename LexemeT> | |
| struct select_confix_parse_lexeme; | |
| template <> | |
| struct select_confix_parse_lexeme<is_lexeme> { | |
| template <typename ParserT, typename ScannerT> | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse(ParserT const& p, ScannerT const& scan) | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type result_t; | |
| return contiguous_parser_parse<result_t>(p, scan, scan); | |
| } | |
| }; | |
| template <> | |
| struct select_confix_parse_lexeme<non_lexeme> { | |
| template <typename ParserT, typename ScannerT> | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse(ParserT const& p, ScannerT const& scan) | |
| { | |
| return p.parse(scan); | |
| } | |
| }; | |
| /////////////////////////////////////////////////////////////////////////// | |
| // parse confix sequences with refactoring | |
| template <typename NestedT> | |
| struct select_confix_parse_refactor; | |
| template <> | |
| struct select_confix_parse_refactor<is_nested> { | |
| template < | |
| typename LexemeT, typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| LexemeT const &, ParserT const& this_, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| typedef refactor_action_gen<refactor_unary_gen<> > refactor_t; | |
| const refactor_t refactor_body_d = refactor_t(refactor_unary_d); | |
| return select_confix_parse_lexeme<LexemeT>::parse(( | |
| open | |
| >> (this_ | refactor_body_d[expr - close]) | |
| >> close | |
| ), scan); | |
| } | |
| }; | |
| template <> | |
| struct select_confix_parse_refactor<non_nested> { | |
| template < | |
| typename LexemeT, typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| LexemeT const &, ParserT const& /*this_*/, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| typedef refactor_action_gen<refactor_unary_gen<> > refactor_t; | |
| const refactor_t refactor_body_d = refactor_t(refactor_unary_d); | |
| return select_confix_parse_lexeme<LexemeT>::parse(( | |
| open | |
| >> refactor_body_d[expr - close] | |
| >> close | |
| ), scan); | |
| } | |
| }; | |
| /////////////////////////////////////////////////////////////////////////// | |
| // parse confix sequences without refactoring | |
| template <typename NestedT> | |
| struct select_confix_parse_no_refactor; | |
| template <> | |
| struct select_confix_parse_no_refactor<is_nested> { | |
| template < | |
| typename LexemeT, typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| LexemeT const &, ParserT const& this_, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| return select_confix_parse_lexeme<LexemeT>::parse(( | |
| open | |
| >> (this_ | (expr - close)) | |
| >> close | |
| ), scan); | |
| } | |
| }; | |
| template <> | |
| struct select_confix_parse_no_refactor<non_nested> { | |
| template < | |
| typename LexemeT, typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| LexemeT const &, ParserT const & /*this_*/, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| return select_confix_parse_lexeme<LexemeT>::parse(( | |
| open | |
| >> (expr - close) | |
| >> close | |
| ), scan); | |
| } | |
| }; | |
| // the refactoring is handled by the refactoring parsers, so here there | |
| // is no need to pay attention to these issues. | |
| template <typename CategoryT> | |
| struct confix_parser_type { | |
| template < | |
| typename NestedT, typename LexemeT, | |
| typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| NestedT const &, LexemeT const &lexeme, | |
| ParserT const& this_, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| return select_confix_parse_refactor<NestedT>:: | |
| parse(lexeme, this_, scan, open, expr, close); | |
| } | |
| }; | |
| template <> | |
| struct confix_parser_type<plain_parser_category> { | |
| template < | |
| typename NestedT, typename LexemeT, | |
| typename ParserT, typename ScannerT, | |
| typename OpenT, typename ExprT, typename CloseT | |
| > | |
| static typename parser_result<ParserT, ScannerT>::type | |
| parse( | |
| NestedT const &, LexemeT const &lexeme, | |
| ParserT const& this_, ScannerT const& scan, | |
| OpenT const& open, ExprT const& expr, CloseT const& close) | |
| { | |
| return select_confix_parse_no_refactor<NestedT>:: | |
| parse(lexeme, this_, scan, open, expr, close); | |
| } | |
| }; | |
| } // namespace impl | |
| /////////////////////////////////////////////////////////////////////////////// | |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
| }} // namespace boost::spirit | |
| #endif | |