Warning, /include/clang/Basic/TokenKinds.def is written in an unsupported language. File is not indexed.
0001 //===--- TokenKinds.def - C Family Token Kind Database ----------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 //
0009 // This file defines the TokenKind database. This includes normal tokens like
0010 // tok::ampamp (corresponding to the && token) as well as keywords for various
0011 // languages. Users of this file must optionally #define the TOK, KEYWORD,
0012 // CXX11_KEYWORD, ALIAS, or PPKEYWORD macros to make use of this file.
0013 //
0014 //===----------------------------------------------------------------------===//
0015
0016 #ifndef TOK
0017 #define TOK(X)
0018 #endif
0019 #ifndef PUNCTUATOR
0020 #define PUNCTUATOR(X,Y) TOK(X)
0021 #endif
0022 #ifndef KEYWORD
0023 #define KEYWORD(X,Y) TOK(kw_ ## X)
0024 #endif
0025 #ifndef CXX11_KEYWORD
0026 #define CXX11_KEYWORD(X,Y) KEYWORD(X,KEYCXX11|(Y))
0027 #endif
0028 #ifndef CXX20_KEYWORD
0029 #define CXX20_KEYWORD(X,Y) KEYWORD(X,KEYCXX20|(Y))
0030 #endif
0031 #ifndef C99_KEYWORD
0032 #define C99_KEYWORD(X,Y) KEYWORD(X,KEYC99|(Y))
0033 #endif
0034 #ifndef C23_KEYWORD
0035 #define C23_KEYWORD(X,Y) KEYWORD(X,KEYC23|(Y))
0036 #endif
0037 #ifndef COROUTINES_KEYWORD
0038 #define COROUTINES_KEYWORD(X) CXX20_KEYWORD(X,KEYCOROUTINES)
0039 #endif
0040 #ifndef MODULES_KEYWORD
0041 #define MODULES_KEYWORD(X) KEYWORD(X,KEYMODULES)
0042 #endif
0043 #ifndef TYPE_TRAIT
0044 #define TYPE_TRAIT(N,I,K) KEYWORD(I,K)
0045 #endif
0046 #ifndef TYPE_TRAIT_1
0047 #define TYPE_TRAIT_1(I,E,K) TYPE_TRAIT(1,I,K)
0048 #endif
0049 #ifndef TYPE_TRAIT_2
0050 #define TYPE_TRAIT_2(I,E,K) TYPE_TRAIT(2,I,K)
0051 #endif
0052 #ifndef TYPE_TRAIT_N
0053 #define TYPE_TRAIT_N(I,E,K) TYPE_TRAIT(0,I,K)
0054 #endif
0055 #ifndef ARRAY_TYPE_TRAIT
0056 #define ARRAY_TYPE_TRAIT(I,E,K) KEYWORD(I,K)
0057 #endif
0058 #ifndef UNARY_EXPR_OR_TYPE_TRAIT
0059 #define UNARY_EXPR_OR_TYPE_TRAIT(I,E,K) KEYWORD(I,K)
0060 #endif
0061 #ifndef CXX11_UNARY_EXPR_OR_TYPE_TRAIT
0062 #define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(I,E,K) CXX11_KEYWORD(I,K)
0063 #endif
0064 #ifndef EXPRESSION_TRAIT
0065 #define EXPRESSION_TRAIT(I,E,K) KEYWORD(I,K)
0066 #endif
0067 #ifndef TRANSFORM_TYPE_TRAIT_DEF
0068 #define TRANSFORM_TYPE_TRAIT_DEF(K, Trait) KEYWORD(__##Trait, KEYCXX)
0069 #endif
0070
0071 #ifndef ALIAS
0072 #define ALIAS(X,Y,Z)
0073 #endif
0074 #ifndef PPKEYWORD
0075 #define PPKEYWORD(X)
0076 #endif
0077 #ifndef CXX_KEYWORD_OPERATOR
0078 #define CXX_KEYWORD_OPERATOR(X,Y)
0079 #endif
0080 #ifndef OBJC_AT_KEYWORD
0081 #define OBJC_AT_KEYWORD(X)
0082 #endif
0083 #ifndef TESTING_KEYWORD
0084 #define TESTING_KEYWORD(X, L) KEYWORD(X, L)
0085 #endif
0086 #ifndef ANNOTATION
0087 #define ANNOTATION(X) TOK(annot_ ## X)
0088 #endif
0089 #ifndef PRAGMA_ANNOTATION
0090 #define PRAGMA_ANNOTATION(X) ANNOTATION(X)
0091 #endif
0092 #ifndef NOTABLE_IDENTIFIER
0093 #define NOTABLE_IDENTIFIER(X)
0094 #endif
0095
0096 //===----------------------------------------------------------------------===//
0097 // Preprocessor keywords.
0098 //===----------------------------------------------------------------------===//
0099
0100 // These have meaning after a '#' at the start of a line. These define enums in
0101 // the tok::pp_* namespace. Note that IdentifierInfo::getPPKeywordID must be
0102 // manually updated if something is added here.
0103 PPKEYWORD(not_keyword)
0104
0105 // C99 6.10.1 - Conditional Inclusion.
0106 PPKEYWORD(if)
0107 PPKEYWORD(ifdef)
0108 PPKEYWORD(ifndef)
0109 PPKEYWORD(elif)
0110 PPKEYWORD(elifdef)
0111 PPKEYWORD(elifndef)
0112 PPKEYWORD(else)
0113 PPKEYWORD(endif)
0114 PPKEYWORD(defined)
0115
0116 // C99 6.10.2 - Source File Inclusion.
0117 PPKEYWORD(include)
0118 PPKEYWORD(__include_macros)
0119
0120 // C99 6.10.3 - Macro Replacement.
0121 PPKEYWORD(define)
0122 PPKEYWORD(undef)
0123
0124 // C99 6.10.4 - Line Control.
0125 PPKEYWORD(line)
0126
0127 // C99 6.10.5 - Error Directive.
0128 PPKEYWORD(error)
0129
0130 // C99 6.10.6 - Pragma Directive.
0131 PPKEYWORD(pragma)
0132
0133 // C23 & C++26 #embed
0134 PPKEYWORD(embed)
0135
0136 // GNU Extensions.
0137 PPKEYWORD(import)
0138 PPKEYWORD(include_next)
0139 PPKEYWORD(warning)
0140 PPKEYWORD(ident)
0141 PPKEYWORD(sccs)
0142 PPKEYWORD(assert)
0143 PPKEYWORD(unassert)
0144
0145 // Clang extensions
0146 PPKEYWORD(__public_macro)
0147 PPKEYWORD(__private_macro)
0148
0149 //===----------------------------------------------------------------------===//
0150 // Language keywords.
0151 //===----------------------------------------------------------------------===//
0152
0153 // These define members of the tok::* namespace.
0154
0155 TOK(unknown) // Not a token.
0156 TOK(eof) // End of file.
0157 TOK(eod) // End of preprocessing directive (end of line inside a
0158 // directive).
0159 TOK(code_completion) // Code completion marker
0160
0161 // C99 6.4.9: Comments.
0162 TOK(comment) // Comment (only in -E -C[C] mode)
0163
0164 // C99 6.4.2: Identifiers.
0165 TOK(identifier) // abcde123
0166 TOK(raw_identifier) // Used only in raw lexing mode.
0167
0168 // C99 6.4.4.1: Integer Constants
0169 // C99 6.4.4.2: Floating Constants
0170 TOK(numeric_constant) // 0x123
0171
0172 // Directly holds numerical value. Used to process C23 #embed.
0173 TOK(binary_data)
0174
0175 // C99 6.4.4: Character Constants
0176 TOK(char_constant) // 'a'
0177 TOK(wide_char_constant) // L'b'
0178
0179 // C++17 Character Constants
0180 TOK(utf8_char_constant) // u8'a'
0181
0182 // C++11 Character Constants
0183 TOK(utf16_char_constant) // u'a'
0184 TOK(utf32_char_constant) // U'a'
0185
0186 // C99 6.4.5: String Literals.
0187 TOK(string_literal) // "foo"
0188 TOK(wide_string_literal) // L"foo"
0189
0190 // C11 6.4.7: Header Names
0191 TOK(header_name) // <foo>, or "foo" lexed as a header-name
0192
0193 // C++11 String Literals.
0194 TOK(utf8_string_literal) // u8"foo"
0195 TOK(utf16_string_literal)// u"foo"
0196 TOK(utf32_string_literal)// U"foo"
0197
0198 // C99 6.4.6: Punctuators.
0199 PUNCTUATOR(l_square, "[")
0200 PUNCTUATOR(r_square, "]")
0201 PUNCTUATOR(l_paren, "(")
0202 PUNCTUATOR(r_paren, ")")
0203 PUNCTUATOR(l_brace, "{")
0204 PUNCTUATOR(r_brace, "}")
0205 PUNCTUATOR(period, ".")
0206 PUNCTUATOR(ellipsis, "...")
0207 PUNCTUATOR(amp, "&")
0208 PUNCTUATOR(ampamp, "&&")
0209 PUNCTUATOR(ampequal, "&=")
0210 PUNCTUATOR(star, "*")
0211 PUNCTUATOR(starequal, "*=")
0212 PUNCTUATOR(plus, "+")
0213 PUNCTUATOR(plusplus, "++")
0214 PUNCTUATOR(plusequal, "+=")
0215 PUNCTUATOR(minus, "-")
0216 PUNCTUATOR(arrow, "->")
0217 PUNCTUATOR(minusminus, "--")
0218 PUNCTUATOR(minusequal, "-=")
0219 PUNCTUATOR(tilde, "~")
0220 PUNCTUATOR(exclaim, "!")
0221 PUNCTUATOR(exclaimequal, "!=")
0222 PUNCTUATOR(slash, "/")
0223 PUNCTUATOR(slashequal, "/=")
0224 PUNCTUATOR(percent, "%")
0225 PUNCTUATOR(percentequal, "%=")
0226 PUNCTUATOR(less, "<")
0227 PUNCTUATOR(lessless, "<<")
0228 PUNCTUATOR(lessequal, "<=")
0229 PUNCTUATOR(lesslessequal, "<<=")
0230 PUNCTUATOR(spaceship, "<=>")
0231 PUNCTUATOR(greater, ">")
0232 PUNCTUATOR(greatergreater, ">>")
0233 PUNCTUATOR(greaterequal, ">=")
0234 PUNCTUATOR(greatergreaterequal, ">>=")
0235 PUNCTUATOR(caret, "^")
0236 PUNCTUATOR(caretequal, "^=")
0237 PUNCTUATOR(pipe, "|")
0238 PUNCTUATOR(pipepipe, "||")
0239 PUNCTUATOR(pipeequal, "|=")
0240 PUNCTUATOR(question, "?")
0241 PUNCTUATOR(colon, ":")
0242 PUNCTUATOR(semi, ";")
0243 PUNCTUATOR(equal, "=")
0244 PUNCTUATOR(equalequal, "==")
0245 PUNCTUATOR(comma, ",")
0246 PUNCTUATOR(hash, "#")
0247 PUNCTUATOR(hashhash, "##")
0248 PUNCTUATOR(hashat, "#@")
0249
0250 // C++ Support
0251 PUNCTUATOR(periodstar, ".*")
0252 PUNCTUATOR(arrowstar, "->*")
0253 PUNCTUATOR(coloncolon, "::")
0254
0255 // Objective C support.
0256 PUNCTUATOR(at, "@")
0257
0258 // CUDA support.
0259 PUNCTUATOR(lesslessless, "<<<")
0260 PUNCTUATOR(greatergreatergreater, ">>>")
0261
0262 // C99 6.4.1: Keywords. These turn into kw_* tokens.
0263 // Flags allowed:
0264 // KEYALL - This is a keyword in all variants of C and C++, or it
0265 // is a keyword in the implementation namespace that should
0266 // always be treated as a keyword
0267 // KEYC99 - This is a keyword introduced to C in C99
0268 // KEYC11 - This is a keyword introduced to C in C11
0269 // KEYC23 - This is a keyword introduced to C in C23
0270 // KEYCXX - This is a C++ keyword, or a C++-specific keyword in the
0271 // implementation namespace
0272 // KEYNOCXX - This is a keyword in every non-C++ dialect.
0273 // KEYCXX11 - This is a C++ keyword introduced to C++ in C++11
0274 // KEYCXX20 - This is a C++ keyword introduced to C++ in C++20
0275 // KEYMODULES - This is a keyword if the C++ extensions for modules
0276 // are enabled.
0277 // KEYGNU - This is a keyword if GNU extensions are enabled
0278 // KEYMS - This is a keyword if Microsoft extensions are enabled
0279 // KEYMSCOMPAT - This is a keyword if Microsoft compatibility mode is enabled
0280 // KEYNOMS18 - This is a keyword that must never be enabled under
0281 // MSVC <= v18.
0282 // KEYOPENCLC - This is a keyword in OpenCL C
0283 // KEYOPENCLCXX - This is a keyword in C++ for OpenCL
0284 // KEYNOOPENCL - This is a keyword that is not supported in OpenCL
0285 // KEYALTIVEC - This is a keyword in AltiVec
0286 // KEYZVECTOR - This is a keyword for the System z vector extensions,
0287 // which are heavily based on AltiVec
0288 // KEYBORLAND - This is a keyword if Borland extensions are enabled
0289 // KEYCOROUTINES - This is a keyword if support for C++ coroutines is enabled
0290 // BOOLSUPPORT - This is a keyword if 'bool' is a built-in type
0291 // HALFSUPPORT - This is a keyword if 'half' is a built-in type
0292 // WCHARSUPPORT - This is a keyword if 'wchar_t' is a built-in type
0293 // CHAR8SUPPORT - This is a keyword if 'char8_t' is a built-in type
0294 // KEYFIXEDPOINT - This is a keyword according to the N1169 fixed point
0295 // extension.
0296 // KEYZOS - This is a keyword in C/C++ on z/OS
0297 //
0298 KEYWORD(auto , KEYALL)
0299 KEYWORD(break , KEYALL)
0300 KEYWORD(case , KEYALL)
0301 KEYWORD(char , KEYALL)
0302 KEYWORD(const , KEYALL)
0303 KEYWORD(continue , KEYALL)
0304 KEYWORD(default , KEYALL)
0305 KEYWORD(do , KEYALL)
0306 KEYWORD(double , KEYALL)
0307 KEYWORD(else , KEYALL)
0308 KEYWORD(enum , KEYALL)
0309 KEYWORD(extern , KEYALL)
0310 KEYWORD(float , KEYALL)
0311 KEYWORD(for , KEYALL)
0312 KEYWORD(goto , KEYALL)
0313 KEYWORD(if , KEYALL)
0314 KEYWORD(int , KEYALL)
0315 KEYWORD(_ExtInt , KEYALL)
0316 KEYWORD(_BitInt , KEYALL)
0317 KEYWORD(long , KEYALL)
0318 KEYWORD(register , KEYALL)
0319 KEYWORD(return , KEYALL)
0320 KEYWORD(short , KEYALL)
0321 KEYWORD(signed , KEYALL)
0322 UNARY_EXPR_OR_TYPE_TRAIT(sizeof, SizeOf, KEYALL)
0323 UNARY_EXPR_OR_TYPE_TRAIT(__datasizeof, DataSizeOf, KEYCXX)
0324 KEYWORD(static , KEYALL)
0325 KEYWORD(struct , KEYALL)
0326 KEYWORD(switch , KEYALL)
0327 KEYWORD(typedef , KEYALL)
0328 KEYWORD(union , KEYALL)
0329 KEYWORD(unsigned , KEYALL)
0330 KEYWORD(void , KEYALL)
0331 KEYWORD(volatile , KEYALL)
0332 KEYWORD(while , KEYALL)
0333 KEYWORD(_Alignas , KEYALL)
0334 KEYWORD(_Alignof , KEYALL)
0335 KEYWORD(_Atomic , KEYALL|KEYNOOPENCL)
0336 KEYWORD(_Bool , KEYNOCXX)
0337 KEYWORD(_Complex , KEYALL)
0338 KEYWORD(_Generic , KEYALL)
0339 // Note, C2y removed support for _Imaginary; we retain it as a keyword because
0340 // 1) it's a reserved identifier, so we're allowed to steal it, 2) there's no
0341 // good way to specify a keyword in earlier but not later language modes within
0342 // this file, 3) this allows us to provide a better diagnostic in case a user
0343 // does use the keyword.
0344 KEYWORD(_Imaginary , KEYALL)
0345 KEYWORD(_Noreturn , KEYALL)
0346 KEYWORD(_Static_assert , KEYALL)
0347 KEYWORD(_Thread_local , KEYALL)
0348 KEYWORD(__func__ , KEYALL)
0349 KEYWORD(__objc_yes , KEYALL)
0350 KEYWORD(__objc_no , KEYALL)
0351
0352
0353 // C++ 2.11p1: Keywords.
0354 KEYWORD(asm , KEYCXX|KEYGNU)
0355 KEYWORD(bool , BOOLSUPPORT|KEYC23)
0356 KEYWORD(catch , KEYCXX)
0357 KEYWORD(class , KEYCXX)
0358 KEYWORD(const_cast , KEYCXX)
0359 KEYWORD(delete , KEYCXX)
0360 KEYWORD(dynamic_cast , KEYCXX)
0361 KEYWORD(explicit , KEYCXX)
0362 KEYWORD(export , KEYCXX)
0363 KEYWORD(false , BOOLSUPPORT|KEYC23)
0364 KEYWORD(friend , KEYCXX)
0365 KEYWORD(mutable , KEYCXX)
0366 KEYWORD(namespace , KEYCXX)
0367 KEYWORD(new , KEYCXX)
0368 KEYWORD(operator , KEYCXX)
0369 KEYWORD(private , KEYCXX)
0370 KEYWORD(protected , KEYCXX)
0371 KEYWORD(public , KEYCXX)
0372 KEYWORD(reinterpret_cast , KEYCXX)
0373 KEYWORD(static_cast , KEYCXX)
0374 KEYWORD(template , KEYCXX)
0375 KEYWORD(this , KEYCXX)
0376 KEYWORD(throw , KEYCXX)
0377 KEYWORD(true , BOOLSUPPORT|KEYC23)
0378 KEYWORD(try , KEYCXX)
0379 KEYWORD(typename , KEYCXX)
0380 KEYWORD(typeid , KEYCXX)
0381 KEYWORD(using , KEYCXX)
0382 KEYWORD(virtual , KEYCXX)
0383 KEYWORD(wchar_t , WCHARSUPPORT)
0384
0385 // C++ 2.5p2: Alternative Representations.
0386 CXX_KEYWORD_OPERATOR(and , ampamp)
0387 CXX_KEYWORD_OPERATOR(and_eq , ampequal)
0388 CXX_KEYWORD_OPERATOR(bitand , amp)
0389 CXX_KEYWORD_OPERATOR(bitor , pipe)
0390 CXX_KEYWORD_OPERATOR(compl , tilde)
0391 CXX_KEYWORD_OPERATOR(not , exclaim)
0392 CXX_KEYWORD_OPERATOR(not_eq , exclaimequal)
0393 CXX_KEYWORD_OPERATOR(or , pipepipe)
0394 CXX_KEYWORD_OPERATOR(or_eq , pipeequal)
0395 CXX_KEYWORD_OPERATOR(xor , caret)
0396 CXX_KEYWORD_OPERATOR(xor_eq , caretequal)
0397
0398 // C99 Keywords.
0399 C99_KEYWORD(restrict , 0)
0400 C99_KEYWORD(inline , KEYCXX|KEYGNU)
0401
0402
0403 // C++11 keywords
0404 CXX11_KEYWORD(alignas , KEYC23)
0405 // alignof and _Alignof return the required ABI alignment
0406 CXX11_UNARY_EXPR_OR_TYPE_TRAIT(alignof, AlignOf, KEYC23)
0407 CXX11_KEYWORD(char16_t , KEYNOMS18)
0408 CXX11_KEYWORD(char32_t , KEYNOMS18)
0409 CXX11_KEYWORD(constexpr , KEYC23)
0410 CXX11_KEYWORD(decltype , 0)
0411 CXX11_KEYWORD(noexcept , 0)
0412 CXX11_KEYWORD(nullptr , KEYC23)
0413 CXX11_KEYWORD(static_assert , KEYMSCOMPAT|KEYC23)
0414 CXX11_KEYWORD(thread_local , KEYC23)
0415
0416 // C++20 / coroutines keywords
0417 COROUTINES_KEYWORD(co_await)
0418 COROUTINES_KEYWORD(co_return)
0419 COROUTINES_KEYWORD(co_yield)
0420
0421 // C++20 keywords
0422 MODULES_KEYWORD(module)
0423 MODULES_KEYWORD(import)
0424
0425 // C++20 keywords.
0426 CXX20_KEYWORD(consteval , 0)
0427 CXX20_KEYWORD(constinit , 0)
0428 CXX20_KEYWORD(concept , 0)
0429 CXX20_KEYWORD(requires , 0)
0430
0431 // Not a CXX20_KEYWORD because it is disabled by -fno-char8_t.
0432 KEYWORD(char8_t , CHAR8SUPPORT)
0433
0434 // C11 Extension
0435 KEYWORD(_Float16 , KEYALL)
0436
0437 // C23 keywords
0438 C23_KEYWORD(typeof , KEYGNU)
0439 C23_KEYWORD(typeof_unqual , 0)
0440
0441 // ISO/IEC JTC1 SC22 WG14 N1169 Extension
0442 KEYWORD(_Accum , KEYFIXEDPOINT)
0443 KEYWORD(_Fract , KEYFIXEDPOINT)
0444 KEYWORD(_Sat , KEYFIXEDPOINT)
0445
0446 // GNU Extensions (in impl-reserved namespace)
0447 KEYWORD(_Decimal32 , KEYALL)
0448 KEYWORD(_Decimal64 , KEYALL)
0449 KEYWORD(_Decimal128 , KEYALL)
0450 KEYWORD(__null , KEYCXX)
0451 // __alignof returns the preferred alignment of a type, the alignment
0452 // clang will attempt to give an object of the type if allowed by ABI.
0453 UNARY_EXPR_OR_TYPE_TRAIT(__alignof, PreferredAlignOf, KEYALL)
0454 KEYWORD(__attribute , KEYALL)
0455 KEYWORD(__builtin_choose_expr , KEYALL)
0456 KEYWORD(__builtin_offsetof , KEYALL)
0457 KEYWORD(__builtin_FILE , KEYALL)
0458 KEYWORD(__builtin_FILE_NAME , KEYALL)
0459 KEYWORD(__builtin_FUNCTION , KEYALL)
0460 KEYWORD(__builtin_FUNCSIG , KEYMS)
0461 KEYWORD(__builtin_LINE , KEYALL)
0462 KEYWORD(__builtin_COLUMN , KEYALL)
0463 KEYWORD(__builtin_source_location , KEYCXX)
0464
0465 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
0466 // type trait.
0467 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX)
0468 KEYWORD(__builtin_va_arg , KEYALL)
0469 KEYWORD(__extension__ , KEYALL)
0470 KEYWORD(__float128 , KEYALL)
0471 KEYWORD(__ibm128 , KEYALL)
0472 KEYWORD(__imag , KEYALL)
0473 KEYWORD(__int128 , KEYALL)
0474 KEYWORD(__label__ , KEYALL)
0475 KEYWORD(__real , KEYALL)
0476 KEYWORD(__thread , KEYALL)
0477 KEYWORD(__FUNCTION__ , KEYALL)
0478 KEYWORD(__PRETTY_FUNCTION__ , KEYALL)
0479 KEYWORD(__auto_type , KEYALL)
0480
0481 // MS Extensions
0482 KEYWORD(__FUNCDNAME__ , KEYMS)
0483 KEYWORD(__FUNCSIG__ , KEYMS)
0484 KEYWORD(L__FUNCTION__ , KEYMS)
0485 KEYWORD(L__FUNCSIG__ , KEYMS)
0486 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS)
0487 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
0488
0489 // MSVC12.0 / VS2013 Type Traits
0490 TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYALL)
0491 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX)
0492 TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYALL)
0493 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
0494 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
0495 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX)
0496
0497 // MSVC14.0 / VS2015 Type Traits
0498 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
0499
0500 // MSVC Type Traits of unknown vintage
0501 TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX)
0502 TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX)
0503 TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX)
0504
0505 // GNU and MS Type Traits
0506 TYPE_TRAIT_1(__builtin_is_implicit_lifetime, IsImplicitLifetime, KEYCXX)
0507 TYPE_TRAIT_2(__builtin_is_virtual_base_of, IsVirtualBaseOf, KEYCXX)
0508 TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX)
0509 TYPE_TRAIT_1(__has_nothrow_copy, HasNothrowCopy, KEYCXX)
0510 TYPE_TRAIT_1(__has_nothrow_constructor, HasNothrowConstructor, KEYCXX)
0511 TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYCXX)
0512 TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYCXX)
0513 TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYCXX)
0514 TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYCXX)
0515 TYPE_TRAIT_1(__has_virtual_destructor, HasVirtualDestructor, KEYCXX)
0516 TYPE_TRAIT_1(__is_abstract, IsAbstract, KEYCXX)
0517 TYPE_TRAIT_1(__is_aggregate, IsAggregate, KEYCXX)
0518 TYPE_TRAIT_2(__is_base_of, IsBaseOf, KEYCXX)
0519 TYPE_TRAIT_1(__is_class, IsClass, KEYCXX)
0520 TYPE_TRAIT_2(__is_convertible_to, IsConvertibleTo, KEYCXX)
0521 TYPE_TRAIT_1(__is_empty, IsEmpty, KEYCXX)
0522 TYPE_TRAIT_1(__is_enum, IsEnum, KEYCXX)
0523 TYPE_TRAIT_1(__is_final, IsFinal, KEYCXX)
0524 TYPE_TRAIT_1(__is_literal, IsLiteral, KEYCXX)
0525 // Name for GCC 4.6 compatibility - people have already written libraries using
0526 // this name unfortunately.
0527 ALIAS("__is_literal_type", __is_literal, KEYCXX)
0528 TYPE_TRAIT_1(__is_pod, IsPOD, KEYCXX)
0529 TYPE_TRAIT_1(__is_polymorphic, IsPolymorphic, KEYCXX)
0530 TYPE_TRAIT_1(__is_standard_layout, IsStandardLayout, KEYCXX)
0531 TYPE_TRAIT_1(__is_trivial, IsTrivial, KEYCXX)
0532 TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX)
0533 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX)
0534 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX)
0535 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
0536 TYPE_TRAIT_1(__has_unique_object_representations,
0537 HasUniqueObjectRepresentations, KEYCXX)
0538 TYPE_TRAIT_2(__is_layout_compatible, IsLayoutCompatible, KEYCXX)
0539 TYPE_TRAIT_2(__is_pointer_interconvertible_base_of, IsPointerInterconvertibleBaseOf, KEYCXX)
0540
0541 #include "clang/Basic/TransformTypeTraits.def"
0542
0543 // Clang-only C++ Type Traits
0544 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
0545 TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
0546 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
0547 TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
0548 TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
0549 TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
0550 TYPE_TRAIT_1(__can_pass_in_regs, CanPassInRegs, KEYCXX)
0551 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
0552 TYPE_TRAIT_2(__reference_constructs_from_temporary, ReferenceConstructsFromTemporary, KEYCXX)
0553 TYPE_TRAIT_2(__reference_converts_from_temporary, ReferenceConvertsFromTemporary, KEYCXX)
0554 // IsDeducible is only used internally by clang for CTAD implementation and
0555 // is not exposed to users.
0556 TYPE_TRAIT_2(/*EmptySpellingName*/, IsDeducible, KEYCXX)
0557
0558 TYPE_TRAIT_1(__is_bitwise_cloneable, IsBitwiseCloneable, KEYALL)
0559
0560 // Embarcadero Expression Traits
0561 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
0562 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
0563
0564 // Embarcadero Unary Type Traits
0565 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)
0566 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX)
0567 TYPE_TRAIT_1(__is_integral, IsIntegral, KEYCXX)
0568 TYPE_TRAIT_1(__is_complete_type, IsCompleteType, KEYCXX)
0569 TYPE_TRAIT_1(__is_void, IsVoid, KEYCXX)
0570 TYPE_TRAIT_1(__is_array, IsArray, KEYCXX)
0571 TYPE_TRAIT_1(__is_function, IsFunction, KEYCXX)
0572 TYPE_TRAIT_1(__is_reference, IsReference, KEYCXX)
0573 TYPE_TRAIT_1(__is_lvalue_reference, IsLvalueReference, KEYCXX)
0574 TYPE_TRAIT_1(__is_rvalue_reference, IsRvalueReference, KEYCXX)
0575 TYPE_TRAIT_1(__is_fundamental, IsFundamental, KEYCXX)
0576 TYPE_TRAIT_1(__is_object, IsObject, KEYCXX)
0577 TYPE_TRAIT_1(__is_scalar, IsScalar, KEYCXX)
0578 TYPE_TRAIT_1(__is_compound, IsCompound, KEYCXX)
0579 TYPE_TRAIT_1(__is_pointer, IsPointer, KEYCXX)
0580 TYPE_TRAIT_1(__is_member_object_pointer, IsMemberObjectPointer, KEYCXX)
0581 TYPE_TRAIT_1(__is_member_function_pointer, IsMemberFunctionPointer, KEYCXX)
0582 TYPE_TRAIT_1(__is_member_pointer, IsMemberPointer, KEYCXX)
0583 TYPE_TRAIT_1(__is_const, IsConst, KEYCXX)
0584 TYPE_TRAIT_1(__is_volatile, IsVolatile, KEYCXX)
0585 TYPE_TRAIT_1(__is_signed, IsSigned, KEYCXX)
0586 TYPE_TRAIT_1(__is_unsigned, IsUnsigned, KEYCXX)
0587
0588 // Embarcadero Binary Type Traits
0589 TYPE_TRAIT_2(__is_same, IsSame, KEYCXX)
0590 TYPE_TRAIT_2(__is_convertible, IsConvertible, KEYCXX)
0591 TYPE_TRAIT_2(__is_nothrow_convertible, IsNothrowConvertible, KEYCXX)
0592 ARRAY_TYPE_TRAIT(__array_rank, ArrayRank, KEYCXX)
0593 ARRAY_TYPE_TRAIT(__array_extent, ArrayExtent, KEYCXX)
0594 // Name for GCC 6 compatibility.
0595 ALIAS("__is_same_as", __is_same, KEYCXX)
0596
0597 // Apple Extension.
0598 KEYWORD(__private_extern__ , KEYALL)
0599 KEYWORD(__module_private__ , KEYALL)
0600
0601 UNARY_EXPR_OR_TYPE_TRAIT(__builtin_ptrauth_type_discriminator, PtrAuthTypeDiscriminator, KEYALL)
0602
0603 // Extension that will be enabled for Microsoft, Borland and PS4, but can be
0604 // disabled via '-fno-declspec'.
0605 KEYWORD(__declspec , 0)
0606
0607 // Microsoft Extension.
0608 KEYWORD(__cdecl , KEYALL)
0609 KEYWORD(__stdcall , KEYALL)
0610 KEYWORD(__fastcall , KEYALL)
0611 KEYWORD(__thiscall , KEYALL)
0612 KEYWORD(__regcall , KEYALL)
0613 KEYWORD(__vectorcall , KEYALL)
0614 KEYWORD(__forceinline , KEYMS)
0615 KEYWORD(__unaligned , KEYMS)
0616 KEYWORD(__super , KEYMS)
0617
0618 // OpenCL address space qualifiers
0619 KEYWORD(__global , KEYOPENCLC | KEYOPENCLCXX)
0620 KEYWORD(__local , KEYOPENCLC | KEYOPENCLCXX)
0621 KEYWORD(__constant , KEYOPENCLC | KEYOPENCLCXX)
0622 KEYWORD(__private , KEYOPENCLC | KEYOPENCLCXX)
0623 KEYWORD(__generic , KEYOPENCLC | KEYOPENCLCXX)
0624 ALIAS("global", __global , KEYOPENCLC | KEYOPENCLCXX)
0625 ALIAS("local", __local , KEYOPENCLC | KEYOPENCLCXX)
0626 ALIAS("constant", __constant , KEYOPENCLC | KEYOPENCLCXX)
0627 ALIAS("private", __private , KEYOPENCLC)
0628 ALIAS("generic", __generic , KEYOPENCLC | KEYOPENCLCXX)
0629 // OpenCL function qualifiers
0630 KEYWORD(__kernel , KEYOPENCLC | KEYOPENCLCXX)
0631 ALIAS("kernel", __kernel , KEYOPENCLC | KEYOPENCLCXX)
0632 // OpenCL access qualifiers
0633 KEYWORD(__read_only , KEYOPENCLC | KEYOPENCLCXX)
0634 KEYWORD(__write_only , KEYOPENCLC | KEYOPENCLCXX)
0635 KEYWORD(__read_write , KEYOPENCLC | KEYOPENCLCXX)
0636 ALIAS("read_only", __read_only , KEYOPENCLC | KEYOPENCLCXX)
0637 ALIAS("write_only", __write_only , KEYOPENCLC | KEYOPENCLCXX)
0638 ALIAS("read_write", __read_write , KEYOPENCLC | KEYOPENCLCXX)
0639 // OpenCL builtins
0640 KEYWORD(__builtin_astype , KEYOPENCLC | KEYOPENCLCXX)
0641 UNARY_EXPR_OR_TYPE_TRAIT(vec_step, VecStep, KEYOPENCLC | KEYOPENCLCXX | KEYALTIVEC | KEYZVECTOR)
0642 #define GENERIC_IMAGE_TYPE(ImgType, Id) KEYWORD(ImgType##_t, KEYOPENCLC | KEYOPENCLCXX)
0643 #include "clang/Basic/OpenCLImageTypes.def"
0644 KEYWORD(pipe , KEYOPENCLC | KEYOPENCLCXX)
0645 // C++ for OpenCL s2.3.1: addrspace_cast operator
0646 KEYWORD(addrspace_cast , KEYOPENCLCXX)
0647
0648 // CUDA/HIP function attributes
0649 KEYWORD(__noinline__ , KEYCUDA)
0650
0651 // HLSL keywords.
0652 KEYWORD(cbuffer , KEYHLSL)
0653 KEYWORD(tbuffer , KEYHLSL)
0654 KEYWORD(groupshared , KEYHLSL)
0655 KEYWORD(in , KEYHLSL)
0656 KEYWORD(inout , KEYHLSL)
0657 KEYWORD(out , KEYHLSL)
0658 // HLSL Intangible Types
0659 #define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) KEYWORD(Name, KEYHLSL)
0660 #include "clang/Basic/HLSLIntangibleTypes.def"
0661
0662 // HLSL Type traits
0663 TYPE_TRAIT_2(__builtin_hlsl_is_scalarized_layout_compatible, IsScalarizedLayoutCompatible, KEYHLSL)
0664 TYPE_TRAIT_1(__builtin_hlsl_is_intangible, IsIntangibleType, KEYHLSL)
0665 TYPE_TRAIT_1(__builtin_hlsl_is_typed_resource_element_compatible, IsTypedResourceElementCompatible, KEYHLSL)
0666
0667 // OpenMP Type Traits
0668 UNARY_EXPR_OR_TYPE_TRAIT(__builtin_omp_required_simd_align, OpenMPRequiredSimdAlign, KEYALL)
0669
0670 // Borland Extensions.
0671 KEYWORD(__pascal , KEYALL)
0672
0673 // Altivec Extension.
0674 KEYWORD(__vector , KEYALTIVEC|KEYZVECTOR)
0675 KEYWORD(__pixel , KEYALTIVEC)
0676 KEYWORD(__bool , KEYALTIVEC|KEYZVECTOR)
0677
0678 // ARM NEON extensions.
0679 ALIAS("__fp16", half , KEYALL)
0680 KEYWORD(__bf16 , KEYALL)
0681
0682 // OpenCL Extension.
0683 KEYWORD(half , HALFSUPPORT)
0684
0685 // Objective-C ARC keywords.
0686 KEYWORD(__bridge , KEYOBJC)
0687 KEYWORD(__bridge_transfer , KEYOBJC)
0688 KEYWORD(__bridge_retained , KEYOBJC)
0689 KEYWORD(__bridge_retain , KEYOBJC)
0690
0691 // Objective-C keywords.
0692 KEYWORD(__covariant , KEYOBJC)
0693 KEYWORD(__contravariant , KEYOBJC)
0694 KEYWORD(__kindof , KEYOBJC)
0695
0696 // Alternate spelling for various tokens. There are GCC extensions in all
0697 // languages, but should not be disabled in strict conformance mode.
0698 ALIAS("__alignof__" , __alignof , KEYALL)
0699 ALIAS("__asm" , asm , KEYALL)
0700 ALIAS("__asm__" , asm , KEYALL)
0701 ALIAS("__attribute__" , __attribute , KEYALL)
0702 ALIAS("__complex" , _Complex , KEYALL)
0703 ALIAS("__complex__" , _Complex , KEYALL)
0704 ALIAS("__const" , const , KEYALL)
0705 ALIAS("__const__" , const , KEYALL)
0706 ALIAS("__decltype" , decltype , KEYCXX)
0707 ALIAS("__imag__" , __imag , KEYALL)
0708 ALIAS("__inline" , inline , KEYALL)
0709 ALIAS("__inline__" , inline , KEYALL)
0710 ALIAS("__nullptr" , nullptr , KEYALL)
0711 ALIAS("__real__" , __real , KEYALL)
0712 ALIAS("__restrict" , restrict , KEYALL)
0713 ALIAS("__restrict__" , restrict , KEYALL)
0714 ALIAS("__signed" , signed , KEYALL)
0715 ALIAS("__signed__" , signed , KEYALL)
0716 ALIAS("__typeof" , typeof , KEYALL)
0717 ALIAS("__typeof__" , typeof , KEYALL)
0718 ALIAS("__typeof_unqual" , typeof_unqual, KEYALL)
0719 ALIAS("__typeof_unqual__", typeof_unqual, KEYALL)
0720 ALIAS("__volatile" , volatile , KEYALL)
0721 ALIAS("__volatile__" , volatile , KEYALL)
0722
0723 // Type nullability.
0724 KEYWORD(_Nonnull , KEYALL)
0725 KEYWORD(_Nullable , KEYALL)
0726 KEYWORD(_Nullable_result , KEYALL)
0727 KEYWORD(_Null_unspecified , KEYALL)
0728
0729 // WebAssembly Type Extension
0730 KEYWORD(__funcref , KEYALL)
0731
0732 // Microsoft extensions which should be disabled in strict conformance mode
0733 KEYWORD(__ptr64 , KEYMS)
0734 KEYWORD(__ptr32 , KEYMS | KEYZOS)
0735 KEYWORD(__sptr , KEYMS)
0736 KEYWORD(__uptr , KEYMS)
0737 KEYWORD(__w64 , KEYMS)
0738 KEYWORD(__uuidof , KEYMS | KEYBORLAND)
0739 KEYWORD(__try , KEYMS | KEYBORLAND)
0740 KEYWORD(__finally , KEYMS | KEYBORLAND)
0741 KEYWORD(__leave , KEYMS | KEYBORLAND)
0742 KEYWORD(__int64 , KEYMS)
0743 KEYWORD(__if_exists , KEYMS)
0744 KEYWORD(__if_not_exists , KEYMS)
0745 KEYWORD(__single_inheritance , KEYMS)
0746 KEYWORD(__multiple_inheritance , KEYMS)
0747 KEYWORD(__virtual_inheritance , KEYMS)
0748 KEYWORD(__interface , KEYMS)
0749 ALIAS("__int8" , char , KEYMS)
0750 ALIAS("__int16" , short , KEYMS)
0751 ALIAS("__int32" , int , KEYMS)
0752 ALIAS("__wchar_t" , wchar_t , KEYMS)
0753 ALIAS("__builtin_alignof", __alignof , KEYMS)
0754
0755 // Microsoft single-underscore prefixed aliases for double-underscore prefixed
0756 // keywords.
0757 ALIAS("_asm" , asm , KEYMS)
0758 ALIAS("_alignof" , __alignof , KEYMS)
0759 ALIAS("_cdecl" , __cdecl , KEYMS | KEYBORLAND)
0760 ALIAS("_declspec" , __declspec , KEYMS)
0761 ALIAS("_fastcall" , __fastcall , KEYMS | KEYBORLAND)
0762 ALIAS("_finally" , __finally , KEYMSCOMPAT)
0763 ALIAS("_forceinline" , __forceinline, KEYMSCOMPAT)
0764 ALIAS("_inline" , inline , KEYMS)
0765 ALIAS("_int8" , char , KEYMS)
0766 ALIAS("_int16" , short , KEYMS)
0767 ALIAS("_int32" , int , KEYMS)
0768 ALIAS("_int64" , __int64 , KEYMS)
0769 ALIAS("_leave" , __leave , KEYMSCOMPAT)
0770 ALIAS("_multiple_inheritance", __multiple_inheritance, KEYMSCOMPAT)
0771 ALIAS("_ptr32" , __ptr32 , KEYMSCOMPAT)
0772 ALIAS("_ptr64" , __ptr64 , KEYMSCOMPAT)
0773 ALIAS("_restrict" , restrict , KEYMSCOMPAT)
0774 ALIAS("_stdcall" , __stdcall , KEYMS | KEYBORLAND)
0775 ALIAS("_thiscall" , __thiscall , KEYMS)
0776 ALIAS("_try" , __try , KEYMSCOMPAT)
0777 ALIAS("_vectorcall" , __vectorcall , KEYMS)
0778 ALIAS("_unaligned" , __unaligned , KEYMSCOMPAT)
0779 ALIAS("_uptr" , __uptr , KEYMSCOMPAT)
0780 ALIAS("_uuidof" , __uuidof , KEYMS | KEYBORLAND)
0781 ALIAS("_virtual_inheritance", __virtual_inheritance, KEYMSCOMPAT)
0782 ALIAS("_w64" , __w64 , KEYMSCOMPAT)
0783
0784 // Borland Extensions which should be disabled in strict conformance mode.
0785 ALIAS("_pascal" , __pascal , KEYBORLAND)
0786
0787 // Clang Extensions.
0788 KEYWORD(__builtin_convertvector , KEYALL)
0789 UNARY_EXPR_OR_TYPE_TRAIT(__builtin_vectorelements, VectorElements, KEYALL)
0790 ALIAS("__char16_t" , char16_t , KEYCXX)
0791 ALIAS("__char32_t" , char32_t , KEYCXX)
0792 KEYWORD(__builtin_bit_cast , KEYALL)
0793 KEYWORD(__builtin_available , KEYALL)
0794 KEYWORD(__builtin_sycl_unique_stable_name, KEYSYCL)
0795
0796 // Keywords defined by Attr.td.
0797 // The "EMPTY ## X" is used to prevent early macro-expansion of the keyword.
0798 #ifndef KEYWORD_ATTRIBUTE
0799 #define KEYWORD_ATTRIBUTE(X, HASARG, EMPTY) KEYWORD(EMPTY ## X, KEYALL)
0800 #endif
0801 #include "clang/Basic/RegularKeywordAttrInfo.inc"
0802
0803 // Clang-specific keywords enabled only in testing.
0804 TESTING_KEYWORD(__unknown_anytype , KEYALL)
0805
0806
0807 //===----------------------------------------------------------------------===//
0808 // Objective-C @-preceded keywords.
0809 //===----------------------------------------------------------------------===//
0810
0811 // These have meaning after an '@' in Objective-C mode. These define enums in
0812 // the tok::objc_* namespace.
0813
0814 OBJC_AT_KEYWORD(not_keyword)
0815 OBJC_AT_KEYWORD(class)
0816 OBJC_AT_KEYWORD(compatibility_alias)
0817 OBJC_AT_KEYWORD(defs)
0818 OBJC_AT_KEYWORD(encode)
0819 OBJC_AT_KEYWORD(end)
0820 OBJC_AT_KEYWORD(implementation)
0821 OBJC_AT_KEYWORD(interface)
0822 OBJC_AT_KEYWORD(private)
0823 OBJC_AT_KEYWORD(protected)
0824 OBJC_AT_KEYWORD(protocol)
0825 OBJC_AT_KEYWORD(public)
0826 OBJC_AT_KEYWORD(selector)
0827 OBJC_AT_KEYWORD(throw)
0828 OBJC_AT_KEYWORD(try)
0829 OBJC_AT_KEYWORD(catch)
0830 OBJC_AT_KEYWORD(finally)
0831 OBJC_AT_KEYWORD(synchronized)
0832 OBJC_AT_KEYWORD(autoreleasepool)
0833
0834 OBJC_AT_KEYWORD(property)
0835 OBJC_AT_KEYWORD(package)
0836 OBJC_AT_KEYWORD(required)
0837 OBJC_AT_KEYWORD(optional)
0838 OBJC_AT_KEYWORD(synthesize)
0839 OBJC_AT_KEYWORD(dynamic)
0840 OBJC_AT_KEYWORD(import)
0841 OBJC_AT_KEYWORD(available)
0842
0843 //===----------------------------------------------------------------------===//
0844 // Notable identifiers.
0845 //===----------------------------------------------------------------------===//
0846 NOTABLE_IDENTIFIER(not_notable)
0847 NOTABLE_IDENTIFIER(FILE)
0848 NOTABLE_IDENTIFIER(jmp_buf)
0849 NOTABLE_IDENTIFIER(sigjmp_buf)
0850 NOTABLE_IDENTIFIER(ucontext_t)
0851 NOTABLE_IDENTIFIER(float_t)
0852 NOTABLE_IDENTIFIER(double_t)
0853
0854 // TODO: What to do about context-sensitive keywords like:
0855 // bycopy/byref/in/inout/oneway/out?
0856
0857 ANNOTATION(cxxscope) // annotation for a C++ scope spec, e.g. "::foo::bar::"
0858 ANNOTATION(typename) // annotation for a C typedef name, a C++ (possibly
0859 // qualified) typename, e.g. "foo::MyClass", or
0860 // template-id that names a type ("std::vector<int>")
0861 ANNOTATION(template_id) // annotation for a C++ template-id that names a
0862 // function template specialization (not a type),
0863 // e.g., "std::swap<int>", or a type-constraint (which
0864 // might not have explicit template arguments),
0865 // e.g. "C", "C<int>".
0866 ANNOTATION(non_type) // annotation for a single non-type declaration
0867 ANNOTATION(non_type_undeclared) // annotation for an undeclared identifier that
0868 // was assumed to be an ADL-only function name
0869 ANNOTATION(non_type_dependent) // annotation for an assumed non-type member of
0870 // a dependent base class
0871 ANNOTATION(overload_set) // annotation for an unresolved overload set
0872 ANNOTATION(primary_expr) // annotation for a primary expression, used when
0873 // tentatively parsing a lambda init-capture or ObjC
0874 // message send
0875 ANNOTATION(decltype) // annotation for a decltype expression,
0876 // e.g., "decltype(foo.bar())"
0877 ANNOTATION(pack_indexing_type) // annotation for an indexed pack of type,
0878 // e.g., "T...[expr]"
0879
0880 // Annotation for #pragma unused(...)
0881 // For each argument inside the parentheses the pragma handler will produce
0882 // one 'pragma_unused' annotation token followed by the argument token.
0883 PRAGMA_ANNOTATION(pragma_unused)
0884
0885 // Annotation for #pragma GCC visibility...
0886 // The lexer produces these so that they only take effect when the parser
0887 // handles them.
0888 PRAGMA_ANNOTATION(pragma_vis)
0889
0890 // Annotation for #pragma pack...
0891 // The lexer produces these so that they only take effect when the parser
0892 // handles them.
0893 PRAGMA_ANNOTATION(pragma_pack)
0894
0895 // Annotation for #pragma clang __debug parser_crash...
0896 // The lexer produces these so that they only take effect when the parser
0897 // handles them.
0898 PRAGMA_ANNOTATION(pragma_parser_crash)
0899
0900 // Annotation for #pragma clang __debug captured...
0901 // The lexer produces these so that they only take effect when the parser
0902 // handles them.
0903 PRAGMA_ANNOTATION(pragma_captured)
0904
0905 // Annotation for #pragma clang __debug dump...
0906 // The lexer produces these so that the parser and semantic analysis can
0907 // look up and dump the operand.
0908 PRAGMA_ANNOTATION(pragma_dump)
0909
0910 // Annotation for #pragma ms_struct...
0911 // The lexer produces these so that they only take effect when the parser
0912 // handles them.
0913 PRAGMA_ANNOTATION(pragma_msstruct)
0914
0915 // Annotation for #pragma align...
0916 // The lexer produces these so that they only take effect when the parser
0917 // handles them.
0918 PRAGMA_ANNOTATION(pragma_align)
0919
0920 // Annotation for #pragma weak id
0921 // The lexer produces these so that they only take effect when the parser
0922 // handles them.
0923 PRAGMA_ANNOTATION(pragma_weak)
0924
0925 // Annotation for #pragma weak id = id
0926 // The lexer produces these so that they only take effect when the parser
0927 // handles them.
0928 PRAGMA_ANNOTATION(pragma_weakalias)
0929
0930 // Annotation for #pragma redefine_extname...
0931 // The lexer produces these so that they only take effect when the parser
0932 // handles them.
0933 PRAGMA_ANNOTATION(pragma_redefine_extname)
0934
0935 // Annotation for #pragma STDC FP_CONTRACT...
0936 // The lexer produces these so that they only take effect when the parser
0937 // handles them.
0938 PRAGMA_ANNOTATION(pragma_fp_contract)
0939
0940 // Annotations for #pragma STDC FENV_ACCESS and #pragma fenv_access (MS compat)
0941 // The lexer produces these so that they only take effect when the parser
0942 // handles them.
0943 PRAGMA_ANNOTATION(pragma_fenv_access)
0944 PRAGMA_ANNOTATION(pragma_fenv_access_ms)
0945
0946 // Annotation for #pragma STDC FENV_ROUND
0947 // The lexer produces these so that they only take effect when the parser
0948 // handles them.
0949 PRAGMA_ANNOTATION(pragma_fenv_round)
0950
0951 // Annotation for #pragma STDC CX_LIMITED_RANGE
0952 // The lexer produces these so that they only take effect when the parser
0953 // handles them.
0954 PRAGMA_ANNOTATION(pragma_cx_limited_range)
0955
0956 // Annotation for #pragma float_control
0957 // The lexer produces these so that they only take effect when the parser
0958 // handles them.
0959 PRAGMA_ANNOTATION(pragma_float_control)
0960
0961 // Annotation for #pragma pointers_to_members...
0962 // The lexer produces these so that they only take effect when the parser
0963 // handles them.
0964 PRAGMA_ANNOTATION(pragma_ms_pointers_to_members)
0965
0966 // Annotation for #pragma vtordisp...
0967 // The lexer produces these so that they only take effect when the parser
0968 // handles them.
0969 PRAGMA_ANNOTATION(pragma_ms_vtordisp)
0970
0971 // Annotation for all microsoft #pragmas...
0972 // The lexer produces these so that they only take effect when the parser
0973 // handles them.
0974 PRAGMA_ANNOTATION(pragma_ms_pragma)
0975
0976 // Annotation for #pragma OPENCL EXTENSION...
0977 // The lexer produces these so that they only take effect when the parser
0978 // handles them.
0979 PRAGMA_ANNOTATION(pragma_opencl_extension)
0980
0981 // Annotations for OpenMP pragma directives - #pragma omp ...
0982 // The parser produces this annotation token when it parses an [[omp::*]]
0983 // attribute. The tokens from the attribute argument list are replayed to the
0984 // token stream with this leading token (and a trailing pragma_openmp_end) so
0985 // that the parser can reuse the OpenMP parsing logic but still be able to
0986 // distinguish between a real pragma and a converted pragma. It is not marked
0987 // as a PRAGMA_ANNOTATION because it doesn't get generated from a #pragma.
0988 ANNOTATION(attr_openmp)
0989 // The lexer produces these so that they only take effect when the parser
0990 // handles #pragma omp ... directives.
0991 PRAGMA_ANNOTATION(pragma_openmp)
0992 PRAGMA_ANNOTATION(pragma_openmp_end)
0993
0994 // Annotations for OpenACC pragma directives - #pragma acc.
0995 // Like with OpenMP, these are produced by the lexer when it parses a
0996 // #pragma acc directive so it can be handled during parsing of the directives.
0997 PRAGMA_ANNOTATION(pragma_openacc)
0998 PRAGMA_ANNOTATION(pragma_openacc_end)
0999
1000 // Annotations for loop pragma directives #pragma clang loop ...
1001 // The lexer produces these so that they only take effect when the parser
1002 // handles #pragma loop ... directives.
1003 PRAGMA_ANNOTATION(pragma_loop_hint)
1004
1005 PRAGMA_ANNOTATION(pragma_fp)
1006
1007 // Annotation for the attribute pragma directives - #pragma clang attribute ...
1008 PRAGMA_ANNOTATION(pragma_attribute)
1009
1010 // Annotation for the riscv pragma directives - #pragma clang riscv intrinsic ...
1011 PRAGMA_ANNOTATION(pragma_riscv)
1012
1013 // Annotations for module import translated from #include etc.
1014 ANNOTATION(module_include)
1015 ANNOTATION(module_begin)
1016 ANNOTATION(module_end)
1017
1018 // Annotation for a header_name token that has been looked up and transformed
1019 // into the name of a header unit.
1020 ANNOTATION(header_unit)
1021
1022 // Annotation for end of input in clang-repl.
1023 ANNOTATION(repl_input_end)
1024
1025 // Annotation for #embed
1026 ANNOTATION(embed)
1027
1028 #undef PRAGMA_ANNOTATION
1029 #undef ANNOTATION
1030 #undef TESTING_KEYWORD
1031 #undef OBJC_AT_KEYWORD
1032 #undef CXX_KEYWORD_OPERATOR
1033 #undef PPKEYWORD
1034 #undef ALIAS
1035 #undef EXPRESSION_TRAIT
1036 #undef CXX11_UNARY_EXPR_OR_TYPE_TRAIT
1037 #undef UNARY_EXPR_OR_TYPE_TRAIT
1038 #undef ARRAY_TYPE_TRAIT
1039 #undef TYPE_TRAIT_N
1040 #undef TYPE_TRAIT_2
1041 #undef TYPE_TRAIT_1
1042 #undef TYPE_TRAIT
1043 #undef CXX20_KEYWORD
1044 #undef CXX11_KEYWORD
1045 #undef KEYWORD
1046 #undef PUNCTUATOR
1047 #undef TOK
1048 #undef C99_KEYWORD
1049 #undef C23_KEYWORD
1050 #undef NOTABLE_IDENTIFIER
