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
|
/*=============================================================================
Boost.Wave: A Standard compliant C++ preprocessor library
Definition of the lexer iterator for the xpressive lexer
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(XLEX_ITERATOR_HPP)
#define XLEX_ITERATOR_HPP
#include <string>
#include <iostream>
#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 "xlex_interface.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {
namespace cpplexer {
namespace xlex {
namespace impl {
///////////////////////////////////////////////////////////////////////////////
//
// lex_iterator_functor_shim
//
///////////////////////////////////////////////////////////////////////////////
template <typename TokenT>
class xlex_iterator_functor_shim
{
public:
template <typename IteratorT>
xlex_iterator_functor_shim(IteratorT const &first, IteratorT const &last,
typename TokenT::position_type const &pos,
boost::wave::language_support language)
: functor_ptr(xlex_input_interface<TokenT>
::new_lexer(first, last, pos, language))
{}
// interface to the boost::spirit::multi_pass_policies::functor_input policy
typedef TokenT result_type;
/*static*/ 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
{
return functor_ptr->has_include_guards(guard_name);
}
#endif
private:
boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr;
};
///////////////////////////////////////////////////////////////////////////////
// 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();
///////////////////////////////////////////////////////////////////////////////
} // 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.)
//
///////////////////////////////////////////////////////////////////////////////
template <typename TokenT>
class xlex_iterator
: public boost::spirit::multi_pass<
impl::xlex_iterator_functor_shim<TokenT>,
boost::wave::util::functor_input
>
{
typedef impl::xlex_iterator_functor_shim<TokenT> input_policy_type;
typedef
boost::spirit::multi_pass<input_policy_type,
boost::wave::util::functor_input>
base_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(input_policy_type(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 = base_type::get_input();
position_type currpos = currtoken.get_position();
currpos.set_file(pos.get_file());
currpos.set_line(pos.get_line());
base_type::get_input().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
bool has_include_guards(std::string& guard_name) const
{
return base_type::get_functor().has_include_guards(guard_name);
}
#endif
};
///////////////////////////////////////////////////////////////////////////////
} // namespace xlex
} // namespace cpplexer
} // namespace wave
} // namespace boost
#endif // !defined(XLEX_ITERATOR_HPP)
|
