1 // Copyright (c) 2001-2011 Hartmut Kaiser
2 //
3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6 #include <boost/detail/lightweight_test.hpp>
7 #include <boost/config/warning_disable.hpp>
8
9 #include <boost/spirit/include/lex_lexertl.hpp>
10
11 namespace lex = boost::spirit::lex;
12
13 typedef lex::lexertl::token<std::string::iterator> token_type;
14 typedef lex::lexertl::actor_lexer<token_type> lexer_type;
15
16 ///////////////////////////////////////////////////////////////////////////////
17 static bool found_identifier_flag = false;
18
19 ///////////////////////////////////////////////////////////////////////////////
found_identifier_sa0()20 void found_identifier_sa0()
21 {
22 found_identifier_flag = true;
23 }
24
25 template <typename Lexer>
26 struct lexer_sa0 : lex::lexer<Lexer>
27 {
lexer_sa0lexer_sa028 lexer_sa0()
29 {
30 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
31 this->self += identifier [&found_identifier_sa0];
32 }
33 lex::token_def<> identifier;
34 };
35
36 ///////////////////////////////////////////////////////////////////////////////
37 static std::string found_identifier_str;
38
found_identifier_sa2(std::string::iterator & start,std::string::iterator & end)39 void found_identifier_sa2(std::string::iterator& start
40 , std::string::iterator& end)
41 {
42 found_identifier_flag = true;
43 found_identifier_str = std::string(start, end);
44 }
45
46 template <typename Lexer>
47 struct lexer_sa2 : lex::lexer<Lexer>
48 {
lexer_sa2lexer_sa249 lexer_sa2()
50 {
51 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
52 this->self += identifier [&found_identifier_sa2];
53 }
54 lex::token_def<> identifier;
55 };
56
57 ///////////////////////////////////////////////////////////////////////////////
found_identifier_sa3_normal(std::string::iterator & start,std::string::iterator & end,BOOST_SCOPED_ENUM (lex::pass_flags)& pass)58 void found_identifier_sa3_normal(std::string::iterator& start
59 , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
60 {
61 BOOST_TEST(pass == lex::pass_flags::pass_normal);
62
63 found_identifier_flag = true;
64 found_identifier_str = std::string(start, end);
65 }
66
67 template <typename Lexer>
68 struct lexer_sa3_normal : lex::lexer<Lexer>
69 {
lexer_sa3_normallexer_sa3_normal70 lexer_sa3_normal()
71 {
72 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
73 this->self += identifier [&found_identifier_sa3_normal];
74 }
75 lex::token_def<> identifier;
76 };
77
found_identifier_sa3_fail(std::string::iterator &,std::string::iterator &,BOOST_SCOPED_ENUM (lex::pass_flags)& pass)78 void found_identifier_sa3_fail(std::string::iterator&, std::string::iterator&
79 , BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
80 {
81 pass = lex::pass_flags::pass_fail;
82 }
83
84 template <typename Lexer>
85 struct lexer_sa3_fail : lex::lexer<Lexer>
86 {
lexer_sa3_faillexer_sa3_fail87 lexer_sa3_fail()
88 {
89 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
90 this->self += identifier [&found_identifier_sa3_fail];
91 }
92 lex::token_def<> identifier;
93 };
94
found_identifier_sa3_ignore(std::string::iterator &,std::string::iterator &,BOOST_SCOPED_ENUM (lex::pass_flags)& pass)95 void found_identifier_sa3_ignore(std::string::iterator&, std::string::iterator&
96 , BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
97 {
98 pass = lex::pass_flags::pass_ignore;
99 }
100
101 template <typename Lexer>
102 struct lexer_sa3_ignore : lex::lexer<Lexer>
103 {
lexer_sa3_ignorelexer_sa3_ignore104 lexer_sa3_ignore()
105 {
106 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
107 this->self += identifier [&found_identifier_sa3_ignore];
108 }
109 lex::token_def<> identifier;
110 };
111
112 ///////////////////////////////////////////////////////////////////////////////
113 static std::size_t found_identifier_id = 0;
114
found_identifier_sa4(std::string::iterator & start,std::string::iterator & end,BOOST_SCOPED_ENUM (lex::pass_flags)& pass,std::size_t id)115 void found_identifier_sa4(std::string::iterator& start
116 , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
117 , std::size_t id)
118 {
119 BOOST_TEST(pass == lex::pass_flags::pass_normal);
120
121 found_identifier_flag = true;
122 found_identifier_str = std::string(start, end);
123 found_identifier_id = id;
124 }
125
126 template <typename Lexer>
127 struct lexer_sa4 : lex::lexer<Lexer>
128 {
lexer_sa4lexer_sa4129 lexer_sa4()
130 {
131 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
132 this->self += identifier [&found_identifier_sa4];
133 }
134 lex::token_def<> identifier;
135 };
136
found_identifier_sa4_id(std::string::iterator & start,std::string::iterator & end,BOOST_SCOPED_ENUM (lex::pass_flags)& pass,std::size_t & id)137 void found_identifier_sa4_id(std::string::iterator& start
138 , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
139 , std::size_t& id)
140 {
141 BOOST_TEST(pass == lex::pass_flags::pass_normal);
142
143 found_identifier_flag = true;
144 found_identifier_str = std::string(start, end);
145 found_identifier_id = id;
146 id = 1;
147 }
148
149 template <typename Lexer>
150 struct lexer_sa4_id : lex::lexer<Lexer>
151 {
lexer_sa4_idlexer_sa4_id152 lexer_sa4_id()
153 {
154 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
155 this->self += identifier [&found_identifier_sa4_id];
156 }
157 lex::token_def<> identifier;
158 };
159
160 static std::size_t found_identifier_id2 = 0;
161
identifier_token(token_type const & t)162 bool identifier_token(token_type const& t)
163 {
164 found_identifier_id2 = t.id();
165 return true;
166 }
167
168 ///////////////////////////////////////////////////////////////////////////////
169 struct found_identifier_sa5
170 {
171 template <typename Context>
operator ()found_identifier_sa5172 void operator()(std::string::iterator& /*start*/
173 , std::string::iterator& /*end*/, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
174 , std::size_t& /*id*/, Context& ctx)
175 {
176 BOOST_TEST(pass == lex::pass_flags::pass_normal);
177
178 found_identifier_flag = true;
179 found_identifier_str = std::string(ctx.get_value().begin(), ctx.get_value().end());
180 }
181 };
182
183 template <typename Lexer>
184 struct lexer_sa5 : lex::lexer<Lexer>
185 {
lexer_sa5lexer_sa5186 lexer_sa5()
187 {
188 identifier = "[a-zA-Z][_a-zA-Z0-9]*";
189 this->self += identifier [found_identifier_sa5()];
190 }
191 lex::token_def<> identifier;
192 };
193
194 ///////////////////////////////////////////////////////////////////////////////
main()195 int main()
196 {
197 std::string identifier ("id_1234");
198 std::string::iterator first = identifier.begin();
199 std::string::iterator last = identifier.end();
200
201 // test semantic action taking no arguments
202 found_identifier_flag = false;
203 {
204 lexer_sa0<lexer_type> sa0;
205 BOOST_TEST(lex::tokenize(first, last, sa0));
206 BOOST_TEST(first == last);
207 BOOST_TEST(found_identifier_flag);
208 }
209
210 // test semantic action taking two arguments (iterator pair for matched
211 // sequence)
212 found_identifier_flag = false;
213 found_identifier_str.clear();
214 first = identifier.begin();
215 {
216 lexer_sa2<lexer_type> sa2;
217 BOOST_TEST(lex::tokenize(first, last, sa2));
218 BOOST_TEST(first == last);
219 BOOST_TEST(found_identifier_flag);
220 BOOST_TEST(found_identifier_str == identifier);
221 }
222
223 // test semantic action taking three arguments (iterator pair for matched
224 // sequence and pass_flags) - pass_flags::pass_normal
225 found_identifier_flag = false;
226 found_identifier_str.clear();
227 first = identifier.begin();
228 {
229 lexer_sa3_normal<lexer_type> sa3;
230 BOOST_TEST(lex::tokenize(first, last, sa3));
231 BOOST_TEST(first == last);
232 BOOST_TEST(found_identifier_flag);
233 BOOST_TEST(found_identifier_str == identifier);
234 }
235
236 // test semantic action taking three arguments (iterator pair for matched
237 // sequence and pass_flags) - pass_flags::pass_fail
238 first = identifier.begin();
239 {
240 lexer_sa3_fail<lexer_type> sa3;
241 BOOST_TEST(!lex::tokenize(first, last, sa3));
242 BOOST_TEST(first != last);
243 }
244
245 // test semantic action taking three arguments (iterator pair for matched
246 // sequence and pass_flags) - pass_flags::pass_ignore
247 first = identifier.begin();
248 {
249 lexer_sa3_ignore<lexer_type> sa3;
250 BOOST_TEST(lex::tokenize(first, last, sa3));
251 BOOST_TEST(first == last);
252 }
253
254 // test semantic action taking four arguments (iterator pair for matched
255 // sequence and pass_flags, and token id)
256 found_identifier_flag = false;
257 found_identifier_str.clear();
258 first = identifier.begin();
259 found_identifier_id = 0;
260 {
261 lexer_sa4<lexer_type> sa4;
262 BOOST_TEST(lex::tokenize(first, last, sa4));
263 BOOST_TEST(first == last);
264 BOOST_TEST(found_identifier_flag);
265 BOOST_TEST(found_identifier_str == identifier);
266 BOOST_TEST(found_identifier_id == lex::min_token_id);
267 }
268
269 found_identifier_flag = false;
270 found_identifier_str.clear();
271 first = identifier.begin();
272 found_identifier_id = 0;
273 found_identifier_id2 = 0;
274 {
275 lexer_sa4_id<lexer_type> sa4;
276 BOOST_TEST(lex::tokenize(first, last, sa4, identifier_token));
277 BOOST_TEST(first == last);
278 BOOST_TEST(found_identifier_flag);
279 BOOST_TEST(found_identifier_str == identifier);
280 BOOST_TEST(found_identifier_id == lex::min_token_id);
281 BOOST_TEST(found_identifier_id2 == 1);
282 }
283
284 // test semantic action taking four arguments (iterator pair for matched
285 // sequence and pass_flags, token id, and context)
286 found_identifier_flag = false;
287 found_identifier_str.clear();
288 first = identifier.begin();
289 found_identifier_id = 0;
290 found_identifier_id2 = 0;
291 {
292 lexer_sa5<lexer_type> sa5;
293 BOOST_TEST(lex::tokenize(first, last, sa5));
294 BOOST_TEST(first == last);
295 BOOST_TEST(found_identifier_flag);
296 BOOST_TEST(found_identifier_str == identifier);
297 }
298
299 return boost::report_errors();
300 }
301