source: NonGTP/Boost/boost/wave/token_ids.hpp @ 857

Revision 857, 27.6 KB checked in by igarcia, 19 years ago (diff)
RevLine 
[857]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-2005 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#if !defined(TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED)
14#define TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED
15
16#include <string>
17#include <boost/assert.hpp>
18
19#include <boost/wave/wave_config.hpp>
20
21///////////////////////////////////////////////////////////////////////////////
22//  Allow external redefinition of the token identifiers to use
23#if !defined(BOOST_WAVE_TOKEN_IDS_DEFINED)
24#define BOOST_WAVE_TOKEN_IDS_DEFINED
25
26#if defined (__FreeBSD__) && defined (T_DIVIDE)
27#undef T_DIVIDE
28#endif
29
30///////////////////////////////////////////////////////////////////////////////
31namespace boost {
32namespace wave {
33
34///////////////////////////////////////////////////////////////////////////////
35//  assemble tokenid's
36#define TOKEN_FROM_ID(id, cat)   ((id) | (cat))
37#define ID_FROM_TOKEN(tok)       ((tok) & ~TokenTypeMask)
38#define BASEID_FROM_TOKEN(tok)   ((tok) & ~ExtTokenTypeMask)
39
40///////////////////////////////////////////////////////////////////////////////
41//  the token_category helps to classify the different token types
42enum token_category {
43    IdentifierTokenType         = 0x10000000,
44    ParameterTokenType          = 0x11000000,
45    ExtParameterTokenType       = 0x11100000,
46    KeywordTokenType            = 0x20000000,
47    OperatorTokenType           = 0x30000000,
48    LiteralTokenType            = 0x40000000,
49    IntegerLiteralTokenType     = 0x41000000,
50    FloatingLiteralTokenType    = 0x42000000,
51    StringLiteralTokenType      = 0x43000000,
52    CharacterLiteralTokenType   = 0x44000000,
53    BoolLiteralTokenType        = 0x45000000,
54    PPTokenType                 = 0x50000000,
55    PPConditionalTokenType      = 0x50800000,
56
57    UnknownTokenType            = 0xA0000000,
58    EOLTokenType                = 0xB0000000,
59    EOFTokenType                = 0xC0000000,
60    WhiteSpaceTokenType         = 0xD0000000,
61    InternalTokenType           = 0xE0000000,
62   
63    TokenTypeMask               = 0xFF000000,
64    AltTokenType                = 0x00100000,
65    TriGraphTokenType           = 0x00200000,
66    AltExtTokenType             = 0x00500000,   // and, bit_and etc.
67    ExtTokenTypeMask            = 0xFFF00000,
68    ExtTokenOnlyMask            = 0x00F00000,
69    TokenValueMask              = 0x000FFFFF,
70    MainTokenMask               = 0xFF0FFFFF    // TokenTypeMask|TokenValueMask
71};
72
73///////////////////////////////////////////////////////////////////////////////
74//  the token_id assigns unique numbers to the different C++ lexemes
75enum token_id {
76    T_FIRST_TOKEN  = 256,
77    T_AND          = TOKEN_FROM_ID(T_FIRST_TOKEN, OperatorTokenType),
78    T_AND_ALT      = TOKEN_FROM_ID(T_FIRST_TOKEN, OperatorTokenType|AltExtTokenType),
79    T_ANDAND       = TOKEN_FROM_ID(257, OperatorTokenType),
80    T_ANDAND_ALT   = TOKEN_FROM_ID(257, OperatorTokenType|AltExtTokenType),
81    T_ASSIGN       = TOKEN_FROM_ID(258, OperatorTokenType),
82    T_ANDASSIGN    = TOKEN_FROM_ID(259, OperatorTokenType),
83    T_ANDASSIGN_ALT     = TOKEN_FROM_ID(259, OperatorTokenType|AltExtTokenType),
84    T_OR           = TOKEN_FROM_ID(260, OperatorTokenType),
85    T_OR_ALT       = TOKEN_FROM_ID(260, OperatorTokenType|AltExtTokenType),
86    T_OR_TRIGRAPH  = TOKEN_FROM_ID(260, OperatorTokenType|TriGraphTokenType),
87    T_ORASSIGN     = TOKEN_FROM_ID(261, OperatorTokenType),
88    T_ORASSIGN_ALT          = TOKEN_FROM_ID(261, OperatorTokenType|AltExtTokenType),
89    T_ORASSIGN_TRIGRAPH     = TOKEN_FROM_ID(261, OperatorTokenType|TriGraphTokenType),
90    T_XOR          = TOKEN_FROM_ID(262, OperatorTokenType),
91    T_XOR_ALT      = TOKEN_FROM_ID(262, OperatorTokenType|AltExtTokenType),
92    T_XOR_TRIGRAPH = TOKEN_FROM_ID(262, OperatorTokenType|TriGraphTokenType),
93    T_XORASSIGN    = TOKEN_FROM_ID(263, OperatorTokenType),
94    T_XORASSIGN_ALT         = TOKEN_FROM_ID(263, OperatorTokenType|AltExtTokenType),
95    T_XORASSIGN_TRIGRAPH    = TOKEN_FROM_ID(263, OperatorTokenType|TriGraphTokenType),
96    T_COMMA        = TOKEN_FROM_ID(264, OperatorTokenType),
97    T_COLON        = TOKEN_FROM_ID(265, OperatorTokenType),
98    T_DIVIDE       = TOKEN_FROM_ID(266, OperatorTokenType),
99    T_DIVIDEASSIGN = TOKEN_FROM_ID(267, OperatorTokenType),
100    T_DOT          = TOKEN_FROM_ID(268, OperatorTokenType),
101    T_DOTSTAR      = TOKEN_FROM_ID(269, OperatorTokenType),
102    T_ELLIPSIS     = TOKEN_FROM_ID(270, OperatorTokenType),
103    T_EQUAL        = TOKEN_FROM_ID(271, OperatorTokenType),
104    T_GREATER      = TOKEN_FROM_ID(272, OperatorTokenType),
105    T_GREATEREQUAL = TOKEN_FROM_ID(273, OperatorTokenType),
106    T_LEFTBRACE    = TOKEN_FROM_ID(274, OperatorTokenType),
107    T_LEFTBRACE_ALT         = TOKEN_FROM_ID(274, OperatorTokenType|AltTokenType),
108    T_LEFTBRACE_TRIGRAPH    = TOKEN_FROM_ID(274, OperatorTokenType|TriGraphTokenType),
109    T_LESS         = TOKEN_FROM_ID(275, OperatorTokenType),
110    T_LESSEQUAL    = TOKEN_FROM_ID(276, OperatorTokenType),
111    T_LEFTPAREN    = TOKEN_FROM_ID(277, OperatorTokenType),
112    T_LEFTBRACKET  = TOKEN_FROM_ID(278, OperatorTokenType),
113    T_LEFTBRACKET_ALT       = TOKEN_FROM_ID(278, OperatorTokenType|AltTokenType),
114    T_LEFTBRACKET_TRIGRAPH  = TOKEN_FROM_ID(278, OperatorTokenType|TriGraphTokenType),
115    T_MINUS        = TOKEN_FROM_ID(279, OperatorTokenType),
116    T_MINUSASSIGN  = TOKEN_FROM_ID(280, OperatorTokenType),
117    T_MINUSMINUS   = TOKEN_FROM_ID(281, OperatorTokenType),
118    T_PERCENT      = TOKEN_FROM_ID(282, OperatorTokenType),
119    T_PERCENTASSIGN = TOKEN_FROM_ID(283, OperatorTokenType),
120    T_NOT          = TOKEN_FROM_ID(284, OperatorTokenType),
121    T_NOT_ALT      = TOKEN_FROM_ID(284, OperatorTokenType|AltExtTokenType),
122    T_NOTEQUAL     = TOKEN_FROM_ID(285, OperatorTokenType),
123    T_NOTEQUAL_ALT      = TOKEN_FROM_ID(285, OperatorTokenType|AltExtTokenType),
124    T_OROR         = TOKEN_FROM_ID(286, OperatorTokenType),
125    T_OROR_ALT     = TOKEN_FROM_ID(286, OperatorTokenType|AltExtTokenType),
126    T_OROR_TRIGRAPH     = TOKEN_FROM_ID(286, OperatorTokenType|TriGraphTokenType),
127    T_PLUS         = TOKEN_FROM_ID(287, OperatorTokenType),
128    T_PLUSASSIGN   = TOKEN_FROM_ID(288, OperatorTokenType),
129    T_PLUSPLUS     = TOKEN_FROM_ID(289, OperatorTokenType),
130    T_ARROW        = TOKEN_FROM_ID(290, OperatorTokenType),
131    T_ARROWSTAR    = TOKEN_FROM_ID(291, OperatorTokenType),
132    T_QUESTION_MARK = TOKEN_FROM_ID(292, OperatorTokenType),
133    T_RIGHTBRACE   = TOKEN_FROM_ID(293, OperatorTokenType),
134    T_RIGHTBRACE_ALT        = TOKEN_FROM_ID(293, OperatorTokenType|AltTokenType),
135    T_RIGHTBRACE_TRIGRAPH   = TOKEN_FROM_ID(293, OperatorTokenType|TriGraphTokenType),
136    T_RIGHTPAREN   = TOKEN_FROM_ID(294, OperatorTokenType),
137    T_RIGHTBRACKET = TOKEN_FROM_ID(295, OperatorTokenType),
138    T_RIGHTBRACKET_ALT      = TOKEN_FROM_ID(295, OperatorTokenType|AltTokenType),
139    T_RIGHTBRACKET_TRIGRAPH = TOKEN_FROM_ID(295, OperatorTokenType|TriGraphTokenType),
140    T_COLON_COLON  = TOKEN_FROM_ID(296, OperatorTokenType),
141    T_SEMICOLON    = TOKEN_FROM_ID(297, OperatorTokenType),
142    T_SHIFTLEFT    = TOKEN_FROM_ID(298, OperatorTokenType),
143    T_SHIFTLEFTASSIGN = TOKEN_FROM_ID(299, OperatorTokenType),
144    T_SHIFTRIGHT   = TOKEN_FROM_ID(300, OperatorTokenType),
145    T_SHIFTRIGHTASSIGN = TOKEN_FROM_ID(301, OperatorTokenType),
146    T_STAR         = TOKEN_FROM_ID(302, OperatorTokenType),
147    T_COMPL        = TOKEN_FROM_ID(303, OperatorTokenType),
148    T_COMPL_ALT         = TOKEN_FROM_ID(303, OperatorTokenType|AltExtTokenType),
149    T_COMPL_TRIGRAPH    = TOKEN_FROM_ID(303, OperatorTokenType|TriGraphTokenType),
150    T_STARASSIGN   = TOKEN_FROM_ID(304, OperatorTokenType),
151    T_ASM          = TOKEN_FROM_ID(305, KeywordTokenType),
152    T_AUTO         = TOKEN_FROM_ID(306, KeywordTokenType),
153    T_BOOL         = TOKEN_FROM_ID(307, KeywordTokenType),
154    T_FALSE        = TOKEN_FROM_ID(308, BoolLiteralTokenType),
155    T_TRUE         = TOKEN_FROM_ID(309, BoolLiteralTokenType),
156    T_BREAK        = TOKEN_FROM_ID(310, KeywordTokenType),
157    T_CASE         = TOKEN_FROM_ID(311, KeywordTokenType),
158    T_CATCH        = TOKEN_FROM_ID(312, KeywordTokenType),
159    T_CHAR         = TOKEN_FROM_ID(313, KeywordTokenType),
160    T_CLASS        = TOKEN_FROM_ID(314, KeywordTokenType),
161    T_CONST        = TOKEN_FROM_ID(315, KeywordTokenType),
162    T_CONSTCAST    = TOKEN_FROM_ID(316, KeywordTokenType),
163    T_CONTINUE     = TOKEN_FROM_ID(317, KeywordTokenType),
164    T_DEFAULT      = TOKEN_FROM_ID(318, KeywordTokenType),
165    T_DEFINED      = TOKEN_FROM_ID(319, KeywordTokenType),
166    T_DELETE       = TOKEN_FROM_ID(320, KeywordTokenType),
167    T_DO           = TOKEN_FROM_ID(321, KeywordTokenType),
168    T_DOUBLE       = TOKEN_FROM_ID(322, KeywordTokenType),
169    T_DYNAMICCAST  = TOKEN_FROM_ID(323, KeywordTokenType),
170    T_ELSE         = TOKEN_FROM_ID(324, KeywordTokenType),
171    T_ENUM         = TOKEN_FROM_ID(325, KeywordTokenType),
172    T_EXPLICIT     = TOKEN_FROM_ID(326, KeywordTokenType),
173    T_EXPORT       = TOKEN_FROM_ID(327, KeywordTokenType),
174    T_EXTERN       = TOKEN_FROM_ID(328, KeywordTokenType),
175    T_FLOAT        = TOKEN_FROM_ID(329, KeywordTokenType),
176    T_FOR          = TOKEN_FROM_ID(330, KeywordTokenType),
177    T_FRIEND       = TOKEN_FROM_ID(331, KeywordTokenType),
178    T_GOTO         = TOKEN_FROM_ID(332, KeywordTokenType),
179    T_IF           = TOKEN_FROM_ID(333, KeywordTokenType),
180    T_INLINE       = TOKEN_FROM_ID(334, KeywordTokenType),
181    T_INT          = TOKEN_FROM_ID(335, KeywordTokenType),
182    T_LONG         = TOKEN_FROM_ID(336, KeywordTokenType),
183    T_MUTABLE      = TOKEN_FROM_ID(337, KeywordTokenType),
184    T_NAMESPACE    = TOKEN_FROM_ID(338, KeywordTokenType),
185    T_NEW          = TOKEN_FROM_ID(339, KeywordTokenType),
186    T_OPERATOR     = TOKEN_FROM_ID(340, KeywordTokenType),
187    T_PRIVATE      = TOKEN_FROM_ID(341, KeywordTokenType),
188    T_PROTECTED    = TOKEN_FROM_ID(342, KeywordTokenType),
189    T_PUBLIC       = TOKEN_FROM_ID(343, KeywordTokenType),
190    T_REGISTER     = TOKEN_FROM_ID(344, KeywordTokenType),
191    T_REINTERPRETCAST = TOKEN_FROM_ID(345, KeywordTokenType),
192    T_RETURN       = TOKEN_FROM_ID(346, KeywordTokenType),
193    T_SHORT        = TOKEN_FROM_ID(347, KeywordTokenType),
194    T_SIGNED       = TOKEN_FROM_ID(348, KeywordTokenType),
195    T_SIZEOF       = TOKEN_FROM_ID(349, KeywordTokenType),
196    T_STATIC       = TOKEN_FROM_ID(350, KeywordTokenType),
197    T_STATICCAST   = TOKEN_FROM_ID(351, KeywordTokenType),
198    T_STRUCT       = TOKEN_FROM_ID(352, KeywordTokenType),
199    T_SWITCH       = TOKEN_FROM_ID(353, KeywordTokenType),
200    T_TEMPLATE     = TOKEN_FROM_ID(354, KeywordTokenType),
201    T_THIS         = TOKEN_FROM_ID(355, KeywordTokenType),
202    T_THROW        = TOKEN_FROM_ID(356, KeywordTokenType),
203    T_TRY          = TOKEN_FROM_ID(357, KeywordTokenType),
204    T_TYPEDEF      = TOKEN_FROM_ID(358, KeywordTokenType),
205    T_TYPEID       = TOKEN_FROM_ID(359, KeywordTokenType),
206    T_TYPENAME     = TOKEN_FROM_ID(360, KeywordTokenType),
207    T_UNION        = TOKEN_FROM_ID(361, KeywordTokenType),
208    T_UNSIGNED     = TOKEN_FROM_ID(362, KeywordTokenType),
209    T_USING        = TOKEN_FROM_ID(363, KeywordTokenType),
210    T_VIRTUAL      = TOKEN_FROM_ID(364, KeywordTokenType),
211    T_VOID         = TOKEN_FROM_ID(365, KeywordTokenType),
212    T_VOLATILE     = TOKEN_FROM_ID(366, KeywordTokenType),
213    T_WCHART       = TOKEN_FROM_ID(367, KeywordTokenType),
214    T_WHILE        = TOKEN_FROM_ID(368, KeywordTokenType),
215    T_PP_DEFINE    = TOKEN_FROM_ID(369, PPTokenType),
216    T_PP_IF        = TOKEN_FROM_ID(370, PPConditionalTokenType),
217    T_PP_IFDEF     = TOKEN_FROM_ID(371, PPConditionalTokenType),
218    T_PP_IFNDEF    = TOKEN_FROM_ID(372, PPConditionalTokenType),
219    T_PP_ELSE      = TOKEN_FROM_ID(373, PPConditionalTokenType),
220    T_PP_ELIF      = TOKEN_FROM_ID(374, PPConditionalTokenType),
221    T_PP_ENDIF     = TOKEN_FROM_ID(375, PPConditionalTokenType),
222    T_PP_ERROR     = TOKEN_FROM_ID(376, PPTokenType),
223    T_PP_LINE      = TOKEN_FROM_ID(377, PPTokenType),
224    T_PP_PRAGMA    = TOKEN_FROM_ID(378, PPTokenType),
225    T_PP_UNDEF     = TOKEN_FROM_ID(379, PPTokenType),
226    T_PP_WARNING   = TOKEN_FROM_ID(380, PPTokenType),
227    T_IDENTIFIER   = TOKEN_FROM_ID(381, IdentifierTokenType),
228    T_OCTALINT     = TOKEN_FROM_ID(382, IntegerLiteralTokenType),
229    T_DECIMALINT   = TOKEN_FROM_ID(383, IntegerLiteralTokenType),
230    T_HEXAINT      = TOKEN_FROM_ID(384, IntegerLiteralTokenType),
231    T_INTLIT       = TOKEN_FROM_ID(385, IntegerLiteralTokenType),
232    T_LONGINTLIT   = TOKEN_FROM_ID(386, IntegerLiteralTokenType),
233    T_FLOATLIT     = TOKEN_FROM_ID(387, FloatingLiteralTokenType),
234    T_FIXEDPOINTLIT = TOKEN_FROM_ID(387, FloatingLiteralTokenType|AltTokenType),  // IDL specific
235    T_CCOMMENT     = TOKEN_FROM_ID(388, WhiteSpaceTokenType),
236    T_CPPCOMMENT   = TOKEN_FROM_ID(389, WhiteSpaceTokenType),
237    T_CHARLIT      = TOKEN_FROM_ID(390, CharacterLiteralTokenType),
238    T_STRINGLIT    = TOKEN_FROM_ID(391, StringLiteralTokenType),
239    T_CONTLINE     = TOKEN_FROM_ID(392, EOLTokenType),
240    T_SPACE        = TOKEN_FROM_ID(393, WhiteSpaceTokenType),
241    T_SPACE2       = TOKEN_FROM_ID(394, WhiteSpaceTokenType),
242    T_NEWLINE      = TOKEN_FROM_ID(395, EOLTokenType),
243    T_POUND_POUND           = TOKEN_FROM_ID(396, OperatorTokenType),
244    T_POUND_POUND_ALT       = TOKEN_FROM_ID(396, OperatorTokenType|AltTokenType),
245    T_POUND_POUND_TRIGRAPH  = TOKEN_FROM_ID(396, OperatorTokenType|TriGraphTokenType),
246    T_POUND                 = TOKEN_FROM_ID(397, OperatorTokenType),
247    T_POUND_ALT             = TOKEN_FROM_ID(397, OperatorTokenType|AltTokenType),
248    T_POUND_TRIGRAPH        = TOKEN_FROM_ID(397, OperatorTokenType|TriGraphTokenType),
249    T_ANY          = TOKEN_FROM_ID(398, UnknownTokenType),
250    T_ANY_TRIGRAPH = TOKEN_FROM_ID(398, UnknownTokenType|TriGraphTokenType),
251    T_PP_INCLUDE   = TOKEN_FROM_ID(399, PPTokenType),
252    T_PP_QHEADER   = TOKEN_FROM_ID(400, PPTokenType),
253    T_PP_HHEADER   = TOKEN_FROM_ID(401, PPTokenType),
254    T_PP_INCLUDE_NEXT   = TOKEN_FROM_ID(399, PPTokenType|AltTokenType),
255    T_PP_QHEADER_NEXT   = TOKEN_FROM_ID(400, PPTokenType|AltTokenType),
256    T_PP_HHEADER_NEXT   = TOKEN_FROM_ID(401, PPTokenType|AltTokenType),
257    T_EOF          = TOKEN_FROM_ID(402, EOFTokenType),      // end of file reached
258    T_EOI          = TOKEN_FROM_ID(403, EOFTokenType),      // end of input reached
259   
260// MS extensions
261    T_MSEXT_INT8   = TOKEN_FROM_ID(404, KeywordTokenType),
262    T_MSEXT_INT16  = TOKEN_FROM_ID(405, KeywordTokenType),
263    T_MSEXT_INT32  = TOKEN_FROM_ID(406, KeywordTokenType),
264    T_MSEXT_INT64  = TOKEN_FROM_ID(407, KeywordTokenType),
265    T_MSEXT_BASED  = TOKEN_FROM_ID(408, KeywordTokenType),
266    T_MSEXT_DECLSPEC = TOKEN_FROM_ID(409, KeywordTokenType),
267    T_MSEXT_CDECL  = TOKEN_FROM_ID(410, KeywordTokenType),
268    T_MSEXT_FASTCALL = TOKEN_FROM_ID(411, KeywordTokenType),
269    T_MSEXT_STDCALL = TOKEN_FROM_ID(412, KeywordTokenType),
270    T_MSEXT_TRY    = TOKEN_FROM_ID(413, KeywordTokenType),
271    T_MSEXT_EXCEPT = TOKEN_FROM_ID(414, KeywordTokenType),
272    T_MSEXT_FINALLY = TOKEN_FROM_ID(415, KeywordTokenType),
273    T_MSEXT_LEAVE  = TOKEN_FROM_ID(416, KeywordTokenType),
274    T_MSEXT_INLINE = TOKEN_FROM_ID(417, KeywordTokenType),
275    T_MSEXT_ASM    = TOKEN_FROM_ID(418, KeywordTokenType),
276
277    T_MSEXT_PP_REGION    = TOKEN_FROM_ID(419, PPTokenType),
278    T_MSEXT_PP_ENDREGION = TOKEN_FROM_ID(420, PPTokenType),
279   
280    T_LAST_TOKEN_ID,
281    T_LAST_TOKEN = ID_FROM_TOKEN(T_LAST_TOKEN_ID),
282   
283// pseudo tokens to help streamlining macro replacement, these should not
284// returned from the lexer nor should these be returned from the pp-iterator
285    T_NONREPLACABLE_IDENTIFIER = TOKEN_FROM_ID(T_LAST_TOKEN+1, IdentifierTokenType),
286    T_PLACEHOLDER = TOKEN_FROM_ID(T_LAST_TOKEN+2, WhiteSpaceTokenType),
287    T_PLACEMARKER = TOKEN_FROM_ID(T_LAST_TOKEN+3, InternalTokenType),
288    T_PARAMETERBASE = TOKEN_FROM_ID(T_LAST_TOKEN+4, ParameterTokenType),
289    T_EXTPARAMETERBASE = TOKEN_FROM_ID(T_LAST_TOKEN+5, ExtParameterTokenType)
290};
291
292///////////////////////////////////////////////////////////////////////////////
293//  redefine the TOKEN_FROM_ID macro to be more type safe
294#undef TOKEN_FROM_ID
295#define TOKEN_FROM_ID(id, cat)   boost::wave::token_id((id) | (cat))
296
297#undef ID_FROM_TOKEN
298#define ID_FROM_TOKEN(tok)       ((tok) & ~boost::wave::TokenTypeMask)
299
300#undef BASEID_FROM_TOKEN
301#define BASEID_FROM_TOKEN(tok)                                                \
302    boost::wave::token_id(((tok) & ~boost::wave::ExtTokenTypeMask))           \
303  /**/
304#define BASE_TOKEN(tok)                                                       \
305    boost::wave::token_id((tok) & boost::wave::MainTokenMask)                 \
306  /**/
307#define CATEGORY_FROM_TOKEN(tok) ((tok) & boost::wave::TokenTypeMask)
308#define EXTCATEGORY_FROM_TOKEN(tok) ((tok) & boost::wave::ExtTokenTypeMask)
309#define IS_CATEGORY(tok, cat)    \
310    ((CATEGORY_FROM_TOKEN(tok) == (cat)) ? true : false) \
311    /**/
312#define IS_EXTCATEGORY(tok, cat)    \
313    ((EXTCATEGORY_FROM_TOKEN(tok) == (cat)) ? true : false) \
314    /**/
315
316///////////////////////////////////////////////////////////////////////////////
317//  return a token name
318inline BOOST_WAVE_STRINGTYPE
319get_token_name(token_id tokid)
320{
321//  Table of token names
322//
323//      Please note that the sequence of token names must match the sequence of
324//      token id's defined in then enum token_id above.
325static char const *tok_names[] = {
326    /* 256 */   "AND",
327    /* 257 */   "ANDAND",
328    /* 258 */   "ASSIGN",
329    /* 259 */   "ANDASSIGN",
330    /* 260 */   "OR",
331    /* 261 */   "ORASSIGN",
332    /* 262 */   "XOR",
333    /* 263 */   "XORASSIGN",
334    /* 264 */   "COMMA",
335    /* 265 */   "COLON",
336    /* 266 */   "DIVIDE",
337    /* 267 */   "DIVIDEASSIGN",
338    /* 268 */   "DOT",
339    /* 269 */   "DOTSTAR",
340    /* 270 */   "ELLIPSIS",
341    /* 271 */   "EQUAL",
342    /* 272 */   "GREATER",
343    /* 273 */   "GREATEREQUAL",
344    /* 274 */   "LEFTBRACE",
345    /* 275 */   "LESS",
346    /* 276 */   "LESSEQUAL",
347    /* 277 */   "LEFTPAREN",
348    /* 278 */   "LEFTBRACKET",
349    /* 279 */   "MINUS",
350    /* 280 */   "MINUSASSIGN",
351    /* 281 */   "MINUSMINUS",
352    /* 282 */   "PERCENT",
353    /* 283 */   "PERCENTASSIGN",
354    /* 284 */   "NOT",
355    /* 285 */   "NOTEQUAL",
356    /* 286 */   "OROR",
357    /* 287 */   "PLUS",
358    /* 288 */   "PLUSASSIGN",
359    /* 289 */   "PLUSPLUS",
360    /* 290 */   "ARROW",
361    /* 291 */   "ARROWSTAR",
362    /* 292 */   "QUESTION_MARK",
363    /* 293 */   "RIGHTBRACE",
364    /* 294 */   "RIGHTPAREN",
365    /* 295 */   "RIGHTBRACKET",
366    /* 296 */   "COLON_COLON",
367    /* 297 */   "SEMICOLON",
368    /* 298 */   "SHIFTLEFT",
369    /* 299 */   "SHIFTLEFTASSIGN",
370    /* 300 */   "SHIFTRIGHT",
371    /* 301 */   "SHIFTRIGHTASSIGN",
372    /* 302 */   "STAR",
373    /* 303 */   "COMPL",
374    /* 304 */   "STARASSIGN",
375    /* 305 */   "ASM",
376    /* 306 */   "AUTO",
377    /* 307 */   "BOOL",
378    /* 308 */   "FALSE",
379    /* 309 */   "TRUE",
380    /* 310 */   "BREAK",
381    /* 311 */   "CASE",
382    /* 312 */   "CATCH",
383    /* 313 */   "CHAR",
384    /* 314 */   "CLASS",
385    /* 315 */   "CONST",
386    /* 316 */   "CONSTCAST",
387    /* 317 */   "CONTINUE",
388    /* 318 */   "DEFAULT",
389    /* 319 */   "DEFINED",
390    /* 320 */   "DELETE",
391    /* 321 */   "DO",
392    /* 322 */   "DOUBLE",
393    /* 323 */   "DYNAMICCAST",
394    /* 324 */   "ELSE",
395    /* 325 */   "ENUM",
396    /* 326 */   "EXPLICIT",
397    /* 327 */   "EXPORT",
398    /* 328 */   "EXTERN",
399    /* 329 */   "FLOAT",
400    /* 330 */   "FOR",
401    /* 331 */   "FRIEND",
402    /* 332 */   "GOTO",
403    /* 333 */   "IF",
404    /* 334 */   "INLINE",
405    /* 335 */   "INT",
406    /* 336 */   "LONG",
407    /* 337 */   "MUTABLE",
408    /* 338 */   "NAMESPACE",
409    /* 339 */   "NEW",
410    /* 340 */   "OPERATOR",
411    /* 341 */   "PRIVATE",
412    /* 342 */   "PROTECTED",
413    /* 343 */   "PUBLIC",
414    /* 344 */   "REGISTER",
415    /* 345 */   "REINTERPRETCAST",
416    /* 346 */   "RETURN",
417    /* 347 */   "SHORT",
418    /* 348 */   "SIGNED",
419    /* 349 */   "SIZEOF",
420    /* 350 */   "STATIC",
421    /* 351 */   "STATICCAST",
422    /* 352 */   "STRUCT",
423    /* 353 */   "SWITCH",
424    /* 354 */   "TEMPLATE",
425    /* 355 */   "THIS",
426    /* 356 */   "THROW",
427    /* 357 */   "TRY",
428    /* 358 */   "TYPEDEF",
429    /* 359 */   "TYPEID",
430    /* 360 */   "TYPENAME",
431    /* 361 */   "UNION",
432    /* 362 */   "UNSIGNED",
433    /* 363 */   "USING",
434    /* 364 */   "VIRTUAL",
435    /* 365 */   "VOID",
436    /* 366 */   "VOLATILE",
437    /* 367 */   "WCHART",
438    /* 368 */   "WHILE",
439    /* 369 */   "PP_DEFINE",
440    /* 370 */   "PP_IF",
441    /* 371 */   "PP_IFDEF",
442    /* 372 */   "PP_IFNDEF",
443    /* 373 */   "PP_ELSE",
444    /* 374 */   "PP_ELIF",
445    /* 375 */   "PP_ENDIF",
446    /* 376 */   "PP_ERROR",
447    /* 377 */   "PP_LINE",
448    /* 378 */   "PP_PRAGMA",
449    /* 379 */   "PP_UNDEF",
450    /* 380 */   "PP_WARNING",
451    /* 381 */   "IDENTIFIER",
452    /* 382 */   "OCTALINT",
453    /* 383 */   "DECIMALINT",
454    /* 384 */   "HEXAINT",
455    /* 385 */   "INTLIT",
456    /* 386 */   "LONGINTLIT",
457    /* 387 */   "FLOATLIT",
458    /* 388 */   "CCOMMENT",
459    /* 389 */   "CPPCOMMENT",
460    /* 390 */   "CHARLIT",
461    /* 391 */   "STRINGLIT",
462    /* 392 */   "CONTLINE",
463    /* 393 */   "SPACE",
464    /* 394 */   "SPACE2",
465    /* 395 */   "NEWLINE",
466    /* 396 */   "POUND_POUND",
467    /* 397 */   "POUND",
468    /* 398 */   "ANY",
469    /* 399 */   "PP_INCLUDE",
470    /* 400 */   "PP_QHEADER",
471    /* 401 */   "PP_HHEADER",
472    /* 402 */   "EOF",
473    /* 403 */   "EOI",
474
475              // MS extensions
476    /* 404 */   "MSEXT_INT8",
477    /* 405 */   "MSEXT_INT16",
478    /* 406 */   "MSEXT_INT32",
479    /* 407 */   "MSEXT_INT64",
480    /* 408 */   "MSEXT_BASED",
481    /* 409 */   "MSEXT_DECLSPEC",
482    /* 410 */   "MSEXT_CDECL",
483    /* 411 */   "MSEXT_FASTCALL",
484    /* 412 */   "MSEXT_STDCALL",
485    /* 413 */   "MSEXT_TRY",
486    /* 414 */   "MSEXT_EXCEPT",
487    /* 415 */   "MSEXT_FINALLY",
488    /* 416 */   "MSEXT_LEAVE",
489    /* 417 */   "MSEXT_INLINE",
490    /* 418 */   "MSEXT_ASM",
491    /* 419 */   "MSEXT_REGION",
492    /* 420 */   "MSEXT_ENDREGION",
493    };   
494     
495    unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
496
497    BOOST_ASSERT(id < T_LAST_TOKEN-T_FIRST_TOKEN);
498    return tok_names[id];
499}
500
501///////////////////////////////////////////////////////////////////////////////
502//  return a token name
503inline char const *
504get_token_value(token_id tokid)
505{
506//  Table of token values
507//
508//      Please note that the sequence of token names must match the sequence of
509//      token id's defined in then enum token_id above.
510static char const *tok_names[] = {
511    /* 256 */   "&",
512    /* 257 */   "&&",
513    /* 258 */   "=",
514    /* 259 */   "&=",
515    /* 260 */   "|",
516    /* 261 */   "|=",
517    /* 262 */   "^",
518    /* 263 */   "^=",
519    /* 264 */   ",",
520    /* 265 */   ":",
521    /* 266 */   "/",
522    /* 267 */   "/=",
523    /* 268 */   ".",
524    /* 269 */   ".*",
525    /* 270 */   "...",
526    /* 271 */   "==",
527    /* 272 */   ">",
528    /* 273 */   ">=",
529    /* 274 */   "{",
530    /* 275 */   "<",
531    /* 276 */   "<=",
532    /* 277 */   "(",
533    /* 278 */   "[",
534    /* 279 */   "-",
535    /* 280 */   "-=",
536    /* 281 */   "--",
537    /* 282 */   "%",
538    /* 283 */   "%=",
539    /* 284 */   "!",
540    /* 285 */   "!=",
541    /* 286 */   "||",
542    /* 287 */   "+",
543    /* 288 */   "+=",
544    /* 289 */   "++",
545    /* 290 */   "->",
546    /* 291 */   "->*",
547    /* 292 */   "?",
548    /* 293 */   "}",
549    /* 294 */   ")",
550    /* 295 */   "]",
551    /* 296 */   "::",
552    /* 297 */   ";",
553    /* 298 */   "<<",
554    /* 299 */   "<<=",
555    /* 300 */   ">>",
556    /* 301 */   ">>=",
557    /* 302 */   "*",
558    /* 303 */   "~",
559    /* 304 */   "*=",
560    /* 305 */   "asm",
561    /* 306 */   "auto",
562    /* 307 */   "bool",
563    /* 308 */   "false",
564    /* 309 */   "true",
565    /* 310 */   "break",
566    /* 311 */   "case",
567    /* 312 */   "catch",
568    /* 313 */   "char",
569    /* 314 */   "class",
570    /* 315 */   "const",
571    /* 316 */   "const_cast",
572    /* 317 */   "continue",
573    /* 318 */   "default",
574    /* 319 */   "defined",
575    /* 320 */   "delete",
576    /* 321 */   "do",
577    /* 322 */   "double",
578    /* 323 */   "dynamic_cast",
579    /* 324 */   "else",
580    /* 325 */   "enum",
581    /* 326 */   "explicit",
582    /* 327 */   "export",
583    /* 328 */   "extern",
584    /* 329 */   "float",
585    /* 330 */   "for",
586    /* 331 */   "friend",
587    /* 332 */   "goto",
588    /* 333 */   "if",
589    /* 334 */   "inline",
590    /* 335 */   "int",
591    /* 336 */   "long",
592    /* 337 */   "mutable",
593    /* 338 */   "namespace",
594    /* 339 */   "new",
595    /* 340 */   "operator",
596    /* 341 */   "private",
597    /* 342 */   "protected",
598    /* 343 */   "public",
599    /* 344 */   "register",
600    /* 345 */   "reinterpret_cast",
601    /* 346 */   "return",
602    /* 347 */   "short",
603    /* 348 */   "signed",
604    /* 349 */   "sizeof",
605    /* 350 */   "static",
606    /* 351 */   "static_cast",
607    /* 352 */   "struct",
608    /* 353 */   "switch",
609    /* 354 */   "template",
610    /* 355 */   "this",
611    /* 356 */   "throw",
612    /* 357 */   "try",
613    /* 358 */   "typedef",
614    /* 359 */   "typeid",
615    /* 360 */   "typename",
616    /* 361 */   "union",
617    /* 362 */   "unsigned",
618    /* 363 */   "using",
619    /* 364 */   "virtual",
620    /* 365 */   "void",
621    /* 366 */   "volatile",
622    /* 367 */   "wchar_t",
623    /* 368 */   "while",
624    /* 369 */   "#define",
625    /* 370 */   "#if",
626    /* 371 */   "#ifdef",
627    /* 372 */   "#ifndef",
628    /* 373 */   "#else",
629    /* 374 */   "#elif",
630    /* 375 */   "#endif",
631    /* 376 */   "#error",
632    /* 377 */   "#line",
633    /* 378 */   "#pragma ",
634    /* 379 */   "#undef ",
635    /* 380 */   "#warning",
636    /* 381 */   "",   // identifier
637    /* 382 */   "",   // octalint
638    /* 383 */   "",   // decimalint
639    /* 384 */   "",   // hexlit
640    /* 385 */   "",   // intlit
641    /* 386 */   "",   // longintlit
642    /* 387 */   "",   // floatlit
643    /* 388 */   "",   // ccomment
644    /* 389 */   "",   // cppcomment
645    /* 390 */   "",   // charlit
646    /* 391 */   "",   // stringlit
647    /* 392 */   "",   // contline
648    /* 393 */   "",   // space
649    /* 394 */   "",   // space2
650    /* 395 */   "\n",
651    /* 396 */   "##",
652    /* 397 */   "#",
653    /* 398 */   "",   // any
654    /* 399 */   "#include",
655    /* 400 */   "#include",
656    /* 401 */   "#include",
657    /* 402 */   "",   // eof
658    /* 403 */   "",   // eoi
659
660              // MS extensions
661    /* 404 */   "__int8",
662    /* 405 */   "__int16",
663    /* 406 */   "__int32",
664    /* 407 */   "__int64",
665    /* 408 */   "__based",
666    /* 409 */   "__declspec",
667    /* 410 */   "__cdecl",
668    /* 411 */   "__fastcall",
669    /* 412 */   "__stdcall",
670    /* 413 */   "__try",
671    /* 414 */   "__except",
672    /* 415 */   "__finally",
673    /* 416 */   "__leave",
674    /* 417 */   "__inline",
675    /* 418 */   "__asm",
676    /* 419 */   "#region",
677    /* 420 */   "#endregion",
678    };   
679     
680    unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
681
682    BOOST_ASSERT(id < T_LAST_TOKEN-T_FIRST_TOKEN);
683    return tok_names[id];
684}
685
686///////////////////////////////////////////////////////////////////////////////
687}   // namespace wave
688}   // namespace boost
689
690#endif // #if !defined(BOOST_WAVE_TOKEN_IDS_DEFINED)
691
692#endif // !defined(TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED)
693
Note: See TracBrowser for help on using the repository browser.