diff options
author | Vlad Voicu <vladv@rosedu.org> | 2012-03-02 10:01:11 (GMT) |
---|---|---|
committer | Kevin Smith <git@kismith.co.uk> | 2012-03-09 15:04:05 (GMT) |
commit | 1c8cd160b79b6bbcec72042bdb104ba530508a93 (patch) | |
tree | cff302b81e74c557fbc9e30fd43144d981b613d0 /3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp | |
parent | 2944711aefec9a9dd66052440bc4f921910dd780 (diff) | |
download | swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.zip swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.tar.bz2 |
Added spirit to bundled boost
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp new file mode 100644 index 0000000..530bc26 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor.hpp @@ -0,0 +1,297 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// +// 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) + +#if !defined(BOOST_SPIRIT_LEX_LEXER_FUNCTOR_NOV_18_2007_1112PM) +#define BOOST_SPIRIT_LEX_LEXER_FUNCTOR_NOV_18_2007_1112PM + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/mpl/bool.hpp> +#include <boost/detail/iterator.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/spirit/home/lex/lexer/pass_flags.hpp> +#include <boost/assert.hpp> + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +#define BOOST_SPIRIT_STATIC_EOF 1 +#define BOOST_SPIRIT_EOF_PREFIX static +#else +#define BOOST_SPIRIT_EOF_PREFIX +#endif + +namespace boost { namespace spirit { namespace lex { namespace lexertl +{ + /////////////////////////////////////////////////////////////////////////// + // + // functor is a template usable as the functor object for the + // multi_pass iterator allowing to wrap a lexertl based dfa into a + // iterator based interface. + // + // Token: the type of the tokens produced by this functor + // this needs to expose a constructor with the following + // prototype: + // + // Token(std::size_t id, std::size_t state, + // Iterator start, Iterator end) + // + // where 'id' is the token id, state is the lexer state, + // this token has been matched in, and 'first' and 'end' + // mark the start and the end of the token with respect + // to the underlying character stream. + // FunctorData: + // this is expected to encapsulate the shared part of the + // functor (see lex/lexer/lexertl/functor_data.hpp for an + // example and documentation). + // Iterator: the type of the underlying iterator + // SupportsActors: + // this is expected to be a mpl::bool_, if mpl::true_ the + // functor invokes functors which (optionally) have + // been attached to the token definitions. + // SupportState: + // this is expected to be a mpl::bool_, if mpl::true_ the + // functor supports different lexer states, + // otherwise no lexer state is supported. + // + /////////////////////////////////////////////////////////////////////////// + template <typename Token + , template <typename, typename, typename, typename> class FunctorData + , typename Iterator = typename Token::iterator_type + , typename SupportsActors = mpl::false_ + , typename SupportsState = typename Token::has_state> + class functor + { + public: + typedef typename + boost::detail::iterator_traits<Iterator>::value_type + char_type; + + private: + // Needed by compilers not implementing the resolution to DR45. For + // reference, see + // http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#45. + typedef typename Token::token_value_type token_value_type; + friend class FunctorData<Iterator, SupportsActors, SupportsState + , token_value_type>; + + // Helper template allowing to assign a value on exit + template <typename T> + struct assign_on_exit + { + assign_on_exit(T& dst, T const& src) + : dst_(dst), src_(src) {} + + ~assign_on_exit() + { + dst_ = src_; + } + + T& dst_; + T const& src_; + + private: + // silence MSVC warning C4512: assignment operator could not be generated + assign_on_exit& operator= (assign_on_exit const&); + }; + + public: + functor() +#if defined(__PGI) + : eof() +#endif + {} + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310) + // somehow VC7.1 needs this (meaningless) assignment operator + functor& operator=(functor const& rhs) + { + return *this; + } +#endif + + /////////////////////////////////////////////////////////////////////// + // interface to the iterator_policies::split_functor_input policy + typedef Token result_type; + typedef functor unique; + typedef FunctorData<Iterator, SupportsActors, SupportsState + , token_value_type> shared; + + BOOST_SPIRIT_EOF_PREFIX result_type const eof; + + /////////////////////////////////////////////////////////////////////// + typedef Iterator iterator_type; + typedef typename shared::semantic_actions_type semantic_actions_type; + typedef typename shared::next_token_functor next_token_functor; + typedef typename shared::get_state_name_type get_state_name_type; + + // this is needed to wrap the semantic actions in a proper way + typedef typename shared::wrap_action_type wrap_action_type; + + /////////////////////////////////////////////////////////////////////// + template <typename MultiPass> + static result_type& get_next(MultiPass& mp, result_type& result) + { + typedef typename result_type::id_type id_type; + + shared& data = mp.shared()->ftor; + for(;;) + { + if (data.get_first() == data.get_last()) +#if defined(BOOST_SPIRIT_STATIC_EOF) + return result = eof; +#else + return result = mp.ftor.eof; +#endif + + data.reset_value(); + Iterator end = data.get_first(); + std::size_t unique_id = boost::lexer::npos; + bool prev_bol = false; + + // lexer matching might change state + std::size_t state = data.get_state(); + std::size_t id = data.next(end, unique_id, prev_bol); + + if (boost::lexer::npos == id) { // no match +#if defined(BOOST_SPIRIT_LEXERTL_DEBUG) + std::string next; + Iterator it = data.get_first(); + for (std::size_t i = 0; i < 10 && it != data.get_last(); ++it, ++i) + next += *it; + + std::cerr << "Not matched, in state: " << state + << ", lookahead: >" << next << "<" << std::endl; +#endif + return result = result_type(0); + } + else if (0 == id) { // EOF reached +#if defined(BOOST_SPIRIT_STATIC_EOF) + return result = eof; +#else + return result = mp.ftor.eof; +#endif + } + +#if defined(BOOST_SPIRIT_LEXERTL_DEBUG) + { + std::string next; + Iterator it = end; + for (std::size_t i = 0; i < 10 && it != data.get_last(); ++it, ++i) + next += *it; + + std::cerr << "Matched: " << id << ", in state: " + << state << ", string: >" + << std::basic_string<char_type>(data.get_first(), end) << "<" + << ", lookahead: >" << next << "<" << std::endl; + if (data.get_state() != state) { + std::cerr << "Switched to state: " + << data.get_state() << std::endl; + } + } +#endif + // account for a possibly pending lex::more(), i.e. moving + // data.first_ back to the start of the previously matched token. + bool adjusted = data.adjust_start(); + + // invoke attached semantic actions, if defined, might change + // state, id, data.first_, and/or end + BOOST_SCOPED_ENUM(pass_flags) pass = + data.invoke_actions(state, id, unique_id, end); + + if (data.has_value()) { + // return matched token using the token value as set before + // using data.set_value(), advancing 'data.first_' past the + // matched sequence + assign_on_exit<Iterator> on_exit(data.get_first(), end); + return result = result_type(id_type(id), state, data.get_value()); + } + else if (pass_flags::pass_normal == pass) { + // return matched token, advancing 'data.first_' past the + // matched sequence + assign_on_exit<Iterator> on_exit(data.get_first(), end); + return result = result_type(id_type(id), state, data.get_first(), end); + } + else if (pass_flags::pass_fail == pass) { +#if defined(BOOST_SPIRIT_LEXERTL_DEBUG) + std::cerr << "Matching forced to fail" << std::endl; +#endif + // if the data.first_ got adjusted above, revert this adjustment + if (adjusted) + data.revert_adjust_start(); + + // one of the semantic actions signaled no-match + data.reset_bol(prev_bol); + if (state != data.get_state()) + continue; // retry matching if state has changed + + // if the state is unchanged repeating the match wouldn't + // move the input forward, causing an infinite loop + return result = result_type(0); + } + +#if defined(BOOST_SPIRIT_LEXERTL_DEBUG) + std::cerr << "Token ignored, continuing matching" << std::endl; +#endif + // if this token needs to be ignored, just repeat the matching, + // while starting right after the current match + data.get_first() = end; + } + } + + // set_state are propagated up to the iterator interface, allowing to + // manipulate the current lexer state through any of the exposed + // iterators. + template <typename MultiPass> + static std::size_t set_state(MultiPass& mp, std::size_t state) + { + std::size_t oldstate = mp.shared()->ftor.get_state(); + mp.shared()->ftor.set_state(state); + +#if defined(BOOST_SPIRIT_LEXERTL_DEBUG) + std::cerr << "Switching state from: " << oldstate + << " to: " << state + << std::endl; +#endif + return oldstate; + } + + template <typename MultiPass> + static std::size_t get_state(MultiPass& mp) + { + return mp.shared()->ftor.get_state(); + } + + template <typename MultiPass> + static std::size_t + map_state(MultiPass const& mp, char_type const* statename) + { + return mp.shared()->ftor.get_state_id(statename); + } + + // we don't need this, but it must be there + template <typename MultiPass> + static void destroy(MultiPass const&) {} + }; + +#if defined(BOOST_SPIRIT_STATIC_EOF) + /////////////////////////////////////////////////////////////////////////// + // eof token + /////////////////////////////////////////////////////////////////////////// + template <typename Token + , template <typename, typename, typename, typename> class FunctorData + , typename Iterator, typename SupportsActors, typename SupportsState> + typename functor<Token, FunctorData, Iterator, SupportsActors, SupportsState>::result_type const + functor<Token, FunctorData, Iterator, SupportsActors, SupportsState>::eof = + typename functor<Token, FunctorData, Iterator, SupportsActors + , SupportsState>::result_type(); +#endif + +}}}} + +#undef BOOST_SPIRIT_EOF_PREFIX +#undef BOOST_SPIRIT_STATIC_EOF + +#endif |