pygments.rb 2.3.1 → 2.4.0

data/vendor/pygments-main/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-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -25,9 +25,6 @@ class CFamilyLexer(RegexLexer):
     definitions.
     """
 
-    #: optional Comment or Whitespace
-    _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
-
     # The trailing ?, rather than *, avoids a geometric performance drop here.
     #: only one /* */ style comment
     _ws1 = r'\s*(?:/[*].*?[*]/\s*)?'
@@ -42,8 +39,19 @@ class CFamilyLexer(RegexLexer):
     _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})*'
-    _namespaced_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}|::)*'
+    _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}|::)+'
+
+    # Single and multiline comment regexes
+    # Beware not to use *? for the inner content! When these regexes
+    # are embedded in larger regexes, that can cause the stuff*? to
+    # match more than it would have if the regex had been used in
+    # a standalone way ...
+    _comment_single = r'//(?:.|(?<=\\)\n)*\n'
+    _comment_multiline = r'/(?:\\\n)?[*](?:[^*]|[*](?!(?:\\\n)?/))*[*](?:\\\n)?/'
+
+    # Regex to match optional comments
+    _possible_comments = rf'\s*(?:(?:(?:{_comment_single})|(?:{_comment_multiline}))\s*)*'
 
     tokens = {
         'whitespace': [
@@ -55,12 +63,20 @@ class CFamilyLexer(RegexLexer):
              bygroups(using(this), Comment.Preproc), 'if0'),
             ('^(' + _ws1 + ')(#)',
              bygroups(using(this), Comment.Preproc), 'macro'),
+            # Labels:
+            # Line start and possible indentation.
+            (r'(^[ \t]*)'
+             # Not followed by keywords which can be mistaken as labels.
+             r'(?!(?:public|private|protected|default)\b)'
+             # Actual label, followed by a single colon.
+             r'(' + _ident + r')(\s*)(:)(?!:)',
+             bygroups(Whitespace, Name.Label, Whitespace, Punctuation)),
             (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),
-            # Open until EOF, so no ending delimeter
+            (_comment_single, Comment.Single),
+            (_comment_multiline, Comment.Multiline),
+            # Open until EOF, so no ending delimiter
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
@@ -71,10 +87,13 @@ class CFamilyLexer(RegexLexer):
              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'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'(-)?(' + _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),
@@ -82,7 +101,6 @@ class CFamilyLexer(RegexLexer):
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'[()\[\],.]', Punctuation),
             (r'(true|false|NULL)\b', Name.Builtin),
-            (r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
             (_ident, Name)
         ],
         'types': [
@@ -92,10 +110,11 @@ class CFamilyLexer(RegexLexer):
                     'unsigned', 'signed', 'void'), suffix=r'\b'), Keyword.Type)
         ],
         'keywords': [
-            (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', 'struct',
+            (r'(struct|union)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
+            (r'case\b', Keyword, 'case-value'),
+            (words(('asm', 'auto', 'break', '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'),
                    suffix=r'\b'), Keyword),
@@ -116,19 +135,30 @@ class CFamilyLexer(RegexLexer):
             include('keywords'),
             # functions
             (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
+             r'(' + _possible_comments + r')'
              r'(' + _namespaced_ident + r')'             # method name
-             r'(\s*\([^;]*?\))'            # signature
-             r'([^;{]*)(\{)',
-             bygroups(using(this), Name.Function, using(this), using(this),
-                      Punctuation),
+             r'(' + _possible_comments + r')'
+             r'(\([^;"\')]*?\))'                         # signature
+             r'(' + _possible_comments + r')'
+             r'([^;{/"\']*)(\{)',
+             bygroups(using(this), using(this, state='whitespace'),
+                      Name.Function, using(this, state='whitespace'),
+                      using(this), using(this, state='whitespace'),
+                      using(this), Punctuation),
              'function'),
             # function declarations
             (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
+             r'(' + _possible_comments + r')'
              r'(' + _namespaced_ident + r')'             # method name
-             r'(\s*\([^;]*?\))'            # signature
-             r'([^;]*)(;)',
-             bygroups(using(this), Name.Function, using(this), using(this),
-                      Punctuation)),
+             r'(' + _possible_comments + r')'
+             r'(\([^;"\')]*?\))'                         # signature
+             r'(' + _possible_comments + r')'
+             r'([^;/"\']*)(;)',
+             bygroups(using(this), using(this, state='whitespace'),
+                      Name.Function, using(this, state='whitespace'),
+                      using(this), using(this, state='whitespace'),
+                      using(this), Punctuation)),
+            include('types'),
             default('statement'),
         ],
         'statement': [
@@ -154,9 +184,11 @@ class CFamilyLexer(RegexLexer):
         ],
         'macro': [
             (r'('+_ws1+r')(include)('+_ws1+r')("[^"]+")([^\n]*)',
-                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
+                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)),
+                bygroups(using(this), Comment.Preproc, using(this),
+                         Comment.PreprocFile, Comment.Single)),
             (r'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (r'//.*?\n', Comment.Single, '#pop'),
@@ -175,6 +207,13 @@ class CFamilyLexer(RegexLexer):
             # template specification
             (r'\s*(?=>)', Text, '#pop'),
             default('#pop')
+        ],
+        # Mark identifiers preceded by `case` keyword as constants.
+        'case-value': [
+            (r'(?<!:)(:)(?!:)', Punctuation, '#pop'),
+            (_ident, Name.Constant),
+            include('whitespace'),
+            include('statements'),
         ]
     }
 
@@ -194,12 +233,12 @@ class CFamilyLexer(RegexLexer):
         '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_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_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_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',
@@ -212,9 +251,9 @@ class CFamilyLexer(RegexLexer):
         self.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True)
         RegexLexer.__init__(self, **options)
 
-    def get_tokens_unprocessed(self, text):
+    def get_tokens_unprocessed(self, text, stack=('root',)):
         for index, token, value in \
-                RegexLexer.get_tokens_unprocessed(self, text):
+                RegexLexer.get_tokens_unprocessed(self, text, stack):
             if token is Name:
                 if self.stdlibhighlighting and value in self.stdlib_types:
                     token = Keyword.Type
@@ -252,14 +291,14 @@ class CLexer(CFamilyLexer):
     """
     name = 'C'
     aliases = ['c']
-    filenames = ['*.c', '*.h', '*.idc']
-    mimetypes = ['text/x-chdr', 'text/x-csrc']
+    filenames = ['*.c', '*.h', '*.idc', '*.x[bp]m']
+    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', 
+                '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local',
                 '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'),
                 suffix=r'\b'), Keyword),
             inherit
@@ -301,10 +340,11 @@ class CppLexer(CFamilyLexer):
         (default: ``True``).
     """
     name = 'C++'
+    url = 'https://isocpp.org/'
     aliases = ['cpp', 'c++']
     filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++',
                  '*.cc', '*.hh', '*.cxx', '*.hxx',
-                 '*.C', '*.H', '*.cp', '*.CPP']
+                 '*.C', '*.H', '*.cp', '*.CPP', '*.tpp']
     mimetypes = ['text/x-c++hdr', 'text/x-c++src']
     priority = 0.1
 
@@ -335,19 +375,19 @@ class CppLexer(CFamilyLexer):
             default('#pop')
         ],
         'keywords': [
-            (r'(class|concept|typename)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (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', 
+                '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, Text), 'enumname'),
+            (r'(enum)(\s+)', bygroups(Keyword, Whitespace), 'enumname'),
             inherit
         ],
         'types': [

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

@@ -4,7 +4,7 @@
 
     Lexers for other C-like languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -38,10 +38,11 @@ class PikeLexer(CppLexer):
         'statements': [
             (words((
                 'catch', 'new', 'private', 'protected', 'public', 'gauge',
-                'throw', 'throws', 'class', 'interface', 'implement', 'abstract', 'extends', 'from',
-                'this', 'super', 'constant', 'final', 'static', 'import', 'use', 'extern',
-                'inline', 'proto', 'break', 'continue', 'if', 'else', 'for',
-                'while', 'do', 'switch', 'case', 'as', 'in', 'version', 'return', 'true', 'false', 'null',
+                'throw', 'throws', 'class', 'interface', 'implement', 'abstract',
+                'extends', 'from', 'this', 'super', 'constant', 'final', 'static',
+                'import', 'use', 'extern', 'inline', 'proto', 'break', 'continue',
+                'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'as', 'in',
+                'version', 'return', 'true', 'false', 'null',
                 '__VERSION__', '__MAJOR__', '__MINOR__', '__BUILD__', '__REAL_VERSION__',
                 '__REAL_MAJOR__', '__REAL_MINOR__', '__REAL_BUILD__', '__DATE__', '__TIME__',
                 '__FILE__', '__DIR__', '__LINE__', '__AUTO_BIGNUM__', '__NT__', '__PIKE__',
@@ -51,14 +52,14 @@ class PikeLexer(CppLexer):
              r'array|multiset|program|function|lambda|mixed|'
              r'[a-z_][a-z0-9_]*_t)\b',
              Keyword.Type),
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (r'(class)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
             (r'[~!%^&*+=|?:<>/@-]', Operator),
             inherit,
         ],
         'classname': [
             (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
             # template specification
-            (r'\s*(?=>)', Text, '#pop'),
+            (r'\s*(?=>)', Whitespace, '#pop'),
         ],
     }
 
@@ -104,7 +105,7 @@ class ClayLexer(RegexLexer):
     mimetypes = ['text/x-clay']
     tokens = {
         'root': [
-            (r'\s', Text),
+            (r'\s+', Whitespace),
             (r'//.*?$', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'\b(public|private|import|as|record|variant|instance'
@@ -126,7 +127,7 @@ class ClayLexer(RegexLexer):
         ],
         'strings': [
             (r'(?i)\\(x[0-9a-f]{2}|.)', String.Escape),
-            (r'.', String),
+            (r'[^\\"]+', String),
         ],
         'nl': [
             (r'\n', String),
@@ -169,7 +170,7 @@ class ECLexer(CLexer):
             (words(('uint', 'uint16', 'uint32', 'uint64', 'bool', 'byte',
                     'unichar', 'int64'), suffix=r'\b'),
              Keyword.Type),
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (r'(class)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
             (r'(null|value|this)\b', Name.Builtin),
             inherit,
         ]
@@ -190,8 +191,8 @@ class ValaLexer(RegexLexer):
     tokens = {
         'whitespace': [
             (r'^\s*#if\s+0', Comment.Preproc, 'if0'),
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
             (r'\\\n', Text),  # line continuation
             (r'//(\n|(.|\n)*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
@@ -226,10 +227,10 @@ class ValaLexer(RegexLexer):
                 'public', 'ref', 'requires', 'signal', 'static', 'throws', 'unowned',
                 'var', 'virtual', 'volatile', 'weak', 'yields'), suffix=r'\b'),
              Keyword.Declaration),
-            (r'(namespace|using)(\s+)', bygroups(Keyword.Namespace, Text),
+            (r'(namespace|using)(\s+)', bygroups(Keyword.Namespace, Whitespace),
              'namespace'),
             (r'(class|errordomain|interface|struct)(\s+)',
-             bygroups(Keyword.Declaration, Text), 'class'),
+             bygroups(Keyword.Declaration, Whitespace), 'class'),
             (r'(\.)([a-zA-Z_]\w*)',
              bygroups(Operator, Name.Attribute)),
             # void is an actual keyword, others are in glib-2.0.vapi
@@ -304,8 +305,8 @@ class CudaLexer(CLexer):
                  '__syncthreads_or'}
     execution_confs = {'<<<', '>>>'}
 
-    def get_tokens_unprocessed(self, text):
-        for index, token, value in CLexer.get_tokens_unprocessed(self, text):
+    def get_tokens_unprocessed(self, text, stack=('root',)):
+        for index, token, value in CLexer.get_tokens_unprocessed(self, text, stack):
             if token is Name:
                 if value in self.variable_qualifiers:
                     token = Keyword.Type
@@ -525,8 +526,8 @@ class ArduinoLexer(CppLexer):
         '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):
+    def get_tokens_unprocessed(self, text, stack=('root',)):
+        for index, token, value in CppLexer.get_tokens_unprocessed(self, text, stack):
             if value in self.structure:
                 yield index, Name.Builtin, value
             elif value in self.operators:
@@ -573,12 +574,13 @@ class CharmciLexer(CppLexer):
 
 class OmgIdlLexer(CLexer):
     """
-    Lexer for `Object Management Group Interface Definition Language <https://www.omg.org/spec/IDL/About-IDL/>`_.
+    Lexer for Object Management Group Interface Definition Language.
 
     .. versionadded:: 2.9
     """
 
     name = 'OMG Interface Definition Language'
+    url = 'https://www.omg.org/spec/IDL/About-IDL/'
     aliases = ['omg-idl']
     filenames = ['*.idl', '*.pidl']
     mimetypes = []

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

@@ -4,30 +4,27 @@
 
     Lexers for the Cap'n Proto schema language.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import re
-
 from pygments.lexer import RegexLexer, default
-from pygments.token import Text, Comment, Keyword, Name, Literal
+from pygments.token import Text, Comment, Keyword, Name, Literal, Whitespace
 
 __all__ = ['CapnProtoLexer']
 
 
 class CapnProtoLexer(RegexLexer):
     """
-    For `Cap'n Proto <https://capnproto.org>`_ source.
+    For Cap'n Proto source.
 
     .. versionadded:: 2.2
     """
     name = 'Cap\'n Proto'
+    url = 'https://capnproto.org'
     filenames = ['*.capnp']
     aliases = ['capnp']
 
-    flags = re.MULTILINE | re.UNICODE
-
     tokens = {
         'root': [
             (r'#.*?$', Comment.Single),
@@ -39,7 +36,8 @@ class CapnProtoLexer(RegexLexer):
              r'extends|in|of|on|as|with|from|fixed)\b',
              Keyword),
             (r'[\w.]+', Name),
-            (r'[^#@=:$\w]+', Text),
+            (r'[^#@=:$\w\s]+', Text),
+            (r'\s+', Whitespace),
         ],
         'type': [
             (r'[^][=;,(){}$]+', Name.Class),

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

@@ -0,0 +1,96 @@
+"""
+    pygments.lexers.carbon
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Carbon programming language.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+import re
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['CarbonLexer']
+
+
+class CarbonLexer(RegexLexer):
+    """
+    For Carbon source.
+
+    .. versionadded:: 2.15
+    """
+    name = 'Carbon'
+    url = 'https://github.com/carbon-language/carbon-lang'
+    filenames = ['*.carbon']
+    aliases = ['carbon']
+    mimetypes = ['text/x-carbon']
+
+    flags = re.MULTILINE | re.DOTALL
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'\\\n', Text),
+            # comments
+            (r'//(.*?)\n', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+            # Declaration
+            (r'(package|import|api|namespace|library)\b', Keyword.Namespace),
+            (r'(abstract|alias|fn|class|interface|let|var|virtual|external|'
+             r'base|addr|extends|choice|constraint|impl)\b', Keyword.Declaration),
+            # Keywords
+            (words(('as', 'or', 'not', 'and', 'break', 'continue', 'case',
+                    'default', 'if', 'else', 'destructor', 'for', 'forall',
+                    'while', 'where', 'then', 'in', 'is', 'return', 'returned',
+                    'friend', 'partial', 'private', 'protected', 'observe', 'Self',
+                    'override', 'final', 'match', 'type', 'like'), suffix=r'\b'), Keyword),
+            (r'(self)\b', Keyword.Pseudo),
+            (r'(true|false)\b', Keyword.Constant),
+            (r'(auto|bool|string|i8|i16|i32|i64|u8|u16|u32|u64|'
+             r'f8|f16|f32|f64)\b', Keyword.Type),
+            # numeric literals
+            (r'[0-9]*[.][0-9]+?', Number.Double),
+            (r'0b[01]+?', Number.Bin),
+            (r'0o[0-7]+?', Number.Oct),
+            (r'0x[0-9a-fA-F]+?', Number.Hex),
+            (r'[0-9]+?', Number.Integer),
+            # string literal
+            (r'"(\\.|[^"\\])*"', String),
+            # char literal
+            (r'\'(\\.|[^\'\\])\'', String.Char),
+            # tokens
+            (r'<<=|>>=|<<|>>|<=|>=|\+=|-=|\*=|/=|\%=|\|=|&=|\^=|&&|\|\||&|\||'
+             r'\+\+|--|\%|\^|\~|==|!=|::|[.]{3}|->|=>|[+\-*/&]', Operator),
+            (r'[|<>=!()\[\]{}.,;:\?]', Punctuation),
+            # identifiers
+            (r'[^\W\d]\w*', Name.Other),
+        ]
+    }
+
+    def analyse_text(text):
+        result = 0
+        if 'forall' in text:
+            result += 0.1
+        if 'type' in text:
+            result += 0.1
+        if 'Self' in text:
+            result += 0.1
+        if 'observe' in text:
+            result += 0.1
+        if 'package' in text:
+            result += 0.1
+        if 'library' in text:
+            result += 0.1
+        if 'choice' in text:
+            result += 0.1
+        if 'addr' in text:
+            result += 0.1
+        if 'constraint' in text:
+            result += 0.1
+        if 'impl' in text:
+            result += 0.1
+        return result

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

@@ -8,27 +8,16 @@
     More information:
     https://datatracker.ietf.org/doc/rfc8610/
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import re
+from pygments.lexer import RegexLexer, bygroups, include, words
+from pygments.token import Comment, Error, Keyword, Name, Number, Operator, \
+    Punctuation, String, Whitespace
 
 __all__ = ['CddlLexer']
 
-from pygments.lexer import RegexLexer, bygroups, include, words
-from pygments.token import (
-    Comment,
-    Error,
-    Keyword,
-    Name,
-    Number,
-    Operator,
-    Punctuation,
-    String,
-    Text,
-)
-
 
 class CddlLexer(RegexLexer):
     """
@@ -37,6 +26,7 @@ class CddlLexer(RegexLexer):
     .. versionadded:: 2.8
     """
     name = "CDDL"
+    url = 'https://datatracker.ietf.org/doc/rfc8610/'
     aliases = ["cddl"]
     filenames = ["*.cddl"]
     mimetypes = ["text/x-cddl"]
@@ -103,7 +93,8 @@ class CddlLexer(RegexLexer):
 
     _re_id = (
         r"[$@A-Z_a-z]"
-        r"(?:[\-\.]*[$@0-9A-Z_a-z]|[$@0-9A-Z_a-z])*"
+        r"(?:[\-\.]+(?=[$@0-9A-Z_a-z])|[$@0-9A-Z_a-z])*"
+
     )
 
     # While the spec reads more like "an int must not start with 0" we use a
@@ -112,15 +103,13 @@ class CddlLexer(RegexLexer):
     _re_uint = r"(?:0b[01]+|0x[0-9a-fA-F]+|[1-9]\d*|0(?!\d))"
     _re_int = r"-?" + _re_uint
 
-    flags = re.UNICODE | re.MULTILINE
-
     tokens = {
-        "commentsandwhitespace": [(r"\s+", Text), (r";.+$", Comment.Single)],
+        "commentsandwhitespace": [(r"\s+", Whitespace), (r";.+$", Comment.Single)],
         "root": [
             include("commentsandwhitespace"),
             # tag types
             (r"#(\d\.{uint})?".format(uint=_re_uint), Keyword.Type),  # type or any
-            # occurence
+            # occurrence
             (
                 r"({uint})?(\*)({uint})?".format(uint=_re_uint),
                 bygroups(Number, Operator, Number),
@@ -142,15 +131,11 @@ class CddlLexer(RegexLexer):
             # Barewords as member keys (must be matched before values, types, typenames,
             # groupnames).
             # Token type is String as barewords are always interpreted as such.
-            (
-                r"({bareword})(\s*)(:)".format(bareword=_re_id),
-                bygroups(String, Text, Punctuation),
-            ),
+            (r"({bareword})(\s*)(:)".format(bareword=_re_id),
+             bygroups(String, Whitespace, Punctuation)),
             # predefined types
-            (
-                words(_prelude_types, prefix=r"(?![\-_$@])\b", suffix=r"\b(?![\-_$@])"),
-                Name.Builtin,
-            ),
+            (words(_prelude_types, prefix=r"(?![\-_$@])\b", suffix=r"\b(?![\-_$@])"),
+             Name.Builtin),
             # user-defined groupnames, typenames
             (_re_id, Name.Class),
             # values
@@ -159,10 +144,8 @@ class CddlLexer(RegexLexer):
             (r"0x[0-9a-fA-F]+(\.[0-9a-fA-F]+)?p[+-]?\d+", Number.Hex),  # hexfloat
             (r"0x[0-9a-fA-F]+", Number.Hex),  # hex
             # Float
-            (
-                r"{int}(?=(\.\d|e[+-]?\d))(?:\.\d+)?(?:e[+-]?\d+)?".format(int=_re_int),
-                Number.Float,
-            ),
+            (r"{int}(?=(\.\d|e[+-]?\d))(?:\.\d+)?(?:e[+-]?\d+)?".format(int=_re_int),
+             Number.Float),
             # Int
             (_re_int, Number.Integer),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
@@ -185,6 +168,6 @@ class CddlLexer(RegexLexer):
         "bstr": [
             (r"'", String.Single, "#pop"),
             (r"\\.", String.Escape),
-            (r"[^']", String.Single),
+            (r"[^'\\]+", String.Single),
         ],
     }