| /*============================================================================= |
| Boost.Wave: A Standard compliant C++ preprocessor library |
| |
| Definition of the lexer iterator for the xpressive lexer |
| |
| http://www.boost.org/ |
| |
| Copyright (c) 2001-2010 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(XLEX_ITERATOR_HPP) |
| #define XLEX_ITERATOR_HPP |
| |
| #include <string> |
| #include <iostream> |
| |
| #include <boost/assert.hpp> |
| #include <boost/shared_ptr.hpp> |
| #include <boost/spirit/include/support_multi_pass.hpp> |
| |
| #include <boost/wave/language_support.hpp> |
| #include <boost/wave/util/file_position.hpp> |
| #include <boost/wave/util/functor_input.hpp> |
| |
| #include "xlex_interface.hpp" |
| |
| #if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) |
| #define BOOST_WAVE_EOF_PREFIX static |
| #else |
| #define BOOST_WAVE_EOF_PREFIX |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { |
| namespace wave { |
| namespace cpplexer { |
| namespace xlex { |
| namespace impl { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // lex_iterator_functor_shim |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| template <typename TokenT> |
| class xlex_iterator_functor_shim |
| { |
| typedef typename TokenT::position_type position_type; |
| |
| public: |
| xlex_iterator_functor_shim() |
| #if /*0 != __DECCXX_VER || */defined(__PGI) |
| : eof() |
| #endif // 0 != __DECCXX_VER |
| {} |
| |
| // interface to the boost::spirit::classic::iterator_policies::functor_input |
| // policy |
| typedef TokenT result_type; |
| |
| BOOST_WAVE_EOF_PREFIX result_type const eof; |
| typedef xlex_iterator_functor_shim unique; |
| typedef lex_input_interface<TokenT>* shared; |
| |
| template <typename MultiPass> |
| static result_type& get_next(MultiPass& mp, result_type& result) |
| { |
| return mp.shared()->ftor->get(result); |
| } |
| |
| // this will be called whenever the last reference to a multi_pass will |
| // be released |
| template <typename MultiPass> |
| static void destroy(MultiPass& mp) |
| { |
| delete mp.shared()->ftor; |
| } |
| |
| template <typename MultiPass> |
| static void set_position(MultiPass& mp, position_type const &pos) |
| { |
| mp.shared()->ftor->set_position(pos); |
| } |
| |
| #if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 |
| template <typename MultiPass> |
| static bool has_include_guards(MultiPass& mp, std::string& guard_name) |
| { |
| return mp.shared()->ftor->has_include_guards(guard_name); |
| } |
| #endif |
| |
| private: |
| boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr; |
| }; |
| |
| #if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) |
| /////////////////////////////////////////////////////////////////////////////// |
| // eof token |
| template <typename TokenT> |
| typename xlex_iterator_functor_shim<TokenT>::result_type const |
| xlex_iterator_functor_shim<TokenT>::eof = |
| typename xlex_iterator_functor_shim<TokenT>::result_type(); |
| #endif // 0 != __COMO_VERSION__ |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| } // namespace impl |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // xlex_iterator |
| // |
| // A generic C++ lexer interface class, which allows to plug in different |
| // lexer implementations (template parameter LexT). The following |
| // requirement apply: |
| // |
| // - the lexer type should have a function implemented, which returns |
| // the next lexed token from the input stream: |
| // typename LexT::token_type get(); |
| // - at the end of the input stream this function should return the |
| // eof token equivalent |
| // - the lexer should implement a constructor taking two iterators |
| // pointing to the beginning and the end of the input stream and |
| // a third parameter containing the name of the parsed input file, |
| // the 4th parameter contains the information about the mode the |
| // preprocessor is used in (C99/C++ mode etc.) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Divide the given functor type into its components (unique and shared) |
| // and build a std::pair from these parts |
| template <typename FunctorData> |
| struct make_multi_pass |
| { |
| typedef |
| std::pair<typename FunctorData::unique, typename FunctorData::shared> |
| functor_data_type; |
| typedef typename FunctorData::result_type result_type; |
| |
| typedef boost::spirit::iterator_policies::split_functor_input input_policy; |
| typedef boost::spirit::iterator_policies::ref_counted ownership_policy; |
| #if defined(BOOST_WAVE_DEBUG) |
| typedef boost::spirit::iterator_policies::buf_id_check check_policy; |
| #else |
| typedef boost::spirit::iterator_policies::no_check check_policy; |
| #endif |
| typedef boost::spirit::iterator_policies::split_std_deque storage_policy; |
| |
| typedef boost::spirit::iterator_policies::default_policy< |
| ownership_policy, check_policy, input_policy, storage_policy> |
| policy_type; |
| typedef boost::spirit::multi_pass<functor_data_type, policy_type> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename TokenT> |
| class xlex_iterator |
| : public make_multi_pass<impl::xlex_iterator_functor_shim<TokenT> >::type |
| { |
| typedef impl::xlex_iterator_functor_shim<TokenT> input_policy_type; |
| |
| typedef typename make_multi_pass<input_policy_type>::type base_type; |
| typedef typename make_multi_pass<input_policy_type>::functor_data_type |
| functor_data_type; |
| |
| typedef typename input_policy_type::unique unique_functor_type; |
| typedef typename input_policy_type::shared shared_functor_type; |
| |
| public: |
| typedef TokenT token_type; |
| |
| xlex_iterator() |
| {} |
| |
| template <typename IteratorT> |
| xlex_iterator(IteratorT const &first, IteratorT const &last, |
| typename TokenT::position_type const &pos, |
| boost::wave::language_support language) |
| : base_type( |
| functor_data_type( |
| unique_functor_type(), |
| xlex_input_interface<TokenT> |
| ::new_lexer(first, last, pos, language) |
| ) |
| ) |
| {} |
| |
| void set_position(typename TokenT::position_type const &pos) |
| { |
| typedef typename token_type::position_type position_type; |
| |
| // set the new position in the current token |
| token_type const& currtoken = this->base_type::dereference(*this); |
| position_type currpos = currtoken.get_position(); |
| |
| currpos.set_file(pos.get_file()); |
| currpos.set_line(pos.get_line()); |
| const_cast<token_type&>(currtoken).set_position(currpos); |
| |
| // set the new position for future tokens as well |
| if (token_type::string_type::npos != |
| currtoken.get_value().find_first_of('\n')) |
| { |
| currpos.set_line(pos.get_line() + 1); |
| } |
| unique_functor_type::set_position(*this, currpos); |
| } |
| |
| #if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 |
| // return, whether the current file has include guards |
| // this function returns meaningful results only if the file was scanned |
| // completely |
| bool has_include_guards(std::string& guard_name) const |
| { |
| return unique_functor_type::has_include_guards(*this, guard_name); |
| } |
| #endif |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| } // namespace xlex |
| } // namespace cpplexer |
| } // namespace wave |
| } // namespace boost |
| |
| #undef BOOST_WAVE_EOF_PREFIX |
| |
| #endif // !defined(XLEX_ITERATOR_HPP) |