/*=============================================================================

     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_HPP

 #define BOOST_SPIRIT_CONFIX_HPP

 ///////////////////////////////////////////////////////////////////////////////

 #include <boost/config.hpp>

 #include <boost/spirit/meta/as_parser.hpp>

 #include <boost/spirit/core/composite/operators.hpp>

 #include <boost/spirit/utility/confix_fwd.hpp>

 #include <boost/spirit/utility/impl/confix.ipp>

 ///////////////////////////////////////////////////////////////////////////////

 namespace boost { namespace spirit {

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  confix_parser class

 //

 //      Parses a sequence of 3 sub-matches. This class may

 //      be used to parse structures, where the opening part is possibly

 //      contained in the expression part and the whole sequence is only

 //      parsed after seeing the closing part matching the first opening

 //      subsequence. Example: C-comments:

 //

 //      /* This is a C-comment */

 //

 ///////////////////////////////////////////////////////////////////////////////

 template<typename NestedT = non_nested, typename LexemeT = non_lexeme>

 struct confix_parser_gen;

 template <

     typename OpenT, typename ExprT, typename CloseT, typename CategoryT,

     typename NestedT, typename LexemeT

 >

 struct confix_parser :

     public parser<

         confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT>

     >

 {

     typedef

         confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT>

         self_t;

     confix_parser(OpenT const &open_, ExprT const &expr_, CloseT const &close_)

     : open(open_), expr(expr_), close(close_)

     {}

     template <typename ScannerT>

     typename parser_result<self_t, ScannerT>::type

     parse(ScannerT const& scan) const

     {

         return impl::confix_parser_type<CategoryT>::

             parse(NestedT(), LexemeT(), *this, scan, open, expr, close);

     }

 private:

     typename as_parser<OpenT>::type::embed_t open;

     typename as_parser<ExprT>::type::embed_t expr;

     typename as_parser<CloseT>::type::embed_t close;

 };

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Confix parser generator template

 //

 //      This is a helper for generating a correct confix_parser<> from

 //      auxiliary parameters. There are the following types supported as

 //      parameters yet: parsers, single characters and strings (see

 //      as_parser).

 //

 //      If the body parser is an action_parser_category type parser (a parser

 //      with an attached semantic action) we have to do something special. This

 //      happens, if the user wrote something like:

 //

 //          confix_p(open, body[f], close)

 //

 //      where 'body' is the parser matching the body of the confix sequence

 //      and 'f' is a functor to be called after matching the body. If we would

 //      do nothing, the resulting code would parse the sequence as follows:

 //

 //          start >> (body[f] - close) >> close

 //

 //      what in most cases is not what the user expects.

 //      (If this _is_ what you've expected, then please use the confix_p

 //      generator function 'direct()', which will inhibit

 //      re-attaching the actor to the body parser).

 //

 //      To make the confix parser behave as expected:

 //

 //          start >> (body - close)[f] >> close

 //

 //      the actor attached to the 'body' parser has to be re-attached to the

 //      (body - close) parser construct, which will make the resulting confix

 //      parser 'do the right thing'. This refactoring is done by the help of

 //      the refactoring parsers (see the files refactoring.[hi]pp).

 //

 //      Additionally special care must be taken, if the body parser is a

 //      unary_parser_category type parser as

 //

 //          confix_p(open, *anychar_p, close)

 //

 //      which without any refactoring would result in

 //

 //          start >> (*anychar_p - close) >> close

 //

 //      and will not give the expected result (*anychar_p will eat up all the

 //      input up to the end of the input stream). So we have to refactor this

 //      into:

 //

 //          start >> *(anychar_p - close) >> close

 //

 //      what will give the correct result.

 //

 //      The case, where the body parser is a combination of the two mentioned

 //      problems (i.e. the body parser is a unary parser  with an attached

 //      action), is handled accordingly too:

 //

 //          confix_p(start, (*anychar_p)[f], end)

 //

 //      will be parsed as expected:

 //

 //          start >> (*(anychar_p - end))[f] >> end.

 //

 ///////////////////////////////////////////////////////////////////////////////

 template<typename NestedT, typename LexemeT>

 struct confix_parser_gen

 {

     // Generic generator function for creation of concrete confix parsers

     template<typename StartT, typename ExprT, typename EndT>

     struct paren_op_result_type

     {

         typedef confix_parser<

             typename as_parser<StartT>::type,

             typename as_parser<ExprT>::type,

             typename as_parser<EndT>::type,

             typename as_parser<ExprT>::type::parser_category_t,

             NestedT,

             LexemeT

         > type;

     };

     template<typename StartT, typename ExprT, typename EndT>

     typename paren_op_result_type<StartT, ExprT, EndT>::type 

     operator()(StartT const &start_, ExprT const &expr_, EndT const &end_) const

     {

         typedef typename paren_op_result_type<StartT,ExprT,EndT>::type 

             return_t;

         return return_t(

             as_parser<StartT>::convert(start_),

             as_parser<ExprT>::convert(expr_),

             as_parser<EndT>::convert(end_)

         );

     }

     // Generic generator function for creation of concrete confix parsers

     // which have an action directly attached to the ExprT part of the

     // parser (see comment above, no automatic refactoring)

     template<typename StartT, typename ExprT, typename EndT>

     struct direct_result_type

     {

         typedef confix_parser<

             typename as_parser<StartT>::type,

             typename as_parser<ExprT>::type,

             typename as_parser<EndT>::type,

             plain_parser_category,   // do not re-attach action

             NestedT,

             LexemeT

         > type;

     };

     template<typename StartT, typename ExprT, typename EndT>

     typename direct_result_type<StartT,ExprT,EndT>::type

     direct(StartT const &start_, ExprT const &expr_, EndT const &end_) const

     {

         typedef typename direct_result_type<StartT,ExprT,EndT>::type

             return_t;

         return return_t(

             as_parser<StartT>::convert(start_),

             as_parser<ExprT>::convert(expr_),

             as_parser<EndT>::convert(end_)

         );

     }

 };

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Predefined non_nested confix parser generators

 //

 ///////////////////////////////////////////////////////////////////////////////

 const confix_parser_gen<non_nested, non_lexeme> confix_p =

     confix_parser_gen<non_nested, non_lexeme>();

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Comments are special types of confix parsers

 //

 //      Comment parser generator template. This is a helper for generating a

 //      correct confix_parser<> from auxiliary parameters, which is able to

 //      parse comment constructs: (StartToken >> Comment text >> EndToken).

 //

 //      There are the following types supported as parameters yet: parsers,

 //      single characters and strings (see as_parser).

 //

 //      There are two diffenerent predefined comment parser generators

 //      (comment_p and comment_nest_p, see below), which may be used for

 //      creating special comment parsers in two different ways.

 //

 //      If these are used with one parameter, a comment starting with the given

 //      first parser parameter up to the end of the line is matched. So for

 //      instance the following parser matches C++ style comments:

 //

 //          comment_p("//").

 //

 //      If these are used with two parameters, a comment starting with the

 //      first parser parameter up to the second parser parameter is matched.

 //      For instance a C style comment parser should be constrcuted as:

 //

 //          comment_p("/*", "*/").

 //

 //      Please note, that a comment is parsed implicitly as if the whole

 //      comment_p(...) statement were embedded into a lexeme_d[] directive.

 //

 ///////////////////////////////////////////////////////////////////////////////

 template<typename NestedT>

 struct comment_parser_gen

 {

     // Generic generator function for creation of concrete comment parsers

     // from an open token. The newline parser eol_p is used as the

     // closing token.

     template<typename StartT>

     struct paren_op1_result_type

     {

         typedef confix_parser<

             typename as_parser<StartT>::type,

             kleene_star<anychar_parser>,

             alternative<eol_parser, end_parser>,

             unary_parser_category,          // there is no action to re-attach

             NestedT,

             is_lexeme                       // insert implicit lexeme_d[]

         >

         type;

     };

     template<typename StartT>

     typename paren_op1_result_type<StartT>::type 

     operator() (StartT const &start_) const

     {

         typedef typename paren_op1_result_type<StartT>::type

             return_t;

         return return_t(

             as_parser<StartT>::convert(start_),

             *anychar_p,

             eol_p | end_p

         );

     }

     // Generic generator function for creation of concrete comment parsers

     // from an open and a close tokens.

     template<typename StartT, typename EndT>

     struct paren_op2_result_type

     {

         typedef confix_parser<

             typename as_parser<StartT>::type,

             kleene_star<anychar_parser>,

             typename as_parser<EndT>::type,

             unary_parser_category,          // there is no action to re-attach

             NestedT,

             is_lexeme                       // insert implicit lexeme_d[]

         > type;

     };

     template<typename StartT, typename EndT>

     typename paren_op2_result_type<StartT,EndT>::type

     operator() (StartT const &start_, EndT const &end_) const

     {

         typedef typename paren_op2_result_type<StartT,EndT>::type

             return_t;

         return return_t(

             as_parser<StartT>::convert(start_),

             *anychar_p,

             as_parser<EndT>::convert(end_)

         );

     }

 };

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Predefined non_nested comment parser generator

 //

 ///////////////////////////////////////////////////////////////////////////////

 const comment_parser_gen<non_nested> comment_p =

     comment_parser_gen<non_nested>();

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  comment_nest_parser class

 //

 //      Parses a nested comments.

 //      Example: nested PASCAL-comments:

 //

 //      { This is a { nested } PASCAL-comment }

 //

 ///////////////////////////////////////////////////////////////////////////////

 template<typename OpenT, typename CloseT>

 struct comment_nest_parser:

     public parser<comment_nest_parser<OpenT, CloseT> >

 {

     typedef comment_nest_parser<OpenT, CloseT> self_t;

     comment_nest_parser(OpenT const &open_, CloseT const &close_):

         open(open_), close(close_)

     {}

     template<typename ScannerT>

     typename parser_result<self_t, ScannerT>::type

         parse(ScannerT const &scan) const

     {

         return do_parse(

             open >> *(*this | (anychar_p - close)) >> close,

             scan);

     }

 private:

     template<typename ParserT, typename ScannerT>

     typename parser_result<self_t, ScannerT>::type

         do_parse(ParserT const &p, ScannerT const &scan) const

     {

         return

             impl::contiguous_parser_parse<

                 typename parser_result<ParserT, ScannerT>::type

             >(p, scan, scan);

     }

     typename as_parser<OpenT>::type::embed_t open;

     typename as_parser<CloseT>::type::embed_t close;

 };

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Predefined nested comment parser generator

 //

 ///////////////////////////////////////////////////////////////////////////////

 template<typename OpenT, typename CloseT>

 struct comment_nest_p_result

 {

     typedef comment_nest_parser<

         typename as_parser<OpenT>::type,

         typename as_parser<CloseT>::type

     > type;

 };

 template<typename OpenT, typename CloseT>

 inline typename comment_nest_p_result<OpenT,CloseT>::type 

 comment_nest_p(OpenT const &open, CloseT const &close)

 {

     typedef typename comment_nest_p_result<OpenT,CloseT>::type

         result_t;

     return result_t(

         as_parser<OpenT>::convert(open),

         as_parser<CloseT>::convert(close)

     );

 }

 ///////////////////////////////////////////////////////////////////////////////

 }} // namespace boost::spirit

 #endif