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

    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