1 //===--- TokenKinds.def - C Family Token Kind Database ----------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the TokenKind database. This includes normal tokens like 11 // tok::ampamp (corresponding to the && token) as well as keywords for various 12 // languages. Users of this file must optionally #define the TOK, KEYWORD, 13 // CXX11_KEYWORD, CONCEPTS_KEYWORD, ALIAS, or PPKEYWORD macros to make use of 14 // this file. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #ifndef TOK 19 #define TOK(X) 20 #endif 21 #ifndef PUNCTUATOR 22 #define PUNCTUATOR(X,Y) TOK(X) 23 #endif 24 #ifndef KEYWORD 25 #define KEYWORD(X,Y) TOK(kw_ ## X) 26 #endif 27 #ifndef CXX11_KEYWORD 28 #define CXX11_KEYWORD(X,Y) KEYWORD(X,KEYCXX11|(Y)) 29 #endif 30 #ifndef CONCEPTS_KEYWORD 31 #define CONCEPTS_KEYWORD(X) KEYWORD(X,KEYCONCEPTS) 32 #endif 33 #ifndef MODULES_KEYWORD 34 #define MODULES_KEYWORD(X) KEYWORD(X,KEYMODULES) 35 #endif 36 #ifndef TYPE_TRAIT 37 #define TYPE_TRAIT(N,I,K) KEYWORD(I,K) 38 #endif 39 #ifndef TYPE_TRAIT_1 40 #define TYPE_TRAIT_1(I,E,K) TYPE_TRAIT(1,I,K) 41 #endif 42 #ifndef TYPE_TRAIT_2 43 #define TYPE_TRAIT_2(I,E,K) TYPE_TRAIT(2,I,K) 44 #endif 45 #ifndef TYPE_TRAIT_N 46 #define TYPE_TRAIT_N(I,E,K) TYPE_TRAIT(0,I,K) 47 #endif 48 #ifndef ALIAS 49 #define ALIAS(X,Y,Z) 50 #endif 51 #ifndef PPKEYWORD 52 #define PPKEYWORD(X) 53 #endif 54 #ifndef CXX_KEYWORD_OPERATOR 55 #define CXX_KEYWORD_OPERATOR(X,Y) 56 #endif 57 #ifndef OBJC1_AT_KEYWORD 58 #define OBJC1_AT_KEYWORD(X) 59 #endif 60 #ifndef OBJC2_AT_KEYWORD 61 #define OBJC2_AT_KEYWORD(X) 62 #endif 63 #ifndef TESTING_KEYWORD 64 #define TESTING_KEYWORD(X, L) KEYWORD(X, L) 65 #endif 66 #ifndef ANNOTATION 67 #define ANNOTATION(X) TOK(annot_ ## X) 68 #endif 69 70 //===----------------------------------------------------------------------===// 71 // Preprocessor keywords. 72 //===----------------------------------------------------------------------===// 73 74 // These have meaning after a '#' at the start of a line. These define enums in 75 // the tok::pp_* namespace. Note that IdentifierInfo::getPPKeywordID must be 76 // manually updated if something is added here. 77 PPKEYWORD(not_keyword) 78 79 // C99 6.10.1 - Conditional Inclusion. 80 PPKEYWORD(if) 81 PPKEYWORD(ifdef) 82 PPKEYWORD(ifndef) 83 PPKEYWORD(elif) 84 PPKEYWORD(else) 85 PPKEYWORD(endif) 86 PPKEYWORD(defined) 87 88 // C99 6.10.2 - Source File Inclusion. 89 PPKEYWORD(include) 90 PPKEYWORD(__include_macros) 91 92 // C99 6.10.3 - Macro Replacement. 93 PPKEYWORD(define) 94 PPKEYWORD(undef) 95 96 // C99 6.10.4 - Line Control. 97 PPKEYWORD(line) 98 99 // C99 6.10.5 - Error Directive. 100 PPKEYWORD(error) 101 102 // C99 6.10.6 - Pragma Directive. 103 PPKEYWORD(pragma) 104 105 // GNU Extensions. 106 PPKEYWORD(import) 107 PPKEYWORD(include_next) 108 PPKEYWORD(warning) 109 PPKEYWORD(ident) 110 PPKEYWORD(sccs) 111 PPKEYWORD(assert) 112 PPKEYWORD(unassert) 113 114 // Clang extensions 115 PPKEYWORD(__public_macro) 116 PPKEYWORD(__private_macro) 117 118 //===----------------------------------------------------------------------===// 119 // Language keywords. 120 //===----------------------------------------------------------------------===// 121 122 // These define members of the tok::* namespace. 123 124 TOK(unknown) // Not a token. 125 TOK(eof) // End of file. 126 TOK(eod) // End of preprocessing directive (end of line inside a 127 // directive). 128 TOK(code_completion) // Code completion marker 129 130 // C99 6.4.9: Comments. 131 TOK(comment) // Comment (only in -E -C[C] mode) 132 133 // C99 6.4.2: Identifiers. 134 TOK(identifier) // abcde123 135 TOK(raw_identifier) // Used only in raw lexing mode. 136 137 // C99 6.4.4.1: Integer Constants 138 // C99 6.4.4.2: Floating Constants 139 TOK(numeric_constant) // 0x123 140 141 // C99 6.4.4: Character Constants 142 TOK(char_constant) // 'a' 143 TOK(wide_char_constant) // L'b' 144 145 // C++1z Character Constants 146 TOK(utf8_char_constant) // u8'a' 147 148 // C++11 Character Constants 149 TOK(utf16_char_constant) // u'a' 150 TOK(utf32_char_constant) // U'a' 151 152 // C99 6.4.5: String Literals. 153 TOK(string_literal) // "foo" 154 TOK(wide_string_literal) // L"foo" 155 TOK(angle_string_literal)// <foo> 156 157 // C++11 String Literals. 158 TOK(utf8_string_literal) // u8"foo" 159 TOK(utf16_string_literal)// u"foo" 160 TOK(utf32_string_literal)// U"foo" 161 162 // C99 6.4.6: Punctuators. 163 PUNCTUATOR(l_square, "[") 164 PUNCTUATOR(r_square, "]") 165 PUNCTUATOR(l_paren, "(") 166 PUNCTUATOR(r_paren, ")") 167 PUNCTUATOR(l_brace, "{") 168 PUNCTUATOR(r_brace, "}") 169 PUNCTUATOR(period, ".") 170 PUNCTUATOR(ellipsis, "...") 171 PUNCTUATOR(amp, "&") 172 PUNCTUATOR(ampamp, "&&") 173 PUNCTUATOR(ampequal, "&=") 174 PUNCTUATOR(star, "*") 175 PUNCTUATOR(starequal, "*=") 176 PUNCTUATOR(plus, "+") 177 PUNCTUATOR(plusplus, "++") 178 PUNCTUATOR(plusequal, "+=") 179 PUNCTUATOR(minus, "-") 180 PUNCTUATOR(arrow, "->") 181 PUNCTUATOR(minusminus, "--") 182 PUNCTUATOR(minusequal, "-=") 183 PUNCTUATOR(tilde, "~") 184 PUNCTUATOR(exclaim, "!") 185 PUNCTUATOR(exclaimequal, "!=") 186 PUNCTUATOR(slash, "/") 187 PUNCTUATOR(slashequal, "/=") 188 PUNCTUATOR(percent, "%") 189 PUNCTUATOR(percentequal, "%=") 190 PUNCTUATOR(less, "<") 191 PUNCTUATOR(lessless, "<<") 192 PUNCTUATOR(lessequal, "<=") 193 PUNCTUATOR(lesslessequal, "<<=") 194 PUNCTUATOR(greater, ">") 195 PUNCTUATOR(greatergreater, ">>") 196 PUNCTUATOR(greaterequal, ">=") 197 PUNCTUATOR(greatergreaterequal, ">>=") 198 PUNCTUATOR(caret, "^") 199 PUNCTUATOR(caretequal, "^=") 200 PUNCTUATOR(pipe, "|") 201 PUNCTUATOR(pipepipe, "||") 202 PUNCTUATOR(pipeequal, "|=") 203 PUNCTUATOR(question, "?") 204 PUNCTUATOR(colon, ":") 205 PUNCTUATOR(semi, ";") 206 PUNCTUATOR(equal, "=") 207 PUNCTUATOR(equalequal, "==") 208 PUNCTUATOR(comma, ",") 209 PUNCTUATOR(hash, "#") 210 PUNCTUATOR(hashhash, "##") 211 PUNCTUATOR(hashat, "#@") 212 213 // C++ Support 214 PUNCTUATOR(periodstar, ".*") 215 PUNCTUATOR(arrowstar, "->*") 216 PUNCTUATOR(coloncolon, "::") 217 218 // Objective C support. 219 PUNCTUATOR(at, "@") 220 221 // CUDA support. 222 PUNCTUATOR(lesslessless, "<<<") 223 PUNCTUATOR(greatergreatergreater, ">>>") 224 225 // CL support 226 PUNCTUATOR(caretcaret, "^^") 227 228 // C99 6.4.1: Keywords. These turn into kw_* tokens. 229 // Flags allowed: 230 // KEYALL - This is a keyword in all variants of C and C++, or it 231 // is a keyword in the implementation namespace that should 232 // always be treated as a keyword 233 // KEYC99 - This is a keyword introduced to C in C99 234 // KEYC11 - This is a keyword introduced to C in C11 235 // KEYCXX - This is a C++ keyword, or a C++-specific keyword in the 236 // implementation namespace 237 // KEYNOCXX - This is a keyword in every non-C++ dialect. 238 // KEYCXX11 - This is a C++ keyword introduced to C++ in C++11 239 // KEYCONCEPTS - This is a keyword if the C++ extensions for concepts 240 // are enabled. 241 // KEYMODULES - This is a keyword if the C++ extensions for modules 242 // are enabled. 243 // KEYGNU - This is a keyword if GNU extensions are enabled 244 // KEYMS - This is a keyword if Microsoft extensions are enabled 245 // KEYNOMS18 - This is a keyword that must never be enabled under 246 // MSVC <= v18. 247 // KEYOPENCL - This is a keyword in OpenCL 248 // KEYNOOPENCL - This is a keyword that is not supported in OpenCL 249 // KEYALTIVEC - This is a keyword in AltiVec 250 // KEYZVECTOR - This is a keyword for the System z vector extensions, 251 // which are heavily based on AltiVec 252 // KEYBORLAND - This is a keyword if Borland extensions are enabled 253 // KEYCOROUTINES - This is a keyword if support for the C++ coroutines 254 // TS is enabled 255 // BOOLSUPPORT - This is a keyword if 'bool' is a built-in type 256 // HALFSUPPORT - This is a keyword if 'half' is a built-in type 257 // WCHARSUPPORT - This is a keyword if 'wchar_t' is a built-in type 258 // 259 KEYWORD(auto , KEYALL) 260 KEYWORD(break , KEYALL) 261 KEYWORD(case , KEYALL) 262 KEYWORD(char , KEYALL) 263 KEYWORD(const , KEYALL) 264 KEYWORD(continue , KEYALL) 265 KEYWORD(default , KEYALL) 266 KEYWORD(do , KEYALL) 267 KEYWORD(double , KEYALL) 268 KEYWORD(else , KEYALL) 269 KEYWORD(enum , KEYALL) 270 KEYWORD(extern , KEYALL) 271 KEYWORD(float , KEYALL) 272 KEYWORD(for , KEYALL) 273 KEYWORD(goto , KEYALL) 274 KEYWORD(if , KEYALL) 275 KEYWORD(inline , KEYC99|KEYCXX|KEYGNU) 276 KEYWORD(int , KEYALL) 277 KEYWORD(long , KEYALL) 278 KEYWORD(register , KEYALL) 279 KEYWORD(restrict , KEYC99) 280 KEYWORD(return , KEYALL) 281 KEYWORD(short , KEYALL) 282 KEYWORD(signed , KEYALL) 283 KEYWORD(sizeof , KEYALL) 284 KEYWORD(static , KEYALL) 285 KEYWORD(struct , KEYALL) 286 KEYWORD(switch , KEYALL) 287 KEYWORD(typedef , KEYALL) 288 KEYWORD(union , KEYALL) 289 KEYWORD(unsigned , KEYALL) 290 KEYWORD(void , KEYALL) 291 KEYWORD(volatile , KEYALL) 292 KEYWORD(while , KEYALL) 293 KEYWORD(_Alignas , KEYALL) 294 KEYWORD(_Alignof , KEYALL) 295 KEYWORD(_Atomic , KEYALL|KEYNOOPENCL) 296 KEYWORD(_Bool , KEYNOCXX) 297 KEYWORD(_Complex , KEYALL) 298 KEYWORD(_Generic , KEYALL) 299 KEYWORD(_Imaginary , KEYALL) 300 KEYWORD(_Noreturn , KEYALL) 301 KEYWORD(_Static_assert , KEYALL) 302 KEYWORD(_Thread_local , KEYALL) 303 KEYWORD(__func__ , KEYALL) 304 KEYWORD(__objc_yes , KEYALL) 305 KEYWORD(__objc_no , KEYALL) 306 307 308 // C++ 2.11p1: Keywords. 309 KEYWORD(asm , KEYCXX|KEYGNU) 310 KEYWORD(bool , BOOLSUPPORT) 311 KEYWORD(catch , KEYCXX) 312 KEYWORD(class , KEYCXX) 313 KEYWORD(const_cast , KEYCXX) 314 KEYWORD(delete , KEYCXX) 315 KEYWORD(dynamic_cast , KEYCXX) 316 KEYWORD(explicit , KEYCXX) 317 KEYWORD(export , KEYCXX) 318 KEYWORD(false , BOOLSUPPORT) 319 KEYWORD(friend , KEYCXX) 320 KEYWORD(mutable , KEYCXX) 321 KEYWORD(namespace , KEYCXX) 322 KEYWORD(new , KEYCXX) 323 KEYWORD(operator , KEYCXX) 324 KEYWORD(private , KEYCXX) 325 KEYWORD(protected , KEYCXX) 326 KEYWORD(public , KEYCXX) 327 KEYWORD(reinterpret_cast , KEYCXX) 328 KEYWORD(static_cast , KEYCXX) 329 KEYWORD(template , KEYCXX) 330 KEYWORD(this , KEYCXX) 331 KEYWORD(throw , KEYCXX) 332 KEYWORD(true , BOOLSUPPORT) 333 KEYWORD(try , KEYCXX) 334 KEYWORD(typename , KEYCXX) 335 KEYWORD(typeid , KEYCXX) 336 KEYWORD(using , KEYCXX) 337 KEYWORD(virtual , KEYCXX) 338 KEYWORD(wchar_t , WCHARSUPPORT) 339 340 // C++ 2.5p2: Alternative Representations. 341 CXX_KEYWORD_OPERATOR(and , ampamp) 342 CXX_KEYWORD_OPERATOR(and_eq , ampequal) 343 CXX_KEYWORD_OPERATOR(bitand , amp) 344 CXX_KEYWORD_OPERATOR(bitor , pipe) 345 CXX_KEYWORD_OPERATOR(compl , tilde) 346 CXX_KEYWORD_OPERATOR(not , exclaim) 347 CXX_KEYWORD_OPERATOR(not_eq , exclaimequal) 348 CXX_KEYWORD_OPERATOR(or , pipepipe) 349 CXX_KEYWORD_OPERATOR(or_eq , pipeequal) 350 CXX_KEYWORD_OPERATOR(xor , caret) 351 CXX_KEYWORD_OPERATOR(xor_eq , caretequal) 352 353 // C++11 keywords 354 CXX11_KEYWORD(alignas , 0) 355 CXX11_KEYWORD(alignof , 0) 356 CXX11_KEYWORD(char16_t , KEYNOMS18) 357 CXX11_KEYWORD(char32_t , KEYNOMS18) 358 CXX11_KEYWORD(constexpr , 0) 359 CXX11_KEYWORD(decltype , 0) 360 CXX11_KEYWORD(noexcept , 0) 361 CXX11_KEYWORD(nullptr , 0) 362 CXX11_KEYWORD(static_assert , 0) 363 CXX11_KEYWORD(thread_local , 0) 364 365 // C++ concepts TS keywords 366 CONCEPTS_KEYWORD(concept) 367 CONCEPTS_KEYWORD(requires) 368 369 // C++ coroutines TS keywords 370 KEYWORD(co_await , KEYCOROUTINES) 371 KEYWORD(co_return , KEYCOROUTINES) 372 KEYWORD(co_yield , KEYCOROUTINES) 373 374 // C++ modules TS keywords 375 MODULES_KEYWORD(module) 376 MODULES_KEYWORD(import) 377 378 // GNU Extensions (in impl-reserved namespace) 379 KEYWORD(_Decimal32 , KEYALL) 380 KEYWORD(_Decimal64 , KEYALL) 381 KEYWORD(_Decimal128 , KEYALL) 382 KEYWORD(__null , KEYCXX) 383 KEYWORD(__alignof , KEYALL) 384 KEYWORD(__attribute , KEYALL) 385 KEYWORD(__builtin_choose_expr , KEYALL) 386 KEYWORD(__builtin_offsetof , KEYALL) 387 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++ 388 // type trait. 389 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX) 390 KEYWORD(__builtin_va_arg , KEYALL) 391 KEYWORD(__extension__ , KEYALL) 392 KEYWORD(__float128 , KEYALL) 393 KEYWORD(__imag , KEYALL) 394 KEYWORD(__int128 , KEYALL) 395 KEYWORD(__label__ , KEYALL) 396 KEYWORD(__real , KEYALL) 397 KEYWORD(__thread , KEYALL) 398 KEYWORD(__FUNCTION__ , KEYALL) 399 KEYWORD(__PRETTY_FUNCTION__ , KEYALL) 400 KEYWORD(__auto_type , KEYALL) 401 402 // GNU Extensions (outside impl-reserved namespace) 403 KEYWORD(typeof , KEYGNU) 404 405 // MS Extensions 406 KEYWORD(__FUNCDNAME__ , KEYMS) 407 KEYWORD(__FUNCSIG__ , KEYMS) 408 KEYWORD(L__FUNCTION__ , KEYMS) 409 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS) 410 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS) 411 412 // MSVC12.0 / VS2013 Type Traits 413 TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS) 414 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX) 415 TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS) 416 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX) 417 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX) 418 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX) 419 420 // MSVC14.0 / VS2015 Type Traits 421 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX) 422 423 // GNU and MS Type Traits 424 TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX) 425 TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX) 426 TYPE_TRAIT_1(__has_nothrow_copy, HasNothrowCopy, KEYCXX) 427 TYPE_TRAIT_1(__has_nothrow_constructor, HasNothrowConstructor, KEYCXX) 428 TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYCXX) 429 TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX) 430 TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYCXX) 431 TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYCXX) 432 TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX) 433 TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYCXX) 434 TYPE_TRAIT_1(__has_virtual_destructor, HasVirtualDestructor, KEYCXX) 435 TYPE_TRAIT_1(__is_abstract, IsAbstract, KEYCXX) 436 TYPE_TRAIT_1(__is_aggregate, IsAggregate, KEYCXX) 437 TYPE_TRAIT_2(__is_base_of, IsBaseOf, KEYCXX) 438 TYPE_TRAIT_1(__is_class, IsClass, KEYCXX) 439 TYPE_TRAIT_2(__is_convertible_to, IsConvertibleTo, KEYCXX) 440 TYPE_TRAIT_1(__is_empty, IsEmpty, KEYCXX) 441 TYPE_TRAIT_1(__is_enum, IsEnum, KEYCXX) 442 TYPE_TRAIT_1(__is_final, IsFinal, KEYCXX) 443 TYPE_TRAIT_1(__is_literal, IsLiteral, KEYCXX) 444 // Name for GCC 4.6 compatibility - people have already written libraries using 445 // this name unfortunately. 446 ALIAS("__is_literal_type", __is_literal, KEYCXX) 447 TYPE_TRAIT_1(__is_pod, IsPOD, KEYCXX) 448 TYPE_TRAIT_1(__is_polymorphic, IsPolymorphic, KEYCXX) 449 TYPE_TRAIT_1(__is_trivial, IsTrivial, KEYCXX) 450 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX) 451 452 // Clang-only C++ Type Traits 453 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX) 454 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX) 455 TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX) 456 KEYWORD(__underlying_type , KEYCXX) 457 458 // Embarcadero Expression Traits 459 KEYWORD(__is_lvalue_expr , KEYCXX) 460 KEYWORD(__is_rvalue_expr , KEYCXX) 461 462 // Embarcadero Unary Type Traits 463 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX) 464 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX) 465 TYPE_TRAIT_1(__is_integral, IsIntegral, KEYCXX) 466 TYPE_TRAIT_1(__is_complete_type, IsCompleteType, KEYCXX) 467 TYPE_TRAIT_1(__is_void, IsVoid, KEYCXX) 468 TYPE_TRAIT_1(__is_array, IsArray, KEYCXX) 469 TYPE_TRAIT_1(__is_function, IsFunction, KEYCXX) 470 TYPE_TRAIT_1(__is_reference, IsReference, KEYCXX) 471 TYPE_TRAIT_1(__is_lvalue_reference, IsLvalueReference, KEYCXX) 472 TYPE_TRAIT_1(__is_rvalue_reference, IsRvalueReference, KEYCXX) 473 TYPE_TRAIT_1(__is_fundamental, IsFundamental, KEYCXX) 474 TYPE_TRAIT_1(__is_object, IsObject, KEYCXX) 475 TYPE_TRAIT_1(__is_scalar, IsScalar, KEYCXX) 476 TYPE_TRAIT_1(__is_compound, IsCompound, KEYCXX) 477 TYPE_TRAIT_1(__is_pointer, IsPointer, KEYCXX) 478 TYPE_TRAIT_1(__is_member_object_pointer, IsMemberObjectPointer, KEYCXX) 479 TYPE_TRAIT_1(__is_member_function_pointer, IsMemberFunctionPointer, KEYCXX) 480 TYPE_TRAIT_1(__is_member_pointer, IsMemberPointer, KEYCXX) 481 TYPE_TRAIT_1(__is_const, IsConst, KEYCXX) 482 TYPE_TRAIT_1(__is_volatile, IsVolatile, KEYCXX) 483 TYPE_TRAIT_1(__is_standard_layout, IsStandardLayout, KEYCXX) 484 TYPE_TRAIT_1(__is_signed, IsSigned, KEYCXX) 485 TYPE_TRAIT_1(__is_unsigned, IsUnsigned, KEYCXX) 486 487 // Embarcadero Binary Type Traits 488 TYPE_TRAIT_2(__is_same, IsSame, KEYCXX) 489 TYPE_TRAIT_2(__is_convertible, IsConvertible, KEYCXX) 490 KEYWORD(__array_rank , KEYCXX) 491 KEYWORD(__array_extent , KEYCXX) 492 493 // Apple Extension. 494 KEYWORD(__private_extern__ , KEYALL) 495 KEYWORD(__module_private__ , KEYALL) 496 497 // Extension that will be enabled for Microsoft, Borland and PS4, but can be 498 // disabled via '-fno-declspec'. 499 KEYWORD(__declspec , 0) 500 501 // Microsoft Extension. 502 KEYWORD(__cdecl , KEYALL) 503 KEYWORD(__stdcall , KEYALL) 504 KEYWORD(__fastcall , KEYALL) 505 KEYWORD(__thiscall , KEYALL) 506 KEYWORD(__regcall , KEYALL) 507 KEYWORD(__vectorcall , KEYALL) 508 KEYWORD(__forceinline , KEYMS) 509 KEYWORD(__unaligned , KEYMS) 510 KEYWORD(__super , KEYMS) 511 512 // OpenCL address space qualifiers 513 KEYWORD(__global , KEYOPENCL) 514 KEYWORD(__local , KEYOPENCL) 515 KEYWORD(__constant , KEYOPENCL) 516 KEYWORD(__private , KEYOPENCL) 517 KEYWORD(__generic , KEYOPENCL) 518 ALIAS("global", __global , KEYOPENCL) 519 ALIAS("local", __local , KEYOPENCL) 520 ALIAS("constant", __constant , KEYOPENCL) 521 ALIAS("private", __private , KEYOPENCL) 522 ALIAS("generic", __generic , KEYOPENCL) 523 // OpenCL function qualifiers 524 KEYWORD(__kernel , KEYOPENCL) 525 ALIAS("kernel", __kernel , KEYOPENCL) 526 // OpenCL access qualifiers 527 KEYWORD(__read_only , KEYOPENCL) 528 KEYWORD(__write_only , KEYOPENCL) 529 KEYWORD(__read_write , KEYOPENCL) 530 ALIAS("read_only", __read_only , KEYOPENCL) 531 ALIAS("write_only", __write_only , KEYOPENCL) 532 ALIAS("read_write", __read_write , KEYOPENCL) 533 // OpenCL builtins 534 KEYWORD(__builtin_astype , KEYOPENCL) 535 KEYWORD(vec_step , KEYOPENCL|KEYALTIVEC|KEYZVECTOR) 536 #define GENERIC_IMAGE_TYPE(ImgType, Id) KEYWORD(ImgType##_t, KEYOPENCL) 537 #include "clang/Basic/OpenCLImageTypes.def" 538 539 // OpenMP Type Traits 540 KEYWORD(__builtin_omp_required_simd_align, KEYALL) 541 542 KEYWORD(pipe , KEYOPENCL) 543 544 // Borland Extensions. 545 KEYWORD(__pascal , KEYALL) 546 547 // Altivec Extension. 548 KEYWORD(__vector , KEYALTIVEC|KEYZVECTOR) 549 KEYWORD(__pixel , KEYALTIVEC) 550 KEYWORD(__bool , KEYALTIVEC|KEYZVECTOR) 551 552 // ARM NEON extensions. 553 ALIAS("__fp16", half , KEYALL) 554 555 // OpenCL Extension. 556 KEYWORD(half , HALFSUPPORT) 557 558 // Objective-C ARC keywords. 559 KEYWORD(__bridge , KEYARC) 560 KEYWORD(__bridge_transfer , KEYARC) 561 KEYWORD(__bridge_retained , KEYARC) 562 KEYWORD(__bridge_retain , KEYARC) 563 564 // Objective-C keywords. 565 KEYWORD(__covariant , KEYOBJC2) 566 KEYWORD(__contravariant , KEYOBJC2) 567 KEYWORD(__kindof , KEYOBJC2) 568 569 // Alternate spelling for various tokens. There are GCC extensions in all 570 // languages, but should not be disabled in strict conformance mode. 571 ALIAS("__alignof__" , __alignof , KEYALL) 572 ALIAS("__asm" , asm , KEYALL) 573 ALIAS("__asm__" , asm , KEYALL) 574 ALIAS("__attribute__", __attribute, KEYALL) 575 ALIAS("__complex" , _Complex , KEYALL) 576 ALIAS("__complex__" , _Complex , KEYALL) 577 ALIAS("__const" , const , KEYALL) 578 ALIAS("__const__" , const , KEYALL) 579 ALIAS("__decltype" , decltype , KEYCXX) 580 ALIAS("__imag__" , __imag , KEYALL) 581 ALIAS("__inline" , inline , KEYALL) 582 ALIAS("__inline__" , inline , KEYALL) 583 ALIAS("__nullptr" , nullptr , KEYCXX) 584 ALIAS("__real__" , __real , KEYALL) 585 ALIAS("__restrict" , restrict , KEYALL) 586 ALIAS("__restrict__" , restrict , KEYALL) 587 ALIAS("__signed" , signed , KEYALL) 588 ALIAS("__signed__" , signed , KEYALL) 589 ALIAS("__typeof" , typeof , KEYALL) 590 ALIAS("__typeof__" , typeof , KEYALL) 591 ALIAS("__volatile" , volatile , KEYALL) 592 ALIAS("__volatile__" , volatile , KEYALL) 593 594 // Type nullability. 595 KEYWORD(_Nonnull , KEYALL) 596 KEYWORD(_Nullable , KEYALL) 597 KEYWORD(_Null_unspecified , KEYALL) 598 599 // Microsoft extensions which should be disabled in strict conformance mode 600 KEYWORD(__ptr64 , KEYMS) 601 KEYWORD(__ptr32 , KEYMS) 602 KEYWORD(__sptr , KEYMS) 603 KEYWORD(__uptr , KEYMS) 604 KEYWORD(__w64 , KEYMS) 605 KEYWORD(__uuidof , KEYMS | KEYBORLAND) 606 KEYWORD(__try , KEYMS | KEYBORLAND) 607 KEYWORD(__finally , KEYMS | KEYBORLAND) 608 KEYWORD(__leave , KEYMS | KEYBORLAND) 609 KEYWORD(__int64 , KEYMS) 610 KEYWORD(__if_exists , KEYMS) 611 KEYWORD(__if_not_exists , KEYMS) 612 KEYWORD(__single_inheritance , KEYMS) 613 KEYWORD(__multiple_inheritance , KEYMS) 614 KEYWORD(__virtual_inheritance , KEYMS) 615 KEYWORD(__interface , KEYMS) 616 ALIAS("__int8" , char , KEYMS) 617 ALIAS("_int8" , char , KEYMS) 618 ALIAS("__int16" , short , KEYMS) 619 ALIAS("_int16" , short , KEYMS) 620 ALIAS("__int32" , int , KEYMS) 621 ALIAS("_int32" , int , KEYMS) 622 ALIAS("_int64" , __int64 , KEYMS) 623 ALIAS("__wchar_t" , wchar_t , KEYMS) 624 ALIAS("_asm" , asm , KEYMS) 625 ALIAS("_alignof" , __alignof , KEYMS) 626 ALIAS("__builtin_alignof", __alignof , KEYMS) 627 ALIAS("_cdecl" , __cdecl , KEYMS | KEYBORLAND) 628 ALIAS("_fastcall" , __fastcall , KEYMS | KEYBORLAND) 629 ALIAS("_stdcall" , __stdcall , KEYMS | KEYBORLAND) 630 ALIAS("_thiscall" , __thiscall , KEYMS) 631 ALIAS("_vectorcall" , __vectorcall, KEYMS) 632 ALIAS("_uuidof" , __uuidof , KEYMS | KEYBORLAND) 633 ALIAS("_inline" , inline , KEYMS) 634 ALIAS("_declspec" , __declspec , KEYMS) 635 636 // Borland Extensions which should be disabled in strict conformance mode. 637 ALIAS("_pascal" , __pascal , KEYBORLAND) 638 639 // Clang Extensions. 640 KEYWORD(__builtin_convertvector , KEYALL) 641 ALIAS("__char16_t" , char16_t , KEYCXX) 642 ALIAS("__char32_t" , char32_t , KEYCXX) 643 644 KEYWORD(__builtin_available , KEYALL) 645 646 // Clang-specific keywords enabled only in testing. 647 TESTING_KEYWORD(__unknown_anytype , KEYALL) 648 649 650 //===----------------------------------------------------------------------===// 651 // Objective-C @-preceded keywords. 652 //===----------------------------------------------------------------------===// 653 654 // These have meaning after an '@' in Objective-C mode. These define enums in 655 // the tok::objc_* namespace. 656 657 OBJC1_AT_KEYWORD(not_keyword) 658 OBJC1_AT_KEYWORD(class) 659 OBJC1_AT_KEYWORD(compatibility_alias) 660 OBJC1_AT_KEYWORD(defs) 661 OBJC1_AT_KEYWORD(encode) 662 OBJC1_AT_KEYWORD(end) 663 OBJC1_AT_KEYWORD(implementation) 664 OBJC1_AT_KEYWORD(interface) 665 OBJC1_AT_KEYWORD(private) 666 OBJC1_AT_KEYWORD(protected) 667 OBJC1_AT_KEYWORD(protocol) 668 OBJC1_AT_KEYWORD(public) 669 OBJC1_AT_KEYWORD(selector) 670 OBJC1_AT_KEYWORD(throw) 671 OBJC1_AT_KEYWORD(try) 672 OBJC1_AT_KEYWORD(catch) 673 OBJC1_AT_KEYWORD(finally) 674 OBJC1_AT_KEYWORD(synchronized) 675 OBJC1_AT_KEYWORD(autoreleasepool) 676 677 OBJC2_AT_KEYWORD(property) 678 OBJC2_AT_KEYWORD(package) 679 OBJC2_AT_KEYWORD(required) 680 OBJC2_AT_KEYWORD(optional) 681 OBJC2_AT_KEYWORD(synthesize) 682 OBJC2_AT_KEYWORD(dynamic) 683 OBJC2_AT_KEYWORD(import) 684 OBJC2_AT_KEYWORD(available) 685 686 // TODO: What to do about context-sensitive keywords like: 687 // bycopy/byref/in/inout/oneway/out? 688 689 ANNOTATION(cxxscope) // annotation for a C++ scope spec, e.g. "::foo::bar::" 690 ANNOTATION(typename) // annotation for a C typedef name, a C++ (possibly 691 // qualified) typename, e.g. "foo::MyClass", or 692 // template-id that names a type ("std::vector<int>") 693 ANNOTATION(template_id) // annotation for a C++ template-id that names a 694 // function template specialization (not a type), 695 // e.g., "std::swap<int>" 696 ANNOTATION(primary_expr) // annotation for a primary expression 697 ANNOTATION(decltype) // annotation for a decltype expression, 698 // e.g., "decltype(foo.bar())" 699 700 // Annotation for #pragma unused(...) 701 // For each argument inside the parentheses the pragma handler will produce 702 // one 'pragma_unused' annotation token followed by the argument token. 703 ANNOTATION(pragma_unused) 704 705 // Annotation for #pragma GCC visibility... 706 // The lexer produces these so that they only take effect when the parser 707 // handles them. 708 ANNOTATION(pragma_vis) 709 710 // Annotation for #pragma pack... 711 // The lexer produces these so that they only take effect when the parser 712 // handles them. 713 ANNOTATION(pragma_pack) 714 715 // Annotation for #pragma clang __debug parser_crash... 716 // The lexer produces these so that they only take effect when the parser 717 // handles them. 718 ANNOTATION(pragma_parser_crash) 719 720 // Annotation for #pragma clang __debug captured... 721 // The lexer produces these so that they only take effect when the parser 722 // handles them. 723 ANNOTATION(pragma_captured) 724 725 // Annotation for #pragma clang __debug dump... 726 // The lexer produces these so that the parser and semantic analysis can 727 // look up and dump the operand. 728 ANNOTATION(pragma_dump) 729 730 // Annotation for #pragma ms_struct... 731 // The lexer produces these so that they only take effect when the parser 732 // handles them. 733 ANNOTATION(pragma_msstruct) 734 735 // Annotation for #pragma align... 736 // The lexer produces these so that they only take effect when the parser 737 // handles them. 738 ANNOTATION(pragma_align) 739 740 // Annotation for #pragma weak id 741 // The lexer produces these so that they only take effect when the parser 742 // handles them. 743 ANNOTATION(pragma_weak) 744 745 // Annotation for #pragma weak id = id 746 // The lexer produces these so that they only take effect when the parser 747 // handles them. 748 ANNOTATION(pragma_weakalias) 749 750 // Annotation for #pragma redefine_extname... 751 // The lexer produces these so that they only take effect when the parser 752 // handles them. 753 ANNOTATION(pragma_redefine_extname) 754 755 // Annotation for #pragma STDC FP_CONTRACT... 756 // The lexer produces these so that they only take effect when the parser 757 // handles them. 758 ANNOTATION(pragma_fp_contract) 759 760 // Annotation for #pragma pointers_to_members... 761 // The lexer produces these so that they only take effect when the parser 762 // handles them. 763 ANNOTATION(pragma_ms_pointers_to_members) 764 765 // Annotation for #pragma vtordisp... 766 // The lexer produces these so that they only take effect when the parser 767 // handles them. 768 ANNOTATION(pragma_ms_vtordisp) 769 770 // Annotation for all microsoft #pragmas... 771 // The lexer produces these so that they only take effect when the parser 772 // handles them. 773 ANNOTATION(pragma_ms_pragma) 774 775 // Annotation for #pragma OPENCL EXTENSION... 776 // The lexer produces these so that they only take effect when the parser 777 // handles them. 778 ANNOTATION(pragma_opencl_extension) 779 780 // Annotations for OpenMP pragma directives - #pragma omp ... 781 // The lexer produces these so that they only take effect when the parser 782 // handles #pragma omp ... directives. 783 ANNOTATION(pragma_openmp) 784 ANNOTATION(pragma_openmp_end) 785 786 // Annotations for loop pragma directives #pragma clang loop ... 787 // The lexer produces these so that they only take effect when the parser 788 // handles #pragma loop ... directives. 789 ANNOTATION(pragma_loop_hint) 790 791 ANNOTATION(pragma_fp) 792 793 // Annotation for the attribute pragma directives - #pragma clang attribute ... 794 ANNOTATION(pragma_attribute) 795 796 // Annotations for module import translated from #include etc. 797 ANNOTATION(module_include) 798 ANNOTATION(module_begin) 799 ANNOTATION(module_end) 800 801 #undef ANNOTATION 802 #undef TESTING_KEYWORD 803 #undef OBJC2_AT_KEYWORD 804 #undef OBJC1_AT_KEYWORD 805 #undef CXX_KEYWORD_OPERATOR 806 #undef PPKEYWORD 807 #undef ALIAS 808 #undef TYPE_TRAIT_N 809 #undef TYPE_TRAIT_2 810 #undef TYPE_TRAIT_1 811 #undef TYPE_TRAIT 812 #undef CONCEPTS_KEYWORD 813 #undef CXX11_KEYWORD 814 #undef KEYWORD 815 #undef PUNCTUATOR 816 #undef TOK 817
