pygments.rb 2.3.1 → 2.4.0

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

@@ -0,0 +1,67 @@
+"""
+    pygments.lexers.fift
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for fift.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include
+from pygments.token import Literal, Comment, Name, String, Number, Whitespace
+
+__all__ = ['FiftLexer']
+
+
+class FiftLexer(RegexLexer):
+    """
+    For Fift source code.
+    """
+
+    name = 'Fift'
+    aliases = ['fift', 'fif']
+    filenames = ['*.fif']
+    url = 'https://ton-blockchain.github.io/docs/fiftbase.pdf'
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+
+            include('comments'),
+
+            (r'[\.+]?\"', String, 'string'),
+
+            # numbers
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'0b[01]+', Number.Bin),
+            (r'-?[0-9]+("/"-?[0-9]+)?', Number.Decimal),
+
+            # slices
+            (r'b\{[01]+\}', Literal),
+            (r'x\{[0-9a-fA-F_]+\}', Literal),
+
+            # byte literal
+            (r'B\{[0-9a-fA-F_]+\}', Literal),
+
+            # treat anything as word
+            (r'\S+', Name)
+        ],
+
+        'string': [
+            (r'\\.', String.Escape),
+            (r'\"', String, '#pop'),
+            (r'[^\"\r\n\\]+', String)
+        ],
+
+        'comments': [
+            (r'//.*', Comment.Singleline),
+            (r'/\*', Comment.Multiline, 'comment'),
+        ],
+        'comment': [
+            (r'[^/*]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+        ],
+    }

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

@@ -4,25 +4,26 @@
 
     Lexer for FloScript
 
-    :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, include
+from pygments.lexer import RegexLexer, include, bygroups
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['FloScriptLexer']
 
 
 class FloScriptLexer(RegexLexer):
     """
-    For `FloScript <https://github.com/ioflo/ioflo>`_ configuration language source code.
+    For FloScript configuration language source code.
 
     .. versionadded:: 2.4
     """
 
     name = 'FloScript'
+    url = 'https://github.com/ioflo/ioflo'
     aliases = ['floscript', 'flo']
     filenames = ['*.flo']
 
@@ -41,11 +42,10 @@ class FloScriptLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\n', Text),
-            (r'[^\S\n]+', Text),
+            (r'\s+', Whitespace),
 
             (r'[]{}:(),;[]', Punctuation),
-            (r'\\\n', Text),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),
             (r'\\', Text),
             (r'(to|by|with|from|per|for|cum|qua|via|as|at|in|of|on|re|is|if|be|into|'
              r'and|not)\b', Operator.Word),

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

@@ -4,14 +4,15 @@
 
     Lexer for the Forth 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, bygroups
-from pygments.token import Text, Comment, Keyword, Name, String, Number
+from pygments.token import Text, Comment, Keyword, Name, String, Number, \
+    Whitespace
 
 
 __all__ = ['ForthLexer']
@@ -24,6 +25,7 @@ class ForthLexer(RegexLexer):
     .. versionadded:: 2.2
     """
     name = 'Forth'
+    url = 'https://www.forth.com/forth/'
     aliases = ['forth']
     filenames = ['*.frt', '*.fs']
     mimetypes = ['application/x-forth']
@@ -32,15 +34,15 @@ class ForthLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             # All comment types
-            (r'\\.*?\n', Comment.Single),
+            (r'\\.*?$', Comment.Single),
             (r'\([\s].*?\)', Comment.Single),
             # defining words. The next word is a new command name
             (r'(:|variable|constant|value|buffer:)(\s+)',
-             bygroups(Keyword.Namespace, Text), 'worddef'),
+             bygroups(Keyword.Namespace, Whitespace), 'worddef'),
             # strings are rather simple
-            (r'([.sc]")(\s+?)', bygroups(String, Text), 'stringdef'),
+            (r'([.sc]")(\s+?)', bygroups(String, Whitespace), 'stringdef'),
             # keywords from the various wordsets
             # *** Wordset BLOCK
             (r'(blk|block|buffer|evaluate|flush|load|save-buffers|update|'

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

@@ -4,7 +4,7 @@
 
     Lexers for Fortran 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.
 """
 
@@ -24,7 +24,8 @@ class FortranLexer(RegexLexer):
     .. versionadded:: 0.10
     """
     name = 'Fortran'
-    aliases = ['fortran']
+    url = 'https://fortran-lang.org/'
+    aliases = ['fortran', 'f90']
     filenames = ['*.f03', '*.f90', '*.F03', '*.F90']
     mimetypes = ['text/x-fortran']
     flags = re.IGNORECASE | re.MULTILINE
@@ -44,15 +45,19 @@ class FortranLexer(RegexLexer):
             include('core'),
             (r'[a-z][\w$]*', Name),
             include('nums'),
-            (r'[\s]+', Text),
+            (r'[\s]+', Text.Whitespace),
         ],
         'core': [
             # Statements
+
+            (r'\b(DO)(\s+)(CONCURRENT)\b', bygroups(Keyword, Text.Whitespace, Keyword)),
+            (r'\b(GO)(\s*)(TO)\b', bygroups(Keyword, Text.Whitespace, Keyword)),
+
             (words((
                 'ABSTRACT', 'ACCEPT', 'ALL', 'ALLSTOP', 'ALLOCATABLE', 'ALLOCATE',
                 'ARRAY', 'ASSIGN', 'ASSOCIATE', 'ASYNCHRONOUS', 'BACKSPACE', 'BIND',
                 'BLOCK', 'BLOCKDATA', 'BYTE', 'CALL', 'CASE', 'CLASS', 'CLOSE',
-                'CODIMENSION', 'COMMON', 'CONCURRRENT', 'CONTIGUOUS', 'CONTAINS',
+                'CODIMENSION', 'COMMON', 'CONTIGUOUS', 'CONTAINS',
                 'CONTINUE', 'CRITICAL', 'CYCLE', 'DATA', 'DEALLOCATE', 'DECODE',
                 'DEFERRED', 'DIMENSION', 'DO', 'ELEMENTAL', 'ELSE', 'ENCODE', 'END',
                 'ENDASSOCIATE', 'ENDBLOCK', 'ENDDO', 'ENDENUM', 'ENDFORALL',
@@ -60,11 +65,11 @@ class FortranLexer(RegexLexer):
                 'ENDSELECT', 'ENDSUBMODULE', 'ENDSUBROUTINE', 'ENDTYPE', 'ENDWHERE',
                 'ENTRY', 'ENUM', 'ENUMERATOR', 'EQUIVALENCE', 'ERROR STOP', 'EXIT',
                 'EXTENDS', 'EXTERNAL', 'EXTRINSIC', 'FILE', 'FINAL', 'FORALL', 'FORMAT',
-                'FUNCTION', 'GENERIC', 'GOTO', 'IF', 'IMAGES', 'IMPLICIT',
+                'FUNCTION', 'GENERIC', 'IF', 'IMAGES', 'IMPLICIT',
                 'IMPORT', 'IMPURE', 'INCLUDE', 'INQUIRE', 'INTENT', 'INTERFACE',
                 'INTRINSIC', 'IS', 'LOCK', 'MEMORY', 'MODULE', 'NAMELIST', 'NULLIFY',
-                'NONE', 'NON_INTRINSIC', 'NON_OVERRIDABLE', 'NOPASS', 'ONLY', 'OPEN', 
-                'OPTIONAL', 'OPTIONS', 'PARAMETER', 'PASS', 'PAUSE', 'POINTER', 'PRINT', 
+                'NONE', 'NON_INTRINSIC', 'NON_OVERRIDABLE', 'NOPASS', 'ONLY', 'OPEN',
+                'OPTIONAL', 'OPTIONS', 'PARAMETER', 'PASS', 'PAUSE', 'POINTER', 'PRINT',
                 'PRIVATE', 'PROGRAM', 'PROCEDURE', 'PROTECTED', 'PUBLIC', 'PURE', 'READ',
                 'RECURSIVE', 'RESULT', 'RETURN', 'REWIND', 'SAVE', 'SELECT', 'SEQUENCE',
                 'STOP', 'SUBMODULE', 'SUBROUTINE', 'SYNC', 'SYNCALL', 'SYNCIMAGES',
@@ -152,8 +157,8 @@ class FortranLexer(RegexLexer):
         ],
 
         'strings': [
-            (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
-            (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
+            (r'"(\\[0-7]+|\\[^0-7]|[^"\\])*"', String.Double),
+            (r"'(\\[0-7]+|\\[^0-7]|[^'\\])*'", String.Single),
         ],
 
         'nums': [
@@ -201,8 +206,8 @@ class FortranFixedLexer(RegexLexer):
         ],
         'code': [
             (r'(.{66})(.*)(\n)',
-             bygroups(_lex_fortran, Comment, Text), 'root'),
-            (r'(.*)(\n)', bygroups(_lex_fortran, Text), 'root'),
+             bygroups(_lex_fortran, Comment, Text.Whitespace), 'root'),
+            (r'(.*)(\n)', bygroups(_lex_fortran, Text.Whitespace), 'root'),
             default('root'),
         ]
     }

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

@@ -4,7 +4,7 @@
 
     Simple lexer for Microsoft Visual FoxPro source code.
 
-    :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
 from pygments.token import Punctuation, Text, Comment, Operator, Keyword, \
-     Name, String
+    Name, String
 
 __all__ = ['FoxProLexer']
 

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

@@ -4,24 +4,20 @@
 
     Lexer for FreeFem++ 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, include, bygroups, inherit, words, \
-    default
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.token import Comment, Operator, Keyword, Name
 
-from pygments.lexers.c_cpp import CLexer, CppLexer
-from pygments.lexers import _mql_builtins
+from pygments.lexers.c_cpp import CppLexer
 
 __all__ = ['FreeFemLexer']
 
 
 class FreeFemLexer(CppLexer):
     """
-    For `FreeFem++ <https://freefem.org/>`_ source.
+    For FreeFem++ source.
 
     This is an extension of the CppLexer, as the FreeFem Language is a superset
     of C++.
@@ -30,6 +26,7 @@ class FreeFemLexer(CppLexer):
     """
 
     name = 'Freefem'
+    url = 'https://freefem.org/'
     aliases = ['freefem']
     filenames = ['*.edp']
     mimetypes = ['text/x-freefem']
@@ -875,8 +872,8 @@ class FreeFemLexer(CppLexer):
                 'using'
     }
 
-    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.operators:
                 yield index, Operator, value
             elif value in self.types:

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

@@ -0,0 +1,108 @@
+"""
+    pygments.lexers.func
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for FunC.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Whitespace, Punctuation
+
+__all__ = ['FuncLexer']
+
+
+class FuncLexer(RegexLexer):
+    """
+    For FunC source code.
+    """
+
+    name = 'FunC'
+    aliases = ['func', 'fc']
+    filenames = ['*.fc', '*.func']
+
+    # 1. Does not start from "
+    # 2. Can start from ` and end with `, containing any character
+    # 3. Starts with underscore or { or } and have more than 1 character after it
+    # 4. Starts with letter, contains letters, numbers and underscores
+    identifier = r'(?!")(`([^`]+)`|((?=_)_|(?=\{)\{|(?=\})\}|(?![_`{}]))([^;,\[\]\(\)\s~.]+))'
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+
+            include('keywords'),
+            include('strings'),
+            include('directives'),
+            include('numeric'),
+            include('comments'),
+            include('storage'),
+            include('functions'),
+            include('variables'),
+
+            (r'[.;(),\[\]~{}]', Punctuation)
+        ],
+        'keywords': [
+            (words((
+                '<=>', '>=', '<=', '!=', '==', '^>>', '~>>',
+                '>>', '<<', '/%', '^%', '~%', '^/', '~/', '+=',
+                '-=', '*=', '/=', '~/=', '^/=', '%=', '^%=', '<<=',
+                '>>=', '~>>=', '^>>=', '&=', '|=', '^=', '^', '=',
+                '~', '/', '%', '-', '*', '+','>',
+                '<', '&', '|', ':', '?'), prefix=r'(?<=\s)', suffix=r'(?=\s)'),
+             Operator),
+            (words((
+                'if', 'ifnot',
+                'else', 'elseif', 'elseifnot',
+                'while', 'do', 'until', 'repeat',
+                'return', 'impure', 'method_id',
+                'forall', 'asm', 'inline', 'inline_ref'), prefix=r'\b', suffix=r'\b'),
+             Keyword),
+            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
+        ],
+        'directives': [
+            (r'#include|#pragma', Keyword, 'directive'),
+        ],
+        'directive': [
+            include('strings'),
+            (r'\s+', Whitespace),
+            (r'version|not-version', Keyword),
+            (r'(>=|<=|=|>|<|\^)?([0-9]+)(.[0-9]+)?(.[0-9]+)?', Number), # version
+            (r';', Text, '#pop')
+        ],
+        'strings': [
+            (r'\"([^\n\"]+)\"[Hhcusa]?', String),
+        ],
+        'numeric': [
+            (r'\b(-?(?!_)([\d_]+|0x[\d_a-fA-F]+)|0b[1_0]+)(?<!_)(?=[\s\)\],;])', Number)
+        ],
+        'comments': [
+            (r';;([^\n]*)', Comment.Singleline),
+            (r'\{-', Comment.Multiline, 'comment'),
+        ],
+        'comment': [
+            (r'[^-}{]+', Comment.Multiline),
+            (r'\{-', Comment.Multiline, '#push'),
+            (r'-\}', Comment.Multiline, '#pop'),
+            (r'[-}{]', Comment.Multiline),
+        ],
+        'storage': [
+            (words((
+                'var', 'int', 'slice', 'tuple',
+                'cell', 'builder', 'cont', '_'),
+                prefix=r'\b', suffix=r'(?=[\s\(\),\[\]])'),
+             Keyword.Type),
+            (words(('global', 'const'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
+        ],
+        'variables': [
+            (identifier, Name.Variable),
+        ],
+        'functions': [
+            # identifier followed by (
+            (identifier + r'(?=[\(])', Name.Function),
+        ]
+    }

data/vendor/pygments-main/pygments/lexers/functional.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/futhark.py

@@ -4,23 +4,18 @@
 
     Lexer for the Futhark 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
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
 from pygments import unistring as uni
 
 __all__ = ['FutharkLexer']
 
 
-line_re = re.compile('.*?\n')
-
-
 class FutharkLexer(RegexLexer):
     """
     A Futhark lexer
@@ -28,17 +23,17 @@ class FutharkLexer(RegexLexer):
     .. versionadded:: 2.8
     """
     name = 'Futhark'
+    url = 'https://futhark-lang.org/'
     aliases = ['futhark']
     filenames = ['*.fut']
     mimetypes = ['text/x-futhark']
 
-    flags = re.MULTILINE | re.UNICODE
-
     num_types = ('i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64')
 
     other_types = ('bool', )
 
-    reserved = ('if', 'then', 'else', 'let', 'loop', 'in', 'with', 'type',
+    reserved = ('if', 'then', 'else', 'def', 'let', 'loop', 'in', 'with',
+                'type', 'type~', 'type^',
                 'val', 'entry', 'for', 'while', 'do', 'case', 'match',
                 'include', 'import', 'module', 'open', 'local', 'assert', '_')
 
@@ -55,19 +50,19 @@ class FutharkLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'--(.*?)\n', Comment.Single),
-            (r'\s+', Text.Whitespace),
+            (r'--(.*?)$', Comment.Single),
+            (r'\s+', Whitespace),
             (r'\(\)', Punctuation),
             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
             (r'\b(%s)(?!\')\b' % '|'.join(num_types + other_types), Keyword.Type),
 
             # Identifiers
             (r'#\[([a-zA-Z_\(\) ]*)\]', Comment.Preproc),
-            (r'!?(%s\.)*%s' % (identifier_re, identifier_re), Name),
+            (r'[#!]?(%s\.)*%s' % (identifier_re, identifier_re), Name),
 
             (r'\\', Operator),
             (r'[-+/%=!><|&*^][-+/%=!><|&*^.]*', Operator),
-            (r'[][(),:;`{}]', Punctuation),
+            (r'[][(),:;`{}?.\'~^]', Punctuation),
 
             #  Numbers
             (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*_*[pP][+-]?\d(_*\d)*' + num_postfix,
@@ -106,6 +101,6 @@ class FutharkLexer(RegexLexer):
             (r'o[0-7]+', String.Escape, '#pop'),
             (r'x[\da-fA-F]+', String.Escape, '#pop'),
             (r'\d+', String.Escape, '#pop'),
-            (r'\s+\\', String.Escape, '#pop'),
+            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop'),
         ],
     }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.gcodelexer
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the G Code 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.
 """