pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.theorem
     ~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for theorem-proving languages.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -30,6 +29,8 @@ class CoqLexer(RegexLexer):
     filenames = ['*.v']
     mimetypes = ['text/x-coq']
 
+    flags = re.UNICODE
+
     keywords1 = (
         # Vernacular commands
         'Section', 'Module', 'End', 'Require', 'Import', 'Export', 'Variable',
@@ -93,12 +94,11 @@ class CoqLexer(RegexLexer):
         '<->', '=', '>', '>]', r'>\}', r'\?', r'\?\?', r'\[', r'\[<', r'\[>',
         r'\[\|', ']', '_', '`', r'\{', r'\{<', r'\|', r'\|]', r'\}', '~', '=>',
         r'/\\', r'\\/', r'\{\|', r'\|\}',
-        u'Π', u'λ',
+        'Π', 'λ',
     )
     operators = r'[!$%&*+\./:<=>?@^|~-]'
     prefix_syms = r'[!?~]'
     infix_syms = r'[=<>@^|&+\*/$%-]'
-    primitives = ('unit', 'nat', 'bool', 'string', 'ascii', 'list')
 
     tokens = {
         'root': [
@@ -115,7 +115,6 @@ class CoqLexer(RegexLexer):
             (r'\b([A-Z][\w\']*)', Name),
             (r'(%s)' % '|'.join(keyopts[::-1]), Operator),
             (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
-            (r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
 
             (r"[^\W\d][\w']*", Name),
 
@@ -125,14 +124,15 @@ class CoqLexer(RegexLexer):
             (r'0[bB][01][01_]*', Number.Bin),
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
 
-            (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'",
-             String.Char),
+            (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'", String.Char),
+
             (r"'.'", String.Char),
             (r"'", Keyword),  # a stray quote is another syntax element
 
             (r'"', String.Double, 'string'),
 
             (r'[~?][a-z][\w\']*:', Name),
+            (r'\S', Name.Builtin.Pseudo),
         ],
         'comment': [
             (r'[^(*)]+', Comment),
@@ -156,8 +156,8 @@ class CoqLexer(RegexLexer):
     }
 
     def analyse_text(text):
-        if text.startswith('(*'):
-            return True
+        if 'Qed' in text and 'Proof' in text:
+            return 1
 
 
 class IsabelleLexer(RegexLexer):
@@ -390,69 +390,87 @@ class LeanLexer(RegexLexer):
 
     flags = re.MULTILINE | re.UNICODE
 
-    keywords1 = (
-        'import', 'abbreviation', 'opaque_hint', 'tactic_hint', 'definition',
-        'renaming', 'inline', 'hiding', 'exposing', 'parameter', 'parameters',
-        'conjecture', 'hypothesis', 'lemma', 'corollary', 'variable', 'variables',
-        'theorem', 'axiom', 'inductive', 'structure', 'universe', 'alias',
-        'help', 'options', 'precedence', 'postfix', 'prefix', 'calc_trans',
-        'calc_subst', 'calc_refl', 'infix', 'infixl', 'infixr', 'notation', 'eval',
-        'check', 'exit', 'coercion', 'end', 'private', 'using', 'namespace',
-        'including', 'instance', 'section', 'context', 'protected', 'expose',
-        'export', 'set_option', 'add_rewrite', 'extends', 'open', 'example',
-        'constant', 'constants', 'print', 'opaque', 'reducible', 'irreducible',
-    )
-
-    keywords2 = (
-        'forall', 'fun', 'Pi', 'obtain', 'from', 'have', 'show', 'assume',
-        'take', 'let', 'if', 'else', 'then', 'by', 'in', 'with', 'begin',
-        'proof', 'qed', 'calc', 'match',
-    )
-
-    keywords3 = (
-        # Sorts
-        'Type', 'Prop',
-    )
-
-    operators = (
-        u'!=', u'#', u'&', u'&&', u'*', u'+', u'-', u'/', u'@', u'!', u'`',
-        u'-.', u'->', u'.', u'..', u'...', u'::', u':>', u';', u';;', u'<',
-        u'<-', u'=', u'==', u'>', u'_', u'|', u'||', u'~', u'=>', u'<=', u'>=',
-        u'/\\', u'\\/', u'∀', u'Π', u'λ', u'↔', u'∧', u'∨', u'≠', u'≤', u'≥',
-        u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈', u'×', u'⌞',
-        u'⌟', u'≡', u'⟨', u'⟩',
-    )
-
-    punctuation = (u'(', u')', u':', u'{', u'}', u'[', u']', u'⦃', u'⦄',
-                   u':=', u',')
-
     tokens = {
         'root': [
             (r'\s+', Text),
+            (r'/--', String.Doc, 'docstring'),
             (r'/-', Comment, 'comment'),
             (r'--.*?$', Comment.Single),
-            (words(keywords1, prefix=r'\b', suffix=r'\b'), Keyword.Namespace),
-            (words(keywords2, prefix=r'\b', suffix=r'\b'), Keyword),
-            (words(keywords3, prefix=r'\b', suffix=r'\b'), Keyword.Type),
-            (words(operators), Name.Builtin.Pseudo),
-            (words(punctuation), Operator),
-            (u"[A-Za-z_\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2100-\u214f]"
-             u"[A-Za-z_'\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2070-\u2079"
-             u"\u207f-\u2089\u2090-\u209c\u2100-\u214f0-9]*", Name),
+            (words((
+                'import', 'renaming', 'hiding',
+                'namespace',
+                'local',
+                'private', 'protected', 'section',
+                'include', 'omit', 'section',
+                'protected', 'export',
+                'open',
+                'attribute',
+            ), prefix=r'\b', suffix=r'\b'), Keyword.Namespace),
+            (words((
+                'lemma', 'theorem', 'def', 'definition', 'example',
+                'axiom', 'axioms', 'constant', 'constants',
+                'universe', 'universes',
+                'inductive', 'coinductive', 'structure', 'extends',
+                'class', 'instance',
+                'abbreviation',
+
+                'noncomputable theory',
+
+                'noncomputable', 'mutual', 'meta',
+
+                'attribute',
+
+                'parameter', 'parameters',
+                'variable', 'variables',
+
+                'reserve', 'precedence',
+                'postfix', 'prefix', 'notation', 'infix', 'infixl', 'infixr',
+
+                'begin', 'by', 'end',
+
+                'set_option',
+                'run_cmd',
+            ), prefix=r'\b', suffix=r'\b'), Keyword.Declaration),
+            (r'@\[[^\]]*\]', Keyword.Declaration),
+            (words((
+                'forall', 'fun', 'Pi', 'from', 'have', 'show', 'assume', 'suffices',
+                'let', 'if', 'else', 'then', 'in', 'with', 'calc', 'match',
+                'do'
+            ), prefix=r'\b', suffix=r'\b'), Keyword),
+            (words(('sorry', 'admit'), prefix=r'\b', suffix=r'\b'), Generic.Error),
+            (words(('Sort', 'Prop', 'Type'), prefix=r'\b', suffix=r'\b'), Keyword.Type),
+            (words((
+                '#eval', '#check', '#reduce', '#exit',
+                '#print', '#help',
+            ), suffix=r'\b'), Keyword),
+            (words((
+                '(', ')', ':', '{', '}', '[', ']', '⟨', '⟩', '‹', '›', '⦃', '⦄', ':=', ',',
+            )), Operator),
+            (r'[A-Za-z_\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2100-\u214f]'
+             r'[.A-Za-z_\'\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2070-\u2079'
+             r'\u207f-\u2089\u2090-\u209c\u2100-\u214f0-9]*', Name),
+            (r'0x[A-Za-z0-9]+', Number.Integer),
+            (r'0b[01]+', Number.Integer),
             (r'\d+', Number.Integer),
             (r'"', String.Double, 'string'),
-            (r'[~?][a-z][\w\']*:', Name.Variable)
+            (r"'(?:(\\[\\\"'nt])|(\\x[0-9a-fA-F]{2})|(\\u[0-9a-fA-F]{4})|.)'", String.Char),
+            (r'[~?][a-z][\w\']*:', Name.Variable),
+            (r'\S', Name.Builtin.Pseudo),
         ],
         'comment': [
-            # Multiline Comments
             (r'[^/-]', Comment.Multiline),
             (r'/-', Comment.Multiline, '#push'),
             (r'-/', Comment.Multiline, '#pop'),
             (r'[/-]', Comment.Multiline)
         ],
+        'docstring': [
+            (r'[^/-]', String.Doc),
+            (r'-/', String.Doc, '#pop'),
+            (r'[/-]', String.Doc)
+        ],
         'string': [
             (r'[^\\"]+', String.Double),
-            (r'\\[n"\\]', String.Escape),
+            (r"(?:(\\[\\\"'nt])|(\\x[0-9a-fA-F]{2})|(\\u[0-9a-fA-F]{4}))", String.Escape),
             ('"', String.Double, '#pop'),
         ],
     }

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

@@ -0,0 +1,262 @@
+"""
+    pygments.lexers.tnt
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexer for Typographic Number Theory.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import Lexer
+from pygments.token import Text, Comment, Operator, Keyword, Name, Number, \
+     Punctuation, Error
+
+__all__ = ['TNTLexer']
+
+
+class TNTLexer(Lexer):
+    """
+    Lexer for Typographic Number Theory, as described in the book
+    Gödel, Escher, Bach, by Douglas R. Hofstadter,
+    or as summarized here:
+    https://github.com/Kenny2github/language-tnt/blob/master/README.md#summary-of-tnt
+
+    .. versionadded:: 2.7
+    """
+
+    name = 'Typographic Number Theory'
+    aliases = ['tnt']
+    filenames = ['*.tnt']
+
+    cur = []
+
+    LOGIC = set('⊃→]&∧^|∨Vv')
+    OPERATORS = set('+.⋅*')
+    VARIABLES = set('abcde')
+    PRIMES = set("'′")
+    NEGATORS = set('~!')
+    QUANTIFIERS = set('AE∀∃')
+    NUMBERS = set('0123456789')
+    WHITESPACE = set('\t \v\n')
+
+    RULES = re.compile('''(?xi)
+        joining | separation | double-tilde | fantasy\\ rule
+        | carry[- ]over(?:\\ of)?(?:\\ line)?\\ ([0-9]+) | detachment
+        | contrapositive | De\\ Morgan | switcheroo
+        | specification | generalization | interchange
+        | existence | symmetry | transitivity
+        | add\\ S | drop\\ S | induction
+        | axiom\\ ([1-5]) | premise | push | pop
+    ''')
+    LINENOS = re.compile(r'(?:[0-9]+)(?:(?:, ?|,? and )(?:[0-9]+))*')
+    COMMENT = re.compile(r'\[[^\n\]]+\]')
+
+    def __init__(self, *args, **kwargs):
+        Lexer.__init__(self, *args, **kwargs)
+        self.cur = []
+
+    def whitespace(self, start, text, required=False):
+        """Tokenize whitespace."""
+        end = start
+        try:
+            while text[end] in self.WHITESPACE:
+                end += 1
+        except IndexError:
+            end = len(text)
+        if required:
+            assert end != start
+        if end != start:
+            self.cur.append((start, Text, text[start:end]))
+        return end
+
+    def variable(self, start, text):
+        """Tokenize a variable."""
+        assert text[start] in self.VARIABLES
+        end = start+1
+        while text[end] in self.PRIMES:
+            end += 1
+        self.cur.append((start, Name.Variable, text[start:end]))
+        return end
+
+    def term(self, start, text):
+        """Tokenize a term."""
+        if text[start] == 'S':  # S...S(...) or S...0
+            end = start+1
+            while text[end] == 'S':
+                end += 1
+            self.cur.append((start, Number.Integer, text[start:end]))
+            return self.term(end, text)
+        if text[start] == '0':  # the singleton 0
+            self.cur.append((start, Number.Integer, text[start]))
+            return start+1
+        if text[start] in self.VARIABLES:  # a''...
+            return self.variable(start, text)
+        if text[start] == '(':  # (...+...)
+            self.cur.append((start, Punctuation, text[start]))
+            start = self.term(start+1, text)
+            assert text[start] in self.OPERATORS
+            self.cur.append((start, Operator, text[start]))
+            start = self.term(start+1, text)
+            assert text[start] == ')'
+            self.cur.append((start, Punctuation, text[start]))
+            return start+1
+        raise AssertionError  # no matches
+
+    def formula(self, start, text):
+        """Tokenize a formula."""
+        if text[start] in self.NEGATORS:  # ~<...>
+            end = start+1
+            while text[end] in self.NEGATORS:
+                end += 1
+            self.cur.append((start, Operator, text[start:end]))
+            return self.formula(end, text)
+        if text[start] in self.QUANTIFIERS:  # Aa:<...>
+            self.cur.append((start, Keyword.Declaration, text[start]))
+            start = self.variable(start+1, text)
+            assert text[start] == ':'
+            self.cur.append((start, Punctuation, text[start]))
+            return self.formula(start+1, text)
+        if text[start] == '<':  # <...&...>
+            self.cur.append((start, Punctuation, text[start]))
+            start = self.formula(start+1, text)
+            assert text[start] in self.LOGIC
+            self.cur.append((start, Operator, text[start]))
+            start = self.formula(start+1, text)
+            assert text[start] == '>'
+            self.cur.append((start, Punctuation, text[start]))
+            return start+1
+        # ...=...
+        start = self.term(start, text)
+        assert text[start] == '='
+        self.cur.append((start, Operator, text[start]))
+        start = self.term(start+1, text)
+        return start
+
+    def rule(self, start, text):
+        """Tokenize a rule."""
+        match = self.RULES.match(text, start)
+        assert match is not None
+        groups = sorted(match.regs[1:])  # exclude whole match
+        for group in groups:
+            if group[0] >= 0:  # this group matched
+                self.cur.append((start, Keyword, text[start:group[0]]))
+                self.cur.append((group[0], Number.Integer,
+                                 text[group[0]:group[1]]))
+                if group[1] != match.end():
+                    self.cur.append((group[1], Keyword,
+                                     text[group[1]:match.end()]))
+                break
+        else:
+            self.cur.append((start, Keyword, text[start:match.end()]))
+        return match.end()
+
+    def lineno(self, start, text):
+        """Tokenize a line referral."""
+        end = start
+        while text[end] not in self.NUMBERS:
+            end += 1
+        self.cur.append((start, Punctuation, text[start]))
+        self.cur.append((start+1, Text, text[start+1:end]))
+        start = end
+        match = self.LINENOS.match(text, start)
+        assert match is not None
+        assert text[match.end()] == ')'
+        self.cur.append((match.start(), Number.Integer, match.group(0)))
+        self.cur.append((match.end(), Punctuation, text[match.end()]))
+        return match.end() + 1
+
+    def error_till_line_end(self, start, text):
+        """Mark everything from ``start`` to the end of the line as Error."""
+        end = start
+        try:
+            while text[end] != '\n':  # there's whitespace in rules
+                end += 1
+        except IndexError:
+            end = len(text)
+        if end != start:
+            self.cur.append((start, Error, text[start:end]))
+        end = self.whitespace(end, text)
+        return end
+
+    def get_tokens_unprocessed(self, text):
+        """Returns a list of TNT tokens."""
+        self.cur = []
+        start = end = self.whitespace(0, text)
+        while start <= end < len(text):
+            try:
+                # try line number
+                while text[end] in self.NUMBERS:
+                    end += 1
+                if end != start:  # actual number present
+                    self.cur.append((start, Number.Integer, text[start:end]))
+                    # whitespace is required after a line number
+                    orig = len(self.cur)
+                    try:
+                        start = end = self.whitespace(end, text, True)
+                    except AssertionError:
+                        del self.cur[orig:]
+                        start = end = self.error_till_line_end(end, text)
+                        continue
+                # at this point it could be a comment
+                match = self.COMMENT.match(text, start)
+                if match is not None:
+                    self.cur.append((start, Comment, text[start:match.end()]))
+                    start = end = match.end()
+                    # anything after the closing bracket is invalid
+                    start = end = self.error_till_line_end(start, text)
+                    # do not attempt to process the rest
+                    continue
+                del match
+                if text[start] in '[]':  # fantasy push or pop
+                    self.cur.append((start, Keyword, text[start]))
+                    start += 1
+                    end += 1
+                else:
+                    # one formula, possibly containing subformulae
+                    orig = len(self.cur)
+                    try:
+                        start = end = self.formula(start, text)
+                    except AssertionError:  # not well-formed
+                        del self.cur[orig:]
+                        while text[end] not in self.WHITESPACE:
+                            end += 1
+                        self.cur.append((start, Error, text[start:end]))
+                        start = end
+                # skip whitespace after formula
+                orig = len(self.cur)
+                try:
+                    start = end = self.whitespace(end, text, True)
+                except AssertionError:
+                    del self.cur[orig:]
+                    start = end = self.error_till_line_end(start, text)
+                    continue
+                # rule proving this formula a theorem
+                orig = len(self.cur)
+                try:
+                    start = end = self.rule(start, text)
+                except AssertionError:
+                    del self.cur[orig:]
+                    start = end = self.error_till_line_end(start, text)
+                    continue
+                # skip whitespace after rule
+                start = end = self.whitespace(end, text)
+                # line marker
+                if text[start] == '(':
+                    orig = len(self.cur)
+                    try:
+                        start = end = self.lineno(start, text)
+                    except AssertionError:
+                        del self.cur[orig:]
+                        start = end = self.error_till_line_end(start, text)
+                        continue
+                    start = end = self.whitespace(start, text)
+            except IndexError:
+                try:
+                    del self.cur[orig:]
+                except NameError:
+                    pass # if orig was never defined, fine
+                self.error_till_line_end(start, text)
+        return self.cur