Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/wave/token_ids.hpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 17 years ago
added boost
File size: 26.9 KB

Line
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	///////////////////////////////////////////////////////////////////////////////
31	namespace boost {
32	namespace 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
42	enum 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
75	enum 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
318	inline BOOST_WAVE_STRINGTYPE
319	get_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.
325	static 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
503	inline char const *
504	get_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.
510	static 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.

Download in other formats: