[ceph.git] / ceph / src / boost / libs / wave / src / token_ids.cpp

/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library
    The definition of a default set of token identifiers and related
    functions.

    http://www.boost.org/

    Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
    Software License, Version 1.0. (See accompanying file
    LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#define BOOST_WAVE_SOURCE 1

// disable stupid compiler warnings
#include <boost/config/warning_disable.hpp>

#include <string>
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>

#include <boost/wave/wave_config.hpp>
#include <boost/wave/token_ids.hpp>

// this must occur after all of the includes and before any code appears
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_PREFIX
#endif

///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {

///////////////////////////////////////////////////////////////////////////////
//  return a token name
BOOST_WAVE_STRINGTYPE
get_token_name(token_id tokid)
{
//  Table of token names
//
//      Please note that the sequence of token names must match the sequence of
//      token id's defined in then enum token_id above.
static char const *tok_names[] = {
    /* 256 */   "AND",
    /* 257 */   "ANDAND",
    /* 258 */   "ASSIGN",
    /* 259 */   "ANDASSIGN",
    /* 260 */   "OR",
    /* 261 */   "ORASSIGN",
    /* 262 */   "XOR",
    /* 263 */   "XORASSIGN",
    /* 264 */   "COMMA",
    /* 265 */   "COLON",
    /* 266 */   "DIVIDE",
    /* 267 */   "DIVIDEASSIGN",
    /* 268 */   "DOT",
    /* 269 */   "DOTSTAR",
    /* 270 */   "ELLIPSIS",
    /* 271 */   "EQUAL",
    /* 272 */   "GREATER",
    /* 273 */   "GREATEREQUAL",
    /* 274 */   "LEFTBRACE",
    /* 275 */   "LESS",
    /* 276 */   "LESSEQUAL",
    /* 277 */   "LEFTPAREN",
    /* 278 */   "LEFTBRACKET",
    /* 279 */   "MINUS",
    /* 280 */   "MINUSASSIGN",
    /* 281 */   "MINUSMINUS",
    /* 282 */   "PERCENT",
    /* 283 */   "PERCENTASSIGN",
    /* 284 */   "NOT",
    /* 285 */   "NOTEQUAL",
    /* 286 */   "OROR",
    /* 287 */   "PLUS",
    /* 288 */   "PLUSASSIGN",
    /* 289 */   "PLUSPLUS",
    /* 290 */   "ARROW",
    /* 291 */   "ARROWSTAR",
    /* 292 */   "QUESTION_MARK",
    /* 293 */   "RIGHTBRACE",
    /* 294 */   "RIGHTPAREN",
    /* 295 */   "RIGHTBRACKET",
    /* 296 */   "COLON_COLON",
    /* 297 */   "SEMICOLON",
    /* 298 */   "SHIFTLEFT",
    /* 299 */   "SHIFTLEFTASSIGN",
    /* 300 */   "SHIFTRIGHT",
    /* 301 */   "SHIFTRIGHTASSIGN",
    /* 302 */   "STAR",
    /* 303 */   "COMPL",
    /* 304 */   "STARASSIGN",
    /* 305 */   "ASM",
    /* 306 */   "AUTO",
    /* 307 */   "BOOL",
    /* 308 */   "FALSE",
    /* 309 */   "TRUE",
    /* 310 */   "BREAK",
    /* 311 */   "CASE",
    /* 312 */   "CATCH",
    /* 313 */   "CHAR",
    /* 314 */   "CLASS",
    /* 315 */   "CONST",
    /* 316 */   "CONSTCAST",
    /* 317 */   "CONTINUE",
    /* 318 */   "DEFAULT",
    /* 319 */   "DELETE",
    /* 320 */   "DO",
    /* 321 */   "DOUBLE",
    /* 322 */   "DYNAMICCAST",
    /* 323 */   "ELSE",
    /* 324 */   "ENUM",
    /* 325 */   "EXPLICIT",
    /* 326 */   "EXPORT",
    /* 327 */   "EXTERN",
    /* 328 */   "FLOAT",
    /* 329 */   "FOR",
    /* 330 */   "FRIEND",
    /* 331 */   "GOTO",
    /* 332 */   "IF",
    /* 333 */   "INLINE",
    /* 334 */   "INT",
    /* 335 */   "LONG",
    /* 336 */   "MUTABLE",
    /* 337 */   "NAMESPACE",
    /* 338 */   "NEW",
    /* 339 */   "OPERATOR",
    /* 340 */   "PRIVATE",
    /* 341 */   "PROTECTED",
    /* 342 */   "PUBLIC",
    /* 343 */   "REGISTER",
    /* 344 */   "REINTERPRETCAST",
    /* 345 */   "RETURN",
    /* 346 */   "SHORT",
    /* 347 */   "SIGNED",
    /* 348 */   "SIZEOF",
    /* 349 */   "STATIC",
    /* 350 */   "STATICCAST",
    /* 351 */   "STRUCT",
    /* 352 */   "SWITCH",
    /* 353 */   "TEMPLATE",
    /* 354 */   "THIS",
    /* 355 */   "THROW",
    /* 356 */   "TRY",
    /* 357 */   "TYPEDEF",
    /* 358 */   "TYPEID",
    /* 359 */   "TYPENAME",
    /* 360 */   "UNION",
    /* 361 */   "UNSIGNED",
    /* 362 */   "USING",
    /* 363 */   "VIRTUAL",
    /* 364 */   "VOID",
    /* 365 */   "VOLATILE",
    /* 366 */   "WCHART",
    /* 367 */   "WHILE",
    /* 368 */   "PP_DEFINE",
    /* 369 */   "PP_IF",
    /* 370 */   "PP_IFDEF",
    /* 371 */   "PP_IFNDEF",
    /* 372 */   "PP_ELSE",
    /* 373 */   "PP_ELIF",
    /* 374 */   "PP_ENDIF",
    /* 375 */   "PP_ERROR",
    /* 376 */   "PP_LINE",
    /* 377 */   "PP_PRAGMA",
    /* 378 */   "PP_UNDEF",
    /* 379 */   "PP_WARNING",
    /* 380 */   "IDENTIFIER",
    /* 381 */   "OCTALINT",
    /* 382 */   "DECIMALINT",
    /* 383 */   "HEXAINT",
    /* 384 */   "INTLIT",
    /* 385 */   "LONGINTLIT",
    /* 386 */   "FLOATLIT",
    /* 387 */   "CCOMMENT",
    /* 388 */   "CPPCOMMENT",
    /* 389 */   "CHARLIT",
    /* 390 */   "STRINGLIT",
    /* 391 */   "CONTLINE",
    /* 392 */   "SPACE",
    /* 393 */   "SPACE2",
    /* 394 */   "NEWLINE",
    /* 395 */   "POUND_POUND",
    /* 396 */   "POUND",
    /* 397 */   "ANY",
    /* 398 */   "PP_INCLUDE",
    /* 399 */   "PP_QHEADER",
    /* 400 */   "PP_HHEADER",
    /* 401 */   "EOF",
    /* 402 */   "EOI",
    /* 403 */   "PP_NUMBER",

              // MS extensions
    /* 404 */   "MSEXT_INT8",
    /* 405 */   "MSEXT_INT16",
    /* 406 */   "MSEXT_INT32",
    /* 407 */   "MSEXT_INT64",
    /* 408 */   "MSEXT_BASED",
    /* 409 */   "MSEXT_DECLSPEC",
    /* 410 */   "MSEXT_CDECL",
    /* 411 */   "MSEXT_FASTCALL",
    /* 412 */   "MSEXT_STDCALL",
    /* 413 */   "MSEXT_TRY",
    /* 414 */   "MSEXT_EXCEPT",
    /* 415 */   "MSEXT_FINALLY",
    /* 416 */   "MSEXT_LEAVE",
    /* 417 */   "MSEXT_INLINE",
    /* 418 */   "MSEXT_ASM",
    /* 419 */   "MSEXT_REGION",
    /* 420 */   "MSEXT_ENDREGION",

    /* 421 */   "IMPORT",

    /* 422 */   "ALIGNAS",
    /* 423 */   "ALIGNOF",
    /* 424 */   "CHAR16_T",
    /* 425 */   "CHAR32_T",
    /* 426 */   "CONSTEXPR",
    /* 427 */   "DECLTYPE",
    /* 428 */   "NOEXCEPT",
    /* 429 */   "NULLPTR",
    /* 430 */   "STATIC_ASSERT",
    /* 431 */   "THREADLOCAL",
    /* 432 */   "RAWSTRINGLIT",
    };

    // make sure, I have not forgotten any commas (as I did more than once)
    BOOST_STATIC_ASSERT(
        sizeof(tok_names)/sizeof(tok_names[0]) == T_LAST_TOKEN-T_FIRST_TOKEN
    );

    unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
    return (id < T_LAST_TOKEN-T_FIRST_TOKEN) ? tok_names[id] : "<UnknownToken>";
}

///////////////////////////////////////////////////////////////////////////////
//  return a token name
char const *
get_token_value(token_id tokid)
{
//  Table of token values
//
//      Please note that the sequence of token names must match the sequence of
//      token id's defined in then enum token_id above.
static char const *tok_values[] = {
    /* 256 */   "&",
    /* 257 */   "&&",
    /* 258 */   "=",
    /* 259 */   "&=",
    /* 260 */   "|",
    /* 261 */   "|=",
    /* 262 */   "^",
    /* 263 */   "^=",
    /* 264 */   ",",
    /* 265 */   ":",
    /* 266 */   "/",
    /* 267 */   "/=",
    /* 268 */   ".",
    /* 269 */   ".*",
    /* 270 */   "...",
    /* 271 */   "==",
    /* 272 */   ">",
    /* 273 */   ">=",
    /* 274 */   "{",
    /* 275 */   "<",
    /* 276 */   "<=",
    /* 277 */   "(",
    /* 278 */   "[",
    /* 279 */   "-",
    /* 280 */   "-=",
    /* 281 */   "--",
    /* 282 */   "%",
    /* 283 */   "%=",
    /* 284 */   "!",
    /* 285 */   "!=",
    /* 286 */   "||",
    /* 287 */   "+",
    /* 288 */   "+=",
    /* 289 */   "++",
    /* 290 */   "->",
    /* 291 */   "->*",
    /* 292 */   "?",
    /* 293 */   "}",
    /* 294 */   ")",
    /* 295 */   "]",
    /* 296 */   "::",
    /* 297 */   ";",
    /* 298 */   "<<",
    /* 299 */   "<<=",
    /* 300 */   ">>",
    /* 301 */   ">>=",
    /* 302 */   "*",
    /* 303 */   "~",
    /* 304 */   "*=",
    /* 305 */   "asm",
    /* 306 */   "auto",
    /* 307 */   "bool",
    /* 308 */   "false",
    /* 309 */   "true",
    /* 310 */   "break",
    /* 311 */   "case",
    /* 312 */   "catch",
    /* 313 */   "char",
    /* 314 */   "class",
    /* 315 */   "const",
    /* 316 */   "const_cast",
    /* 317 */   "continue",
    /* 318 */   "default",
    /* 319 */   "delete",
    /* 320 */   "do",
    /* 321 */   "double",
    /* 322 */   "dynamic_cast",
    /* 323 */   "else",
    /* 324 */   "enum",
    /* 325 */   "explicit",
    /* 326 */   "export",
    /* 327 */   "extern",
    /* 328 */   "float",
    /* 329 */   "for",
    /* 330 */   "friend",
    /* 331 */   "goto",
    /* 332 */   "if",
    /* 333 */   "inline",
    /* 334 */   "int",
    /* 335 */   "long",
    /* 336 */   "mutable",
    /* 337 */   "namespace",
    /* 338 */   "new",
    /* 339 */   "operator",
    /* 340 */   "private",
    /* 341 */   "protected",
    /* 342 */   "public",
    /* 343 */   "register",
    /* 344 */   "reinterpret_cast",
    /* 345 */   "return",
    /* 346 */   "short",
    /* 347 */   "signed",
    /* 348 */   "sizeof",
    /* 349 */   "static",
    /* 350 */   "static_cast",
    /* 351 */   "struct",
    /* 352 */   "switch",
    /* 353 */   "template",
    /* 354 */   "this",
    /* 355 */   "throw",
    /* 356 */   "try",
    /* 357 */   "typedef",
    /* 358 */   "typeid",
    /* 359 */   "typename",
    /* 360 */   "union",
    /* 361 */   "unsigned",
    /* 362 */   "using",
    /* 363 */   "virtual",
    /* 364 */   "void",
    /* 365 */   "volatile",
    /* 366 */   "wchar_t",
    /* 367 */   "while",
    /* 368 */   "#define",
    /* 369 */   "#if",
    /* 370 */   "#ifdef",
    /* 371 */   "#ifndef",
    /* 372 */   "#else",
    /* 373 */   "#elif",
    /* 374 */   "#endif",
    /* 375 */   "#error",
    /* 376 */   "#line",
    /* 377 */   "#pragma",
    /* 378 */   "#undef",
    /* 379 */   "#warning",
    /* 380 */   "",   // identifier
    /* 381 */   "",   // octalint
    /* 382 */   "",   // decimalint
    /* 383 */   "",   // hexlit
    /* 384 */   "",   // intlit
    /* 385 */   "",   // longintlit
    /* 386 */   "",   // floatlit
    /* 387 */   "",   // ccomment
    /* 388 */   "",   // cppcomment
    /* 389 */   "",   // charlit
    /* 390 */   "",   // stringlit
    /* 391 */   "",   // contline
    /* 392 */   "",   // space
    /* 393 */   "",   // space2
    /* 394 */   "\n",
    /* 395 */   "##",
    /* 396 */   "#",
    /* 397 */   "",   // any
    /* 398 */   "#include",
    /* 399 */   "#include",
    /* 400 */   "#include",
    /* 401 */   "",   // eof
    /* 402 */   "",   // eoi
    /* 403 */   "",   // pp-number

              // MS extensions
    /* 404 */   "__int8",
    /* 405 */   "__int16",
    /* 406 */   "__int32",
    /* 407 */   "__int64",
    /* 408 */   "__based",
    /* 409 */   "__declspec",
    /* 410 */   "__cdecl",
    /* 411 */   "__fastcall",
    /* 412 */   "__stdcall",
    /* 413 */   "__try",
    /* 414 */   "__except",
    /* 415 */   "__finally",
    /* 416 */   "__leave",
    /* 417 */   "__inline",
    /* 418 */   "__asm",
    /* 419 */   "#region",
    /* 420 */   "#endregion",

    /* 421 */   "import",

    /* 422 */   "alignas",
    /* 423 */   "alignof",
    /* 424 */   "char16_t",
    /* 425 */   "char32_t",
    /* 426 */   "constexpr",
    /* 427 */   "decltype",
    /* 428 */   "noexcept",
    /* 429 */   "nullptr",
    /* 430 */   "static_assert",
    /* 431 */   "threadlocal",
    /* 432 */   "",   // extrawstringlit
    };

    // make sure, I have not forgotten any commas (as I did more than once)
    BOOST_STATIC_ASSERT(
        sizeof(tok_values)/sizeof(tok_values[0]) == T_LAST_TOKEN-T_FIRST_TOKEN
    );

    unsigned int id = BASEID_FROM_TOKEN(tokid)-T_FIRST_TOKEN;
    return (id < T_LAST_TOKEN-T_FIRST_TOKEN) ? tok_values[id] : "<UnknownToken>";
}

///////////////////////////////////////////////////////////////////////////////
}   // namespace wave
}   // namespace boost

// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
7c673cae FG	2	Boost.Wave: A Standard compliant C++ preprocessor library
b32b8144	3	The definition of a default set of token identifiers and related
7c673cae	4	functions.
b32b8144	5
7c673cae FG	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
	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",
b32b8144	211
7c673cae	212	/* 421 */ "IMPORT",
b32b8144	213
7c673cae FG	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 *
	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",
b32b8144	413
7c673cae	414	/* 421 */ "import",
b32b8144	415
7c673cae FG	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
b32b8144 FG	427	};
b32b8144 FG	428
7c673cae FG	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