• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*=============================================================================
2     Boost.Wave: A Standard compliant C++ preprocessor library
3     The definition of a default set of token identifiers and related
4     functions.
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 
13 #define BOOST_WAVE_SOURCE 1
14 
15 // disable stupid compiler warnings
16 #include <boost/config/warning_disable.hpp>
17 
18 #include <string>
19 #include <boost/assert.hpp>
20 #include <boost/static_assert.hpp>
21 
22 #include <boost/wave/wave_config.hpp>
23 #include <boost/wave/token_ids.hpp>
24 
25 // this must occur after all of the includes and before any code appears
26 #ifdef BOOST_HAS_ABI_HEADERS
27 #include BOOST_ABI_PREFIX
28 #endif
29 
30 ///////////////////////////////////////////////////////////////////////////////
31 namespace boost {
32 namespace wave {
33 
34 ///////////////////////////////////////////////////////////////////////////////
35 //  return a token name
36 BOOST_WAVE_STRINGTYPE
get_token_name(token_id tokid)37 get_token_name(token_id tokid)
38 {
39 //  Table of token names
40 //
41 //      Please note that the sequence of token names must match the sequence of
42 //      token id's defined in then enum token_id above.
43 static char const *tok_names[] = {
44     /* 256 */   "AND",
45     /* 257 */   "ANDAND",
46     /* 258 */   "ASSIGN",
47     /* 259 */   "ANDASSIGN",
48     /* 260 */   "OR",
49     /* 261 */   "ORASSIGN",
50     /* 262 */   "XOR",
51     /* 263 */   "XORASSIGN",
52     /* 264 */   "COMMA",
53     /* 265 */   "COLON",
54     /* 266 */   "DIVIDE",
55     /* 267 */   "DIVIDEASSIGN",
56     /* 268 */   "DOT",
57     /* 269 */   "DOTSTAR",
58     /* 270 */   "ELLIPSIS",
59     /* 271 */   "EQUAL",
60     /* 272 */   "GREATER",
61     /* 273 */   "GREATEREQUAL",
62     /* 274 */   "LEFTBRACE",
63     /* 275 */   "LESS",
64     /* 276 */   "LESSEQUAL",
65     /* 277 */   "LEFTPAREN",
66     /* 278 */   "LEFTBRACKET",
67     /* 279 */   "MINUS",
68     /* 280 */   "MINUSASSIGN",
69     /* 281 */   "MINUSMINUS",
70     /* 282 */   "PERCENT",
71     /* 283 */   "PERCENTASSIGN",
72     /* 284 */   "NOT",
73     /* 285 */   "NOTEQUAL",
74     /* 286 */   "OROR",
75     /* 287 */   "PLUS",
76     /* 288 */   "PLUSASSIGN",
77     /* 289 */   "PLUSPLUS",
78     /* 290 */   "ARROW",
79     /* 291 */   "ARROWSTAR",
80     /* 292 */   "QUESTION_MARK",
81     /* 293 */   "RIGHTBRACE",
82     /* 294 */   "RIGHTPAREN",
83     /* 295 */   "RIGHTBRACKET",
84     /* 296 */   "COLON_COLON",
85     /* 297 */   "SEMICOLON",
86     /* 298 */   "SHIFTLEFT",
87     /* 299 */   "SHIFTLEFTASSIGN",
88     /* 300 */   "SHIFTRIGHT",
89     /* 301 */   "SHIFTRIGHTASSIGN",
90     /* 302 */   "STAR",
91     /* 303 */   "COMPL",
92     /* 304 */   "STARASSIGN",
93     /* 305 */   "ASM",
94     /* 306 */   "AUTO",
95     /* 307 */   "BOOL",
96     /* 308 */   "FALSE",
97     /* 309 */   "TRUE",
98     /* 310 */   "BREAK",
99     /* 311 */   "CASE",
100     /* 312 */   "CATCH",
101     /* 313 */   "CHAR",
102     /* 314 */   "CLASS",
103     /* 315 */   "CONST",
104     /* 316 */   "CONSTCAST",
105     /* 317 */   "CONTINUE",
106     /* 318 */   "DEFAULT",
107     /* 319 */   "DELETE",
108     /* 320 */   "DO",
109     /* 321 */   "DOUBLE",
110     /* 322 */   "DYNAMICCAST",
111     /* 323 */   "ELSE",
112     /* 324 */   "ENUM",
113     /* 325 */   "EXPLICIT",
114     /* 326 */   "EXPORT",
115     /* 327 */   "EXTERN",
116     /* 328 */   "FLOAT",
117     /* 329 */   "FOR",
118     /* 330 */   "FRIEND",
119     /* 331 */   "GOTO",
120     /* 332 */   "IF",
121     /* 333 */   "INLINE",
122     /* 334 */   "INT",
123     /* 335 */   "LONG",
124     /* 336 */   "MUTABLE",
125     /* 337 */   "NAMESPACE",
126     /* 338 */   "NEW",
127     /* 339 */   "OPERATOR",
128     /* 340 */   "PRIVATE",
129     /* 341 */   "PROTECTED",
130     /* 342 */   "PUBLIC",
131     /* 343 */   "REGISTER",
132     /* 344 */   "REINTERPRETCAST",
133     /* 345 */   "RETURN",
134     /* 346 */   "SHORT",
135     /* 347 */   "SIGNED",
136     /* 348 */   "SIZEOF",
137     /* 349 */   "STATIC",
138     /* 350 */   "STATICCAST",
139     /* 351 */   "STRUCT",
140     /* 352 */   "SWITCH",
141     /* 353 */   "TEMPLATE",
142     /* 354 */   "THIS",
143     /* 355 */   "THROW",
144     /* 356 */   "TRY",
145     /* 357 */   "TYPEDEF",
146     /* 358 */   "TYPEID",
147     /* 359 */   "TYPENAME",
148     /* 360 */   "UNION",
149     /* 361 */   "UNSIGNED",
150     /* 362 */   "USING",
151     /* 363 */   "VIRTUAL",
152     /* 364 */   "VOID",
153     /* 365 */   "VOLATILE",
154     /* 366 */   "WCHART",
155     /* 367 */   "WHILE",
156     /* 368 */   "PP_DEFINE",
157     /* 369 */   "PP_IF",
158     /* 370 */   "PP_IFDEF",
159     /* 371 */   "PP_IFNDEF",
160     /* 372 */   "PP_ELSE",
161     /* 373 */   "PP_ELIF",
162     /* 374 */   "PP_ENDIF",
163     /* 375 */   "PP_ERROR",
164     /* 376 */   "PP_LINE",
165     /* 377 */   "PP_PRAGMA",
166     /* 378 */   "PP_UNDEF",
167     /* 379 */   "PP_WARNING",
168     /* 380 */   "IDENTIFIER",
169     /* 381 */   "OCTALINT",
170     /* 382 */   "DECIMALINT",
171     /* 383 */   "HEXAINT",
172     /* 384 */   "INTLIT",
173     /* 385 */   "LONGINTLIT",
174     /* 386 */   "FLOATLIT",
175     /* 387 */   "CCOMMENT",
176     /* 388 */   "CPPCOMMENT",
177     /* 389 */   "CHARLIT",
178     /* 390 */   "STRINGLIT",
179     /* 391 */   "CONTLINE",
180     /* 392 */   "SPACE",
181     /* 393 */   "SPACE2",
182     /* 394 */   "NEWLINE",
183     /* 395 */   "POUND_POUND",
184     /* 396 */   "POUND",
185     /* 397 */   "ANY",
186     /* 398 */   "PP_INCLUDE",
187     /* 399 */   "PP_QHEADER",
188     /* 400 */   "PP_HHEADER",
189     /* 401 */   "EOF",
190     /* 402 */   "EOI",
191     /* 403 */   "PP_NUMBER",
192 
193               // MS extensions
194     /* 404 */   "MSEXT_INT8",
195     /* 405 */   "MSEXT_INT16",
196     /* 406 */   "MSEXT_INT32",
197     /* 407 */   "MSEXT_INT64",
198     /* 408 */   "MSEXT_BASED",
199     /* 409 */   "MSEXT_DECLSPEC",
200     /* 410 */   "MSEXT_CDECL",
201     /* 411 */   "MSEXT_FASTCALL",
202     /* 412 */   "MSEXT_STDCALL",
203     /* 413 */   "MSEXT_TRY",
204     /* 414 */   "MSEXT_EXCEPT",
205     /* 415 */   "MSEXT_FINALLY",
206     /* 416 */   "MSEXT_LEAVE",
207     /* 417 */   "MSEXT_INLINE",
208     /* 418 */   "MSEXT_ASM",
209     /* 419 */   "MSEXT_REGION",
210     /* 420 */   "MSEXT_ENDREGION",
211 
212     /* 421 */   "IMPORT",
213 
214     /* 422 */   "ALIGNAS",
215     /* 423 */   "ALIGNOF",
216     /* 424 */   "CHAR16_T",
217     /* 425 */   "CHAR32_T",
218     /* 426 */   "CONSTEXPR",
219     /* 427 */   "DECLTYPE",
220     /* 428 */   "NOEXCEPT",
221     /* 429 */   "NULLPTR",
222     /* 430 */   "STATIC_ASSERT",
223     /* 431 */   "THREADLOCAL",
224     /* 432 */   "RAWSTRINGLIT",
225     };
226 
227     // make sure, I have not forgotten any commas (as I did more than once)
228     BOOST_STATIC_ASSERT(
229         sizeof(tok_names)/sizeof(tok_names[0]) == T_LAST_TOKEN-T_FIRST_TOKEN
230     );
231 
232     unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
233     return (id < T_LAST_TOKEN-T_FIRST_TOKEN) ? tok_names[id] : "<UnknownToken>";
234 }
235 
236 ///////////////////////////////////////////////////////////////////////////////
237 //  return a token name
238 char const *
get_token_value(token_id tokid)239 get_token_value(token_id tokid)
240 {
241 //  Table of token values
242 //
243 //      Please note that the sequence of token names must match the sequence of
244 //      token id's defined in then enum token_id above.
245 static char const *tok_values[] = {
246     /* 256 */   "&",
247     /* 257 */   "&&",
248     /* 258 */   "=",
249     /* 259 */   "&=",
250     /* 260 */   "|",
251     /* 261 */   "|=",
252     /* 262 */   "^",
253     /* 263 */   "^=",
254     /* 264 */   ",",
255     /* 265 */   ":",
256     /* 266 */   "/",
257     /* 267 */   "/=",
258     /* 268 */   ".",
259     /* 269 */   ".*",
260     /* 270 */   "...",
261     /* 271 */   "==",
262     /* 272 */   ">",
263     /* 273 */   ">=",
264     /* 274 */   "{",
265     /* 275 */   "<",
266     /* 276 */   "<=",
267     /* 277 */   "(",
268     /* 278 */   "[",
269     /* 279 */   "-",
270     /* 280 */   "-=",
271     /* 281 */   "--",
272     /* 282 */   "%",
273     /* 283 */   "%=",
274     /* 284 */   "!",
275     /* 285 */   "!=",
276     /* 286 */   "||",
277     /* 287 */   "+",
278     /* 288 */   "+=",
279     /* 289 */   "++",
280     /* 290 */   "->",
281     /* 291 */   "->*",
282     /* 292 */   "?",
283     /* 293 */   "}",
284     /* 294 */   ")",
285     /* 295 */   "]",
286     /* 296 */   "::",
287     /* 297 */   ";",
288     /* 298 */   "<<",
289     /* 299 */   "<<=",
290     /* 300 */   ">>",
291     /* 301 */   ">>=",
292     /* 302 */   "*",
293     /* 303 */   "~",
294     /* 304 */   "*=",
295     /* 305 */   "asm",
296     /* 306 */   "auto",
297     /* 307 */   "bool",
298     /* 308 */   "false",
299     /* 309 */   "true",
300     /* 310 */   "break",
301     /* 311 */   "case",
302     /* 312 */   "catch",
303     /* 313 */   "char",
304     /* 314 */   "class",
305     /* 315 */   "const",
306     /* 316 */   "const_cast",
307     /* 317 */   "continue",
308     /* 318 */   "default",
309     /* 319 */   "delete",
310     /* 320 */   "do",
311     /* 321 */   "double",
312     /* 322 */   "dynamic_cast",
313     /* 323 */   "else",
314     /* 324 */   "enum",
315     /* 325 */   "explicit",
316     /* 326 */   "export",
317     /* 327 */   "extern",
318     /* 328 */   "float",
319     /* 329 */   "for",
320     /* 330 */   "friend",
321     /* 331 */   "goto",
322     /* 332 */   "if",
323     /* 333 */   "inline",
324     /* 334 */   "int",
325     /* 335 */   "long",
326     /* 336 */   "mutable",
327     /* 337 */   "namespace",
328     /* 338 */   "new",
329     /* 339 */   "operator",
330     /* 340 */   "private",
331     /* 341 */   "protected",
332     /* 342 */   "public",
333     /* 343 */   "register",
334     /* 344 */   "reinterpret_cast",
335     /* 345 */   "return",
336     /* 346 */   "short",
337     /* 347 */   "signed",
338     /* 348 */   "sizeof",
339     /* 349 */   "static",
340     /* 350 */   "static_cast",
341     /* 351 */   "struct",
342     /* 352 */   "switch",
343     /* 353 */   "template",
344     /* 354 */   "this",
345     /* 355 */   "throw",
346     /* 356 */   "try",
347     /* 357 */   "typedef",
348     /* 358 */   "typeid",
349     /* 359 */   "typename",
350     /* 360 */   "union",
351     /* 361 */   "unsigned",
352     /* 362 */   "using",
353     /* 363 */   "virtual",
354     /* 364 */   "void",
355     /* 365 */   "volatile",
356     /* 366 */   "wchar_t",
357     /* 367 */   "while",
358     /* 368 */   "#define",
359     /* 369 */   "#if",
360     /* 370 */   "#ifdef",
361     /* 371 */   "#ifndef",
362     /* 372 */   "#else",
363     /* 373 */   "#elif",
364     /* 374 */   "#endif",
365     /* 375 */   "#error",
366     /* 376 */   "#line",
367     /* 377 */   "#pragma",
368     /* 378 */   "#undef",
369     /* 379 */   "#warning",
370     /* 380 */   "",   // identifier
371     /* 381 */   "",   // octalint
372     /* 382 */   "",   // decimalint
373     /* 383 */   "",   // hexlit
374     /* 384 */   "",   // intlit
375     /* 385 */   "",   // longintlit
376     /* 386 */   "",   // floatlit
377     /* 387 */   "",   // ccomment
378     /* 388 */   "",   // cppcomment
379     /* 389 */   "",   // charlit
380     /* 390 */   "",   // stringlit
381     /* 391 */   "",   // contline
382     /* 392 */   "",   // space
383     /* 393 */   "",   // space2
384     /* 394 */   "\n",
385     /* 395 */   "##",
386     /* 396 */   "#",
387     /* 397 */   "",   // any
388     /* 398 */   "#include",
389     /* 399 */   "#include",
390     /* 400 */   "#include",
391     /* 401 */   "",   // eof
392     /* 402 */   "",   // eoi
393     /* 403 */   "",   // pp-number
394 
395               // MS extensions
396     /* 404 */   "__int8",
397     /* 405 */   "__int16",
398     /* 406 */   "__int32",
399     /* 407 */   "__int64",
400     /* 408 */   "__based",
401     /* 409 */   "__declspec",
402     /* 410 */   "__cdecl",
403     /* 411 */   "__fastcall",
404     /* 412 */   "__stdcall",
405     /* 413 */   "__try",
406     /* 414 */   "__except",
407     /* 415 */   "__finally",
408     /* 416 */   "__leave",
409     /* 417 */   "__inline",
410     /* 418 */   "__asm",
411     /* 419 */   "#region",
412     /* 420 */   "#endregion",
413 
414     /* 421 */   "import",
415 
416     /* 422 */   "alignas",
417     /* 423 */   "alignof",
418     /* 424 */   "char16_t",
419     /* 425 */   "char32_t",
420     /* 426 */   "constexpr",
421     /* 427 */   "decltype",
422     /* 428 */   "noexcept",
423     /* 429 */   "nullptr",
424     /* 430 */   "static_assert",
425     /* 431 */   "threadlocal",
426     /* 432 */   "",   // extrawstringlit
427     };
428 
429     // make sure, I have not forgotten any commas (as I did more than once)
430     BOOST_STATIC_ASSERT(
431         sizeof(tok_values)/sizeof(tok_values[0]) == T_LAST_TOKEN-T_FIRST_TOKEN
432     );
433 
434     unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
435     return (id < T_LAST_TOKEN-T_FIRST_TOKEN) ? tok_values[id] : "<UnknownToken>";
436 }
437 
438 ///////////////////////////////////////////////////////////////////////////////
439 }   // namespace wave
440 }   // namespace boost
441 
442 // the suffix header occurs after all of the code
443 #ifdef BOOST_HAS_ABI_HEADERS
444 #include BOOST_ABI_SUFFIX
445 #endif
446 
447 
448