1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/*=============================================================================
Boost.Wave: A Standard compliant C++ preprocessor library
Definition of the lexertl based lexer iterator
http://www.boost.org/
Copyright (c) 2001-2008 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_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED)
#define BOOST_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED
#include <string>
#include <boost/assert.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/spirit/iterator/multi_pass.hpp>
#include <boost/wave/language_support.hpp>
#include <boost/wave/util/file_position.hpp>
#include <boost/wave/util/functor_input.hpp>
#include "lexertl_interface.hpp"
#if 0 != __COMO_VERSION__
#define BOOST_WAVE_EOF_PREFIX static
#else
#define BOOST_WAVE_EOF_PREFIX
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace wave { namespace cpplexer { namespace lexertl
{
///////////////////////////////////////////////////////////////////////////////
namespace impl {
///////////////////////////////////////////////////////////////////////////////
//
// lex_iterator_functor_shim
//
///////////////////////////////////////////////////////////////////////////////
template <typename TokenT>
class iterator_functor_shim
{
public:
template <typename IteratorT>
iterator_functor_shim(IteratorT const &first, IteratorT const &last,
typename TokenT::position_type const &pos,
wave::language_support language)
: functor_ptr(lexertl_input_interface<TokenT>
::new_lexer(first, last, pos, language))
#if 0 != __DECCXX_VER
, eof()
#endif // 0 != __DECCXX_VER
{}
// interface to the boost::spirit::multi_pass_policies::functor_input policy
typedef TokenT result_type;
BOOST_WAVE_EOF_PREFIX result_type const eof;
result_type operator()()
{
BOOST_ASSERT(0 != functor_ptr.get());
return functor_ptr->get();
}
void set_position(typename TokenT::position_type const &pos)
{
BOOST_ASSERT(0 != functor_ptr.get());
functor_ptr->set_position(pos);
}
#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0
bool has_include_guards(std::string& guard_name) const
{
BOOST_ASSERT(0 != functor_ptr.get());
return functor_ptr->has_include_guards(guard_name);
}
#endif
private:
boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr;
};
#if 0 != __COMO_VERSION__
///////////////////////////////////////////////////////////////////////////////
// eof token
template <typename TokenT>
typename iterator_functor_shim<TokenT>::result_type const
iterator_functor_shim<TokenT>::eof =
typename iterator_functor_shim<TokenT>::result_type();
#endif // 0 != __COMO_VERSION__
///////////////////////////////////////////////////////////////////////////////
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
//
// lexertl_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 returnes
// 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.)
//
///////////////////////////////////////////////////////////////////////////////
template <typename TokenT>
class lex_iterator
: public boost::spirit::multi_pass<
impl::iterator_functor_shim<TokenT>,
boost::wave::util::functor_input
>
{
typedef impl::iterator_functor_shim<TokenT> input_policy_type;
typedef
boost::spirit::multi_pass<input_policy_type,
boost::wave::util::functor_input>
base_type;
typedef lex_iterator<TokenT> self_type;
public:
typedef TokenT token_type;
lex_iterator()
{}
template <typename IteratorT>
lex_iterator(IteratorT const &first, IteratorT const &last,
typename TokenT::position_type const &pos,
boost::wave::language_support language)
: base_type(input_policy_type(first, last, pos, language))
{}
void set_position(typename TokenT::position_type const &pos)
{
typedef typename TokenT::position_type position_type;
// set the new position in the current token
token_type& currtoken = base_type::get_input();
position_type currpos = currtoken.get_position();
currpos.set_file(pos.get_file());
currpos.set_line(pos.get_line());
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);
}
base_type::get_functor().set_position(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.
// For now we always return false, but this can be fixed easily later on.
bool has_include_guards(std::string& guard_name) const
{
return base_type::get_functor().has_include_guards(guard_name);
}
#endif
};
///////////////////////////////////////////////////////////////////////////////
}}}} // namespace boost::wave::cpplexer::lexertl
#undef BOOST_WAVE_EOF_PREFIX
#endif // !defined(BOOST_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED)
|
