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

1 files changed, 173 insertions, 173 deletions

diff --git a/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py b/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
index 97b957e5d9c..c9d1ed38ead 100644
--- a/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
+++ b/contrib/python/Pygments/py3/pygments/lexers/c_cpp.py
@@ -1,34 +1,34 @@
-""" 
-    pygments.lexers.c_cpp 
-    ~~~~~~~~~~~~~~~~~~~~~ 
- 
-    Lexers for C/C++ languages. 
- 
+"""
+    pygments.lexers.c_cpp
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for C/C++ languages.
+
     :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details. 
-""" 
- 
-import re 
- 
-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, \ 
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+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
- 
-__all__ = ['CLexer', 'CppLexer'] 
- 
- 
-class CFamilyLexer(RegexLexer): 
-    """ 
-    For C family source code.  This is used as a base class to avoid repetitious 
-    definitions. 
-    """ 
- 
-    # The trailing ?, rather than *, avoids a geometric performance drop here. 
-    #: only one /* */ style comment 
-    _ws1 = r'\s*(?:/[*].*?[*]/\s*)?' 
- 
+
+__all__ = ['CLexer', 'CppLexer']
+
+
+class CFamilyLexer(RegexLexer):
+    """
+    For C family source code.  This is used as a base class to avoid repetitious
+    definitions.
+    """
+
+    # The trailing ?, rather than *, avoids a geometric performance drop here.
+    #: 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])*'
@@ -42,27 +42,27 @@ class CFamilyLexer(RegexLexer):
     _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 
+    tokens = {
+        'whitespace': [
+            # preprocessor directives: without whitespace
             (r'^#if\s+0', Comment.Preproc, 'if0'),
-            ('^#', Comment.Preproc, 'macro'), 
-            # or with whitespace 
-            ('^(' + _ws1 + r')(#if\s+0)', 
-             bygroups(using(this), Comment.Preproc), 'if0'), 
-            ('^(' + _ws1 + ')(#)', 
-             bygroups(using(this), Comment.Preproc), 'macro'), 
+            ('^#', Comment.Preproc, 'macro'),
+            # or with whitespace
+            ('^(' + _ws1 + r')(#if\s+0)',
+             bygroups(using(this), Comment.Preproc), 'if0'),
+            ('^(' + _ws1 + ')(#)',
+             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', Text),  # line continuation 
+            (r'\\\n', Text),  # line continuation
             (r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
             # Open until EOF, so no ending delimeter
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
-        ], 
-        'statements': [ 
+        ],
+        'statements': [
             include('keywords'),
             include('types'),
             (r'([LuU]|u8)?(")', bygroups(String.Affix, String), 'string'),
@@ -78,8 +78,8 @@ class CFamilyLexer(RegexLexer):
             (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'[~!%^&*+=|?:<>/-]', Operator),
+            (r'[()\[\],.]', Punctuation),
             (r'(true|false|NULL)\b', Name.Builtin),
             (_ident, Name)
         ],
@@ -96,101 +96,101 @@ class CFamilyLexer(RegexLexer):
                     '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', 
+                   suffix=r'\b'), Keyword),
+            (words(('inline', '_inline', '__inline', 'naked', 'restrict',
                     'thread'), suffix=r'\b'), Keyword.Reserved),
-            # Vector intrinsics 
-            (r'(__m(128i|128d|128|64))\b', Keyword.Reserved), 
-            # Microsoft-isms 
-            (words(( 
+            # 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',
-                'identifier', 'forceinline', 'assume'), 
+                'identifier', 'forceinline', 'assume'),
                 prefix=r'__', suffix=r'\b'), Keyword.Reserved)
-        ], 
-        'root': [ 
-            include('whitespace'), 
+        ],
+        'root': [
+            include('whitespace'),
             include('keywords'),
-            # functions 
+            # functions
             (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'([^;{]*)(\{)',
+             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'(\s*\([^;]*?\))'                          # signature
-             r'([^;]*)(;)', 
-             bygroups(using(this), Name.Function, using(this), using(this), 
-                      Punctuation)), 
+             r'([^;]*)(;)',
+             bygroups(using(this), Name.Function, using(this), using(this),
+                      Punctuation)),
             include('types'),
-            default('statement'), 
-        ], 
-        'statement': [ 
-            include('whitespace'), 
-            include('statements'), 
+            default('statement'),
+        ],
+        'statement': [
+            include('whitespace'),
+            include('statements'),
             (r'\}', Punctuation),
             (r'[{;]', Punctuation, '#pop'),
-        ], 
-        'function': [ 
-            include('whitespace'), 
-            include('statements'), 
-            (';', Punctuation), 
-            (r'\{', Punctuation, '#push'), 
-            (r'\}', Punctuation, '#pop'), 
-        ], 
-        'string': [ 
-            (r'"', String, '#pop'), 
-            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|' 
-             r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape), 
-            (r'[^\\"\n]+', String),  # all other characters 
-            (r'\\\n', String),  # line continuation 
-            (r'\\', String),  # stray backslash 
-        ], 
-        'macro': [ 
+        ],
+        'function': [
+            include('whitespace'),
+            include('statements'),
+            (';', Punctuation),
+            (r'\{', Punctuation, '#push'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|'
+             r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\\n', String),  # line continuation
+            (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'[^/\n]+', Comment.Preproc), 
-            (r'/[*](.|\n)*?[*]/', Comment.Multiline), 
-            (r'//.*?\n', Comment.Single, '#pop'), 
-            (r'/', Comment.Preproc), 
-            (r'(?<=\\)\n', Comment.Preproc), 
-            (r'\n', Comment.Preproc, '#pop'), 
-        ], 
-        'if0': [ 
-            (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'), 
-            (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'), 
-            (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'), 
-            (r'.*?\n', Comment), 
+            (r'[^/\n]+', Comment.Preproc),
+            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
+            (r'//.*?\n', Comment.Single, '#pop'),
+            (r'/', Comment.Preproc),
+            (r'(?<=\\)\n', Comment.Preproc),
+            (r'\n', Comment.Preproc, '#pop'),
+        ],
+        'if0': [
+            (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'),
+            (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')
-        ] 
-    } 
- 
+        ]
+    }
+
     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', 
+        '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',
-        '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', 
+        '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 = {
-        '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', 
+        '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', 
@@ -203,32 +203,32 @@ class CFamilyLexer(RegexLexer):
         '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) 
+
+    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.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True) 
-        RegexLexer.__init__(self, **options) 
- 
-    def get_tokens_unprocessed(self, text): 
-        for index, token, value in \ 
-                RegexLexer.get_tokens_unprocessed(self, text): 
-            if token is Name: 
-                if self.stdlibhighlighting and value in self.stdlib_types: 
-                    token = Keyword.Type 
-                elif self.c99highlighting and value in self.c99_types: 
-                    token = Keyword.Type 
+        self.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True)
+        RegexLexer.__init__(self, **options)
+
+    def get_tokens_unprocessed(self, text):
+        for index, token, value in \
+                RegexLexer.get_tokens_unprocessed(self, text):
+            if token is Name:
+                if self.stdlibhighlighting and value in self.stdlib_types:
+                    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.platformhighlighting and value in self.linux_types: 
-                    token = Keyword.Type 
-            yield index, token, value 
- 
- 
-class CLexer(CFamilyLexer): 
-    """ 
-    For C source code with preprocessor directives. 
+                elif self.platformhighlighting and value in self.linux_types:
+                    token = Keyword.Type
+            yield index, token, value
+
+
+class CLexer(CFamilyLexer):
+    """
+    For C source code with preprocessor directives.
 
     Additional options accepted:
 
@@ -248,13 +248,13 @@ class CLexer(CFamilyLexer):
     `platformhighlighting`
         Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
         (default: ``True``).
-    """ 
-    name = 'C' 
-    aliases = ['c'] 
+    """
+    name = 'C'
+    aliases = ['c']
     filenames = ['*.c', '*.h', '*.idc', '*.x[bp]m']
     mimetypes = ['text/x-chdr', 'text/x-csrc', 'image/x-xbitmap', 'image/x-xpixmap']
-    priority = 0.1 
- 
+    priority = 0.1
+
     tokens = {
         'keywords': [
             (words((
@@ -269,16 +269,16 @@ class CLexer(CFamilyLexer):
         ]
     }
 
-    def analyse_text(text): 
+    def analyse_text(text):
         if re.search(r'^\s*#include [<"]', text, re.MULTILINE):
-            return 0.1 
+            return 0.1
         if re.search(r'^\s*#ifn?def ', text, re.MULTILINE):
-            return 0.1 
- 
- 
-class CppLexer(CFamilyLexer): 
-    """ 
-    For C++ source code with preprocessor directives. 
+            return 0.1
+
+
+class CppLexer(CFamilyLexer):
+    """
+    For C++ source code with preprocessor directives.
 
     Additional options accepted:
 
@@ -298,39 +298,39 @@ class CppLexer(CFamilyLexer):
     `platformhighlighting`
         Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
         (default: ``True``).
-    """ 
-    name = 'C++' 
-    aliases = ['cpp', 'c++'] 
-    filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++', 
-                 '*.cc', '*.hh', '*.cxx', '*.hxx', 
-                 '*.C', '*.H', '*.cp', '*.CPP'] 
-    mimetypes = ['text/x-c++hdr', 'text/x-c++src'] 
-    priority = 0.1 
- 
-    tokens = { 
-        'statements': [ 
+    """
+    name = 'C++'
+    aliases = ['cpp', 'c++']
+    filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++',
+                 '*.cc', '*.hh', '*.cxx', '*.hxx',
+                 '*.C', '*.H', '*.cp', '*.CPP']
+    mimetypes = ['text/x-c++hdr', 'text/x-c++src']
+    priority = 0.1
+
+    tokens = {
+        'statements': [
             # C++11 raw strings
             (r'((?:[LuU]|u8)?R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
              bygroups(String.Affix, String, String.Delimiter, String.Delimiter,
                       String, String.Delimiter, String)),
-            inherit, 
-        ], 
-        'root': [ 
-            inherit, 
-            # C++ Microsoft-isms 
-            (words(('virtual_inheritance', 'uuidof', 'super', 'single_inheritance', 
-                    'multiple_inheritance', 'interface', 'event'), 
-                   prefix=r'__', suffix=r'\b'), Keyword.Reserved), 
-            # Offload C++ extensions, http://offload.codeplay.com/ 
-            (r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo), 
-        ], 
+            inherit,
+        ],
+        'root': [
+            inherit,
+            # C++ Microsoft-isms
+            (words(('virtual_inheritance', 'uuidof', 'super', 'single_inheritance',
+                    'multiple_inheritance', 'interface', 'event'),
+                   prefix=r'__', suffix=r'\b'), Keyword.Reserved),
+            # 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'),
-            # template specification 
-            (r'\s*(?=>)', Text, '#pop'), 
+            # template specification
+            (r'\s*(?=>)', Text, '#pop'),
             default('#pop')
         ],
         'keywords': [
@@ -359,10 +359,10 @@ class CppLexer(CFamilyLexer):
             (CFamilyLexer._ident, Name.Namespace),
             include('statement')
         ]
-    } 
- 
-    def analyse_text(text): 
+    }
+
+    def analyse_text(text):
         if re.search('#include <[a-z_]+>', text):
-            return 0.2 
-        if re.search('using namespace ', text): 
-            return 0.4 
+            return 0.2
+        if re.search('using namespace ', text):
+            return 0.4