/avr-cpp-libs/foreign/cpp/boost/spirit/home/classic/core/composite/actions.hpp

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

    Copyright (c) 1998-2003 Joel de Guzman

    http://spirit.sourceforge.net/



  Distributed under 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_ACTIONS_HPP

#define BOOST_SPIRIT_ACTIONS_HPP



#include <boost/spirit/home/classic/namespace.hpp>

#include <boost/spirit/home/classic/core/parser.hpp>

#include <boost/spirit/home/classic/core/composite/composite.hpp>



namespace boost { namespace spirit {



BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN



#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)

#pragma warning(push)

#pragma warning(disable:4512) //assignment operator could not be generated

#endif



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

    //

    //  action class

    //

    //      The action class binds a parser with a user defined semantic

    //      action. Instances of action are never created manually. Instead,

    //      action objects are typically created indirectly through

    //      expression templates of the form:

    //

    //          p[f]

    //

    //      where p is a parser and f is a function or functor. The semantic

    //      action may be a function or a functor. When the parser is

    //      successful, the actor calls the scanner's action_policy policy

    //      (see scanner.hpp):

    //

    //          scan.do_action(actor, attribute, first, last);

    //

    //      passing in these information:

    //

    //          actor:        The action's function or functor

    //          attribute:    The match (returned by the parser) object's

    //                        attribute (see match.hpp)

    //          first:        Iterator pointing to the start of the matching

    //                        portion of the input

    //          last:         Iterator pointing to one past the end of the

    //                        matching portion of the input

    //

    //      It is the responsibility of the scanner's action_policy policy to

    //      dispatch the function or functor as it sees fit. The expected

    //      function or functor signature depends on the parser being

    //      wrapped. In general, if the attribute type of the parser being

    //      wrapped is a nil_t, the function or functor expect the signature:

    //

    //          void func(Iterator first, Iterator last); // functions

    //

    //          struct ftor // functors

    //          {

    //              void func(Iterator first, Iterator last) const;

    //          };

    //

    //      where Iterator is the type of the iterator that is being used and

    //      first and last are the iterators pointing to the matching portion

    //      of the input.

    //

    //      If the attribute type of the parser being wrapped is not a nil_t,

    //      the function or functor usually expect the signature:

    //

    //          void func(T val); // functions

    //

    //          struct ftor // functors

    //          {

    //              void func(T val) const;

    //          };

    //

    //      where T is the attribute type and val is the attribute value

    //      returned by the parser being wrapped.

    //

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

    template <typename ParserT, typename ActionT>

    class action : public unary<ParserT, parser<action<ParserT, ActionT> > >

    {

    public:



        typedef action<ParserT, ActionT>        self_t;

        typedef action_parser_category          parser_category_t;

        typedef unary<ParserT, parser<self_t> > base_t;

        typedef ActionT                         predicate_t;



        template <typename ScannerT>

        struct result

        {

            typedef typename parser_result<ParserT, ScannerT>::type type;

        };



        action(ParserT const& p, ActionT const& a)

        : base_t(p)

        , actor(a) {}



        template <typename ScannerT>

        typename parser_result<self_t, ScannerT>::type

        parse(ScannerT const& scan) const

        {

            typedef typename ScannerT::iterator_t iterator_t;

            typedef typename parser_result<self_t, ScannerT>::type result_t;



            scan.at_end(); // allow skipper to take effect

            iterator_t save = scan.first;

            result_t hit = this->subject().parse(scan);

            if (hit)

            {

                typename result_t::return_t val = hit.value();

                scan.do_action(actor, val, save, scan.first);

            }

            return hit;

        }



        ActionT const& predicate() const { return actor; }



    private:



        ActionT actor;

    };



BOOST_SPIRIT_CLASSIC_NAMESPACE_END



}} // namespace BOOST_SPIRIT_CLASSIC_NS



#endif