Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/wave/util/insert_whitespace_detection.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
1 /*=============================================================================
2 Boost.Wave: A Standard compliant C++ preprocessor library
3
4 Detect the need to insert a whitespace token into the output stream
5
6 http://www.boost.org/
7
8 Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
9 Software License, Version 1.0. (See accompanying file
10 LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
11 =============================================================================*/
12 #if !defined(INSERT_WHITESPACE_DETECTION_HPP_765EF77B_0513_4967_BDD6_6A38148C4C96_INCLUDED)
13 #define INSERT_WHITESPACE_DETECTION_HPP_765EF77B_0513_4967_BDD6_6A38148C4C96_INCLUDED
14
15 #include <boost/wave/wave_config.hpp>
16 #include <boost/wave/token_ids.hpp>
17
18 // this must occur after all of the includes and before any code appears
19 #ifdef BOOST_HAS_ABI_HEADERS
20 #include BOOST_ABI_PREFIX
21 #endif
22
23 ///////////////////////////////////////////////////////////////////////////////
24 namespace boost {
25 namespace wave {
26 namespace util {
27
28 namespace impl {
29
30 // T_IDENTIFIER
31 template <typename StringT>
32 inline bool
33 would_form_universal_char (StringT const &value)
34 {
35 if ('u' != value[0] && 'U' != value[0])
36 return false;
37 if ('u' == value[0] && value.size() < 5)
38 return false;
39 if ('U' == value[0] && value.size() < 9)
40 return false;
41
42 typename StringT::size_type pos =
43 value.find_first_not_of("0123456789abcdefABCDEF", 1);
44
45 if (StringT::npos == pos ||
46 ('u' == value[0] && pos > 5) ||
47 ('U' == value[0] && pos > 9))
48 {
49 return true; // would form an universal char
50 }
51 return false;
52 }
53 template <typename StringT>
54 inline bool
55 handle_identifier(boost::wave::token_id prev,
56 boost::wave::token_id before, StringT const &value)
57 {
58 using namespace boost::wave;
59 switch (static_cast<unsigned int>(prev)) {
60 case T_IDENTIFIER:
61 case T_NONREPLACABLE_IDENTIFIER:
62 case T_COMPL_ALT:
63 case T_OR_ALT:
64 case T_AND_ALT:
65 case T_NOT_ALT:
66 case T_XOR_ALT:
67 case T_ANDASSIGN_ALT:
68 case T_ORASSIGN_ALT:
69 case T_XORASSIGN_ALT:
70 case T_NOTEQUAL_ALT:
71 case T_FIXEDPOINTLIT:
72 return true;
73
74 case T_FLOATLIT:
75 case T_INTLIT:
76 case T_PP_NUMBER:
77 return (value.size() > 1 || (value[0] != 'e' && value[0] != 'E'));
78
79 // avoid constructing universal characters (\u1234)
80 case TOKEN_FROM_ID('\\', UnknownTokenType):
81 return would_form_universal_char(value);
82 }
83 return false;
84 }
85 // T_INTLIT
86 inline bool
87 handle_intlit(boost::wave::token_id prev, boost::wave::token_id /*before*/)
88 {
89 using namespace boost::wave;
90 switch (static_cast<unsigned int>(prev)) {
91 case T_IDENTIFIER:
92 case T_NONREPLACABLE_IDENTIFIER:
93 case T_INTLIT:
94 case T_FLOATLIT:
95 case T_FIXEDPOINTLIT:
96 case T_PP_NUMBER:
97 return true;
98 }
99 return false;
100 }
101 // T_FLOATLIT
102 inline bool
103 handle_floatlit(boost::wave::token_id prev,
104 boost::wave::token_id /*before*/)
105 {
106 using namespace boost::wave;
107 switch (static_cast<unsigned int>(prev)) {
108 case T_IDENTIFIER:
109 case T_NONREPLACABLE_IDENTIFIER:
110 case T_INTLIT:
111 case T_FLOATLIT:
112 case T_FIXEDPOINTLIT:
113 case T_PP_NUMBER:
114 return true;
115 }
116 return false;
117 }
118 // <% T_LEFTBRACE
119 inline bool
120 handle_alt_leftbrace(boost::wave::token_id prev,
121 boost::wave::token_id /*before*/)
122 {
123 using namespace boost::wave;
124 switch (static_cast<unsigned int>(prev)) {
125 case T_LESS: // <<%
126 case T_SHIFTLEFT: // <<<%
127 return true;
128 }
129 return false;
130 }
131 // <: T_LEFTBRACKET
132 inline bool
133 handle_alt_leftbracket(boost::wave::token_id prev,
134 boost::wave::token_id /*before*/)
135 {
136 using namespace boost::wave;
137 switch (static_cast<unsigned int>(prev)) {
138 case T_LESS: // <<:
139 case T_SHIFTLEFT: // <<<:
140 return true;
141 }
142 return false;
143 }
144 // T_FIXEDPOINTLIT
145 inline bool
146 handle_fixedpointlit(boost::wave::token_id prev,
147 boost::wave::token_id /*before*/)
148 {
149 using namespace boost::wave;
150 switch (static_cast<unsigned int>(prev)) {
151 case T_IDENTIFIER:
152 case T_NONREPLACABLE_IDENTIFIER:
153 case T_INTLIT:
154 case T_FLOATLIT:
155 case T_FIXEDPOINTLIT:
156 case T_PP_NUMBER:
157 return true;
158 }
159 return false;
160 }
161 // T_DOT
162 inline bool
163 handle_dot(boost::wave::token_id prev, boost::wave::token_id before)
164 {
165 using namespace boost::wave;
166 switch (static_cast<unsigned int>(prev)) {
167 case T_DOT:
168 if (T_DOT == before)
169 return true; // ...
170 break;
171 }
172 return false;
173 }
174 // T_QUESTION_MARK
175 inline bool
176 handle_questionmark(boost::wave::token_id prev,
177 boost::wave::token_id /*before*/)
178 {
179 using namespace boost::wave;
180 switch(static_cast<unsigned int>(prev)) {
181 case TOKEN_FROM_ID('\\', UnknownTokenType): // \?
182 case T_QUESTION_MARK: // ??
183 return true;
184 }
185 return false;
186 }
187 // T_NEWLINE
188 inline bool
189 handle_newline(boost::wave::token_id prev,
190 boost::wave::token_id before)
191 {
192 using namespace boost::wave;
193 switch(static_cast<unsigned int>(prev)) {
194 case TOKEN_FROM_ID('\\', UnknownTokenType): // \ \n
195 case T_DIVIDE:
196 if (T_QUESTION_MARK == before)
197 return true; // ?/\n // may be \\n
198 break;
199 }
200 return false;
201 }
202
203 inline bool
204 handle_parens(boost::wave::token_id prev)
205 {
206 switch (static_cast<unsigned int>(prev)) {
207 case T_LEFTPAREN:
208 case T_RIGHTPAREN:
209 case T_LEFTBRACKET:
210 case T_RIGHTBRACKET:
211 case T_LEFTBRACE:
212 case T_RIGHTBRACE:
213 case T_SEMICOLON:
214 case T_COMMA:
215 case T_COLON:
216 // no insertion between parens/brackets/braces and operators
217 return false;
218
219 default:
220 break;
221 }
222 return true;
223 }
224
225 } // namespace impl
226
227 class insert_whitespace_detection
228 {
229 public:
230 insert_whitespace_detection(bool insert_whitespace_ = true)
231 : insert_whitespace(insert_whitespace_),
232 prev(boost::wave::T_EOF), beforeprev(boost::wave::T_EOF)
233 {}
234
235 template <typename StringT>
236 bool must_insert(boost::wave::token_id current, StringT const &value)
237 {
238 if (!insert_whitespace)
239 return false; // skip whitespace insertion alltogether
240
241 using namespace boost::wave;
242 switch (static_cast<unsigned int>(current)) {
243 case T_NONREPLACABLE_IDENTIFIER:
244 case T_IDENTIFIER:
245 return impl::handle_identifier(prev, beforeprev, value);
246 case T_PP_NUMBER:
247 case T_INTLIT:
248 return impl::handle_intlit(prev, beforeprev);
249 case T_FLOATLIT:
250 return impl::handle_floatlit(prev, beforeprev);
251 case T_STRINGLIT:
252 if (TOKEN_FROM_ID('L', IdentifierTokenType) == prev) // 'L'
253 return true;
254 break;
255 case T_LEFTBRACE_ALT:
256 return impl::handle_alt_leftbrace(prev, beforeprev);
257 case T_LEFTBRACKET_ALT:
258 return impl::handle_alt_leftbracket(prev, beforeprev);
259 case T_FIXEDPOINTLIT:
260 return impl::handle_fixedpointlit(prev, beforeprev);
261 case T_DOT:
262 return impl::handle_dot(prev, beforeprev);
263 case T_QUESTION_MARK:
264 return impl::handle_questionmark(prev, beforeprev);
265 case T_NEWLINE:
266 return impl::handle_newline(prev, beforeprev);
267
268 case T_LEFTPAREN:
269 case T_RIGHTPAREN:
270 case T_LEFTBRACKET:
271 case T_RIGHTBRACKET:
272 case T_SEMICOLON:
273 case T_COMMA:
274 case T_COLON:
275 switch (static_cast<unsigned int>(prev)) {
276 case T_LEFTPAREN:
277 case T_RIGHTPAREN:
278 case T_LEFTBRACKET:
279 case T_RIGHTBRACKET:
280 case T_LEFTBRACE:
281 case T_RIGHTBRACE:
282 return false; // no insertion between parens/brackets/braces
283
284 default:
285 if (IS_CATEGORY(prev, OperatorTokenType))
286 return false;
287 break;
288 }
289 break;
290
291 case T_LEFTBRACE:
292 case T_RIGHTBRACE:
293 switch (static_cast<unsigned int>(prev)) {
294 case T_LEFTPAREN:
295 case T_RIGHTPAREN:
296 case T_LEFTBRACKET:
297 case T_RIGHTBRACKET:
298 case T_LEFTBRACE:
299 case T_RIGHTBRACE:
300 case T_SEMICOLON:
301 case T_COMMA:
302 case T_COLON:
303 return false; // no insertion between parens/brackets/braces
304
305 case T_QUESTION_MARK:
306 if (T_QUESTION_MARK == beforeprev)
307 return true;
308 if (IS_CATEGORY(prev, OperatorTokenType))
309 return false;
310 break;
311
312 default:
313 break;
314 }
315 break;
316
317 case T_MINUS:
318 case T_MINUSMINUS:
319 case T_MINUSASSIGN:
320 if (T_MINUS == prev || T_MINUSMINUS == prev)
321 return true;
322 if (!impl::handle_parens(prev))
323 return false;
324 if (T_QUESTION_MARK == prev && T_QUESTION_MARK == beforeprev)
325 return true;
326 break;
327
328 case T_PLUS:
329 case T_PLUSPLUS:
330 case T_PLUSASSIGN:
331 if (T_PLUS == prev || T_PLUSPLUS == prev)
332 return true;
333 if (!impl::handle_parens(prev))
334 return false;
335 if (T_QUESTION_MARK == prev && T_QUESTION_MARK == beforeprev)
336 return true;
337 break;
338
339 case T_DIVIDE:
340 case T_DIVIDEASSIGN:
341 if (T_DIVIDE == prev)
342 return true;
343 if (!impl::handle_parens(prev))
344 return false;
345 if (T_QUESTION_MARK == prev && T_QUESTION_MARK == beforeprev)
346 return true;
347 break;
348
349 case T_EQUAL:
350 case T_ASSIGN:
351 switch (static_cast<unsigned int>(prev)) {
352 case T_PLUSASSIGN:
353 case T_MINUSASSIGN:
354 case T_DIVIDEASSIGN:
355 case T_STARASSIGN:
356 case T_SHIFTRIGHTASSIGN:
357 case T_SHIFTLEFTASSIGN:
358 case T_EQUAL:
359 case T_NOTEQUAL:
360 case T_LESSEQUAL:
361 case T_GREATEREQUAL:
362 case T_LESS:
363 case T_GREATER:
364 case T_PLUS:
365 case T_MINUS:
366 case T_STAR:
367 case T_DIVIDE:
368 case T_ORASSIGN:
369 case T_ANDASSIGN:
370 case T_XORASSIGN:
371 case T_OR:
372 case T_AND:
373 case T_XOR:
374 case T_OROR:
375 case T_ANDAND:
376 return true;
377
378 case T_QUESTION_MARK:
379 if (T_QUESTION_MARK == beforeprev)
380 return true;
381 break;
382
383 default:
384 if (!impl::handle_parens(prev))
385 return false;
386 break;
387 }
388 break;
389
390 case T_GREATER:
391 if (T_MINUS == prev || T_GREATER == prev)
392 return true; // prevent -> or >>
393 if (!impl::handle_parens(prev))
394 return false;
395 if (T_QUESTION_MARK == prev && T_QUESTION_MARK == beforeprev)
396 return true;
397 break;
398
399 case T_LESS:
400 if (T_LESS == prev)
401 return true; // prevent <<
402 // fall through
403 case T_CHARLIT:
404 case T_NOT:
405 case T_NOTEQUAL:
406 if (!impl::handle_parens(prev))
407 return false;
408 if (T_QUESTION_MARK == prev && T_QUESTION_MARK == beforeprev)
409 return true;
410 break;
411
412 case T_AND:
413 case T_ANDAND:
414 if (!impl::handle_parens(prev))
415 return false;
416 if (T_AND == prev || T_ANDAND == prev)
417 return true;
418 break;
419
420 case T_OR:
421 if (!impl::handle_parens(prev))
422 return false;
423 if (T_OR == prev)
424 return true;
425 break;
426
427 case T_XOR:
428 if (!impl::handle_parens(prev))
429 return false;
430 if (T_XOR == prev)
431 return true;
432 break;
433
434 case T_COMPL_ALT:
435 case T_OR_ALT:
436 case T_AND_ALT:
437 case T_NOT_ALT:
438 case T_XOR_ALT:
439 case T_ANDASSIGN_ALT:
440 case T_ORASSIGN_ALT:
441 case T_XORASSIGN_ALT:
442 case T_NOTEQUAL_ALT:
443 switch (static_cast<unsigned int>(prev)) {
444 case T_LEFTPAREN:
445 case T_RIGHTPAREN:
446 case T_LEFTBRACKET:
447 case T_RIGHTBRACKET:
448 case T_LEFTBRACE:
449 case T_RIGHTBRACE:
450 case T_SEMICOLON:
451 case T_COMMA:
452 case T_COLON:
453 // no insertion between parens/brackets/braces and operators
454 return false;
455
456 case T_IDENTIFIER:
457 if (T_NONREPLACABLE_IDENTIFIER == prev ||
458 IS_CATEGORY(prev, KeywordTokenType))
459 {
460 return true;
461 }
462 break;
463
464 default:
465 break;
466 }
467 break;
468
469 case T_STAR:
470 if (T_STAR == prev)
471 return false; // '*****' do not need to be separated
472 if (T_GREATER== prev &&
473 (T_MINUS == beforeprev || T_MINUSMINUS == beforeprev)
474 )
475 {
476 return true; // prevent ->*
477 }
478 break;
479
480 case T_POUND:
481 if (T_POUND == prev)
482 return true;
483 break;
484 }
485
486 // FIXME: else, handle operators separately (will catch to many cases)
487 // if (IS_CATEGORY(current, OperatorTokenType) &&
488 // IS_CATEGORY(prev, OperatorTokenType))
489 // {
490 // return true; // operators must be delimited always
491 // }
492 return false;
493 }
494 void shift_tokens (boost::wave::token_id next_id)
495 {
496 if (insert_whitespace) {
497 beforeprev = prev;
498 prev = next_id;
499 }
500 }
501
502 private:
503 bool insert_whitespace; // enable this component
504 boost::wave::token_id prev; // the previous analyzed token
505 boost::wave::token_id beforeprev; // the token before the previous
506 };
507
508 ///////////////////////////////////////////////////////////////////////////////
509 } // namespace util
510 } // namespace wave
511 } // namespace boost
512
513 // the suffix header occurs after all of the code
514 #ifdef BOOST_HAS_ABI_HEADERS
515 #include BOOST_ABI_SUFFIX
516 #endif
517
518 #endif // !defined(INSERT_WHITESPACE_DETECTION_HPP_765EF77B_0513_4967_BDD6_6A38148C4C96_INCLUDED)