PageRenderTime 15ms CodeModel.GetById 2ms app.highlight 10ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/spirit/home/classic/core/composite/actions.hpp

http://hadesmem.googlecode.com/
C++ Header | 132 lines | 50 code | 16 blank | 66 comment | 1 complexity | a0c08ead4838f02d63e51e77e43d1e43 MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 1998-2003 Joel de Guzman
  3    http://spirit.sourceforge.net/
  4
  5  Distributed under the Boost Software License, Version 1.0. (See accompanying
  6  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7=============================================================================*/
  8#ifndef BOOST_SPIRIT_ACTIONS_HPP
  9#define BOOST_SPIRIT_ACTIONS_HPP
 10
 11#include <boost/spirit/home/classic/namespace.hpp>
 12#include <boost/spirit/home/classic/core/parser.hpp>
 13#include <boost/spirit/home/classic/core/composite/composite.hpp>
 14
 15namespace boost { namespace spirit {
 16
 17BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 18
 19#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 20#pragma warning(push)
 21#pragma warning(disable:4512) //assignment operator could not be generated
 22#endif
 23
 24    ///////////////////////////////////////////////////////////////////////////
 25    //
 26    //  action class
 27    //
 28    //      The action class binds a parser with a user defined semantic
 29    //      action. Instances of action are never created manually. Instead,
 30    //      action objects are typically created indirectly through
 31    //      expression templates of the form:
 32    //
 33    //          p[f]
 34    //
 35    //      where p is a parser and f is a function or functor. The semantic
 36    //      action may be a function or a functor. When the parser is
 37    //      successful, the actor calls the scanner's action_policy policy
 38    //      (see scanner.hpp):
 39    //
 40    //          scan.do_action(actor, attribute, first, last);
 41    //
 42    //      passing in these information:
 43    //
 44    //          actor:        The action's function or functor
 45    //          attribute:    The match (returned by the parser) object's
 46    //                        attribute (see match.hpp)
 47    //          first:        Iterator pointing to the start of the matching
 48    //                        portion of the input
 49    //          last:         Iterator pointing to one past the end of the
 50    //                        matching portion of the input
 51    //
 52    //      It is the responsibility of the scanner's action_policy policy to
 53    //      dispatch the function or functor as it sees fit. The expected
 54    //      function or functor signature depends on the parser being
 55    //      wrapped. In general, if the attribute type of the parser being
 56    //      wrapped is a nil_t, the function or functor expect the signature:
 57    //
 58    //          void func(Iterator first, Iterator last); // functions
 59    //
 60    //          struct ftor // functors
 61    //          {
 62    //              void func(Iterator first, Iterator last) const;
 63    //          };
 64    //
 65    //      where Iterator is the type of the iterator that is being used and
 66    //      first and last are the iterators pointing to the matching portion
 67    //      of the input.
 68    //
 69    //      If the attribute type of the parser being wrapped is not a nil_t,
 70    //      the function or functor usually expect the signature:
 71    //
 72    //          void func(T val); // functions
 73    //
 74    //          struct ftor // functors
 75    //          {
 76    //              void func(T val) const;
 77    //          };
 78    //
 79    //      where T is the attribute type and val is the attribute value
 80    //      returned by the parser being wrapped.
 81    //
 82    ///////////////////////////////////////////////////////////////////////////
 83    template <typename ParserT, typename ActionT>
 84    class action : public unary<ParserT, parser<action<ParserT, ActionT> > >
 85    {
 86    public:
 87
 88        typedef action<ParserT, ActionT>        self_t;
 89        typedef action_parser_category          parser_category_t;
 90        typedef unary<ParserT, parser<self_t> > base_t;
 91        typedef ActionT                         predicate_t;
 92
 93        template <typename ScannerT>
 94        struct result
 95        {
 96            typedef typename parser_result<ParserT, ScannerT>::type type;
 97        };
 98
 99        action(ParserT const& p, ActionT const& a)
100        : base_t(p)
101        , actor(a) {}
102
103        template <typename ScannerT>
104        typename parser_result<self_t, ScannerT>::type
105        parse(ScannerT const& scan) const
106        {
107            typedef typename ScannerT::iterator_t iterator_t;
108            typedef typename parser_result<self_t, ScannerT>::type result_t;
109
110            scan.at_end(); // allow skipper to take effect
111            iterator_t save = scan.first;
112            result_t hit = this->subject().parse(scan);
113            if (hit)
114            {
115                typename result_t::return_t val = hit.value();
116                scan.do_action(actor, val, save, scan.first);
117            }
118            return hit;
119        }
120
121        ActionT const& predicate() const { return actor; }
122
123    private:
124
125        ActionT actor;
126    };
127
128BOOST_SPIRIT_CLASSIC_NAMESPACE_END
129
130}} // namespace BOOST_SPIRIT_CLASSIC_NS
131
132#endif