pygments.rb 2.4.1 → 4.0.0

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

@@ -0,0 +1,177 @@
+"""
+    pygments.lexers.tablegen
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for LLVM's TableGen DSL.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words, using
+from pygments.lexers.c_cpp import CppLexer
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    Punctuation, String, Text, Whitespace, Error
+
+__all__ = ['TableGenLexer']
+
+KEYWORDS = (
+    'assert',
+    'class',
+    'code',
+    'def',
+    'dump',
+    'else',
+    'foreach',
+    'defm',
+    'defset',
+    'defvar',
+    'field',
+    'if',
+    'in',
+    'include',
+    'let',
+    'multiclass',
+    'then',
+)
+
+KEYWORDS_CONST = (
+    'false',
+    'true',
+)
+KEYWORDS_TYPE = (
+    'bit',
+    'bits',
+    'dag',
+    'int',
+    'list',
+    'string',
+)
+
+BANG_OPERATORS = (
+    'add',
+    'and',
+    'cast',
+    'con',
+    'cond',
+    'dag',
+    'div',
+    'empty',
+    'eq',
+    'exists',
+    'filter',
+    'find',
+    'foldl',
+    'foreach',
+    'ge',
+    'getdagarg',
+    'getdagname',
+    'getdagop',
+    'gt',
+    'head',
+    'if',
+    'interleave',
+    'isa',
+    'le',
+    'listconcat',
+    'listremove',
+    'listsplat',
+    'logtwo',
+    'lt',
+    'mul',
+    'ne',
+    'not',
+    'or',
+    'range',
+    'repr',
+    'setdagarg',
+    'setdagname',
+    'setdagop',
+    'shl',
+    'size',
+    'sra',
+    'srl',
+    'strconcat',
+    'sub',
+    'subst',
+    'substr',
+    'tail',
+    'tolower',
+    'toupper',
+    'xor',
+)
+
+class TableGenLexer(RegexLexer):
+    """
+    Lexer for TableGen
+    """
+
+    name = 'TableGen'
+    url = 'https://llvm.org/docs/TableGen/ProgRef.html'
+    aliases = ['tablegen', 'td']
+    filenames = ['*.td']
+
+    version_added = '2.19'
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+
+            (r'/\*', Comment.Multiline, 'comment'),
+            (r'//.*?$', Comment.SingleLine),
+            (r'#(define|ifdef|ifndef|else|endif)', Comment.Preproc),
+
+            # Binary/hex numbers. Note that these take priority over names,
+            # which may begin with numbers.
+            (r'0b[10]+', Number.Bin),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+
+            # Keywords
+            (words(KEYWORDS, suffix=r'\b'), Keyword),
+            (words(KEYWORDS_CONST, suffix=r'\b'), Keyword.Constant),
+            (words(KEYWORDS_TYPE, suffix=r'\b'), Keyword.Type),
+
+            # Bang operators
+            (words(BANG_OPERATORS, prefix=r'\!', suffix=r'\b'), Operator),
+            # Unknown bang operators are an error
+            (r'![a-zA-Z]+', Error),
+
+            # Names and identifiers
+            (r'[0-9]*[a-zA-Z_][a-zA-Z_0-9]*', Name),
+            (r'\$[a-zA-Z_][a-zA-Z_0-9]*', Name.Variable),
+
+            # Place numbers after keywords. Names/identifiers may begin with
+            # numbers, and we want to parse 1X as one name token as opposed to
+            # a number and a name.
+            (r'[-\+]?[0-9]+', Number.Integer),
+
+            # String literals
+            (r'"', String, 'dqs'),
+            (r'\[\{', Text, 'codeblock'),
+
+            # Misc. punctuation
+            (r'[-+\[\]{}()<>\.,;:=?#]+', Punctuation),
+        ],
+        'comment': [
+            (r'[^*/]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline)
+        ],
+        'strings': [
+            (r'\\[\\\'"tn]', String.Escape),
+            (r'[^\\"]+', String),
+        ],
+        # Double-quoted string, a la C
+        'dqs': [
+            (r'"', String, '#pop'),
+            include('strings'),
+        ],
+        # No escaping inside a code block - everything is literal
+        # Assume that the code inside a code block is C++. This isn't always
+        # true in TableGen, but is the far most common scenario.
+        'codeblock': [
+            (r'\}\]', Text, '#pop'),
+            (r'([^}]+|\}[^]])*', using(CppLexer)),
+        ],
+    }

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

@@ -0,0 +1,303 @@
+"""
+    pygments.lexers.tact
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Tact.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, bygroups, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Whitespace, Punctuation
+
+__all__ = ['TactLexer']
+
+
+class TactLexer(RegexLexer):
+    """For Tact source code."""
+
+    name = 'Tact'
+    aliases = ['tact']
+    filenames = ['*.tact']
+    url = "https://tact-lang.org"
+    version_added = '2.18'
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r'[.;(),\[\]{}]', Punctuation),
+            (r'\?|!!', Operator),
+            include('comments'),
+            include('import-in'),
+            include('struct-in'),
+            include('contract-or-trait-in'),
+            include('annotation-in'),
+            include('fun-declaration-in'),
+            include('const-declaration-in'),
+            include('statements'),
+        ],
+        'import-in': [
+            (r'((?<=\.\.\.)|(?<![.$]))\b(import)\b(\s*)', bygroups(Punctuation, Keyword, Whitespace), 'import'),
+        ],
+        'import': [
+            (r';', Punctuation, '#pop'),
+            include('comments'),
+            include('string-in'),
+            (r'\s+', Whitespace),
+        ],
+        'struct-in': [
+            (r'((?<=\.\.\.)|(?<![.$]))\b(struct|message)\b', bygroups(Punctuation, Keyword), 'struct'),
+        ],
+        'struct': [
+            include('comments'),
+            include('struct-header'),
+            include('struct-body-in'),
+            (r'\s+', Whitespace),
+        ],
+        'struct-header': [
+            include('comments'),
+            (r'\b\w+', Name.Class),
+            (r'(\()((?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b)(\))', bygroups(Punctuation, Number.Hex, Punctuation)),
+            (r'(\()((?:\b[0-9]+\b))(\))', bygroups(Punctuation, Number.Integer, Punctuation)),
+        ],
+        'struct-body-in': [
+            (r'\{', Punctuation, 'struct-body'),
+        ],
+        'struct-body': [
+            (r'\}', Punctuation, '#pop:2'),
+            include('comments'),
+            include('field-declaration-in'),
+        ],
+        'contract-or-trait-in': [
+            (r'((?<=\.\.\.)|(?<![.$]))\b(contract|trait)\b', Keyword, 'contract-or-trait'),
+        ],
+        'contract-or-trait': [
+            include('comments'),
+            (r'with', Keyword),
+            (r'\b\w+', Name.Class),
+            include('contract-or-trait-body-in'),
+            (r'\s+', Whitespace),
+            (r',', Punctuation),
+        ],
+        'contract-or-trait-body-in': [
+            (r'\{', Punctuation, 'contract-or-trait-body'),
+        ],
+        'contract-or-trait-body': [
+            (r'\}', Punctuation, '#pop:2'),
+            include('comments'),
+            include('init-declaration-in'),
+            include('receive-declaration-in'),
+            include('bounce-declaration-in'),
+            include('fun-declaration-in'),
+            include('const-declaration-in'),
+            include('field-declaration-in'),
+            (r'\s+', Whitespace),
+        ],
+        'field-declaration-in': [
+            (r'\b\w+', Name.Property, 'field-declaration'),
+        ],
+        'field-declaration': [
+            (r';', Punctuation, '#pop'),
+            include('comments'),
+            include('type-annotation-in'),
+            include('variable-init-in'),
+        ],
+        'const-declaration-in': [
+            (r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*const\b)', Keyword, 'const-declaration'),
+        ],
+        'const-declaration': [
+            (r'(;)', Punctuation, '#pop'),
+            (r'const', Keyword),
+            (words(('get', 'native', 'extends', 'mutates', 'virtual', 'override', 'inline', 'abstract'), suffix=r'\b'), Keyword),
+            (r'\b\w+\b', Name.Constant),
+            include('comments'),
+            include('type-annotation-in'),
+            include('variable-init-in'),
+            (r'\s+', Whitespace),
+        ],
+        'init-declaration-in': [
+            (r'(init)', Keyword, 'init-declaration')
+        ],
+        'init-declaration': [
+            (r'(?<=\})', Punctuation, '#pop'),
+            include('comments'),
+            include('fun-arguments-in'),
+            include('block-declaration-in'),
+            (r'\s+', Whitespace),
+        ],
+        'receive-declaration-in': [
+            (r'(receive|exernal)', Keyword, 'receive-declaration')
+        ],
+        'receive-declaration': [
+            (r'(?<=\})', Punctuation, '#pop'),
+            include('comments'),
+            include('fun-arguments-in'),
+            include('block-declaration-in'),
+        ],
+        'bounce-declaration-in': [
+            (r'(bounced)', Keyword, 'bounce-declaration')
+        ],
+        'bounce-declaration': [
+            (r'(?<=\})', Punctuation, '#pop'),
+            include('comments'),
+            include('fun-arguments-in'),
+            include('block-declaration-in'),
+        ],
+        'fun-declaration-in': [
+            (r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*fun\b)', Keyword, 'fun-declaration')
+        ],
+        'fun-declaration': [
+            (r'(?<=\}|\;)', Punctuation, '#pop'),
+            (r'fun', Keyword),
+            (r'\b(get|native|extends|mutates|virtual|override|inline|abstract)\b', Keyword),
+            (r'\b[\w]+', Name.Function),
+            include('fun-declaration-body'),
+            (r'[,;]', Punctuation),
+        ],
+        'fun-declaration-body': [
+            include('comments'),
+            include('fun-arguments-in'),
+            include('type-annotation-in'),
+            include('block-declaration-in'),
+            (r'\s+', Whitespace),
+        ],
+        'fun-arguments-in': [
+            (r'\(', Punctuation, 'fun-arguments'),
+        ],
+        'fun-arguments': [
+            (r'\)', Punctuation, '#pop'),
+            include('comments'),
+            include('string-in'),
+            include('type-annotation-in'),
+            (r'(self)|(\b[\w]+\b)', bygroups(Name.Variable.Instance, Name.Variable)),
+            (r',', Punctuation),
+            (r'\s+', Whitespace),
+        ],
+        'block-declaration-in': [
+            (r'\{', Punctuation, 'block-declaration')
+        ],
+        'block-declaration': [
+            (r'\}', Punctuation, '#pop'),
+            include('statements'),
+        ],
+        'statements': [
+            include('comments'),
+            include('block-declaration-in'),
+            include('expressions'),
+        ],
+        'annotation-in': [
+            (r'(@)(\w+)(\()', bygroups(Keyword.Pseudo, Keyword, Punctuation), 'annotation')
+        ],
+        'annotation': [
+            (r'\)', Punctuation, '#pop'),
+            include('annotation-argument'),
+            (r'\s+', Whitespace),
+        ],
+        'annotation-argument': [
+            (r'\w+', Name.Function.Magic),
+        ],
+        'expressions': [
+            include('comments'),
+            include('type-annotation-in'),
+            include('keywords'),
+            include('numeric'),
+            include('string-in'),
+            include('variable'),
+            include('function-call'),
+            include('struct-init-in'),
+        ],
+        'struct-init-in': [
+            (r'(\b\w+)(\s*)(\{)', bygroups(Name.Class, Whitespace, Punctuation), 'struct-init')
+        ],
+        'struct-init': [
+            (r'(\})', Punctuation, '#pop'),
+            include('comments'),
+            include('struct-property-in'),
+            (r'\s+', Whitespace),
+            (r',', Punctuation),
+        ],
+        'struct-property-in': [
+            (r'(\b[\w]+)(\s*)(:)', bygroups(Name.Property, Whitespace, Punctuation), 'struct-property')
+        ],
+        'struct-property': [
+            (r'(?=\}|\,)', Punctuation, '#pop'),
+            include('comments'),
+            include('expressions'),
+            (r'\s+', Whitespace),
+        ],
+        'variable-init-in': [
+            (r'(=)', Operator, 'variable-init')
+        ],
+        'variable-init': [
+            (r'(?=\}|\{|\,|\;)',Punctuation, '#pop'),
+            include('comments'),
+            include('expressions'),
+            (r'\s+', Whitespace),
+        ],
+        'type-annotation-in': [
+            (r'(:)(\s+)', bygroups(Punctuation, Whitespace), 'type-annotation')
+        ],
+        'type-annotation': [
+            (r'(?=\{|\;|\=|\,|\))', Punctuation, '#pop'),
+            include('comments'),
+            include('type-as-in'),
+            include('type-generic-in'),
+            (r'\?', Operator),
+            (r'\b\w+', Keyword.Type),
+            (r'\s+', Whitespace),
+        ],
+        'type-generic-in': [
+            (r'<', Punctuation, 'type-generic'),
+        ],
+        'type-generic': [
+            (r'>', Punctuation, '#pop'),
+            include('comments'),
+            include('type-as-in'),
+            (r'\b\w+', Keyword.Type),
+            (r'\s+', Whitespace),
+            (r',', Punctuation),
+        ],
+        'type-as-in': [
+            (r'\b(as)(\s+)', bygroups(Keyword, Whitespace), 'type-as'),
+        ],
+        'type-as': [
+            (r'(?=\{|\;|\=|\,|\)|\>)', Punctuation, '#pop'),
+            include('comments'),
+            (r'\b\w+', Keyword.Type),
+            (r'\s+', Whitespace),
+        ],
+        'keywords': [
+            (words(('if', 'else', 'while', 'do', 'until', 'repeat', 'return', 'extends', 'mutates', 'virtual', 'override', 'inline', 'native', 'let', 'const', 'fun', 'self', 'is', 'initOf', 'map', 'bounced', 'get', 'as'), prefix=r'\b', suffix=r'\b'), Keyword),
+            (r'(<=>|>=|<=|!=|==|\^>>|~>>|>>|<<|\/%|\^%|~%|\^\/|~\/|\+=|-=|\*=|\/=|~\/=|\^\/=|%=|\^%=|<<=|>>=|~>>=|\^>>=|&=|\|=|\^=|\^|=|~|\/|%|-|\*|\+|>|<|&|\||:|\?)', Operator),
+            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
+        ],
+        'string-in': [
+            (r'"', String, 'string'),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\.', String.Escape),
+            (r'[^\\"]+', String.Double),
+        ],
+        'numeric': [
+            (r'(?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b', Number.Hex),
+            (r'(?:\b[0-9]+\b)', Number.Integer),
+        ],
+        'comments': [
+            (r'//.*', Comment.Single),
+            (r'/\*', Comment.Multiline, 'comments-multiline'),
+        ],
+        'comments-multiline': [
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[^*]+', Comment.Multiline),
+            (r'[*]', Comment.Multiline),
+        ],
+        'variable': [
+            (r'\b\w+\b(?!\s*\()(?!\s*\{)', Name.Variable)
+        ],
+        'function-call': [
+            (r'\b\w+\b(?=\s*\()(?!\s*\{)', Name.Function)
+        ],
+    }

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

@@ -6,7 +6,7 @@
 
     .. versionadded:: 2.12
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -19,15 +19,15 @@ __all__ = ['TalLexer']
 
 class TalLexer(RegexLexer):
     """
-    For `Uxntal <https://wiki.xxiivv.com/site/uxntal.html>`_ source code.
-
-    .. versionadded:: 2.12
+    For Uxntal source code.
     """
 
     name = 'Tal'
     aliases = ['tal', 'uxntal']
     filenames = ['*.tal']
     mimetypes = ['text/x-uxntal']
+    url = 'https://wiki.xxiivv.com/site/uxntal.html'
+    version_added = '2.12'
 
     instructions = [
         'BRK', 'LIT', 'INC', 'POP', 'DUP', 'NIP', 'SWP', 'OVR', 'ROT',
@@ -54,19 +54,22 @@ class TalLexer(RegexLexer):
             (r'[][{}](?!\S)', Punctuation), # delimiters
             (r'#([0-9a-f]{2}){1,2}(?!\S)', Number.Hex), # integer
             (r'"\S+', String), # raw string
-            (r"'\S(?!\S)", String.Char), # raw char
             (r'([0-9a-f]{2}){1,2}(?!\S)', Literal), # raw integer
             (r'[|$][0-9a-f]{1,4}(?!\S)', Keyword.Declaration), # abs/rel pad
             (r'%\S+', Name.Decorator), # macro
             (r'@\S+', Name.Function), # label
             (r'&\S+', Name.Label), # sublabel
             (r'/\S+', Name.Tag), # spacer
-            (r'\.\S+', Name.Variable.Magic), # zero page addr
-            (r',\S+', Name.Variable.Instance), # rel addr
-            (r';\S+', Name.Variable.Global), # abs addr
-            (r':\S+', Literal), # raw addr
+            (r'\.\S+', Name.Variable.Magic), # literal zero page addr
+            (r',\S+', Name.Variable.Instance), # literal rel addr
+            (r';\S+', Name.Variable.Global), # literal abs addr
+            (r'-\S+', Literal), # raw zero page addr
+            (r'_\S+', Literal), # raw relative addr
+            (r'=\S+', Literal), # raw absolute addr
+            (r'!\S+', Name.Function), # immediate jump
+            (r'\?\S+', Name.Function), # conditional immediate jump
             (r'~\S+', Keyword.Namespace), # include
-            (r'\S+', Name),
+            (r'\S+', Name.Function), # macro invocation, immediate subroutine
         ]
     }
 

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

@@ -4,7 +4,7 @@
 
     Lexers for Tcl and related languages.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -19,8 +19,6 @@ __all__ = ['TclLexer']
 class TclLexer(RegexLexer):
     """
     For Tcl source code.
-
-    .. versionadded:: 0.10
     """
 
     keyword_cmds_re = words((
@@ -48,6 +46,7 @@ class TclLexer(RegexLexer):
     aliases = ['tcl']
     filenames = ['*.tcl', '*.rvt']
     mimetypes = ['text/x-tcl', 'text/x-script.tcl', 'application/x-tcl']
+    version_added = '0.10'
 
     def _gen_command_rules(keyword_cmds_re, builtin_cmds_re, context=""):
         return [

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

@@ -4,7 +4,7 @@
 
     Lexer for TEAL.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -21,13 +21,12 @@ class TealLexer(RegexLexer):
 
     For more information about the grammar, see:
     https://github.com/algorand/go-algorand/blob/master/data/transactions/logic/assembler.go
-
-    .. versionadded:: 2.9
     """
     name = 'teal'
     url = 'https://developer.algorand.org/docs/reference/teal/specification/'
     aliases = ['teal']
     filenames = ['*.teal']
+    version_added = '2.9'
 
     keywords = words({
         'Sender', 'Fee', 'FirstValid', 'FirstValidTime', 'LastValid', 'Note',