eric: comparison eric6/ThirdParty/Pygments/pygments/lexers/haskell.py

-:bf5f777260a6
+:21b0534faebc
 pygments.lexers.haskell
 ~~~~~~~~~~~~~~~~~~~~~~~
 Lexers for Haskell and related languages.
-:copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 from pygments.lexer import Lexer, RegexLexer, bygroups, do_insertions, \
-default, include
+default, include, inherit
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
 Number, Punctuation, Generic
 from pygments import unistring as uni
-__all__ = ['HaskellLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexer',
+__all__ = ['HaskellLexer', 'HspecLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexer',
 'LiterateHaskellLexer', 'LiterateIdrisLexer', 'LiterateAgdaLexer',
 'LiterateCryptolLexer', 'KokaLexer']
 line_re = re.compile('.*?\n')
 (r"'?[_" + uni.Ll + r"][\w']*", Name),
 (r"('')?[" + uni.Lu + r"][\w\']*", Keyword.Type),
 (r"(')[" + uni.Lu + r"][\w\']*", Keyword.Type),
 (r"(')\[[^\]]*\]", Keyword.Type),  # tuples and lists get special treatment in GHC
 (r"(')\([^)]*\)", Keyword.Type),  # ..
+(r"(')[:!#$%&*+.\\/<=>?@^|~-]+", Keyword.Type),  # promoted type operators
 #  Operators
 (r'\\(?![:!#$%&*+.\\/<=>?@^|~-]+)', Name.Function),  # lambda operator
 (r'(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word),  # specials
 (r':[:!#$%&*+.\\/<=>?@^|~-]*', Keyword.Type),  # Constructor operators
 (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),  # Other operators
 #  Numbers
 (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*_*[pP][+-]?\d(_*\d)*', Number.Float),
-(r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*\.[\da-fA-F](_*[\da-fA-F])*(_*[pP][+-]?\d(_*\d)*)?', Number.Float),
+(r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*\.[\da-fA-F](_*[\da-fA-F])*'
+r'(_*[pP][+-]?\d(_*\d)*)?', Number.Float),
 (r'\d(_*\d)*_*[eE][+-]?\d(_*\d)*', Number.Float),
 (r'\d(_*\d)*\.\d(_*\d)*(_*[eE][+-]?\d(_*\d)*)?', Number.Float),
 (r'0[bB]_*[01](_*[01])*', Number.Bin),
 (r'0[oO]_*[0-7](_*[0-7])*', Number.Oct),
 (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*', Number.Hex),
 (r'\s+\\', String.Escape, '#pop'),
 ],
 }
+class HspecLexer(HaskellLexer):
+"""
+A Haskell lexer with support for Hspec constructs.
+.. versionadded:: 2.4.0
+"""
+name = 'Hspec'
+aliases = ['hspec']
+filenames = []
+mimetypes = []
+tokens = {
+'root': [
+(r'(it\s*)("[^"]*")', bygroups(Text, String.Doc)),
+(r'(describe\s*)("[^"]*")', bygroups(Text, String.Doc)),
+(r'(context\s*)("[^"]*")', bygroups(Text, String.Doc)),
+inherit,
+],
+}
 class IdrisLexer(RegexLexer):
 """
 A lexer for the dependently typed programming language Idris.
 Based on the Haskell and Agda Lexer.
 reserved = ('case', 'class', 'data', 'default', 'using', 'do', 'else',
 'if', 'in', 'infix[lr]?', 'instance', 'rewrite', 'auto',
 'namespace', 'codata', 'mutual', 'private', 'public', 'abstract',
 'total', 'partial',
+'interface', 'implementation', 'export', 'covering', 'constructor',
 'let', 'proof', 'of', 'then', 'static', 'where', '_', 'with',
 'pattern',  'term',  'syntax', 'prefix',
 'postulate', 'parameters', 'record', 'dsl', 'impossible', 'implicit',
 'tactics', 'intros', 'intro', 'compute', 'refine', 'exact', 'trivial')
 'default', 'logging', 'dynamic', 'name', 'error_handlers', 'language')
 tokens = {
 'root': [
 # Comments
-(r'^(\s*)(%%%s)' % '|'.join(directives),
+(r'^(\s*)(%%(%s))' % '|'.join(directives),
 bygroups(Text, Keyword.Reserved)),
 (r'(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$', bygroups(Text, Comment.Single)),
 (r'(\s*)(\|{3}.*?)$', bygroups(Text, Comment.Single)),
 (r'(\s*)(\{-)', bygroups(Text, Comment.Multiline), 'comment'),
 # Declaration
 (r'\{!', Comment.Directive, 'hole'),
 # Lexemes:
 #  Identifiers
 (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
 (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
-(r'\b(Set|Prop)\b', Keyword.Type),
+(u'\\b(Set|Prop)[\u2080-\u2089]*\\b', Keyword.Type),
 #  Special Symbols
 (r'(\(|\)|\{|\})', Operator),
-(u'(\\.{1,3}|\\||\u039B|\u2200|\u2192|:|=|->)', Operator.Word),
+(u'(\\.{1,3}|\\||\u03BB|\u2200|\u2192|:|=|->)', Operator.Word),
 #  Numbers
 (r'\d+[eE][+-]?\d+', Number.Float),
 (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
 (r'0[xX][\da-fA-F]+', Number.Hex),
 (r'\d+', Number.Integer),
 'funclist': [
 (r'\s+', Text),
 (r'[A-Z]\w*', Keyword.Type),
 (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
 # TODO: these don't match the comments in docs, remove.
-#(r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
+# (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
-#(r'{-', Comment.Multiline, 'comment'),
+# (r'{-', Comment.Multiline, 'comment'),
 (r',', Punctuation),
 (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
 # (HACK, but it makes sense to push two instances, believe me)
 (r'\(', Punctuation, ('funclist', 'funclist')),
 (r'\)', Punctuation, '#pop:2'),
 (r'\d+', String.Escape, '#pop'),
 (r'\s+\\', String.Escape, '#pop'),
 ],
 }
-EXTRA_KEYWORDS = set(('join', 'split', 'reverse', 'transpose', 'width',
+EXTRA_KEYWORDS = {'join', 'split', 'reverse', 'transpose', 'width',
 'length', 'tail', '<<', '>>', '<<<', '>>>', 'const',
 'reg', 'par', 'seq', 'ASSERT', 'undefined', 'error',
-'trace'))
+'trace'}
 def get_tokens_unprocessed(self, text):
 stack = ['root']
 for index, token, value in \
 RegexLexer.get_tokens_unprocessed(self, text, stack):

Mercurial Repositories > eric / file comparison

comparison: eric6/ThirdParty/Pygments/pygments/lexers/haskell.py

eric6/ThirdParty/Pygments/pygments/lexers/haskell.py