pygments.rb 1.2.1 → 2.0.0

data/vendor/pygments-main/pygments/lexers/c_cpp.py

@@ -5,7 +5,7 @@
 
     Lexers for C/C++ languages.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -33,10 +33,22 @@ 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.
+    _ident = r'(?:[a-zA-Z_$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})(?:[\w$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})*'
+
     tokens = {
         'whitespace': [
             # preprocessor directives: without whitespace
-            ('^#if\s+0', Comment.Preproc, 'if0'),
+            (r'^#if\s+0', Comment.Preproc, 'if0'),
             ('^#', Comment.Preproc, 'macro'),
             # or with whitespace
             ('^(' + _ws1 + r')(#if\s+0)',
@@ -52,27 +64,33 @@ class CFamilyLexer(RegexLexer):
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
-            (r'(L?)(")', bygroups(String.Affix, String), 'string'),
-            (r"(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
+            (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)),
-            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
-            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
-            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
-            (r'0[0-7]+[LlUu]*', Number.Oct),
-            (r'\d+[LlUu]*', 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'\*/', Error),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'[()\[\],.]', Punctuation),
+            (r'(struct|union)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words(('asm', 'auto', 'break', 'case', 'const', 'continue',
                     'default', 'do', 'else', 'enum', 'extern', 'for', 'goto',
-                    'if', 'register', 'restricted', 'return', 'sizeof',
-                    'static', 'struct', 'switch', 'typedef', 'union',
-                    'volatile', 'while'),
+                    'if', 'register', 'restricted', 'return', 'sizeof', 'struct',
+                    'static', 'switch', 'typedef', 'volatile', 'while', 'union',
+                    'thread_local', 'alignas', 'alignof', 'static_assert', '_Pragma'),
                    suffix=r'\b'), Keyword),
             (r'(bool|int|long|float|short|double|char|unsigned|signed|void)\b',
              Keyword.Type),
             (words(('inline', '_inline', '__inline', 'naked', 'restrict',
-                    'thread', 'typename'), suffix=r'\b'), Keyword.Reserved),
+                    'thread'), suffix=r'\b'), Keyword.Reserved),
             # Vector intrinsics
             (r'(__m(128i|128d|128|64))\b', Keyword.Reserved),
             # Microsoft-isms
@@ -83,22 +101,22 @@ class CFamilyLexer(RegexLexer):
                 'identifier', 'forceinline', 'assume'),
                 prefix=r'__', suffix=r'\b'), Keyword.Reserved),
             (r'(true|false|NULL)\b', Name.Builtin),
-            (r'([a-zA-Z_]\w*)(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
-            ('[a-zA-Z_]\w*', Name),
+            (r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
+            (_ident, Name)
         ],
         'root': [
             include('whitespace'),
             # functions
-            (r'((?:[\w*\s])+?(?:\s|[*]))'  # return arguments
-             r'([a-zA-Z_]\w*)'             # method name
+            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
+             r'(' + _ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;{]*)(\{)',
              bygroups(using(this), Name.Function, using(this), using(this),
                       Punctuation),
              'function'),
             # function declarations
-            (r'((?:[\w*\s])+?(?:\s|[*]))'  # return arguments
-             r'([a-zA-Z_]\w*)'             # method name
+            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
+             r'(' + _ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;]*)(;)',
              bygroups(using(this), Name.Function, using(this), using(this),
@@ -108,8 +126,8 @@ class CFamilyLexer(RegexLexer):
         'statement': [
             include('whitespace'),
             include('statements'),
-            ('[{}]', Punctuation),
-            (';', Punctuation, '#pop'),
+            (r'\}', Punctuation),
+            (r'[{;]', Punctuation, '#pop'),
         ],
         'function': [
             include('whitespace'),
@@ -127,8 +145,8 @@ class CFamilyLexer(RegexLexer):
             (r'\\', String),  # stray backslash
         ],
         'macro': [
-            (r'(include)(' + _ws1 + r')([^\n]+)',
-             bygroups(Comment.Preproc, Text, Comment.PreprocFile)),
+            (r'(include)('+_ws1+r')("[^"]+")([^\n]*)', bygroups(Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
+            (r'(include)('+_ws1+r')(<[^>]+>)([^\n]*)', bygroups(Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
             (r'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (r'//.*?\n', Comment.Single, '#pop'),
@@ -141,28 +159,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')
         ]
     }
 
-    stdlib_types = set((
+    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 = set((
-        '_Bool', '_Complex', '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 = set((
+        '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'))
+        '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.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True)
         RegexLexer.__init__(self, **options)
 
@@ -174,6 +210,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.platformhighlighting and value in self.linux_types:
                     token = Keyword.Type
             yield index, token, value
@@ -182,6 +220,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``).
     """
     name = 'C'
     aliases = ['c']
@@ -189,16 +246,46 @@ class CLexer(CFamilyLexer):
     mimetypes = ['text/x-chdr', 'text/x-csrc']
     priority = 0.1
 
+    tokens = {
+        'statements': [
+            (words((
+                '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local', 
+                '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'),
+                suffix=r'\b'), Keyword),
+            (words(('_Bool', '_Complex', '_Atomic'), suffix=r'\b'), Keyword.Type),
+            inherit
+        ]
+    }
+
     def analyse_text(text):
-        if re.search('^\s*#include [<"]', text, re.MULTILINE):
+        if re.search(r'^\s*#include [<"]', text, re.MULTILINE):
             return 0.1
-        if re.search('^\s*#ifn?def ', text, re.MULTILINE):
+        if re.search(r'^\s*#ifn?def ', text, re.MULTILINE):
             return 0.1
 
 
 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``).
     """
     name = 'C++'
     aliases = ['cpp', 'c++']
@@ -210,23 +297,24 @@ class CppLexer(CFamilyLexer):
 
     tokens = {
         'statements': [
+            (r'(class|concept|typename)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words((
                 'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit',
                 'export', 'friend', 'mutable', 'namespace', 'new', 'operator',
-                'private', 'protected', 'public', 'reinterpret_cast',
+                'private', 'protected', 'public', 'reinterpret_cast', 'class',
                 'restrict', 'static_cast', 'template', 'this', 'throw', 'throws',
-                'try', 'typeid', 'typename', 'using', 'virtual',
-                'constexpr', 'nullptr', 'decltype', 'thread_local',
-                'alignas', 'alignof', 'static_assert', 'noexcept', 'override',
-                'final'), suffix=r'\b'), Keyword),
-            (r'char(16_t|32_t)\b', Keyword.Type),
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+                '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'char(16_t|32_t|8_t)\b', Keyword.Type),
+            (r'(enum)(\s+)', bygroups(Keyword, Text), 'enumname'),
+
             # C++11 raw strings
-            (r'(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)),
-            # C++11 UTF-8/16/32 strings
-            (r'(u8|u|U)(")', bygroups(String.Affix, String), 'string'),
             inherit,
         ],
         'root': [
@@ -238,11 +326,15 @@ class CppLexer(CFamilyLexer):
             # Offload C++ extensions, http://offload.codeplay.com/
             (r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo),
         ],
-        'classname': [
-            (r'[a-zA-Z_]\w*', 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')
+        ]
     }
 
     def analyse_text(text):

data/vendor/pygments-main/pygments/lexers/c_like.py

@@ -5,7 +5,7 @@
 
     Lexers for other C-like languages.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,7 +20,7 @@ from pygments.lexers.c_cpp import CLexer, CppLexer
 from pygments.lexers import _mql_builtins
 
 __all__ = ['PikeLexer', 'NesCLexer', 'ClayLexer', 'ECLexer', 'ValaLexer',
-           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer']
+           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer']
 
 
 class PikeLexer(CppLexer):
@@ -172,12 +172,7 @@ class ECLexer(CLexer):
             (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
             (r'(null|value|this)\b', Name.Builtin),
             inherit,
-        ],
-        'classname': [
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
-            # template specification
-            (r'\s*(?=>)', Text, '#pop'),
-        ],
+        ]
     }
 
 
@@ -245,7 +240,7 @@ class ValaLexer(RegexLexer):
                 'ulong', 'unichar', 'ushort'), suffix=r'\b'),
              Keyword.Type),
             (r'(true|false|null)\b', Name.Builtin),
-            ('[a-zA-Z_]\w*', Name),
+            (r'[a-zA-Z_]\w*', Name),
         ],
         'root': [
             include('whitespace'),
@@ -291,23 +286,23 @@ class CudaLexer(CLexer):
     aliases = ['cuda', 'cu']
     mimetypes = ['text/x-cuda']
 
-    function_qualifiers = set(('__device__', '__global__', '__host__',
-                               '__noinline__', '__forceinline__'))
-    variable_qualifiers = set(('__device__', '__constant__', '__shared__',
-                               '__restrict__'))
-    vector_types = set(('char1', 'uchar1', 'char2', 'uchar2', 'char3', 'uchar3',
-                        'char4', 'uchar4', 'short1', 'ushort1', 'short2', 'ushort2',
-                        'short3', 'ushort3', 'short4', 'ushort4', 'int1', 'uint1',
-                        'int2', 'uint2', 'int3', 'uint3', 'int4', 'uint4', 'long1',
-                        'ulong1', 'long2', 'ulong2', 'long3', 'ulong3', 'long4',
-                        'ulong4', 'longlong1', 'ulonglong1', 'longlong2',
-                        'ulonglong2', 'float1', 'float2', 'float3', 'float4',
-                        'double1', 'double2', 'dim3'))
-    variables = set(('gridDim', 'blockIdx', 'blockDim', 'threadIdx', 'warpSize'))
-    functions = set(('__threadfence_block', '__threadfence', '__threadfence_system',
-                     '__syncthreads', '__syncthreads_count', '__syncthreads_and',
-                     '__syncthreads_or'))
-    execution_confs = set(('<<<', '>>>'))
+    function_qualifiers = {'__device__', '__global__', '__host__',
+                           '__noinline__', '__forceinline__'}
+    variable_qualifiers = {'__device__', '__constant__', '__shared__',
+                           '__restrict__'}
+    vector_types = {'char1', 'uchar1', 'char2', 'uchar2', 'char3', 'uchar3',
+                    'char4', 'uchar4', 'short1', 'ushort1', 'short2', 'ushort2',
+                    'short3', 'ushort3', 'short4', 'ushort4', 'int1', 'uint1',
+                    'int2', 'uint2', 'int3', 'uint3', 'int4', 'uint4', 'long1',
+                    'ulong1', 'long2', 'ulong2', 'long3', 'ulong3', 'long4',
+                    'ulong4', 'longlong1', 'ulonglong1', 'longlong2',
+                    'ulonglong2', 'float1', 'float2', 'float3', 'float4',
+                    'double1', 'double2', 'dim3'}
+    variables = {'gridDim', 'blockIdx', 'blockDim', 'threadIdx', 'warpSize'}
+    functions = {'__threadfence_block', '__threadfence', '__threadfence_system',
+                 '__syncthreads', '__syncthreads_count', '__syncthreads_and',
+                 '__syncthreads_or'}
+    execution_confs = {'<<<', '>>>'}
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in CLexer.get_tokens_unprocessed(self, text):
@@ -344,7 +339,7 @@ class SwigLexer(CppLexer):
             # SWIG directives
             (r'(%[a-z_][a-z0-9_]*)', Name.Function),
             # Special variables
-            ('\$\**\&?\w+', Name),
+            (r'\$\**\&?\w+', Name),
             # Stringification / additional preprocessor directives
             (r'##*[a-zA-Z_]\w*', Comment.Preproc),
             inherit,
@@ -352,7 +347,7 @@ class SwigLexer(CppLexer):
     }
 
     # This is a far from complete set of SWIG directives
-    swig_directives = set((
+    swig_directives = {
         # Most common directives
         '%apply', '%define', '%director', '%enddef', '%exception', '%extend',
         '%feature', '%fragment', '%ignore', '%immutable', '%import', '%include',
@@ -371,7 +366,7 @@ class SwigLexer(CppLexer):
         '%pythoncallback', '%pythoncode', '%pythondynamic', '%pythonmaybecall',
         '%pythonnondynamic', '%pythonprepend', '%refobject', '%shadow', '%sizeof',
         '%trackobjects', '%types', '%unrefobject', '%varargs', '%warn',
-        '%warnfilter'))
+        '%warnfilter'}
 
     def analyse_text(text):
         rv = 0
@@ -412,6 +407,7 @@ class MqlLexer(CppLexer):
         ],
     }
 
+
 class ArduinoLexer(CppLexer):
     """
     For `Arduino(tm) <https://arduino.cc/>`_ source.
@@ -428,13 +424,13 @@ class ArduinoLexer(CppLexer):
     mimetypes = ['text/x-arduino']
 
     # Language sketch main structure functions
-    structure = set(('setup', 'loop'))
+    structure = {'setup', 'loop'}
 
     # Language operators
-    operators = set(('not', 'or', 'and', 'xor'))
+    operators = {'not', 'or', 'and', 'xor'}
 
     # Language 'variables'
-    variables = set((
+    variables = {
         'DIGITAL_MESSAGE', 'FIRMATA_STRING', 'ANALOG_MESSAGE', 'REPORT_DIGITAL',
         'REPORT_ANALOG', 'INPUT_PULLUP', 'SET_PIN_MODE', 'INTERNAL2V56', 'SYSTEM_RESET',
         'LED_BUILTIN', 'INTERNAL1V1', 'SYSEX_START', 'INTERNAL', 'EXTERNAL', 'HIGH',
@@ -451,10 +447,10 @@ class ArduinoLexer(CppLexer):
         'signed', 'inline', 'delete', '_Bool', 'complex', '_Complex', '_Imaginary',
         'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short',
         'atomic_ushort', 'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong',
-        'atomic_llong', 'atomic_ullong', 'PROGMEM'))
+        'atomic_llong', 'atomic_ullong', 'PROGMEM'}
 
     # Language shipped functions and class ( )
-    functions = set((
+    functions = {
         'KeyboardController', 'MouseController', 'SoftwareSerial', 'EthernetServer',
         'EthernetClient', 'LiquidCrystal', 'RobotControl', 'GSMVoiceCall',
         'EthernetUDP', 'EsploraTFT', 'HttpClient', 'RobotMotor', 'WiFiClient',
@@ -514,16 +510,15 @@ class ArduinoLexer(CppLexer):
         'peek', 'beep', 'rect', 'line', 'open', 'seek', 'fill', 'size', 'turn', 'stop',
         'home', 'find', 'step', 'tone', 'sqrt', 'RSSI', 'SSID', 'end', 'bit', 'tan',
         'cos', 'sin', 'pow', 'map', 'abs', 'max', 'min', 'get', 'run', 'put',
-        'isAlphaNumeric', 'isAlpha', 'isAscii', 'isWhitespace', 'isControl', 'isDigit', 
-        'isGraph', 'isLowerCase', 'isPrintable', 'isPunct', 'isSpace', 'isUpperCase', 
-        'isHexadecimalDigit'))    
+        'isAlphaNumeric', 'isAlpha', 'isAscii', 'isWhitespace', 'isControl', 'isDigit',
+        'isGraph', 'isLowerCase', 'isPrintable', 'isPunct', 'isSpace', 'isUpperCase',
+        'isHexadecimalDigit'}
 
     # do not highlight
-    suppress_highlight = set((
-        'namespace', 'template', 'mutable', 'using', 'asm', 'typeid', 
-        'typename', 'this', 'alignof', 'constexpr', 'decltype', 'noexcept', 
-        'static_assert', 'thread_local', 'restrict'))
-
+    suppress_highlight = {
+        'namespace', 'template', 'mutable', 'using', 'asm', 'typeid',
+        'typename', 'this', 'alignof', 'constexpr', 'decltype', 'noexcept',
+        'static_assert', 'thread_local', 'restrict'}
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in CppLexer.get_tokens_unprocessed(self, text):
@@ -539,3 +534,33 @@ class ArduinoLexer(CppLexer):
                 yield index, Name.Function, value
             else:
                 yield index, token, value
+
+
+class CharmciLexer(CppLexer):
+    """
+    For `Charm++ <https://charm.cs.illinois.edu>`_ interface files (.ci).
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'Charmci'
+    aliases = ['charmci']
+    filenames = ['*.ci']
+
+    mimetypes = []
+
+    tokens = {
+        'statements': [
+            (r'(module)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (words(('mainmodule', 'mainchare', 'chare', 'array', 'group',
+                    'nodegroup', 'message', 'conditional')), Keyword),
+            (words(('entry', 'aggregate', 'threaded', 'sync', 'exclusive',
+                    'nokeep', 'notrace', 'immediate', 'expedited', 'inline',
+                    'local', 'python', 'accel', 'readwrite', 'writeonly',
+                    'accelblock', 'memcritical', 'packed', 'varsize',
+                    'initproc', 'initnode', 'initcall', 'stacksize',
+                    'createhere', 'createhome', 'reductiontarget', 'iget',
+                    'nocopy', 'mutable', 'migratable', 'readonly')), Keyword),
+            inherit,
+        ],
+    }

data/vendor/pygments-main/pygments/lexers/capnproto.py

@@ -5,7 +5,7 @@
 
     Lexers for the Cap'n Proto schema language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -44,34 +44,34 @@ class CapnProtoLexer(RegexLexer):
         ],
         'type': [
             (r'[^][=;,(){}$]+', Name.Class),
-            (r'[[(]', Name.Class, 'parentype'),
+            (r'[\[(]', Name.Class, 'parentype'),
             default('#pop'),
         ],
         'parentype': [
             (r'[^][;()]+', Name.Class),
-            (r'[[(]', Name.Class, '#push'),
+            (r'[\[(]', Name.Class, '#push'),
             (r'[])]', Name.Class, '#pop'),
             default('#pop'),
         ],
         'expression': [
             (r'[^][;,(){}$]+', Literal),
-            (r'[[(]', Literal, 'parenexp'),
+            (r'[\[(]', Literal, 'parenexp'),
             default('#pop'),
         ],
         'parenexp': [
             (r'[^][;()]+', Literal),
-            (r'[[(]', Literal, '#push'),
+            (r'[\[(]', Literal, '#push'),
             (r'[])]', Literal, '#pop'),
             default('#pop'),
         ],
         'annotation': [
             (r'[^][;,(){}=:]+', Name.Attribute),
-            (r'[[(]', Name.Attribute, 'annexp'),
+            (r'[\[(]', Name.Attribute, 'annexp'),
             default('#pop'),
         ],
         'annexp': [
             (r'[^][;()]+', Name.Attribute),
-            (r'[[(]', Name.Attribute, '#push'),
+            (r'[\[(]', Name.Attribute, '#push'),
             (r'[])]', Name.Attribute, '#pop'),
             default('#pop'),
         ],

data/vendor/pygments-main/pygments/lexers/chapel.py

@@ -5,7 +5,7 @@
 
     Lexer for the Chapel language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -18,7 +18,7 @@ __all__ = ['ChapelLexer']
 
 class ChapelLexer(RegexLexer):
     """
-    For `Chapel <http://chapel.cray.com/>`_ source.
+    For `Chapel <https://chapel-lang.org/>`_ source.
 
     .. versionadded:: 2.0
     """
@@ -38,20 +38,30 @@ class ChapelLexer(RegexLexer):
 
             (r'(config|const|in|inout|out|param|ref|type|var)\b',
              Keyword.Declaration),
-            (r'(false|nil|true)\b', Keyword.Constant),
-            (r'(bool|complex|imag|int|opaque|range|real|string|uint)\b',
+            (r'(false|nil|none|true)\b', Keyword.Constant),
+            (r'(bool|bytes|complex|imag|int|nothing|opaque|range|real|string|uint|void)\b',
              Keyword.Type),
             (words((
-                'align', 'as', 'atomic', 'begin', 'break', 'by', 'cobegin',
-                'coforall', 'continue', 'delete', 'dmapped', 'do', 'domain',
-                'else', 'enum', 'except', 'export', 'extern', 'for', 'forall',
-                'if', 'index', 'inline', 'iter', 'label', 'lambda', 'let',
-                'local', 'new', 'noinit', 'on', 'only', 'otherwise', 'pragma',
-                'private', 'public', 'reduce', 'require', 'return', 'scan',
-                'select', 'serial', 'single', 'sparse', 'subdomain', 'sync',
-                'then', 'use', 'when', 'where', 'while', 'with', 'yield',
+                'align', 'as', 'atomic',
+                'begin', 'borrowed', 'break', 'by',
+                'catch', 'cobegin', 'coforall', 'continue',
+                'defer', 'delete', 'dmapped', 'do', 'domain',
+                'else', 'enum', 'except', 'export', 'extern',
+                'for', 'forall', 'forwarding',
+                'if', 'import', 'index', 'init', 'inline',
+                'label', 'lambda', 'let', 'lifetime', 'local', 'locale'
+                'new', 'noinit',
+                'on', 'only', 'otherwise', 'override', 'owned',
+                'pragma', 'private', 'prototype', 'public',
+                'reduce', 'require', 'return',
+                'scan', 'select', 'serial', 'shared', 'single', 'sparse', 'subdomain', 'sync',
+                'then', 'this', 'throw', 'throws', 'try',
+                'unmanaged', 'use',
+                'when', 'where', 'while', 'with',
+                'yield',
                 'zip'), suffix=r'\b'),
              Keyword),
+            (r'(iter)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
             (r'(proc)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
             (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text),
              'classname'),
@@ -96,7 +106,7 @@ class ChapelLexer(RegexLexer):
             (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'),
         ],
         'procname': [
-            (r'([a-zA-Z_][\w$]+|\~[a-zA-Z_][\w$]+|[+*/!~%<>=&^|\-]{1,2})',
+            (r'([a-zA-Z_][.\w$]*|\~[a-zA-Z_][.\w$]*|[+*/!~%<>=&^|\-]{1,2})',
              Name.Function, '#pop'),
         ],
     }