Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 169 insertions, 169 deletions

diff --git a/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py b/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
index c9d1ed38ea..ee26907c4f 100644
--- a/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
+++ b/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
@@ -4,7 +4,7 @@
 
     Lexers for C/C++ languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. 
     :license: BSD, see LICENSE for details.
 """
 
@@ -14,7 +14,7 @@ from pygments.lexer import RegexLexer, include, bygroups, using, \
     this, inherit, default, words
 from pygments.util import get_bool_opt
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
+    Number, Punctuation, Whitespace 
 
 __all__ = ['CLexer', 'CppLexer']
 
@@ -29,19 +29,19 @@ class CFamilyLexer(RegexLexer):
     #: only one /* */ style comment
     _ws1 = r'\s*(?:/[*].*?[*]/\s*)?'
 
-    # Hexadecimal part in an hexadecimal integer/floating-point literal.
-    # This includes decimal separators matching.
-    _hexpart = r'[0-9a-fA-F](\'?[0-9a-fA-F])*'
-    # Decimal part in an decimal integer/floating-point literal.
-    # This includes decimal separators matching.
-    _decpart = r'\d(\'?\d)*'
-    # Integer literal suffix (e.g. 'ull' or 'll').
-    _intsuffix = r'(([uU][lL]{0,2})|[lL]{1,2}[uU]?)?'
-
-    # Identifier regex with C and C++ Universal Character Name (UCN) support.
+    # Hexadecimal part in an hexadecimal integer/floating-point literal. 
+    # This includes decimal separators matching. 
+    _hexpart = r'[0-9a-fA-F](\'?[0-9a-fA-F])*' 
+    # Decimal part in an decimal integer/floating-point literal. 
+    # This includes decimal separators matching. 
+    _decpart = r'\d(\'?\d)*' 
+    # Integer literal suffix (e.g. 'ull' or 'll'). 
+    _intsuffix = r'(([uU][lL]{0,2})|[lL]{1,2}[uU]?)?' 
+ 
+    # Identifier regex with C and C++ Universal Character Name (UCN) support. 
     _ident = r'(?!\d)(?:[\w$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})+'
     _namespaced_ident = r'(?!\d)(?:[\w$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|::)+'
-
+ 
     tokens = {
         'whitespace': [
             # preprocessor directives: without whitespace
@@ -54,8 +54,8 @@ class CFamilyLexer(RegexLexer):
              bygroups(using(this), Comment.Preproc), 'macro'),
             (r'(^[ \t]*)(?!(?:public|private|protected|default)\b)(case\b\s+)?(' + _ident + r')(\s*)(:)(?!:)',
              bygroups(Whitespace, using(this), Name.Label, Whitespace, Punctuation)),
-            (r'\n', Whitespace),
-            (r'[^\S\n]+', Whitespace),
+            (r'\n', Whitespace), 
+            (r'[^\S\n]+', Whitespace), 
             (r'\\\n', Text),  # line continuation
             (r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
@@ -63,66 +63,66 @@ class CFamilyLexer(RegexLexer):
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
-            include('keywords'),
-            include('types'),
-            (r'([LuU]|u8)?(")', bygroups(String.Affix, String), 'string'),
-            (r"([LuU]|u8)?(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
+            include('keywords'), 
+            include('types'), 
+            (r'([LuU]|u8)?(")', bygroups(String.Affix, String), 'string'), 
+            (r"([LuU]|u8)?(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')", 
              bygroups(String.Affix, String.Char, String.Char, String.Char)),
-
-             # Hexadecimal floating-point literals (C11, C++17)
-            (r'0[xX](' + _hexpart + r'\.' + _hexpart + r'|\.' + _hexpart + r'|' + _hexpart + r')[pP][+-]?' + _hexpart + r'[lL]?', Number.Float),
-
-            (r'(-)?(' + _decpart + r'\.' + _decpart + r'|\.' + _decpart + r'|' + _decpart + r')[eE][+-]?' + _decpart + r'[fFlL]?', Number.Float),
-            (r'(-)?((' + _decpart + r'\.(' + _decpart + r')?|\.' + _decpart + r')[fFlL]?)|(' + _decpart + r'[fFlL])', Number.Float),
-            (r'(-)?0[xX]' + _hexpart + _intsuffix, Number.Hex),
-            (r'(-)?0[bB][01](\'?[01])*' + _intsuffix, Number.Bin),
-            (r'(-)?0(\'?[0-7])+' + _intsuffix, Number.Oct),
-            (r'(-)?' + _decpart + _intsuffix, Number.Integer),
+ 
+             # Hexadecimal floating-point literals (C11, C++17) 
+            (r'0[xX](' + _hexpart + r'\.' + _hexpart + r'|\.' + _hexpart + r'|' + _hexpart + r')[pP][+-]?' + _hexpart + r'[lL]?', Number.Float), 
+ 
+            (r'(-)?(' + _decpart + r'\.' + _decpart + r'|\.' + _decpart + r'|' + _decpart + r')[eE][+-]?' + _decpart + r'[fFlL]?', Number.Float), 
+            (r'(-)?((' + _decpart + r'\.(' + _decpart + r')?|\.' + _decpart + r')[fFlL]?)|(' + _decpart + r'[fFlL])', Number.Float), 
+            (r'(-)?0[xX]' + _hexpart + _intsuffix, Number.Hex), 
+            (r'(-)?0[bB][01](\'?[01])*' + _intsuffix, Number.Bin), 
+            (r'(-)?0(\'?[0-7])+' + _intsuffix, Number.Oct), 
+            (r'(-)?' + _decpart + _intsuffix, Number.Integer), 
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'[()\[\],.]', Punctuation),
-            (r'(true|false|NULL)\b', Name.Builtin),
-            (_ident, Name)
-        ],
-        'types': [
-            (words(('int8', 'int16', 'int32', 'int64', 'wchar_t'), prefix=r'__',
-                    suffix=r'\b'), Keyword.Reserved),
-            (words(('bool', 'int', 'long', 'float', 'short', 'double', 'char',
-                    'unsigned', 'signed', 'void'), suffix=r'\b'), Keyword.Type)
-        ],
-        'keywords': [
+            (r'(true|false|NULL)\b', Name.Builtin), 
+            (_ident, Name) 
+        ], 
+        'types': [ 
+            (words(('int8', 'int16', 'int32', 'int64', 'wchar_t'), prefix=r'__', 
+                    suffix=r'\b'), Keyword.Reserved), 
+            (words(('bool', 'int', 'long', 'float', 'short', 'double', 'char', 
+                    'unsigned', 'signed', 'void'), suffix=r'\b'), Keyword.Type) 
+        ], 
+        'keywords': [ 
             (r'(struct|union)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
             (words(('asm', 'auto', 'break', 'case', 'const', 'continue',
                     'default', 'do', 'else', 'enum', 'extern', 'for', 'goto',
-                    'if', 'register', 'restricted', 'return', 'sizeof', 'struct',
-                    'static', 'switch', 'typedef', 'volatile', 'while', 'union',
-                    'thread_local', 'alignas', 'alignof', 'static_assert', '_Pragma'),
+                    'if', 'register', 'restricted', 'return', 'sizeof', 'struct', 
+                    'static', 'switch', 'typedef', 'volatile', 'while', 'union', 
+                    'thread_local', 'alignas', 'alignof', 'static_assert', '_Pragma'), 
                    suffix=r'\b'), Keyword),
             (words(('inline', '_inline', '__inline', 'naked', 'restrict',
-                    'thread'), suffix=r'\b'), Keyword.Reserved),
+                    'thread'), suffix=r'\b'), Keyword.Reserved), 
             # Vector intrinsics
             (r'(__m(128i|128d|128|64))\b', Keyword.Reserved),
             # Microsoft-isms
             (words((
-                'asm', 'based', 'except', 'stdcall', 'cdecl',
-                'fastcall', 'declspec', 'finally', 'try',
-                'leave', 'w64', 'unaligned', 'raise', 'noop',
+                'asm', 'based', 'except', 'stdcall', 'cdecl', 
+                'fastcall', 'declspec', 'finally', 'try', 
+                'leave', 'w64', 'unaligned', 'raise', 'noop', 
                 'identifier', 'forceinline', 'assume'),
-                prefix=r'__', suffix=r'\b'), Keyword.Reserved)
+                prefix=r'__', suffix=r'\b'), Keyword.Reserved) 
         ],
         'root': [
             include('whitespace'),
-            include('keywords'),
+            include('keywords'), 
             # functions
-            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
-             r'(' + _namespaced_ident + r')'             # method name
+            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments 
+             r'(' + _namespaced_ident + r')'             # method name 
              r'(\s*\([^;]*?\))'                          # signature
              r'([^;{]*)(\{)',
              bygroups(using(this), Name.Function, using(this), using(this),
                       Punctuation),
              'function'),
             # function declarations
-            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
-             r'(' + _namespaced_ident + r')'             # method name
+            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments 
+             r'(' + _namespaced_ident + r')'             # method name 
              r'(\s*\([^;]*?\))'                          # signature
              r'([^;]*)(;)',
              bygroups(using(this), Name.Function, using(this), using(this),
@@ -133,8 +133,8 @@ class CFamilyLexer(RegexLexer):
         'statement': [
             include('whitespace'),
             include('statements'),
-            (r'\}', Punctuation),
-            (r'[{;]', Punctuation, '#pop'),
+            (r'\}', Punctuation), 
+            (r'[{;]', Punctuation, '#pop'), 
         ],
         'function': [
             include('whitespace'),
@@ -152,10 +152,10 @@ class CFamilyLexer(RegexLexer):
             (r'\\', String),  # stray backslash
         ],
         'macro': [
-            (r'('+_ws1+r')(include)('+_ws1+r')("[^"]+")([^\n]*)',
-                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
-            (r'('+_ws1+r')(include)('+_ws1+r')(<[^>]+>)([^\n]*)',
-                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
+            (r'('+_ws1+r')(include)('+_ws1+r')("[^"]+")([^\n]*)', 
+                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)), 
+            (r'('+_ws1+r')(include)('+_ws1+r')(<[^>]+>)([^\n]*)', 
+                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)), 
             (r'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (r'//.*?\n', Comment.Single, '#pop'),
@@ -168,46 +168,46 @@ class CFamilyLexer(RegexLexer):
             (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'),
             (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'),
             (r'.*?\n', Comment),
-        ],
-        'classname': [
-            (_ident, Name.Class, '#pop'),
-            # template specification
-            (r'\s*(?=>)', Text, '#pop'),
-            default('#pop')
+        ], 
+        'classname': [ 
+            (_ident, Name.Class, '#pop'), 
+            # template specification 
+            (r'\s*(?=>)', Text, '#pop'), 
+            default('#pop') 
         ]
     }
 
-    stdlib_types = {
+    stdlib_types = { 
         'size_t', 'ssize_t', 'off_t', 'wchar_t', 'ptrdiff_t', 'sig_atomic_t', 'fpos_t',
         'clock_t', 'time_t', 'va_list', 'jmp_buf', 'FILE', 'DIR', 'div_t', 'ldiv_t',
-        'mbstate_t', 'wctrans_t', 'wint_t', 'wctype_t'}
-    c99_types = {
-        'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t',
+        'mbstate_t', 'wctrans_t', 'wint_t', 'wctype_t'} 
+    c99_types = { 
+        'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t', 
         'uint16_t', 'uint32_t', 'uint64_t', 'int_least8_t', 'int_least16_t',
         'int_least32_t', 'int_least64_t', 'uint_least8_t', 'uint_least16_t',
         'uint_least32_t', 'uint_least64_t', 'int_fast8_t', 'int_fast16_t', 'int_fast32_t',
         'int_fast64_t', 'uint_fast8_t', 'uint_fast16_t', 'uint_fast32_t', 'uint_fast64_t',
-        'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t'}
-    linux_types = {
+        'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t'} 
+    linux_types = { 
         'clockid_t', 'cpu_set_t', 'cpumask_t', 'dev_t', 'gid_t', 'id_t', 'ino_t', 'key_t',
         'mode_t', 'nfds_t', 'pid_t', 'rlim_t', 'sig_t', 'sighandler_t', 'siginfo_t',
-        'sigset_t', 'sigval_t', 'socklen_t', 'timer_t', 'uid_t'}
-    c11_atomic_types = {
-        'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short', 
-        'atomic_ushort', 'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong',
-        'atomic_llong', 'atomic_ullong', 'atomic_char16_t', 'atomic_char32_t', 'atomic_wchar_t', 
-        'atomic_int_least8_t', 'atomic_uint_least8_t', 'atomic_int_least16_t', 
-        'atomic_uint_least16_t', 'atomic_int_least32_t', 'atomic_uint_least32_t',
-        'atomic_int_least64_t', 'atomic_uint_least64_t', 'atomic_int_fast8_t', 
-        'atomic_uint_fast8_t', 'atomic_int_fast16_t', 'atomic_uint_fast16_t',
-        'atomic_int_fast32_t', 'atomic_uint_fast32_t', 'atomic_int_fast64_t',
-        'atomic_uint_fast64_t', 'atomic_intptr_t', 'atomic_uintptr_t', 'atomic_size_t',
-        'atomic_ptrdiff_t', 'atomic_intmax_t', 'atomic_uintmax_t'}
+        'sigset_t', 'sigval_t', 'socklen_t', 'timer_t', 'uid_t'} 
+    c11_atomic_types = { 
+        'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short',  
+        'atomic_ushort', 'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong', 
+        'atomic_llong', 'atomic_ullong', 'atomic_char16_t', 'atomic_char32_t', 'atomic_wchar_t',  
+        'atomic_int_least8_t', 'atomic_uint_least8_t', 'atomic_int_least16_t',  
+        'atomic_uint_least16_t', 'atomic_int_least32_t', 'atomic_uint_least32_t', 
+        'atomic_int_least64_t', 'atomic_uint_least64_t', 'atomic_int_fast8_t',  
+        'atomic_uint_fast8_t', 'atomic_int_fast16_t', 'atomic_uint_fast16_t', 
+        'atomic_int_fast32_t', 'atomic_uint_fast32_t', 'atomic_int_fast64_t', 
+        'atomic_uint_fast64_t', 'atomic_intptr_t', 'atomic_uintptr_t', 'atomic_size_t', 
+        'atomic_ptrdiff_t', 'atomic_intmax_t', 'atomic_uintmax_t'} 
 
     def __init__(self, **options):
         self.stdlibhighlighting = get_bool_opt(options, 'stdlibhighlighting', True)
         self.c99highlighting = get_bool_opt(options, 'c99highlighting', True)
-        self.c11highlighting = get_bool_opt(options, 'c11highlighting', True)
+        self.c11highlighting = get_bool_opt(options, 'c11highlighting', True) 
         self.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True)
         RegexLexer.__init__(self, **options)
 
@@ -219,8 +219,8 @@ class CFamilyLexer(RegexLexer):
                     token = Keyword.Type
                 elif self.c99highlighting and value in self.c99_types:
                     token = Keyword.Type
-                elif self.c11highlighting and value in self.c11_atomic_types:
-                    token = Keyword.Type
+                elif self.c11highlighting and value in self.c11_atomic_types: 
+                    token = Keyword.Type 
                 elif self.platformhighlighting and value in self.linux_types:
                     token = Keyword.Type
             yield index, token, value
@@ -229,25 +229,25 @@ class CFamilyLexer(RegexLexer):
 class CLexer(CFamilyLexer):
     """
     For C source code with preprocessor directives.
-
-    Additional options accepted:
-
-    `stdlibhighlighting`
-        Highlight common types found in the C/C++ standard library (e.g. `size_t`).
-        (default: ``True``).
-
-    `c99highlighting`
-        Highlight common types found in the C99 standard library (e.g. `int8_t`).
-        Actually, this includes all fixed-width integer types.
-        (default: ``True``).
-
-    `c11highlighting`
-        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`).
-        (default: ``True``).
-
-    `platformhighlighting`
-        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
-        (default: ``True``).
+ 
+    Additional options accepted: 
+ 
+    `stdlibhighlighting` 
+        Highlight common types found in the C/C++ standard library (e.g. `size_t`). 
+        (default: ``True``). 
+ 
+    `c99highlighting` 
+        Highlight common types found in the C99 standard library (e.g. `int8_t`). 
+        Actually, this includes all fixed-width integer types. 
+        (default: ``True``). 
+ 
+    `c11highlighting` 
+        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`). 
+        (default: ``True``). 
+ 
+    `platformhighlighting` 
+        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux). 
+        (default: ``True``). 
     """
     name = 'C'
     aliases = ['c']
@@ -255,20 +255,20 @@ class CLexer(CFamilyLexer):
     mimetypes = ['text/x-chdr', 'text/x-csrc', 'image/x-xbitmap', 'image/x-xpixmap']
     priority = 0.1
 
-    tokens = {
-        'keywords': [
-            (words((
-                '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local', 
-                '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'),
-                suffix=r'\b'), Keyword),
-            inherit
-        ],
-        'types': [
-            (words(('_Bool', '_Complex', '_Atomic'), suffix=r'\b'), Keyword.Type),
-            inherit
-        ]
-    }
-
+    tokens = { 
+        'keywords': [ 
+            (words(( 
+                '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local',  
+                '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'), 
+                suffix=r'\b'), Keyword), 
+            inherit 
+        ], 
+        'types': [ 
+            (words(('_Bool', '_Complex', '_Atomic'), suffix=r'\b'), Keyword.Type), 
+            inherit 
+        ] 
+    } 
+ 
     def analyse_text(text):
         if re.search(r'^\s*#include [<"]', text, re.MULTILINE):
             return 0.1
@@ -279,25 +279,25 @@ class CLexer(CFamilyLexer):
 class CppLexer(CFamilyLexer):
     """
     For C++ source code with preprocessor directives.
-
-    Additional options accepted:
-
-    `stdlibhighlighting`
-        Highlight common types found in the C/C++ standard library (e.g. `size_t`).
-        (default: ``True``).
-
-    `c99highlighting`
-        Highlight common types found in the C99 standard library (e.g. `int8_t`).
-        Actually, this includes all fixed-width integer types.
-        (default: ``True``).
-
-    `c11highlighting`
-        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`).
-        (default: ``True``).
-
-    `platformhighlighting`
-        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
-        (default: ``True``).
+ 
+    Additional options accepted: 
+ 
+    `stdlibhighlighting` 
+        Highlight common types found in the C/C++ standard library (e.g. `size_t`). 
+        (default: ``True``). 
+ 
+    `c99highlighting` 
+        Highlight common types found in the C99 standard library (e.g. `int8_t`). 
+        Actually, this includes all fixed-width integer types. 
+        (default: ``True``). 
+ 
+    `c11highlighting` 
+        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`). 
+        (default: ``True``). 
+ 
+    `platformhighlighting` 
+        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux). 
+        (default: ``True``). 
     """
     name = 'C++'
     aliases = ['cpp', 'c++']
@@ -310,7 +310,7 @@ class CppLexer(CFamilyLexer):
     tokens = {
         'statements': [
             # C++11 raw strings
-            (r'((?:[LuU]|u8)?R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
+            (r'((?:[LuU]|u8)?R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")', 
              bygroups(String.Affix, String, String.Delimiter, String.Delimiter,
                       String, String.Delimiter, String)),
             inherit,
@@ -324,41 +324,41 @@ class CppLexer(CFamilyLexer):
             # Offload C++ extensions, http://offload.codeplay.com/
             (r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo),
         ],
-        'enumname': [
-            include('whitespace'),
-            # 'enum class' and 'enum struct' C++11 support
-            (words(('class', 'struct'), suffix=r'\b'), Keyword),
-            (CFamilyLexer._ident, Name.Class, '#pop'),
+        'enumname': [ 
+            include('whitespace'), 
+            # 'enum class' and 'enum struct' C++11 support 
+            (words(('class', 'struct'), suffix=r'\b'), Keyword), 
+            (CFamilyLexer._ident, Name.Class, '#pop'), 
             # template specification
             (r'\s*(?=>)', Text, '#pop'),
-            default('#pop')
-        ],
-        'keywords': [
+            default('#pop') 
+        ], 
+        'keywords': [ 
             (r'(class|concept|typename)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
-            (words((
-                'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit',
-                'export', 'friend', 'mutable', 'new', 'operator',
-                'private', 'protected', 'public', 'reinterpret_cast', 'class',
-                'restrict', 'static_cast', 'template', 'this', 'throw', 'throws',
-                'try', 'typeid', 'using', 'virtual', 'constexpr', 'nullptr', 'concept',
-                'decltype', 'noexcept', 'override', 'final', 'constinit', 'consteval', 
-                'co_await', 'co_return', 'co_yield', 'requires', 'import', 'module',
-                'typename'),
-               suffix=r'\b'), Keyword),
-            (r'namespace\b', Keyword, 'namespace'),
+            (words(( 
+                'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit', 
+                'export', 'friend', 'mutable', 'new', 'operator', 
+                'private', 'protected', 'public', 'reinterpret_cast', 'class', 
+                'restrict', 'static_cast', 'template', 'this', 'throw', 'throws', 
+                'try', 'typeid', 'using', 'virtual', 'constexpr', 'nullptr', 'concept', 
+                'decltype', 'noexcept', 'override', 'final', 'constinit', 'consteval',  
+                'co_await', 'co_return', 'co_yield', 'requires', 'import', 'module', 
+                'typename'), 
+               suffix=r'\b'), Keyword), 
+            (r'namespace\b', Keyword, 'namespace'), 
             (r'(enum)(\s+)', bygroups(Keyword, Whitespace), 'enumname'),
-            inherit
-        ],
-        'types': [
-            (r'char(16_t|32_t|8_t)\b', Keyword.Type),
-            inherit
-        ],
-        'namespace': [
-            (r'[;{]', Punctuation, ('#pop', 'root')),
-            (r'inline\b', Keyword.Reserved),
-            (CFamilyLexer._ident, Name.Namespace),
-            include('statement')
-        ]
+            inherit 
+        ], 
+        'types': [ 
+            (r'char(16_t|32_t|8_t)\b', Keyword.Type), 
+            inherit 
+        ], 
+        'namespace': [ 
+            (r'[;{]', Punctuation, ('#pop', 'root')), 
+            (r'inline\b', Keyword.Reserved), 
+            (CFamilyLexer._ident, Name.Namespace), 
+            include('statement') 
+        ] 
     }
 
     def analyse_text(text):