pygments.rb 2.3.1 → 2.4.0

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

@@ -4,7 +4,7 @@
 
     Lexers for ActionScript and MXML.
 
-    :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.
 """
 
@@ -12,7 +12,7 @@ import re
 
 from pygments.lexer import RegexLexer, bygroups, using, this, words, default
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['ActionScriptLexer', 'ActionScript3Lexer', 'MxmlLexer']
 
@@ -33,7 +33,7 @@ class ActionScriptLexer(RegexLexer):
     flags = re.DOTALL
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'//.*?\n', Comment.Single),
             (r'/\*.*?\*/', Comment.Multiline),
             (r'/(\\\\|\\[^\\]|[^/\\\n])*/[gim]*', String.Regex),
@@ -123,6 +123,7 @@ class ActionScript3Lexer(RegexLexer):
     """
 
     name = 'ActionScript 3'
+    url = 'https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/index.html'
     aliases = ['actionscript3', 'as3']
     filenames = ['*.as']
     mimetypes = ['application/x-actionscript3', 'text/x-actionscript3',
@@ -134,18 +135,18 @@ class ActionScript3Lexer(RegexLexer):
     flags = re.DOTALL | re.MULTILINE
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'(function\s+)(' + identifier + r')(\s*)(\()',
              bygroups(Keyword.Declaration, Name.Function, Text, Operator),
              'funcparams'),
             (r'(var|const)(\s+)(' + identifier + r')(\s*)(:)(\s*)(' +
              typeidentifier + r')',
-             bygroups(Keyword.Declaration, Text, Name, Text, Punctuation, Text,
+             bygroups(Keyword.Declaration, Whitespace, Name, Whitespace, Punctuation, Whitespace,
                       Keyword.Type)),
             (r'(import|package)(\s+)((?:' + identifier + r'|\.)+)(\s*)',
-             bygroups(Keyword, Text, Name.Namespace, Text)),
+             bygroups(Keyword, Whitespace, Name.Namespace, Whitespace)),
             (r'(new)(\s+)(' + typeidentifier + r')(\s*)(\()',
-             bygroups(Keyword, Text, Keyword.Type, Text, Operator)),
+             bygroups(Keyword, Whitespace, Keyword.Type, Whitespace, Operator)),
             (r'//.*?\n', Comment.Single),
             (r'/\*.*?\*/', Comment.Multiline),
             (r'/(\\\\|\\[^\\]|[^\\\n])*/[gisx]*', String.Regex),
@@ -173,22 +174,22 @@ class ActionScript3Lexer(RegexLexer):
             (r'[~^*!%&<>|+=:;,/?\\{}\[\]().-]+', Operator),
         ],
         'funcparams': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'(\s*)(\.\.\.)?(' + identifier + r')(\s*)(:)(\s*)(' +
              typeidentifier + r'|\*)(\s*)',
-             bygroups(Text, Punctuation, Name, Text, Operator, Text,
-                      Keyword.Type, Text), 'defval'),
+             bygroups(Whitespace, Punctuation, Name, Whitespace, Operator, Whitespace,
+                      Keyword.Type, Whitespace), 'defval'),
             (r'\)', Operator, 'type')
         ],
         'type': [
             (r'(\s*)(:)(\s*)(' + typeidentifier + r'|\*)',
-             bygroups(Text, Operator, Text, Keyword.Type), '#pop:2'),
+             bygroups(Whitespace, Operator, Whitespace, Keyword.Type), '#pop:2'),
             (r'\s+', Text, '#pop:2'),
             default('#pop:2')
         ],
         'defval': [
             (r'(=)(\s*)([^(),]+)(\s*)(,?)',
-             bygroups(Operator, Text, using(this), Text, Operator), '#pop'),
+             bygroups(Operator, Whitespace, using(this), Whitespace, Operator), '#pop'),
             (r',', Operator, '#pop'),
             default('#pop')
         ]
@@ -231,12 +232,12 @@ class MxmlLexer(RegexLexer):
             ('-', Comment),
         ],
         'tag': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[\w.:-]+\s*=', Name.Attribute, 'attr'),
             (r'/?\s*>', Name.Tag, '#pop'),
         ],
         'attr': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             ('".*?"', String, '#pop'),
             ("'.*?'", String, '#pop'),
             (r'[^\s>]+', String, '#pop'),

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

@@ -0,0 +1,144 @@
+"""
+    pygments.lexers.ada
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Ada family languages.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, words, using, this, \
+    default
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation
+from pygments.lexers._ada_builtins import KEYWORD_LIST, BUILTIN_LIST
+
+__all__ = ['AdaLexer']
+
+
+class AdaLexer(RegexLexer):
+    """
+    For Ada source code.
+
+    .. versionadded:: 1.3
+    """
+
+    name = 'Ada'
+    aliases = ['ada', 'ada95', 'ada2005']
+    filenames = ['*.adb', '*.ads', '*.ada']
+    mimetypes = ['text/x-ada']
+
+    flags = re.MULTILINE | re.IGNORECASE
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'--.*?\n', Comment.Single),
+            (r'[^\S\n]+', Text),
+            (r'function|procedure|entry', Keyword.Declaration, 'subprogram'),
+            (r'(subtype|type)(\s+)(\w+)',
+             bygroups(Keyword.Declaration, Text, Keyword.Type), 'type_def'),
+            (r'task|protected', Keyword.Declaration),
+            (r'(subtype)(\s+)', bygroups(Keyword.Declaration, Text)),
+            (r'(end)(\s+)', bygroups(Keyword.Reserved, Text), 'end'),
+            (r'(pragma)(\s+)(\w+)', bygroups(Keyword.Reserved, Text,
+                                             Comment.Preproc)),
+            (r'(true|false|null)\b', Keyword.Constant),
+            # builtin types
+            (words(BUILTIN_LIST, suffix=r'\b'), Keyword.Type),
+            (r'(and(\s+then)?|in|mod|not|or(\s+else)|rem)\b', Operator.Word),
+            (r'generic|private', Keyword.Declaration),
+            (r'package', Keyword.Declaration, 'package'),
+            (r'array\b', Keyword.Reserved, 'array_def'),
+            (r'(with|use)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+            (r'(\w+)(\s*)(:)(\s*)(constant)',
+             bygroups(Name.Constant, Text, Punctuation, Text,
+                      Keyword.Reserved)),
+            (r'<<\w+>>', Name.Label),
+            (r'(\w+)(\s*)(:)(\s*)(declare|begin|loop|for|while)',
+             bygroups(Name.Label, Text, Punctuation, Text, Keyword.Reserved)),
+            # keywords
+            (words(KEYWORD_LIST, prefix=r'\b', suffix=r'\b'),
+             Keyword.Reserved),
+            (r'"[^"]*"', String),
+            include('attribute'),
+            include('numbers'),
+            (r"'[^']'", String.Character),
+            (r'(\w+)(\s*|[(,])', bygroups(Name, using(this))),
+            (r"(<>|=>|:=|@|[\[\]]|[()|:;,.'])", Punctuation),
+            (r'[*<>+=/&-]', Operator),
+            (r'\n+', Text),
+        ],
+        'numbers': [
+            (r'[0-9_]+#[0-9a-f_\.]+#', Number.Hex),
+            (r'[0-9_]+\.[0-9_]*', Number.Float),
+            (r'[0-9_]+', Number.Integer),
+        ],
+        'attribute': [
+            (r"(')(\w+)", bygroups(Punctuation, Name.Attribute)),
+        ],
+        'subprogram': [
+            (r'\(', Punctuation, ('#pop', 'formal_part')),
+            (r';', Punctuation, '#pop'),
+            (r'is\b', Keyword.Reserved, '#pop'),
+            (r'"[^"]+"|\w+', Name.Function),
+            include('root'),
+        ],
+        'end': [
+            ('(if|case|record|loop|select)', Keyword.Reserved),
+            (r'"[^"]+"|[\w.]+', Name.Function),
+            (r'\s+', Text),
+            (';', Punctuation, '#pop'),
+        ],
+        'type_def': [
+            (r';', Punctuation, '#pop'),
+            (r'\(', Punctuation, 'formal_part'),
+            (r'\[', Punctuation, 'formal_part'),
+            (r'with|and|use', Keyword.Reserved),
+            (r'array\b', Keyword.Reserved, ('#pop', 'array_def')),
+            (r'record\b', Keyword.Reserved, ('record_def')),
+            (r'(null record)(;)', bygroups(Keyword.Reserved, Punctuation), '#pop'),
+            include('root'),
+        ],
+        'array_def': [
+            (r';', Punctuation, '#pop'),
+            (r'(\w+)(\s+)(range)', bygroups(Keyword.Type, Text, Keyword.Reserved)),
+            include('root'),
+        ],
+        'record_def': [
+            (r'end record', Keyword.Reserved, '#pop'),
+            include('root'),
+        ],
+        'import': [
+            # TODO: use Name.Namespace if appropriate.  This needs
+            # work to disinguish imports from aspects.
+            (r'[\w.]+', Name, '#pop'),
+            default('#pop'),
+        ],
+        'formal_part': [
+            (r'\)', Punctuation, '#pop'),
+            (r'\]', Punctuation, '#pop'),
+            (r'\w+', Name.Variable),
+            (r',|:[^=]', Punctuation),
+            (r'(in|not|null|out|access)\b', Keyword.Reserved),
+            include('root'),
+        ],
+        'package': [
+            ('body', Keyword.Declaration),
+            (r'is\s+new|renames', Keyword.Reserved),
+            ('is', Keyword.Reserved, '#pop'),
+            (';', Punctuation, '#pop'),
+            (r'\(', Punctuation, 'package_instantiation'),
+            (r'([\w.]+)', Name.Class),
+            include('root'),
+        ],
+        'package_instantiation': [
+            (r'("[^"]+"|\w+)(\s+)(=>)', bygroups(Name.Variable, Text, Punctuation)),
+            (r'[\w.\'"]', Text),
+            (r'\)', Punctuation, '#pop'),
+            include('root'),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Just export lexer classes previously contained in this module.
 
-    :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.
 """
 

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

@@ -4,26 +4,28 @@
 
     Lexers for computer algebra systems.
 
-    :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, words
+from pygments.lexer import Lexer, RegexLexer, bygroups, do_insertions, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Generic, Whitespace
 
-__all__ = ['GAPLexer', 'MathematicaLexer', 'MuPADLexer', 'BCLexer']
+__all__ = ['GAPLexer', 'GAPConsoleLexer', 'MathematicaLexer', 'MuPADLexer',
+           'BCLexer']
 
 
 class GAPLexer(RegexLexer):
     """
-    For `GAP <http://www.gap-system.org>`_ source code.
+    For GAP source code.
 
     .. versionadded:: 2.0
     """
     name = 'GAP'
+    url = 'http://www.gap-system.org'
     aliases = ['gap']
     filenames = ['*.g', '*.gd', '*.gi', '*.gap']
 
@@ -87,13 +89,71 @@ class GAPLexer(RegexLexer):
         return min(score, 1.0)
 
 
+class GAPConsoleLexer(Lexer):
+    """
+    For GAP console sessions. Modeled after JuliaConsoleLexer.
+
+    .. versionadded:: 2.14
+    """
+    name = 'GAP session'
+    aliases = ['gap-console', 'gap-repl']
+    filenames = ['*.tst']
+
+    def get_tokens_unprocessed(self, text):
+        gaplexer = GAPLexer(**self.options)
+        start = 0
+        curcode = ''
+        insertions = []
+        output = False
+        error = False
+
+        for line in text.splitlines(keepends=True):
+            if line.startswith('gap> ') or line.startswith('brk> '):
+                insertions.append((len(curcode), [(0, Generic.Prompt, line[:5])]))
+                curcode += line[5:]
+                output = False
+                error = False
+            elif not output and line.startswith('> '):
+                insertions.append((len(curcode), [(0, Generic.Prompt, line[:2])]))
+                curcode += line[2:]
+            else:
+                if curcode:
+                    yield from do_insertions(
+                        insertions, gaplexer.get_tokens_unprocessed(curcode))
+                    curcode = ''
+                    insertions = []
+                if line.startswith('Error, ') or error:
+                    yield start, Generic.Error, line
+                    error = True
+                else:
+                    yield start, Generic.Output, line
+                output = True
+            start += len(line)
+
+        if curcode:
+            yield from do_insertions(
+                insertions, gaplexer.get_tokens_unprocessed(curcode))
+
+    # the following is needed to distinguish Scilab and GAP .tst files
+    def analyse_text(text):
+        # GAP prompts are a dead give away, although hypothetical;y a
+        # file in another language could be trying to compare a variable
+        # "gap" as in "gap> 0.1". But that this should happen at the
+        # start of a line seems unlikely...
+        if re.search(r"^gap> ", text):
+            return 0.9
+        else:
+            return 0.0
+
+
 class MathematicaLexer(RegexLexer):
     """
-    Lexer for `Mathematica <http://www.wolfram.com/mathematica/>`_ source code.
+    Lexer for Mathematica source code.
 
     .. versionadded:: 2.0
     """
     name = 'Mathematica'
+    url = 'http://www.wolfram.com/mathematica/'
     aliases = ['mathematica', 'mma', 'nb']
     filenames = ['*.nb', '*.cdf', '*.nbp', '*.ma']
     mimetypes = ['application/mathematica',
@@ -136,12 +196,13 @@ class MathematicaLexer(RegexLexer):
 
 class MuPADLexer(RegexLexer):
     """
-    A `MuPAD <http://www.mupad.com>`_ lexer.
+    A MuPAD lexer.
     Contributed by Christopher Creutzig <christopher@creutzig.de>.
 
     .. versionadded:: 0.8
     """
     name = 'MuPAD'
+    url = 'http://www.mupad.com'
     aliases = ['mupad']
     filenames = ['*.mu']
 
@@ -194,10 +255,11 @@ class MuPADLexer(RegexLexer):
               (?:::[a-zA-Z_#][\w#]*|`[^`]*`)*''', Name.Variable),
             (r'[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?', Number),
             (r'\.[0-9]+(?:e[0-9]+)?', Number),
+            (r'\s+', Whitespace),
             (r'.', Text)
         ],
         'comment': [
-            (r'[^*/]', Comment.Multiline),
+            (r'[^/*]+', Comment.Multiline),
             (r'/\*', Comment.Multiline, '#push'),
             (r'\*/', Comment.Multiline, '#pop'),
             (r'[*/]', Comment.Multiline)
@@ -207,11 +269,12 @@ class MuPADLexer(RegexLexer):
 
 class BCLexer(RegexLexer):
     """
-    A `BC <https://www.gnu.org/software/bc/>`_ lexer.
+    A BC lexer.
 
     .. versionadded:: 2.1
     """
     name = 'BC'
+    url = 'https://www.gnu.org/software/bc/'
     aliases = ['bc']
     filenames = ['*.bc']
 

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

@@ -4,26 +4,27 @@
 
     Lexers for AmbientTalk 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, include, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.lexer import RegexLexer, include, words, bygroups
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
 
 __all__ = ['AmbientTalkLexer']
 
 
 class AmbientTalkLexer(RegexLexer):
     """
-    Lexer for `AmbientTalk <https://code.google.com/p/ambienttalk>`_ source code.
+    Lexer for AmbientTalk source code.
 
     .. versionadded:: 2.0
     """
     name = 'AmbientTalk'
+    url = 'https://code.google.com/p/ambienttalk'
     filenames = ['*.at']
     aliases = ['ambienttalk', 'ambienttalk/2', 'at']
     mimetypes = ['text/x-ambienttalk']
@@ -36,7 +37,7 @@ class AmbientTalkLexer(RegexLexer):
                      'mirroredBy:', 'is:'))
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'//.*?\n', Comment.Single),
             (r'/\*.*?\*/', Comment.Multiline),
             (r'(def|deftype|import|alias|exclude)\b', Keyword),
@@ -69,7 +70,7 @@ class AmbientTalkLexer(RegexLexer):
         ],
         'arglist': [
             (r'\|', Punctuation, '#pop'),
-            (r'\s*(,)\s*', Punctuation),
+            (r'(\s*)(,)(\s*)', bygroups(Whitespace, Punctuation, Whitespace)),
             (r'[a-zA-Z_]\w*', Name.Variable),
         ],
     }

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

@@ -4,7 +4,7 @@
 
     Lexers for the AMDGPU ISA assembly.
 
-    :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.
 """
 
@@ -35,11 +35,12 @@ class AMDGPULexer(RegexLexer):
             (r'(([a-z_0-9])*:([a-z_0-9])*)', Name.Attribute),
             (r'(\[|\]|\(|\)|,|\:|\&)', Text),
             (r'([;#]|//).*?\n', Comment.Single),
-            (r'((s_)?(ds|buffer|flat|image)_[a-z0-9_]+)', Keyword.Reserved),
+            (r'((s_)?(scratch|ds|buffer|flat|image)_[a-z0-9_]+)', Keyword.Reserved),
             (r'(_lo|_hi)', Name.Variable),
             (r'(vmcnt|lgkmcnt|expcnt)', Name.Attribute),
+            (r'(attr[0-9].[a-z])', Name.Attribute),
             (words((
-                'op', 'vaddr', 'vdata', 'soffset', 'srsrc', 'format',
+                'op', 'vaddr', 'vdata', 'off', 'soffset', 'srsrc', 'format',
                 'offset', 'offen', 'idxen', 'glc', 'dlc', 'slc', 'tfe', 'lds',
                 'lit', 'unorm'), suffix=r'\b'), Name.Attribute),
             (r'(label_[a-z0-9]+)', Keyword),

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

@@ -4,31 +4,32 @@
 
     Lexers for the AMPL 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.
 """
 
 from pygments.lexer import RegexLexer, bygroups, using, this, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['AmplLexer']
 
 
 class AmplLexer(RegexLexer):
     """
-    For `AMPL <http://ampl.com/>`_ source code.
+    For AMPL source code.
 
     .. versionadded:: 2.2
     """
     name = 'Ampl'
+    url = 'http://ampl.com/'
     aliases = ['ampl']
     filenames = ['*.run']
 
     tokens = {
         'root': [
             (r'\n', Text),
-            (r'\s+', Text.Whitespace),
+            (r'\s+', Whitespace),
             (r'#.*?\n', Comment.Single),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (words((
@@ -53,12 +54,13 @@ class AmplLexer(RegexLexer):
              bygroups(Name.Variable, Punctuation, Keyword.Reserved)),
             (r'(set|param|var|arc|minimize|maximize|subject to|s\.t\.|subj to|'
              r'node|table|suffix|read table|write table)(\s+)(\w+)',
-             bygroups(Keyword.Declaration, Text, Name.Variable)),
+             bygroups(Keyword.Declaration, Whitespace, Name.Variable)),
             (r'(param)(\s*)(:)(\s*)(\w+)(\s*)(:)(\s*)((\w|\s)+)',
-             bygroups(Keyword.Declaration, Text, Punctuation, Text,
-                      Name.Variable, Text, Punctuation, Text, Name.Variable)),
+             bygroups(Keyword.Declaration, Whitespace, Punctuation, Whitespace,
+                      Name.Variable, Whitespace, Punctuation, Whitespace, Name.Variable)),
             (r'(let|fix|unfix)(\s*)((?:\{.*\})?)(\s*)(\w+)',
-             bygroups(Keyword.Declaration, Text, using(this), Text, Name.Variable)),
+             bygroups(Keyword.Declaration, Whitespace, using(this), Whitespace,
+                      Name.Variable)),
             (words((
                 'abs', 'acos', 'acosh', 'alias', 'asin', 'asinh', 'atan', 'atan2',
                 'atanh', 'ceil', 'ctime', 'cos', 'exp', 'floor', 'log', 'log10',