Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	11 KB	-rw-r--r--
_asy_builtins.py	26.65 KB	-rw-r--r--
_cl_builtins.py	13.67 KB	-rw-r--r--
_cocoa_builtins.py	102.72 KB	-rw-r--r--
_csound_builtins.py	17.84 KB	-rw-r--r--
_julia_builtins.py	11.6 KB	-rw-r--r--
_lasso_builtins.py	131.36 KB	-rw-r--r--
_lilypond_builtins.py	101.67 KB	-rw-r--r--
_lua_builtins.py	8.08 KB	-rw-r--r--
_mapping.py	62.33 KB	-rw-r--r--
_mql_builtins.py	24.13 KB	-rw-r--r--
_mysql_builtins.py	23.92 KB	-rw-r--r--
_openedge_builtins.py	48.24 KB	-rw-r--r--
_php_builtins.py	150.72 KB	-rw-r--r--
_postgres_builtins.py	11.9 KB	-rw-r--r--
_scilab_builtins.py	51.15 KB	-rw-r--r--
_sourcemod_builtins.py	26.42 KB	-rw-r--r--
_stan_builtins.py	10.21 KB	-rw-r--r--
_stata_builtins.py	26.59 KB	-rw-r--r--
_tsql_builtins.py	15.1 KB	-rw-r--r--
_usd_builtins.py	1.62 KB	-rw-r--r--
_vbscript_builtins.py	4.13 KB	-rw-r--r--
_vim_builtins.py	55.73 KB	-rw-r--r--
actionscript.py	11.31 KB	-rw-r--r--
agile.py	876 B	-rw-r--r--
algebra.py	7.59 KB	-rw-r--r--
ambient.py	2.54 KB	-rw-r--r--
amdgpu.py	1.57 KB	-rw-r--r--
ampl.py	4.05 KB	-rw-r--r--
apdlexer.py	26.04 KB	-rw-r--r--
apl.py	3.32 KB	-rw-r--r--
archetype.py	11.17 KB	-rw-r--r--
arrow.py	3.47 KB	-rw-r--r--
asc.py	1.54 KB	-rw-r--r--
asm.py	40.19 KB	-rw-r--r--
automation.py	19.34 KB	-rw-r--r--
bare.py	2.97 KB	-rw-r--r--
basic.py	27.22 KB	-rw-r--r--
bdd.py	1.59 KB	-rw-r--r--
bibtex.py	4.62 KB	-rw-r--r--
boa.py	3.87 KB	-rw-r--r--
business.py	27.4 KB	-rw-r--r--
c_cpp.py	15.67 KB	-rw-r--r--
c_like.py	28.45 KB	-rw-r--r--
capnproto.py	2.17 KB	-rw-r--r--
cddl.py	5.2 KB	-rw-r--r--
chapel.py	4.89 KB	-rw-r--r--
clean.py	6.24 KB	-rw-r--r--
compiled.py	1.33 KB	-rw-r--r--
configs.py	39.49 KB	-rw-r--r--
console.py	4.05 KB	-rw-r--r--
crystal.py	15.41 KB	-rw-r--r--
csound.py	16.56 KB	-rw-r--r--
css.py	31.15 KB	-rw-r--r--
d.py	9.61 KB	-rw-r--r--
dalvik.py	4.47 KB	-rw-r--r--
data.py	23.96 KB	-rw-r--r--
devicetree.py	3.92 KB	-rw-r--r--
diff.py	5.04 KB	-rw-r--r--
dotnet.py	28.47 KB	-rw-r--r--
dsls.py	35.45 KB	-rw-r--r--
dylan.py	10.16 KB	-rw-r--r--
ecl.py	6.09 KB	-rw-r--r--
eiffel.py	2.6 KB	-rw-r--r--
elm.py	3.08 KB	-rw-r--r--
elpi.py	5.83 KB	-rw-r--r--
email.py	4.97 KB	-rw-r--r--
erlang.py	18.76 KB	-rw-r--r--
esoteric.py	10.17 KB	-rw-r--r--
ezhil.py	3.27 KB	-rw-r--r--
factor.py	19.12 KB	-rw-r--r--
fantom.py	9.96 KB	-rw-r--r--
felix.py	9.41 KB	-rw-r--r--
floscript.py	2.6 KB	-rw-r--r--
forth.py	6.99 KB	-rw-r--r--
fortran.py	10.07 KB	-rw-r--r--
foxpro.py	25.6 KB	-rw-r--r--
freefem.py	26.43 KB	-rw-r--r--
functional.py	674 B	-rw-r--r--
futhark.py	3.64 KB	-rw-r--r--
gcodelexer.py	826 B	-rw-r--r--
gdscript.py	10.94 KB	-rw-r--r--
go.py	3.65 KB	-rw-r--r--
grammar_notation.py	7.83 KB	-rw-r--r--
graph.py	3.77 KB	-rw-r--r--
graphics.py	38.15 KB	-rw-r--r--
graphviz.py	1.83 KB	-rw-r--r--
gsql.py	3.68 KB	-rw-r--r--
haskell.py	31.98 KB	-rw-r--r--
haxe.py	30.21 KB	-rw-r--r--
hdl.py	21.99 KB	-rw-r--r--
hexdump.py	3.52 KB	-rw-r--r--
html.py	19.34 KB	-rw-r--r--
idl.py	14.87 KB	-rw-r--r--
igor.py	29.87 KB	-rw-r--r--
inferno.py	3.02 KB	-rw-r--r--
installers.py	12.8 KB	-rw-r--r--
int_fiction.py	55.32 KB	-rw-r--r--
iolang.py	1.84 KB	-rw-r--r--
j.py	4.4 KB	-rw-r--r--
javascript.py	58.67 KB	-rw-r--r--
jslt.py	3.61 KB	-rw-r--r--
julia.py	11 KB	-rw-r--r--
jvm.py	70.05 KB	-rw-r--r--
kuin.py	10.5 KB	-rw-r--r--
lilypond.py	8.26 KB	-rw-r--r--
lisp.py	139.4 KB	-rw-r--r--
make.py	7.26 KB	-rw-r--r--
markup.py	26.11 KB	-rw-r--r--
math.py	676 B	-rw-r--r--
matlab.py	129.3 KB	-rw-r--r--
maxima.py	2.65 KB	-rw-r--r--
meson.py	4.33 KB	-rw-r--r--
mime.py	7.36 KB	-rw-r--r--
ml.py	34.47 KB	-rw-r--r--
modeling.py	13.07 KB	-rw-r--r--
modula2.py	51.82 KB	-rw-r--r--
monte.py	6.14 KB	-rw-r--r--
mosel.py	8.97 KB	-rw-r--r--
ncl.py	62.46 KB	-rw-r--r--
nimrod.py	5 KB	-rw-r--r--
nit.py	2.66 KB	-rw-r--r--
nix.py	3.91 KB	-rw-r--r--
oberon.py	4.11 KB	-rw-r--r--
objective.py	22.26 KB	-rw-r--r--
ooc.py	2.91 KB	-rw-r--r--
other.py	1.7 KB	-rw-r--r--
parasail.py	2.65 KB	-rw-r--r--
parsers.py	25.27 KB	-rw-r--r--
pascal.py	31.84 KB	-rw-r--r--
pawn.py	7.96 KB	-rw-r--r--
perl.py	38.16 KB	-rw-r--r--
php.py	12.25 KB	-rw-r--r--
pointless.py	1.92 KB	-rw-r--r--
pony.py	3.17 KB	-rw-r--r--
praat.py	11.99 KB	-rw-r--r--
procfile.py	1.19 KB	-rw-r--r--
prolog.py	12.09 KB	-rw-r--r--
promql.py	4.63 KB	-rw-r--r--
python.py	51.49 KB	-rw-r--r--
qvt.py	5.93 KB	-rw-r--r--
r.py	6.02 KB	-rw-r--r--
rdf.py	15.42 KB	-rw-r--r--
rebol.py	18.16 KB	-rw-r--r--
resource.py	2.83 KB	-rw-r--r--
ride.py	4.93 KB	-rw-r--r--
rita.py	1.16 KB	-rw-r--r--
rnc.py	1.92 KB	-rw-r--r--
roboconf.py	2 KB	-rw-r--r--
robotframework.py	17.99 KB	-rw-r--r--
ruby.py	22.14 KB	-rw-r--r--
rust.py	7.99 KB	-rw-r--r--
sas.py	9.2 KB	-rw-r--r--
savi.py	4.24 KB	-rw-r--r--
scdoc.py	2.19 KB	-rw-r--r--
scripting.py	68.41 KB	-rw-r--r--
sgf.py	2 KB	-rw-r--r--
shell.py	35.06 KB	-rw-r--r--
sieve.py	2.24 KB	-rw-r--r--
slash.py	8.28 KB	-rw-r--r--
smalltalk.py	7.02 KB	-rw-r--r--
smithy.py	2.6 KB	-rw-r--r--
smv.py	2.71 KB	-rw-r--r--
snobol.py	2.67 KB	-rw-r--r--
solidity.py	3.1 KB	-rw-r--r--
sophia.py	3.29 KB	-rw-r--r--
special.py	3.37 KB	-rw-r--r--
spice.py	2.06 KB	-rw-r--r--
sql.py	33.42 KB	-rw-r--r--
srcinfo.py	1.63 KB	-rw-r--r--
stata.py	6.26 KB	-rw-r--r--
supercollider.py	3.61 KB	-rw-r--r--
tcl.py	5.27 KB	-rw-r--r--
teal.py	3.41 KB	-rw-r--r--
templates.py	69.96 KB	-rw-r--r--
teraterm.py	9.65 KB	-rw-r--r--
testing.py	10.52 KB	-rw-r--r--
text.py	1006 B	-rw-r--r--
textedit.py	7.44 KB	-rw-r--r--
textfmts.py	14.8 KB	-rw-r--r--
theorem.py	19.15 KB	-rw-r--r--
thingsdb.py	4.13 KB	-rw-r--r--
tnt.py	10.27 KB	-rw-r--r--
trafficscript.py	1.48 KB	-rw-r--r--
typoscript.py	8.01 KB	-rw-r--r--
unicon.py	18.08 KB	-rw-r--r--
urbi.py	5.9 KB	-rw-r--r--
usd.py	3.37 KB	-rw-r--r--
varnish.py	7.07 KB	-rw-r--r--
verification.py	3.82 KB	-rw-r--r--
web.py	894 B	-rw-r--r--
webassembly.py	5.56 KB	-rw-r--r--
webidl.py	10.23 KB	-rw-r--r--
webmisc.py	39.07 KB	-rw-r--r--
whiley.py	3.89 KB	-rw-r--r--
x10.py	1.84 KB	-rw-r--r--
xorg.py	865 B	-rw-r--r--
yang.py	4.42 KB	-rw-r--r--
zig.py	3.85 KB	-rw-r--r--

Code Editor : haskell.py

"""
    pygments.lexers.haskell
    ~~~~~~~~~~~~~~~~~~~~~~~

Lexers for Haskell and related languages.

:copyright: Copyright 2006-2021 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, inherit
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
    Number, Punctuation, Generic, Whitespace
from pygments import unistring as uni

__all__ = ['HaskellLexer', 'HspecLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexer',
           'LiterateHaskellLexer', 'LiterateIdrisLexer', 'LiterateAgdaLexer',
           'LiterateCryptolLexer', 'KokaLexer']

line_re = re.compile('.*?\n')

class HaskellLexer(RegexLexer):
    """
    A Haskell lexer based on the lexemes defined in the Haskell 98 Report.

.. versionadded:: 0.8
    """
    name = 'Haskell'
    aliases = ['haskell', 'hs']
    filenames = ['*.hs']
    mimetypes = ['text/x-haskell']

flags = re.MULTILINE | re.UNICODE

reserved = ('case', 'class', 'data', 'default', 'deriving', 'do', 'else',
                'family', 'if', 'in', 'infix[lr]?', 'instance',
                'let', 'newtype', 'of', 'then', 'type', 'where', '_')
    ascii = ('NUL', 'SOH', '[SE]TX', 'EOT', 'ENQ', 'ACK',
             'BEL', 'BS', 'HT', 'LF', 'VT', 'FF', 'CR', 'S[OI]', 'DLE',
             'DC[1-4]', 'NAK', 'SYN', 'ETB', 'CAN',
             'EM', 'SUB', 'ESC', '[FGRU]S', 'SP', 'DEL')

tokens = {
        'root': [
            # Whitespace:
            (r'\s+', Whitespace),
            # (r'--\s*|.*$', Comment.Doc),
            (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
            (r'\{-', Comment.Multiline, 'comment'),
            # Lexemes:
            #  Identifiers
            (r'\bimport\b', Keyword.Reserved, 'import'),
            (r'\bmodule\b', Keyword.Reserved, 'module'),
            (r'\berror\b', Name.Exception),
            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
            (r"'[^\\]'", String.Char),  # this has to come before the TH quote
            (r'^[_' + uni.Ll + r'][\w\']*', Name.Function),
            (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])*'
             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'\d(_*\d)*', Number.Integer),
            #  Character/String Literals
            (r"'", String.Char, 'character'),
            (r'"', String, 'string'),
            #  Special
            (r'\[\]', Keyword.Type),
            (r'', Name.Builtin),
            (r'[][(),;`{}]', Punctuation),
        ],
        'import': [
            # Import statements
            (r'\s+', Whitespace),
            (r'"', String, 'string'),
            # after "funclist" state
            (r'\)', Punctuation, '#pop'),
            (r'qualified\b', Keyword),
            # import X as Y
            (r'([' + uni.Lu + r'][\w.]*)(\s+)(as)(\s+)([' + uni.Lu + r'][\w.]*)',
             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Name), '#pop'),
            # import X hiding (functions)
            (r'([' + uni.Lu + r'][\w.]*)(\s+)(hiding)(\s+)(\()',
             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Punctuation), 'funclist'),
            # import X (functions)
            (r'([' + uni.Lu + r'][\w.]*)(\s+)($)',
             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
            # import X
            (r'[\w.]+', Name.Namespace, '#pop'),
        ],
        'module': [
            (r'\s+', Whitespace),
            (r'([' + uni.Lu + r'][\w.]*)(\s+)(\()',
             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
            (r'[' + uni.Lu + r'][\w.]*', Name.Namespace, '#pop'),
        ],
        'funclist': [
            (r'\s+', Whitespace),
            (r'[' + uni.Lu + r']\w*', Keyword.Type),
            (r'(_[\w\']+|[' + uni.Ll + r'][\w\']*)', Name.Function),
            (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
            (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'),
        ],
        # NOTE: the next four states are shared in the AgdaLexer; make sure
        # any change is compatible with Agda as well or copy over and change
        'comment': [
            # Multiline Comments
            (r'[^-{}]+', Comment.Multiline),
            (r'\{-', Comment.Multiline, '#push'),
            (r'-\}', Comment.Multiline, '#pop'),
            (r'[-{}]', Comment.Multiline),
        ],
        'character': [
            # Allows multi-chars, incorrectly.
            (r"[^\\']'", String.Char, '#pop'),
            (r"\\", String.Escape, 'escape'),
            ("'", String.Char, '#pop'),
        ],
        'string': [
            (r'[^\\"]+', String),
            (r"\\", String.Escape, 'escape'),
            ('"', String, '#pop'),
        ],
        'escape': [
            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
            (r'\^[][' + uni.Lu + r'@^_]', String.Escape, '#pop'),
            ('|'.join(ascii), String.Escape, '#pop'),
            (r'o[0-7]+', String.Escape, '#pop'),
            (r'x[\da-fA-F]+', String.Escape, '#pop'),
            (r'\d+', String.Escape, '#pop'),
            (r'(\s+)(\\)', bygroups(Whitespace, 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, Whitespace, String.Doc)),
            (r'(describe)(\s*)("[^"]*")', bygroups(Text, Whitespace, String.Doc)),
            (r'(context)(\s*)("[^"]*")', bygroups(Text, Whitespace, String.Doc)),
            inherit,
        ],
    }

class IdrisLexer(RegexLexer):
    """
    A lexer for the dependently typed programming language Idris.

Based on the Haskell and Agda Lexer.

.. versionadded:: 2.0
    """
    name = 'Idris'
    aliases = ['idris', 'idr']
    filenames = ['*.idr']
    mimetypes = ['text/x-idris']

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')

ascii = ('NUL', 'SOH', '[SE]TX', 'EOT', 'ENQ', 'ACK',
             'BEL', 'BS', 'HT', 'LF', 'VT', 'FF', 'CR', 'S[OI]', 'DLE',
             'DC[1-4]', 'NAK', 'SYN', 'ETB', 'CAN',
             'EM', 'SUB', 'ESC', '[FGRU]S', 'SP', 'DEL')

directives = ('lib', 'link', 'flag', 'include', 'hide', 'freeze', 'access',
                  'default', 'logging', 'dynamic', 'name', 'error_handlers', 'language')

tokens = {
        'root': [
            # Comments
            (r'^(\s*)(%%(%s))' % '|'.join(directives),
             bygroups(Whitespace, Keyword.Reserved)),
            (r'(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$', bygroups(Whitespace, Comment.Single)),
            (r'(\s*)(\|{3}.*?)$', bygroups(Whitespace, Comment.Single)),
            (r'(\s*)(\{-)', bygroups(Whitespace, Comment.Multiline), 'comment'),
            # Declaration
            (r'^(\s*)([^\s(){}]+)(\s*)(:)(\s*)',
             bygroups(Whitespace, Name.Function, Whitespace, Operator.Word, Whitespace)),
            #  Identifiers
            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace), 'module'),
            (r"('')?[A-Z][\w\']*", Keyword.Type),
            (r'[a-z][\w\']*', Text),
            #  Special Symbols
            (r'(<-|::|->|=>|=)', Operator.Word),  # specials
            (r'([(){}\[\]:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word),  # specials
            #  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),
            # Strings
            (r"'", String.Char, 'character'),
            (r'"', String, 'string'),
            (r'[^\s(){}]+', Text),
            (r'\s+?', Whitespace),  # Whitespace
        ],
        'module': [
            (r'\s+', Whitespace),
            (r'([A-Z][\w.]*)(\s+)($)',
             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
            (r'[A-Z][\w.]*', Name.Namespace, '#pop'),
        ],
        'funclist': [
            (r'\s+', Whitespace),
            (r'[A-Z]\w*', Keyword.Type),
            (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
            (r'--.*$', Comment.Single),
            (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'),
        ],
        # NOTE: the next four states are shared in the AgdaLexer; make sure
        # any change is compatible with Agda as well or copy over and change
        'comment': [
            # Multiline Comments
            (r'[^-{}]+', Comment.Multiline),
            (r'\{-', Comment.Multiline, '#push'),
            (r'-\}', Comment.Multiline, '#pop'),
            (r'[-{}]', Comment.Multiline),
        ],
        'character': [
            # Allows multi-chars, incorrectly.
            (r"[^\\']", String.Char),
            (r"\\", String.Escape, 'escape'),
            ("'", String.Char, '#pop'),
        ],
        'string': [
            (r'[^\\"]+', String),
            (r"\\", String.Escape, 'escape'),
            ('"', String, '#pop'),
        ],
        'escape': [
            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
            (r'\^[][A-Z@^_]', String.Escape, '#pop'),
            ('|'.join(ascii), String.Escape, '#pop'),
            (r'o[0-7]+', String.Escape, '#pop'),
            (r'x[\da-fA-F]+', String.Escape, '#pop'),
            (r'\d+', String.Escape, '#pop'),
            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop')
        ],
    }

class AgdaLexer(RegexLexer):
    """
    For the `Agda <http://wiki.portal.chalmers.se/agda/pmwiki.php>`_
    dependently typed functional programming language and proof assistant.

.. versionadded:: 2.0
    """

name = 'Agda'
    aliases = ['agda']
    filenames = ['*.agda']
    mimetypes = ['text/x-agda']

reserved = ['abstract', 'codata', 'coinductive', 'constructor', 'data',
                'field', 'forall', 'hiding', 'in', 'inductive', 'infix',
                'infixl', 'infixr', 'instance', 'let', 'mutual', 'open',
                'pattern', 'postulate', 'primitive', 'private',
                'quote', 'quoteGoal', 'quoteTerm',
                'record', 'renaming', 'rewrite', 'syntax', 'tactic',
                'unquote', 'unquoteDecl', 'using', 'where', 'with']

tokens = {
        'root': [
            # Declaration
            (r'^(\s*)([^\s(){}]+)(\s*)(:)(\s*)',
             bygroups(Whitespace, Name.Function, Whitespace, Operator.Word, Whitespace)),
            # Comments
            (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
            (r'\{-', Comment.Multiline, 'comment'),
            # Holes
            (r'\{!', Comment.Directive, 'hole'),
            # Lexemes:
            #  Identifiers
            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace), 'module'),
            (r'\b(Set|Prop)[\u2080-\u2089]*\b', Keyword.Type),
            #  Special Symbols
            (r'($|$|\{|\})', Operator),
            (r'(\.{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),
            # Strings
            (r"'", String.Char, 'character'),
            (r'"', String, 'string'),
            (r'[^\s(){}]+', Text),
            (r'\s+?', Whitespace),  # Whitespace
        ],
        'hole': [
            # Holes
            (r'[^!{}]+', Comment.Directive),
            (r'\{!', Comment.Directive, '#push'),
            (r'!\}', Comment.Directive, '#pop'),
            (r'[!{}]', Comment.Directive),
        ],
        'module': [
            (r'\{-', Comment.Multiline, 'comment'),
            (r'[a-zA-Z][\w.]*', Name, '#pop'),
            (r'[\W0-9_]+', Text)
        ],
        'comment': HaskellLexer.tokens['comment'],
        'character': HaskellLexer.tokens['character'],
        'string': HaskellLexer.tokens['string'],
        'escape': HaskellLexer.tokens['escape']
    }

class CryptolLexer(RegexLexer):
    """
    FIXME: A Cryptol2 lexer based on the lexemes defined in the Haskell 98 Report.

.. versionadded:: 2.0
    """
    name = 'Cryptol'
    aliases = ['cryptol', 'cry']
    filenames = ['*.cry']
    mimetypes = ['text/x-cryptol']

reserved = ('Arith', 'Bit', 'Cmp', 'False', 'Inf', 'True', 'else',
                'export', 'extern', 'fin', 'if', 'import', 'inf', 'lg2',
                'max', 'min', 'module', 'newtype', 'pragma', 'property',
                'then', 'type', 'where', 'width')
    ascii = ('NUL', 'SOH', '[SE]TX', 'EOT', 'ENQ', 'ACK',
             'BEL', 'BS', 'HT', 'LF', 'VT', 'FF', 'CR', 'S[OI]', 'DLE',
             'DC[1-4]', 'NAK', 'SYN', 'ETB', 'CAN',
             'EM', 'SUB', 'ESC', '[FGRU]S', 'SP', 'DEL')

tokens = {
        'root': [
            # Whitespace:
            (r'\s+', Whitespace),
            # (r'--\s*|.*$', Comment.Doc),
            (r'//.*$', Comment.Single),
            (r'/\*', Comment.Multiline, 'comment'),
            # Lexemes:
            #  Identifiers
            (r'\bimport\b', Keyword.Reserved, 'import'),
            (r'\bmodule\b', Keyword.Reserved, 'module'),
            (r'\berror\b', Name.Exception),
            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
            (r'^[_a-z][\w\']*', Name.Function),
            (r"'?[_a-z][\w']*", Name),
            (r"('')?[A-Z][\w\']*", Keyword.Type),
            #  Operators
            (r'\$?![:!#$%&*+.\\/<=>?@^|~-]+)', Name.Function),  # lambda operator
            (r'(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word),  # specials
            (r':[:!#$%&*+.\\/<=>?@^|~-]*', Keyword.Type),  # Constructor operators
            (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),  # Other operators
            #  Numbers
            (r'\d+[eE][+-]?\d+', Number.Float),
            (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
            (r'0[oO][0-7]+', Number.Oct),
            (r'0[xX][\da-fA-F]+', Number.Hex),
            (r'\d+', Number.Integer),
            #  Character/String Literals
            (r"'", String.Char, 'character'),
            (r'"', String, 'string'),
            #  Special
            (r'\[\]', Keyword.Type),
            (r'\($', Name.Builtin),
            (r'[][(),;`{}]', Punctuation),
        ],
        'import': [
            # Import statements
            (r'\s+', Whitespace),
            (r'"', String, 'string'),
            # after "funclist" state
            (r'\)', Punctuation, '#pop'),
            (r'qualified\b', Keyword),
            # import X as Y
            (r'([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][\w.]*)',
             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Name), '#pop'),
            # import X hiding (functions)
            (r'([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()',
             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Punctuation), 'funclist'),
            # import X (functions)
            (r'([A-Z][\w.]*)(\s+)($)',
             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
            # import X
            (r'[\w.]+', Name.Namespace, '#pop'),
        ],
        'module': [
            (r'\s+', Whitespace),
            (r'([A-Z][\w.]*)(\s+)(\()',
             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
            (r'[A-Z][\w.]*', Name.Namespace, '#pop'),
        ],
        'funclist': [
            (r'\s+', Whitespace),
            (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.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'),
        ],
        'comment': [
            # Multiline Comments
            (r'[^/*]+', Comment.Multiline),
            (r'/\*', Comment.Multiline, '#push'),
            (r'\*/', Comment.Multiline, '#pop'),
            (r'[*/]', Comment.Multiline),
        ],
        'character': [
            # Allows multi-chars, incorrectly.
            (r"[^\\']'", String.Char, '#pop'),
            (r"\\", String.Escape, 'escape'),
            ("'", String.Char, '#pop'),
        ],
        'string': [
            (r'[^\\"]+', String),
            (r"\\", String.Escape, 'escape'),
            ('"', String, '#pop'),
        ],
        'escape': [
            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
            (r'\^[][A-Z@^_]', String.Escape, '#pop'),
            ('|'.join(ascii), String.Escape, '#pop'),
            (r'o[0-7]+', String.Escape, '#pop'),
            (r'x[\da-fA-F]+', String.Escape, '#pop'),
            (r'\d+', String.Escape, '#pop'),
            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop'),
        ],
    }

EXTRA_KEYWORDS = {'join', 'split', 'reverse', 'transpose', 'width',
                      'length', 'tail', '<<', '>>', '<<<', '>>>', 'const',
                      'reg', 'par', 'seq', 'ASSERT', 'undefined', 'error',
                      'trace'}

def get_tokens_unprocessed(self, text):
        stack = ['root']
        for index, token, value in \
                RegexLexer.get_tokens_unprocessed(self, text, stack):
            if token is Name and value in self.EXTRA_KEYWORDS:
                yield index, Name.Builtin, value
            else:
                yield index, token, value

class LiterateLexer(Lexer):
    """
    Base class for lexers of literate file formats based on LaTeX or Bird-style
    (prefixing each code line with ">").

Additional options accepted:

`litstyle`
        If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
        is autodetected: if the first non-whitespace character in the source
        is a backslash or percent character, LaTeX is assumed, else Bird.
    """

bird_re = re.compile(r'(>[ \t]*)(.*\n)')

def __init__(self, baselexer, **options):
        self.baselexer = baselexer
        Lexer.__init__(self, **options)

def get_tokens_unprocessed(self, text):
        style = self.options.get('litstyle')
        if style is None:
            style = (text.lstrip()[0:1] in '%\\') and 'latex' or 'bird'

code = ''
        insertions = []
        if style == 'bird':
            # bird-style
            for match in line_re.finditer(text):
                line = match.group()
                m = self.bird_re.match(line)
                if m:
                    insertions.append((len(code),
                                       [(0, Comment.Special, m.group(1))]))
                    code += m.group(2)
                else:
                    insertions.append((len(code), [(0, Text, line)]))
        else:
            # latex-style
            from pygments.lexers.markup import TexLexer
            lxlexer = TexLexer(**self.options)
            codelines = 0
            latex = ''
            for match in line_re.finditer(text):
                line = match.group()
                if codelines:
                    if line.lstrip().startswith('\\end{code}'):
                        codelines = 0
                        latex += line
                    else:
                        code += line
                elif line.lstrip().startswith('\\begin{code}'):
                    codelines = 1
                    latex += line
                    insertions.append((len(code),
                                       list(lxlexer.get_tokens_unprocessed(latex))))
                    latex = ''
                else:
                    latex += line
            insertions.append((len(code),
                               list(lxlexer.get_tokens_unprocessed(latex))))
        yield from do_insertions(insertions, self.baselexer.get_tokens_unprocessed(code))

class LiterateHaskellLexer(LiterateLexer):
    """
    For Literate Haskell (Bird-style or LaTeX) source.

Additional options accepted:

.. versionadded:: 0.9
    """
    name = 'Literate Haskell'
    aliases = ['literate-haskell', 'lhaskell', 'lhs']
    filenames = ['*.lhs']
    mimetypes = ['text/x-literate-haskell']

def __init__(self, **options):
        hslexer = HaskellLexer(**options)
        LiterateLexer.__init__(self, hslexer, **options)

class LiterateIdrisLexer(LiterateLexer):
    """
    For Literate Idris (Bird-style or LaTeX) source.

Additional options accepted:

.. versionadded:: 2.0
    """
    name = 'Literate Idris'
    aliases = ['literate-idris', 'lidris', 'lidr']
    filenames = ['*.lidr']
    mimetypes = ['text/x-literate-idris']

def __init__(self, **options):
        hslexer = IdrisLexer(**options)
        LiterateLexer.__init__(self, hslexer, **options)

class LiterateAgdaLexer(LiterateLexer):
    """
    For Literate Agda source.

Additional options accepted:

.. versionadded:: 2.0
    """
    name = 'Literate Agda'
    aliases = ['literate-agda', 'lagda']
    filenames = ['*.lagda']
    mimetypes = ['text/x-literate-agda']

def __init__(self, **options):
        agdalexer = AgdaLexer(**options)
        LiterateLexer.__init__(self, agdalexer, litstyle='latex', **options)

class LiterateCryptolLexer(LiterateLexer):
    """
    For Literate Cryptol (Bird-style or LaTeX) source.

Additional options accepted:

.. versionadded:: 2.0
    """
    name = 'Literate Cryptol'
    aliases = ['literate-cryptol', 'lcryptol', 'lcry']
    filenames = ['*.lcry']
    mimetypes = ['text/x-literate-cryptol']

def __init__(self, **options):
        crylexer = CryptolLexer(**options)
        LiterateLexer.__init__(self, crylexer, **options)

class KokaLexer(RegexLexer):
    """
    Lexer for the `Koka <http://koka.codeplex.com>`_
    language.

.. versionadded:: 1.6
    """

name = 'Koka'
    aliases = ['koka']
    filenames = ['*.kk', '*.kki']
    mimetypes = ['text/x-koka']

keywords = [
        'infix', 'infixr', 'infixl',
        'type', 'cotype', 'rectype', 'alias',
        'struct', 'con',
        'fun', 'function', 'val', 'var',
        'external',
        'if', 'then', 'else', 'elif', 'return', 'match',
        'private', 'public', 'private',
        'module', 'import', 'as',
        'include', 'inline',
        'rec',
        'try', 'yield', 'enum',
        'interface', 'instance',
    ]

# keywords that are followed by a type
    typeStartKeywords = [
        'type', 'cotype', 'rectype', 'alias', 'struct', 'enum',
    ]

# keywords valid in a type
    typekeywords = [
        'forall', 'exists', 'some', 'with',
    ]

# builtin names and special names
    builtin = [
        'for', 'while', 'repeat',
        'foreach', 'foreach-indexed',
        'error', 'catch', 'finally',
        'cs', 'js', 'file', 'ref', 'assigned',
    ]

# symbols that can be in an operator
    symbols = r'[$%&*+@!/\\^~=.:\-?|<>]+'

# symbol boundary: an operator keyword should not be followed by any of these
    sboundary = '(?!' + symbols + ')'

# name boundary: a keyword should not be followed by any of these
    boundary = r'(?![\w/])'

# koka token abstractions
    tokenType = Name.Attribute
    tokenTypeDef = Name.Class
    tokenConstructor = Generic.Emph

# main lexer
    tokens = {
        'root': [
            include('whitespace'),

# go into type mode
            (r'::?' + sboundary, tokenType, 'type'),
            (r'(alias)(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
             'alias-type'),
            (r'(struct)(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
             'struct-type'),
            ((r'(%s)' % '|'.join(typeStartKeywords)) +
             r'(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
             'type'),

# special sequences of tokens (we use ?: for non-capturing group as
            # required by 'bygroups')
            (r'(module)(\s+)(interface(?=\s))?(\s+)?((?:[a-z]\w*/)*[a-z]\w*)',
             bygroups(Keyword, Whitespace, Keyword, Whitespace, Name.Namespace)),
            (r'(import)(\s+)((?:[a-z]\w*/)*[a-z]\w*)'
             r'(?:(\s*)(=)(\s*)(qualified)?(\s*)'
             r'((?:[a-z]\w*/)*[a-z]\w*))?',
             bygroups(Keyword, Whitespace, Name.Namespace, Whitespace, Keyword, Whitespace,
                      Keyword, Whitespace, Name.Namespace)),

(r'^(public|private)?(\s+)?(function|fun|val)'
             r'(\s+)([a-z]\w*|$(?:' + symbols + r'|/)$)',
             bygroups(Keyword, Whitespace, Keyword, Whitespace, Name.Function)),
            (r'^(?:(public|private)(?=\s+external))?((?<!^)\s+)?(external)(\s+)(inline(?=\s))?(\s+)?'
             r'([a-z]\w*|$(?:' + symbols + r'|/)$)',
             bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword, Whitespace, Name.Function)),

# names
            (r'((?:[a-z]\w*/)*)([A-Z]\w*)',
             bygroups(Name.Namespace, tokenConstructor)),
            (r'((?:[a-z]\w*/)*)([a-z]\w*)', bygroups(Name.Namespace, Name)),
            (r'((?:[a-z]\w*/)*)($(?:' + symbols + r'|/)$)',
             bygroups(Name.Namespace, Name)),
            (r'_\w*', Name.Variable),

# literal string
            (r'@"', String.Double, 'litstring'),

# operators
            (symbols + "|/(?![*/])", Operator),
            (r'`', Operator),
            (r'[{}()\[\];,]', Punctuation),

# literals. No check for literal characters with len > 1
            (r'[0-9]+\.[0-9]+([eE][\-+]?[0-9]+)?', Number.Float),
            (r'0[xX][0-9a-fA-F]+', Number.Hex),
            (r'[0-9]+', Number.Integer),

(r"'", String.Char, 'char'),
            (r'"', String.Double, 'string'),
        ],

# type started by alias
        'alias-type': [
            (r'=', Keyword),
            include('type')
        ],

# type started by struct
        'struct-type': [
            (r'(?=$(?!,*$))', Punctuation, '#pop'),
            include('type')
        ],

# type started by colon
        'type': [
            (r'[(\[<]', tokenType, 'type-nested'),
            include('type-content')
        ],

# type nested in brackets: can contain parameters, comma etc.
        'type-nested': [
            (r'[)\]>]', tokenType, '#pop'),
            (r'[(\[<]', tokenType, 'type-nested'),
            (r',', tokenType),
            (r'([a-z]\w*)(\s*)(:)(?!:)',
             bygroups(Name, Whitespace, tokenType)),  # parameter name
            include('type-content')
        ],

# shared contents of a type
        'type-content': [
            include('whitespace'),

# keywords
            (r'(%s)' % '|'.join(typekeywords) + boundary, Keyword),
            (r'(?=((%s)' % '|'.join(keywords) + boundary + '))',
             Keyword, '#pop'),  # need to match because names overlap...

# kinds
            (r'[EPHVX]' + boundary, tokenType),

# type names
            (r'[a-z][0-9]*(?![\w/])', tokenType),
            (r'_\w*', tokenType.Variable),  # Generic.Emph
            (r'((?:[a-z]\w*/)*)([A-Z]\w*)',
             bygroups(Name.Namespace, tokenType)),
            (r'((?:[a-z]\w*/)*)([a-z]\w+)',
             bygroups(Name.Namespace, tokenType)),

# type keyword operators
            (r'::|->|[.:|]', tokenType),

# catchall
            default('#pop')
        ],

# comments and literals
        'whitespace': [
            (r'(\n\s*)(#.*)$', bygroups(Whitespace, Comment.Preproc)),
            (r'\s+', Whitespace),
            (r'/\*', Comment.Multiline, 'comment'),
            (r'//.*$', Comment.Single)
        ],
        'comment': [
            (r'[^/*]+', Comment.Multiline),
            (r'/\*', Comment.Multiline, '#push'),
            (r'\*/', Comment.Multiline, '#pop'),
            (r'[*/]', Comment.Multiline),
        ],
        'litstring': [
            (r'[^"]+', String.Double),
            (r'""', String.Escape),
            (r'"', String.Double, '#pop'),
        ],
        'string': [
            (r'[^\\"\n]+', String.Double),
            include('escape-sequence'),
            (r'["\n]', String.Double, '#pop'),
        ],
        'char': [
            (r'[^\\\'\n]+', String.Char),
            include('escape-sequence'),
            (r'[\'\n]', String.Char, '#pop'),
        ],
        'escape-sequence': [
            (r'\\[nrt\\"\']', String.Escape),
            (r'\\x[0-9a-fA-F]{2}', String.Escape),
            (r'\\u[0-9a-fA-F]{4}', String.Escape),
            # Yes, \U literals are 6 hex digits.
            (r'\\U[0-9a-fA-F]{6}', String.Escape)
        ]
    }

${this.title}

Code Editor : haskell.py