contrib/llvm-project/clang/include/clang/Basic/TokenKinds.def

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