sending file stats (total lines in file, language name) to api
This commit is contained in:
parent
0707e2dff0
commit
934cc51a6c
|
@ -31,6 +31,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages'))
|
||||
from .log import setup_logging
|
||||
from .project import find_project
|
||||
from .stats import get_file_stats
|
||||
from .packages import argparse
|
||||
from .packages import simplejson as json
|
||||
try:
|
||||
|
@ -122,7 +123,7 @@ def get_user_agent(plugin):
|
|||
return user_agent
|
||||
|
||||
|
||||
def send_action(project=None, branch=None, key=None, targetFile=None,
|
||||
def send_action(project=None, branch=None, stats={}, key=None, targetFile=None,
|
||||
timestamp=None, endtime=None, isWrite=None, plugin=None, **kwargs):
|
||||
url = 'https://www.wakati.me/api/v1/actions'
|
||||
log.debug('Sending action to api at %s' % url)
|
||||
|
@ -130,6 +131,10 @@ def send_action(project=None, branch=None, key=None, targetFile=None,
|
|||
'time': timestamp,
|
||||
'file': targetFile,
|
||||
}
|
||||
if stats.get('lines'):
|
||||
data['lines'] = stats['lines']
|
||||
if stats.get('language'):
|
||||
data['language'] = stats['language']
|
||||
if endtime:
|
||||
data['endtime'] = endtime
|
||||
if isWrite:
|
||||
|
@ -187,11 +192,17 @@ def main(argv=None):
|
|||
if os.path.isfile(args.targetFile):
|
||||
branch = None
|
||||
name = None
|
||||
stats = get_file_stats(args.targetFile)
|
||||
project = find_project(args.targetFile)
|
||||
if project:
|
||||
branch = project.branch()
|
||||
name = project.name()
|
||||
if send_action(project=name, branch=branch, **vars(args)):
|
||||
if send_action(
|
||||
project=name,
|
||||
branch=branch,
|
||||
stats=stats,
|
||||
**vars(args)
|
||||
):
|
||||
return 0
|
||||
return 102
|
||||
else:
|
||||
|
|
|
@ -0,0 +1,91 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Pygments
|
||||
~~~~~~~~
|
||||
|
||||
Pygments is a syntax highlighting package written in Python.
|
||||
|
||||
It is a generic syntax highlighter for general use in all kinds of software
|
||||
such as forum systems, wikis or other applications that need to prettify
|
||||
source code. Highlights are:
|
||||
|
||||
* a wide range of common languages and markup formats is supported
|
||||
* special attention is paid to details, increasing quality by a fair amount
|
||||
* support for new languages and formats are added easily
|
||||
* a number of output formats, presently HTML, LaTeX, RTF, SVG, all image
|
||||
formats that PIL supports, and ANSI sequences
|
||||
* it is usable as a command-line tool and as a library
|
||||
* ... and it highlights even Brainfuck!
|
||||
|
||||
The `Pygments tip`_ is installable with ``easy_install Pygments==dev``.
|
||||
|
||||
.. _Pygments tip:
|
||||
http://bitbucket.org/birkenfeld/pygments-main/get/tip.zip#egg=Pygments-dev
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
__version__ = '1.6'
|
||||
__docformat__ = 'restructuredtext'
|
||||
|
||||
__all__ = ['lex', 'format', 'highlight']
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pygments.util import StringIO, BytesIO
|
||||
|
||||
|
||||
def lex(code, lexer):
|
||||
"""
|
||||
Lex ``code`` with ``lexer`` and return an iterable of tokens.
|
||||
"""
|
||||
try:
|
||||
return lexer.get_tokens(code)
|
||||
except TypeError, err:
|
||||
if isinstance(err.args[0], str) and \
|
||||
'unbound method get_tokens' in err.args[0]:
|
||||
raise TypeError('lex() argument must be a lexer instance, '
|
||||
'not a class')
|
||||
raise
|
||||
|
||||
|
||||
def format(tokens, formatter, outfile=None):
|
||||
"""
|
||||
Format a tokenlist ``tokens`` with the formatter ``formatter``.
|
||||
|
||||
If ``outfile`` is given and a valid file object (an object
|
||||
with a ``write`` method), the result will be written to it, otherwise
|
||||
it is returned as a string.
|
||||
"""
|
||||
try:
|
||||
if not outfile:
|
||||
#print formatter, 'using', formatter.encoding
|
||||
realoutfile = formatter.encoding and BytesIO() or StringIO()
|
||||
formatter.format(tokens, realoutfile)
|
||||
return realoutfile.getvalue()
|
||||
else:
|
||||
formatter.format(tokens, outfile)
|
||||
except TypeError, err:
|
||||
if isinstance(err.args[0], str) and \
|
||||
'unbound method format' in err.args[0]:
|
||||
raise TypeError('format() argument must be a formatter instance, '
|
||||
'not a class')
|
||||
raise
|
||||
|
||||
|
||||
def highlight(code, lexer, formatter, outfile=None):
|
||||
"""
|
||||
Lex ``code`` with ``lexer`` and format it with the formatter ``formatter``.
|
||||
|
||||
If ``outfile`` is given and a valid file object (an object
|
||||
with a ``write`` method), the result will be written to it, otherwise
|
||||
it is returned as a string.
|
||||
"""
|
||||
return format(lex(code, lexer), formatter, outfile)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from pygments.cmdline import main
|
||||
sys.exit(main(sys.argv))
|
|
@ -0,0 +1,441 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.cmdline
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
Command line interface.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
import sys
|
||||
import getopt
|
||||
from textwrap import dedent
|
||||
|
||||
from pygments import __version__, highlight
|
||||
from pygments.util import ClassNotFound, OptionError, docstring_headline
|
||||
from pygments.lexers import get_all_lexers, get_lexer_by_name, get_lexer_for_filename, \
|
||||
find_lexer_class, guess_lexer, TextLexer
|
||||
from pygments.formatters import get_all_formatters, get_formatter_by_name, \
|
||||
get_formatter_for_filename, find_formatter_class, \
|
||||
TerminalFormatter # pylint:disable-msg=E0611
|
||||
from pygments.filters import get_all_filters, find_filter_class
|
||||
from pygments.styles import get_all_styles, get_style_by_name
|
||||
|
||||
|
||||
USAGE = """\
|
||||
Usage: %s [-l <lexer> | -g] [-F <filter>[:<options>]] [-f <formatter>]
|
||||
[-O <options>] [-P <option=value>] [-o <outfile>] [<infile>]
|
||||
|
||||
%s -S <style> -f <formatter> [-a <arg>] [-O <options>] [-P <option=value>]
|
||||
%s -L [<which> ...]
|
||||
%s -N <filename>
|
||||
%s -H <type> <name>
|
||||
%s -h | -V
|
||||
|
||||
Highlight the input file and write the result to <outfile>.
|
||||
|
||||
If no input file is given, use stdin, if -o is not given, use stdout.
|
||||
|
||||
<lexer> is a lexer name (query all lexer names with -L). If -l is not
|
||||
given, the lexer is guessed from the extension of the input file name
|
||||
(this obviously doesn't work if the input is stdin). If -g is passed,
|
||||
attempt to guess the lexer from the file contents, or pass through as
|
||||
plain text if this fails (this can work for stdin).
|
||||
|
||||
Likewise, <formatter> is a formatter name, and will be guessed from
|
||||
the extension of the output file name. If no output file is given,
|
||||
the terminal formatter will be used by default.
|
||||
|
||||
With the -O option, you can give the lexer and formatter a comma-
|
||||
separated list of options, e.g. ``-O bg=light,python=cool``.
|
||||
|
||||
The -P option adds lexer and formatter options like the -O option, but
|
||||
you can only give one option per -P. That way, the option value may
|
||||
contain commas and equals signs, which it can't with -O, e.g.
|
||||
``-P "heading=Pygments, the Python highlighter".
|
||||
|
||||
With the -F option, you can add filters to the token stream, you can
|
||||
give options in the same way as for -O after a colon (note: there must
|
||||
not be spaces around the colon).
|
||||
|
||||
The -O, -P and -F options can be given multiple times.
|
||||
|
||||
With the -S option, print out style definitions for style <style>
|
||||
for formatter <formatter>. The argument given by -a is formatter
|
||||
dependent.
|
||||
|
||||
The -L option lists lexers, formatters, styles or filters -- set
|
||||
`which` to the thing you want to list (e.g. "styles"), or omit it to
|
||||
list everything.
|
||||
|
||||
The -N option guesses and prints out a lexer name based solely on
|
||||
the given filename. It does not take input or highlight anything.
|
||||
If no specific lexer can be determined "text" is returned.
|
||||
|
||||
The -H option prints detailed help for the object <name> of type <type>,
|
||||
where <type> is one of "lexer", "formatter" or "filter".
|
||||
|
||||
The -h option prints this help.
|
||||
The -V option prints the package version.
|
||||
"""
|
||||
|
||||
|
||||
def _parse_options(o_strs):
|
||||
opts = {}
|
||||
if not o_strs:
|
||||
return opts
|
||||
for o_str in o_strs:
|
||||
if not o_str:
|
||||
continue
|
||||
o_args = o_str.split(',')
|
||||
for o_arg in o_args:
|
||||
o_arg = o_arg.strip()
|
||||
try:
|
||||
o_key, o_val = o_arg.split('=')
|
||||
o_key = o_key.strip()
|
||||
o_val = o_val.strip()
|
||||
except ValueError:
|
||||
opts[o_arg] = True
|
||||
else:
|
||||
opts[o_key] = o_val
|
||||
return opts
|
||||
|
||||
|
||||
def _parse_filters(f_strs):
|
||||
filters = []
|
||||
if not f_strs:
|
||||
return filters
|
||||
for f_str in f_strs:
|
||||
if ':' in f_str:
|
||||
fname, fopts = f_str.split(':', 1)
|
||||
filters.append((fname, _parse_options([fopts])))
|
||||
else:
|
||||
filters.append((f_str, {}))
|
||||
return filters
|
||||
|
||||
|
||||
def _print_help(what, name):
|
||||
try:
|
||||
if what == 'lexer':
|
||||
cls = find_lexer_class(name)
|
||||
print "Help on the %s lexer:" % cls.name
|
||||
print dedent(cls.__doc__)
|
||||
elif what == 'formatter':
|
||||
cls = find_formatter_class(name)
|
||||
print "Help on the %s formatter:" % cls.name
|
||||
print dedent(cls.__doc__)
|
||||
elif what == 'filter':
|
||||
cls = find_filter_class(name)
|
||||
print "Help on the %s filter:" % name
|
||||
print dedent(cls.__doc__)
|
||||
except AttributeError:
|
||||
print >>sys.stderr, "%s not found!" % what
|
||||
|
||||
|
||||
def _print_list(what):
|
||||
if what == 'lexer':
|
||||
print
|
||||
print "Lexers:"
|
||||
print "~~~~~~~"
|
||||
|
||||
info = []
|
||||
for fullname, names, exts, _ in get_all_lexers():
|
||||
tup = (', '.join(names)+':', fullname,
|
||||
exts and '(filenames ' + ', '.join(exts) + ')' or '')
|
||||
info.append(tup)
|
||||
info.sort()
|
||||
for i in info:
|
||||
print ('* %s\n %s %s') % i
|
||||
|
||||
elif what == 'formatter':
|
||||
print
|
||||
print "Formatters:"
|
||||
print "~~~~~~~~~~~"
|
||||
|
||||
info = []
|
||||
for cls in get_all_formatters():
|
||||
doc = docstring_headline(cls)
|
||||
tup = (', '.join(cls.aliases) + ':', doc, cls.filenames and
|
||||
'(filenames ' + ', '.join(cls.filenames) + ')' or '')
|
||||
info.append(tup)
|
||||
info.sort()
|
||||
for i in info:
|
||||
print ('* %s\n %s %s') % i
|
||||
|
||||
elif what == 'filter':
|
||||
print
|
||||
print "Filters:"
|
||||
print "~~~~~~~~"
|
||||
|
||||
for name in get_all_filters():
|
||||
cls = find_filter_class(name)
|
||||
print "* " + name + ':'
|
||||
print " %s" % docstring_headline(cls)
|
||||
|
||||
elif what == 'style':
|
||||
print
|
||||
print "Styles:"
|
||||
print "~~~~~~~"
|
||||
|
||||
for name in get_all_styles():
|
||||
cls = get_style_by_name(name)
|
||||
print "* " + name + ':'
|
||||
print " %s" % docstring_headline(cls)
|
||||
|
||||
|
||||
def main(args=sys.argv):
|
||||
"""
|
||||
Main command line entry point.
|
||||
"""
|
||||
# pylint: disable-msg=R0911,R0912,R0915
|
||||
|
||||
usage = USAGE % ((args[0],) * 6)
|
||||
|
||||
if sys.platform in ['win32', 'cygwin']:
|
||||
try:
|
||||
# Provide coloring under Windows, if possible
|
||||
import colorama
|
||||
colorama.init()
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
try:
|
||||
popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHg")
|
||||
except getopt.GetoptError, err:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
opts = {}
|
||||
O_opts = []
|
||||
P_opts = []
|
||||
F_opts = []
|
||||
for opt, arg in popts:
|
||||
if opt == '-O':
|
||||
O_opts.append(arg)
|
||||
elif opt == '-P':
|
||||
P_opts.append(arg)
|
||||
elif opt == '-F':
|
||||
F_opts.append(arg)
|
||||
opts[opt] = arg
|
||||
|
||||
if not opts and not args:
|
||||
print usage
|
||||
return 0
|
||||
|
||||
if opts.pop('-h', None) is not None:
|
||||
print usage
|
||||
return 0
|
||||
|
||||
if opts.pop('-V', None) is not None:
|
||||
print 'Pygments version %s, (c) 2006-2013 by Georg Brandl.' % __version__
|
||||
return 0
|
||||
|
||||
# handle ``pygmentize -L``
|
||||
L_opt = opts.pop('-L', None)
|
||||
if L_opt is not None:
|
||||
if opts:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
# print version
|
||||
main(['', '-V'])
|
||||
if not args:
|
||||
args = ['lexer', 'formatter', 'filter', 'style']
|
||||
for arg in args:
|
||||
_print_list(arg.rstrip('s'))
|
||||
return 0
|
||||
|
||||
# handle ``pygmentize -H``
|
||||
H_opt = opts.pop('-H', None)
|
||||
if H_opt is not None:
|
||||
if opts or len(args) != 2:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
what, name = args
|
||||
if what not in ('lexer', 'formatter', 'filter'):
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
_print_help(what, name)
|
||||
return 0
|
||||
|
||||
# parse -O options
|
||||
parsed_opts = _parse_options(O_opts)
|
||||
opts.pop('-O', None)
|
||||
|
||||
# parse -P options
|
||||
for p_opt in P_opts:
|
||||
try:
|
||||
name, value = p_opt.split('=', 1)
|
||||
except ValueError:
|
||||
parsed_opts[p_opt] = True
|
||||
else:
|
||||
parsed_opts[name] = value
|
||||
opts.pop('-P', None)
|
||||
|
||||
# handle ``pygmentize -N``
|
||||
infn = opts.pop('-N', None)
|
||||
if infn is not None:
|
||||
try:
|
||||
lexer = get_lexer_for_filename(infn, **parsed_opts)
|
||||
except ClassNotFound, err:
|
||||
lexer = TextLexer()
|
||||
except OptionError, err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
|
||||
print lexer.aliases[0]
|
||||
return 0
|
||||
|
||||
# handle ``pygmentize -S``
|
||||
S_opt = opts.pop('-S', None)
|
||||
a_opt = opts.pop('-a', None)
|
||||
if S_opt is not None:
|
||||
f_opt = opts.pop('-f', None)
|
||||
if not f_opt:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
if opts or args:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
try:
|
||||
parsed_opts['style'] = S_opt
|
||||
fmter = get_formatter_by_name(f_opt, **parsed_opts)
|
||||
except ClassNotFound, err:
|
||||
print >>sys.stderr, err
|
||||
return 1
|
||||
|
||||
arg = a_opt or ''
|
||||
try:
|
||||
print fmter.get_style_defs(arg)
|
||||
except Exception, err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
return 0
|
||||
|
||||
# if no -S is given, -a is not allowed
|
||||
if a_opt is not None:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
# parse -F options
|
||||
F_opts = _parse_filters(F_opts)
|
||||
opts.pop('-F', None)
|
||||
|
||||
# select formatter
|
||||
outfn = opts.pop('-o', None)
|
||||
fmter = opts.pop('-f', None)
|
||||
if fmter:
|
||||
try:
|
||||
fmter = get_formatter_by_name(fmter, **parsed_opts)
|
||||
except (OptionError, ClassNotFound), err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
|
||||
if outfn:
|
||||
if not fmter:
|
||||
try:
|
||||
fmter = get_formatter_for_filename(outfn, **parsed_opts)
|
||||
except (OptionError, ClassNotFound), err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
try:
|
||||
outfile = open(outfn, 'wb')
|
||||
except Exception, err:
|
||||
print >>sys.stderr, 'Error: cannot open outfile:', err
|
||||
return 1
|
||||
else:
|
||||
if not fmter:
|
||||
fmter = TerminalFormatter(**parsed_opts)
|
||||
outfile = sys.stdout
|
||||
|
||||
# select lexer
|
||||
lexer = opts.pop('-l', None)
|
||||
if lexer:
|
||||
try:
|
||||
lexer = get_lexer_by_name(lexer, **parsed_opts)
|
||||
except (OptionError, ClassNotFound), err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
|
||||
if args:
|
||||
if len(args) > 1:
|
||||
print >>sys.stderr, usage
|
||||
return 2
|
||||
|
||||
infn = args[0]
|
||||
try:
|
||||
code = open(infn, 'rb').read()
|
||||
except Exception, err:
|
||||
print >>sys.stderr, 'Error: cannot read infile:', err
|
||||
return 1
|
||||
|
||||
if not lexer:
|
||||
try:
|
||||
lexer = get_lexer_for_filename(infn, code, **parsed_opts)
|
||||
except ClassNotFound, err:
|
||||
if '-g' in opts:
|
||||
try:
|
||||
lexer = guess_lexer(code, **parsed_opts)
|
||||
except ClassNotFound:
|
||||
lexer = TextLexer(**parsed_opts)
|
||||
else:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
except OptionError, err:
|
||||
print >>sys.stderr, 'Error:', err
|
||||
return 1
|
||||
|
||||
else:
|
||||
if '-g' in opts:
|
||||
code = sys.stdin.read()
|
||||
try:
|
||||
lexer = guess_lexer(code, **parsed_opts)
|
||||
except ClassNotFound:
|
||||
lexer = TextLexer(**parsed_opts)
|
||||
elif not lexer:
|
||||
print >>sys.stderr, 'Error: no lexer name given and reading ' + \
|
||||
'from stdin (try using -g or -l <lexer>)'
|
||||
return 2
|
||||
else:
|
||||
code = sys.stdin.read()
|
||||
|
||||
# No encoding given? Use latin1 if output file given,
|
||||
# stdin/stdout encoding otherwise.
|
||||
# (This is a compromise, I'm not too happy with it...)
|
||||
if 'encoding' not in parsed_opts and 'outencoding' not in parsed_opts:
|
||||
if outfn:
|
||||
# encoding pass-through
|
||||
fmter.encoding = 'latin1'
|
||||
else:
|
||||
if sys.version_info < (3,):
|
||||
# use terminal encoding; Python 3's terminals already do that
|
||||
lexer.encoding = getattr(sys.stdin, 'encoding',
|
||||
None) or 'ascii'
|
||||
fmter.encoding = getattr(sys.stdout, 'encoding',
|
||||
None) or 'ascii'
|
||||
elif not outfn and sys.version_info > (3,):
|
||||
# output to terminal with encoding -> use .buffer
|
||||
outfile = sys.stdout.buffer
|
||||
|
||||
# ... and do it!
|
||||
try:
|
||||
# process filters
|
||||
for fname, fopts in F_opts:
|
||||
lexer.add_filter(fname, **fopts)
|
||||
highlight(code, lexer, fmter, outfile)
|
||||
except Exception, err:
|
||||
import traceback
|
||||
info = traceback.format_exception(*sys.exc_info())
|
||||
msg = info[-1].strip()
|
||||
if len(info) >= 3:
|
||||
# extract relevant file and position info
|
||||
msg += '\n (f%s)' % info[-2].split('\n')[0].strip()[1:]
|
||||
print >>sys.stderr
|
||||
print >>sys.stderr, '*** Error while highlighting:'
|
||||
print >>sys.stderr, msg
|
||||
return 1
|
||||
|
||||
return 0
|
|
@ -0,0 +1,74 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.console
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
Format colored console output.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
esc = "\x1b["
|
||||
|
||||
codes = {}
|
||||
codes[""] = ""
|
||||
codes["reset"] = esc + "39;49;00m"
|
||||
|
||||
codes["bold"] = esc + "01m"
|
||||
codes["faint"] = esc + "02m"
|
||||
codes["standout"] = esc + "03m"
|
||||
codes["underline"] = esc + "04m"
|
||||
codes["blink"] = esc + "05m"
|
||||
codes["overline"] = esc + "06m"
|
||||
|
||||
dark_colors = ["black", "darkred", "darkgreen", "brown", "darkblue",
|
||||
"purple", "teal", "lightgray"]
|
||||
light_colors = ["darkgray", "red", "green", "yellow", "blue",
|
||||
"fuchsia", "turquoise", "white"]
|
||||
|
||||
x = 30
|
||||
for d, l in zip(dark_colors, light_colors):
|
||||
codes[d] = esc + "%im" % x
|
||||
codes[l] = esc + "%i;01m" % x
|
||||
x += 1
|
||||
|
||||
del d, l, x
|
||||
|
||||
codes["darkteal"] = codes["turquoise"]
|
||||
codes["darkyellow"] = codes["brown"]
|
||||
codes["fuscia"] = codes["fuchsia"]
|
||||
codes["white"] = codes["bold"]
|
||||
|
||||
|
||||
def reset_color():
|
||||
return codes["reset"]
|
||||
|
||||
|
||||
def colorize(color_key, text):
|
||||
return codes[color_key] + text + codes["reset"]
|
||||
|
||||
|
||||
def ansiformat(attr, text):
|
||||
"""
|
||||
Format ``text`` with a color and/or some attributes::
|
||||
|
||||
color normal color
|
||||
*color* bold color
|
||||
_color_ underlined color
|
||||
+color+ blinking color
|
||||
"""
|
||||
result = []
|
||||
if attr[:1] == attr[-1:] == '+':
|
||||
result.append(codes['blink'])
|
||||
attr = attr[1:-1]
|
||||
if attr[:1] == attr[-1:] == '*':
|
||||
result.append(codes['bold'])
|
||||
attr = attr[1:-1]
|
||||
if attr[:1] == attr[-1:] == '_':
|
||||
result.append(codes['underline'])
|
||||
attr = attr[1:-1]
|
||||
result.append(codes[attr])
|
||||
result.append(text)
|
||||
result.append(codes['reset'])
|
||||
return ''.join(result)
|
|
@ -0,0 +1,74 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.filter
|
||||
~~~~~~~~~~~~~~~
|
||||
|
||||
Module that implements the default filter.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
|
||||
def apply_filters(stream, filters, lexer=None):
|
||||
"""
|
||||
Use this method to apply an iterable of filters to
|
||||
a stream. If lexer is given it's forwarded to the
|
||||
filter, otherwise the filter receives `None`.
|
||||
"""
|
||||
def _apply(filter_, stream):
|
||||
for token in filter_.filter(lexer, stream):
|
||||
yield token
|
||||
for filter_ in filters:
|
||||
stream = _apply(filter_, stream)
|
||||
return stream
|
||||
|
||||
|
||||
def simplefilter(f):
|
||||
"""
|
||||
Decorator that converts a function into a filter::
|
||||
|
||||
@simplefilter
|
||||
def lowercase(lexer, stream, options):
|
||||
for ttype, value in stream:
|
||||
yield ttype, value.lower()
|
||||
"""
|
||||
return type(f.__name__, (FunctionFilter,), {
|
||||
'function': f,
|
||||
'__module__': getattr(f, '__module__'),
|
||||
'__doc__': f.__doc__
|
||||
})
|
||||
|
||||
|
||||
class Filter(object):
|
||||
"""
|
||||
Default filter. Subclass this class or use the `simplefilter`
|
||||
decorator to create own filters.
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
self.options = options
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class FunctionFilter(Filter):
|
||||
"""
|
||||
Abstract class used by `simplefilter` to create simple
|
||||
function filters on the fly. The `simplefilter` decorator
|
||||
automatically creates subclasses of this class for
|
||||
functions passed to it.
|
||||
"""
|
||||
function = None
|
||||
|
||||
def __init__(self, **options):
|
||||
if not hasattr(self, 'function'):
|
||||
raise TypeError('%r used without bound function' %
|
||||
self.__class__.__name__)
|
||||
Filter.__init__(self, **options)
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
# pylint: disable-msg=E1102
|
||||
for ttype, value in self.function(lexer, stream, self.options):
|
||||
yield ttype, value
|
|
@ -0,0 +1,356 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.filters
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
Module containing filter lookup functions and default
|
||||
filters.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.token import String, Comment, Keyword, Name, Error, Whitespace, \
|
||||
string_to_tokentype
|
||||
from pygments.filter import Filter
|
||||
from pygments.util import get_list_opt, get_int_opt, get_bool_opt, \
|
||||
get_choice_opt, ClassNotFound, OptionError
|
||||
from pygments.plugin import find_plugin_filters
|
||||
|
||||
|
||||
def find_filter_class(filtername):
|
||||
"""
|
||||
Lookup a filter by name. Return None if not found.
|
||||
"""
|
||||
if filtername in FILTERS:
|
||||
return FILTERS[filtername]
|
||||
for name, cls in find_plugin_filters():
|
||||
if name == filtername:
|
||||
return cls
|
||||
return None
|
||||
|
||||
|
||||
def get_filter_by_name(filtername, **options):
|
||||
"""
|
||||
Return an instantiated filter. Options are passed to the filter
|
||||
initializer if wanted. Raise a ClassNotFound if not found.
|
||||
"""
|
||||
cls = find_filter_class(filtername)
|
||||
if cls:
|
||||
return cls(**options)
|
||||
else:
|
||||
raise ClassNotFound('filter %r not found' % filtername)
|
||||
|
||||
|
||||
def get_all_filters():
|
||||
"""
|
||||
Return a generator of all filter names.
|
||||
"""
|
||||
for name in FILTERS:
|
||||
yield name
|
||||
for name, _ in find_plugin_filters():
|
||||
yield name
|
||||
|
||||
|
||||
def _replace_special(ttype, value, regex, specialttype,
|
||||
replacefunc=lambda x: x):
|
||||
last = 0
|
||||
for match in regex.finditer(value):
|
||||
start, end = match.start(), match.end()
|
||||
if start != last:
|
||||
yield ttype, value[last:start]
|
||||
yield specialttype, replacefunc(value[start:end])
|
||||
last = end
|
||||
if last != len(value):
|
||||
yield ttype, value[last:]
|
||||
|
||||
|
||||
class CodeTagFilter(Filter):
|
||||
"""
|
||||
Highlight special code tags in comments and docstrings.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`codetags` : list of strings
|
||||
A list of strings that are flagged as code tags. The default is to
|
||||
highlight ``XXX``, ``TODO``, ``BUG`` and ``NOTE``.
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
tags = get_list_opt(options, 'codetags',
|
||||
['XXX', 'TODO', 'BUG', 'NOTE'])
|
||||
self.tag_re = re.compile(r'\b(%s)\b' % '|'.join([
|
||||
re.escape(tag) for tag in tags if tag
|
||||
]))
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
regex = self.tag_re
|
||||
for ttype, value in stream:
|
||||
if ttype in String.Doc or \
|
||||
ttype in Comment and \
|
||||
ttype not in Comment.Preproc:
|
||||
for sttype, svalue in _replace_special(ttype, value, regex,
|
||||
Comment.Special):
|
||||
yield sttype, svalue
|
||||
else:
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class KeywordCaseFilter(Filter):
|
||||
"""
|
||||
Convert keywords to lowercase or uppercase or capitalize them, which
|
||||
means first letter uppercase, rest lowercase.
|
||||
|
||||
This can be useful e.g. if you highlight Pascal code and want to adapt the
|
||||
code to your styleguide.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`case` : string
|
||||
The casing to convert keywords to. Must be one of ``'lower'``,
|
||||
``'upper'`` or ``'capitalize'``. The default is ``'lower'``.
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
case = get_choice_opt(options, 'case', ['lower', 'upper', 'capitalize'], 'lower')
|
||||
self.convert = getattr(unicode, case)
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
for ttype, value in stream:
|
||||
if ttype in Keyword:
|
||||
yield ttype, self.convert(value)
|
||||
else:
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class NameHighlightFilter(Filter):
|
||||
"""
|
||||
Highlight a normal Name (and Name.*) token with a different token type.
|
||||
|
||||
Example::
|
||||
|
||||
filter = NameHighlightFilter(
|
||||
names=['foo', 'bar', 'baz'],
|
||||
tokentype=Name.Function,
|
||||
)
|
||||
|
||||
This would highlight the names "foo", "bar" and "baz"
|
||||
as functions. `Name.Function` is the default token type.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`names` : list of strings
|
||||
A list of names that should be given the different token type.
|
||||
There is no default.
|
||||
`tokentype` : TokenType or string
|
||||
A token type or a string containing a token type name that is
|
||||
used for highlighting the strings in `names`. The default is
|
||||
`Name.Function`.
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
self.names = set(get_list_opt(options, 'names', []))
|
||||
tokentype = options.get('tokentype')
|
||||
if tokentype:
|
||||
self.tokentype = string_to_tokentype(tokentype)
|
||||
else:
|
||||
self.tokentype = Name.Function
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
for ttype, value in stream:
|
||||
if ttype in Name and value in self.names:
|
||||
yield self.tokentype, value
|
||||
else:
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class ErrorToken(Exception):
|
||||
pass
|
||||
|
||||
class RaiseOnErrorTokenFilter(Filter):
|
||||
"""
|
||||
Raise an exception when the lexer generates an error token.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`excclass` : Exception class
|
||||
The exception class to raise.
|
||||
The default is `pygments.filters.ErrorToken`.
|
||||
|
||||
*New in Pygments 0.8.*
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
self.exception = options.get('excclass', ErrorToken)
|
||||
try:
|
||||
# issubclass() will raise TypeError if first argument is not a class
|
||||
if not issubclass(self.exception, Exception):
|
||||
raise TypeError
|
||||
except TypeError:
|
||||
raise OptionError('excclass option is not an exception class')
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
for ttype, value in stream:
|
||||
if ttype is Error:
|
||||
raise self.exception(value)
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class VisibleWhitespaceFilter(Filter):
|
||||
"""
|
||||
Convert tabs, newlines and/or spaces to visible characters.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`spaces` : string or bool
|
||||
If this is a one-character string, spaces will be replaces by this string.
|
||||
If it is another true value, spaces will be replaced by ``·`` (unicode
|
||||
MIDDLE DOT). If it is a false value, spaces will not be replaced. The
|
||||
default is ``False``.
|
||||
`tabs` : string or bool
|
||||
The same as for `spaces`, but the default replacement character is ``»``
|
||||
(unicode RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK). The default value
|
||||
is ``False``. Note: this will not work if the `tabsize` option for the
|
||||
lexer is nonzero, as tabs will already have been expanded then.
|
||||
`tabsize` : int
|
||||
If tabs are to be replaced by this filter (see the `tabs` option), this
|
||||
is the total number of characters that a tab should be expanded to.
|
||||
The default is ``8``.
|
||||
`newlines` : string or bool
|
||||
The same as for `spaces`, but the default replacement character is ``¶``
|
||||
(unicode PILCROW SIGN). The default value is ``False``.
|
||||
`wstokentype` : bool
|
||||
If true, give whitespace the special `Whitespace` token type. This allows
|
||||
styling the visible whitespace differently (e.g. greyed out), but it can
|
||||
disrupt background colors. The default is ``True``.
|
||||
|
||||
*New in Pygments 0.8.*
|
||||
"""
|
||||
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
for name, default in {'spaces': u'·', 'tabs': u'»', 'newlines': u'¶'}.items():
|
||||
opt = options.get(name, False)
|
||||
if isinstance(opt, basestring) and len(opt) == 1:
|
||||
setattr(self, name, opt)
|
||||
else:
|
||||
setattr(self, name, (opt and default or ''))
|
||||
tabsize = get_int_opt(options, 'tabsize', 8)
|
||||
if self.tabs:
|
||||
self.tabs += ' '*(tabsize-1)
|
||||
if self.newlines:
|
||||
self.newlines += '\n'
|
||||
self.wstt = get_bool_opt(options, 'wstokentype', True)
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
if self.wstt:
|
||||
spaces = self.spaces or ' '
|
||||
tabs = self.tabs or '\t'
|
||||
newlines = self.newlines or '\n'
|
||||
regex = re.compile(r'\s')
|
||||
def replacefunc(wschar):
|
||||
if wschar == ' ':
|
||||
return spaces
|
||||
elif wschar == '\t':
|
||||
return tabs
|
||||
elif wschar == '\n':
|
||||
return newlines
|
||||
return wschar
|
||||
|
||||
for ttype, value in stream:
|
||||
for sttype, svalue in _replace_special(ttype, value, regex,
|
||||
Whitespace, replacefunc):
|
||||
yield sttype, svalue
|
||||
else:
|
||||
spaces, tabs, newlines = self.spaces, self.tabs, self.newlines
|
||||
# simpler processing
|
||||
for ttype, value in stream:
|
||||
if spaces:
|
||||
value = value.replace(' ', spaces)
|
||||
if tabs:
|
||||
value = value.replace('\t', tabs)
|
||||
if newlines:
|
||||
value = value.replace('\n', newlines)
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class GobbleFilter(Filter):
|
||||
"""
|
||||
Gobbles source code lines (eats initial characters).
|
||||
|
||||
This filter drops the first ``n`` characters off every line of code. This
|
||||
may be useful when the source code fed to the lexer is indented by a fixed
|
||||
amount of space that isn't desired in the output.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`n` : int
|
||||
The number of characters to gobble.
|
||||
|
||||
*New in Pygments 1.2.*
|
||||
"""
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
self.n = get_int_opt(options, 'n', 0)
|
||||
|
||||
def gobble(self, value, left):
|
||||
if left < len(value):
|
||||
return value[left:], 0
|
||||
else:
|
||||
return '', left - len(value)
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
n = self.n
|
||||
left = n # How many characters left to gobble.
|
||||
for ttype, value in stream:
|
||||
# Remove ``left`` tokens from first line, ``n`` from all others.
|
||||
parts = value.split('\n')
|
||||
(parts[0], left) = self.gobble(parts[0], left)
|
||||
for i in range(1, len(parts)):
|
||||
(parts[i], left) = self.gobble(parts[i], n)
|
||||
value = '\n'.join(parts)
|
||||
|
||||
if value != '':
|
||||
yield ttype, value
|
||||
|
||||
|
||||
class TokenMergeFilter(Filter):
|
||||
"""
|
||||
Merges consecutive tokens with the same token type in the output stream of a
|
||||
lexer.
|
||||
|
||||
*New in Pygments 1.2.*
|
||||
"""
|
||||
def __init__(self, **options):
|
||||
Filter.__init__(self, **options)
|
||||
|
||||
def filter(self, lexer, stream):
|
||||
current_type = None
|
||||
current_value = None
|
||||
for ttype, value in stream:
|
||||
if ttype is current_type:
|
||||
current_value += value
|
||||
else:
|
||||
if current_type is not None:
|
||||
yield current_type, current_value
|
||||
current_type = ttype
|
||||
current_value = value
|
||||
if current_type is not None:
|
||||
yield current_type, current_value
|
||||
|
||||
|
||||
FILTERS = {
|
||||
'codetagify': CodeTagFilter,
|
||||
'keywordcase': KeywordCaseFilter,
|
||||
'highlight': NameHighlightFilter,
|
||||
'raiseonerror': RaiseOnErrorTokenFilter,
|
||||
'whitespace': VisibleWhitespaceFilter,
|
||||
'gobble': GobbleFilter,
|
||||
'tokenmerge': TokenMergeFilter,
|
||||
}
|
|
@ -0,0 +1,95 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatter
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Base formatter class.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import codecs
|
||||
|
||||
from pygments.util import get_bool_opt
|
||||
from pygments.styles import get_style_by_name
|
||||
|
||||
__all__ = ['Formatter']
|
||||
|
||||
|
||||
def _lookup_style(style):
|
||||
if isinstance(style, basestring):
|
||||
return get_style_by_name(style)
|
||||
return style
|
||||
|
||||
|
||||
class Formatter(object):
|
||||
"""
|
||||
Converts a token stream to text.
|
||||
|
||||
Options accepted:
|
||||
|
||||
``style``
|
||||
The style to use, can be a string or a Style subclass
|
||||
(default: "default"). Not used by e.g. the
|
||||
TerminalFormatter.
|
||||
``full``
|
||||
Tells the formatter to output a "full" document, i.e.
|
||||
a complete self-contained document. This doesn't have
|
||||
any effect for some formatters (default: false).
|
||||
``title``
|
||||
If ``full`` is true, the title that should be used to
|
||||
caption the document (default: '').
|
||||
``encoding``
|
||||
If given, must be an encoding name. This will be used to
|
||||
convert the Unicode token strings to byte strings in the
|
||||
output. If it is "" or None, Unicode strings will be written
|
||||
to the output file, which most file-like objects do not
|
||||
support (default: None).
|
||||
``outencoding``
|
||||
Overrides ``encoding`` if given.
|
||||
"""
|
||||
|
||||
#: Name of the formatter
|
||||
name = None
|
||||
|
||||
#: Shortcuts for the formatter
|
||||
aliases = []
|
||||
|
||||
#: fn match rules
|
||||
filenames = []
|
||||
|
||||
#: If True, this formatter outputs Unicode strings when no encoding
|
||||
#: option is given.
|
||||
unicodeoutput = True
|
||||
|
||||
def __init__(self, **options):
|
||||
self.style = _lookup_style(options.get('style', 'default'))
|
||||
self.full = get_bool_opt(options, 'full', False)
|
||||
self.title = options.get('title', '')
|
||||
self.encoding = options.get('encoding', None) or None
|
||||
if self.encoding == 'guess':
|
||||
# can happen for pygmentize -O encoding=guess
|
||||
self.encoding = 'utf-8'
|
||||
self.encoding = options.get('outencoding', None) or self.encoding
|
||||
self.options = options
|
||||
|
||||
def get_style_defs(self, arg=''):
|
||||
"""
|
||||
Return the style definitions for the current style as a string.
|
||||
|
||||
``arg`` is an additional argument whose meaning depends on the
|
||||
formatter used. Note that ``arg`` can also be a list or tuple
|
||||
for some formatters like the html formatter.
|
||||
"""
|
||||
return ''
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
"""
|
||||
Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
|
||||
tuples and write it into ``outfile``.
|
||||
"""
|
||||
if self.encoding:
|
||||
# wrap the outfile in a StreamWriter
|
||||
outfile = codecs.lookup(self.encoding)[3](outfile)
|
||||
return self.format_unencoded(tokensource, outfile)
|
|
@ -0,0 +1,68 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Pygments formatters.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
import os.path
|
||||
import fnmatch
|
||||
|
||||
from pygments.formatters._mapping import FORMATTERS
|
||||
from pygments.plugin import find_plugin_formatters
|
||||
from pygments.util import ClassNotFound
|
||||
|
||||
ns = globals()
|
||||
for fcls in FORMATTERS:
|
||||
ns[fcls.__name__] = fcls
|
||||
del fcls
|
||||
|
||||
__all__ = ['get_formatter_by_name', 'get_formatter_for_filename',
|
||||
'get_all_formatters'] + [cls.__name__ for cls in FORMATTERS]
|
||||
|
||||
|
||||
_formatter_alias_cache = {}
|
||||
_formatter_filename_cache = []
|
||||
|
||||
def _init_formatter_cache():
|
||||
if _formatter_alias_cache:
|
||||
return
|
||||
for cls in get_all_formatters():
|
||||
for alias in cls.aliases:
|
||||
_formatter_alias_cache[alias] = cls
|
||||
for fn in cls.filenames:
|
||||
_formatter_filename_cache.append((fn, cls))
|
||||
|
||||
|
||||
def find_formatter_class(name):
|
||||
_init_formatter_cache()
|
||||
cls = _formatter_alias_cache.get(name, None)
|
||||
return cls
|
||||
|
||||
|
||||
def get_formatter_by_name(name, **options):
|
||||
_init_formatter_cache()
|
||||
cls = _formatter_alias_cache.get(name, None)
|
||||
if not cls:
|
||||
raise ClassNotFound("No formatter found for name %r" % name)
|
||||
return cls(**options)
|
||||
|
||||
|
||||
def get_formatter_for_filename(fn, **options):
|
||||
_init_formatter_cache()
|
||||
fn = os.path.basename(fn)
|
||||
for pattern, cls in _formatter_filename_cache:
|
||||
if fnmatch.fnmatch(fn, pattern):
|
||||
return cls(**options)
|
||||
raise ClassNotFound("No formatter found for file name %r" % fn)
|
||||
|
||||
|
||||
def get_all_formatters():
|
||||
"""Return a generator for all formatters."""
|
||||
for formatter in FORMATTERS:
|
||||
yield formatter
|
||||
for _, formatter in find_plugin_formatters():
|
||||
yield formatter
|
|
@ -0,0 +1,92 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters._mapping
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter mapping defintions. This file is generated by itself. Everytime
|
||||
you change something on a builtin formatter defintion, run this script from
|
||||
the formatters folder to update it.
|
||||
|
||||
Do not alter the FORMATTERS dictionary by hand.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
# start
|
||||
from pygments.formatters.bbcode import BBCodeFormatter
|
||||
from pygments.formatters.html import HtmlFormatter
|
||||
from pygments.formatters.img import BmpImageFormatter
|
||||
from pygments.formatters.img import GifImageFormatter
|
||||
from pygments.formatters.img import ImageFormatter
|
||||
from pygments.formatters.img import JpgImageFormatter
|
||||
from pygments.formatters.latex import LatexFormatter
|
||||
from pygments.formatters.other import NullFormatter
|
||||
from pygments.formatters.other import RawTokenFormatter
|
||||
from pygments.formatters.rtf import RtfFormatter
|
||||
from pygments.formatters.svg import SvgFormatter
|
||||
from pygments.formatters.terminal import TerminalFormatter
|
||||
from pygments.formatters.terminal256 import Terminal256Formatter
|
||||
|
||||
FORMATTERS = {
|
||||
BBCodeFormatter: ('BBCode', ('bbcode', 'bb'), (), 'Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there.'),
|
||||
BmpImageFormatter: ('img_bmp', ('bmp', 'bitmap'), ('*.bmp',), 'Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
|
||||
GifImageFormatter: ('img_gif', ('gif',), ('*.gif',), 'Create a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
|
||||
HtmlFormatter: ('HTML', ('html',), ('*.html', '*.htm'), "Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass` option."),
|
||||
ImageFormatter: ('img', ('img', 'IMG', 'png'), ('*.png',), 'Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
|
||||
JpgImageFormatter: ('img_jpg', ('jpg', 'jpeg'), ('*.jpg',), 'Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
|
||||
LatexFormatter: ('LaTeX', ('latex', 'tex'), ('*.tex',), 'Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages.'),
|
||||
NullFormatter: ('Text only', ('text', 'null'), ('*.txt',), 'Output the text unchanged without any formatting.'),
|
||||
RawTokenFormatter: ('Raw tokens', ('raw', 'tokens'), ('*.raw',), 'Format tokens as a raw representation for storing token streams.'),
|
||||
RtfFormatter: ('RTF', ('rtf',), ('*.rtf',), 'Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft\xc2\xae Word\xc2\xae documents.'),
|
||||
SvgFormatter: ('SVG', ('svg',), ('*.svg',), 'Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``<text>`` element with explicit ``x`` and ``y`` coordinates containing ``<tspan>`` elements with the individual token styles.'),
|
||||
Terminal256Formatter: ('Terminal256', ('terminal256', 'console256', '256'), (), 'Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'),
|
||||
TerminalFormatter: ('Terminal', ('terminal', 'console'), (), 'Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly.')
|
||||
}
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
import os
|
||||
|
||||
# lookup formatters
|
||||
found_formatters = []
|
||||
imports = []
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
|
||||
from pygments.util import docstring_headline
|
||||
|
||||
for filename in os.listdir('.'):
|
||||
if filename.endswith('.py') and not filename.startswith('_'):
|
||||
module_name = 'pygments.formatters.%s' % filename[:-3]
|
||||
print module_name
|
||||
module = __import__(module_name, None, None, [''])
|
||||
for formatter_name in module.__all__:
|
||||
imports.append((module_name, formatter_name))
|
||||
formatter = getattr(module, formatter_name)
|
||||
found_formatters.append(
|
||||
'%s: %r' % (formatter_name,
|
||||
(formatter.name,
|
||||
tuple(formatter.aliases),
|
||||
tuple(formatter.filenames),
|
||||
docstring_headline(formatter))))
|
||||
# sort them, that should make the diff files for svn smaller
|
||||
found_formatters.sort()
|
||||
imports.sort()
|
||||
|
||||
# extract useful sourcecode from this file
|
||||
f = open(__file__)
|
||||
try:
|
||||
content = f.read()
|
||||
finally:
|
||||
f.close()
|
||||
header = content[:content.find('# start')]
|
||||
footer = content[content.find("if __name__ == '__main__':"):]
|
||||
|
||||
# write new file
|
||||
f = open(__file__, 'w')
|
||||
f.write(header)
|
||||
f.write('# start\n')
|
||||
f.write('\n'.join(['from %s import %s' % imp for imp in imports]))
|
||||
f.write('\n\n')
|
||||
f.write('FORMATTERS = {\n %s\n}\n\n' % ',\n '.join(found_formatters))
|
||||
f.write(footer)
|
||||
f.close()
|
|
@ -0,0 +1,109 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.bbcode
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
BBcode formatter.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.util import get_bool_opt
|
||||
|
||||
__all__ = ['BBCodeFormatter']
|
||||
|
||||
|
||||
class BBCodeFormatter(Formatter):
|
||||
"""
|
||||
Format tokens with BBcodes. These formatting codes are used by many
|
||||
bulletin boards, so you can highlight your sourcecode with pygments before
|
||||
posting it there.
|
||||
|
||||
This formatter has no support for background colors and borders, as there
|
||||
are no common BBcode tags for that.
|
||||
|
||||
Some board systems (e.g. phpBB) don't support colors in their [code] tag,
|
||||
so you can't use the highlighting together with that tag.
|
||||
Text in a [code] tag usually is shown with a monospace font (which this
|
||||
formatter can do with the ``monofont`` option) and no spaces (which you
|
||||
need for indentation) are removed.
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`style`
|
||||
The style to use, can be a string or a Style subclass (default:
|
||||
``'default'``).
|
||||
|
||||
`codetag`
|
||||
If set to true, put the output into ``[code]`` tags (default:
|
||||
``false``)
|
||||
|
||||
`monofont`
|
||||
If set to true, add a tag to show the code with a monospace font
|
||||
(default: ``false``).
|
||||
"""
|
||||
name = 'BBCode'
|
||||
aliases = ['bbcode', 'bb']
|
||||
filenames = []
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
self._code = get_bool_opt(options, 'codetag', False)
|
||||
self._mono = get_bool_opt(options, 'monofont', False)
|
||||
|
||||
self.styles = {}
|
||||
self._make_styles()
|
||||
|
||||
def _make_styles(self):
|
||||
for ttype, ndef in self.style:
|
||||
start = end = ''
|
||||
if ndef['color']:
|
||||
start += '[color=#%s]' % ndef['color']
|
||||
end = '[/color]' + end
|
||||
if ndef['bold']:
|
||||
start += '[b]'
|
||||
end = '[/b]' + end
|
||||
if ndef['italic']:
|
||||
start += '[i]'
|
||||
end = '[/i]' + end
|
||||
if ndef['underline']:
|
||||
start += '[u]'
|
||||
end = '[/u]' + end
|
||||
# there are no common BBcodes for background-color and border
|
||||
|
||||
self.styles[ttype] = start, end
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
if self._code:
|
||||
outfile.write('[code]')
|
||||
if self._mono:
|
||||
outfile.write('[font=monospace]')
|
||||
|
||||
lastval = ''
|
||||
lasttype = None
|
||||
|
||||
for ttype, value in tokensource:
|
||||
while ttype not in self.styles:
|
||||
ttype = ttype.parent
|
||||
if ttype == lasttype:
|
||||
lastval += value
|
||||
else:
|
||||
if lastval:
|
||||
start, end = self.styles[lasttype]
|
||||
outfile.write(''.join((start, lastval, end)))
|
||||
lastval = value
|
||||
lasttype = ttype
|
||||
|
||||
if lastval:
|
||||
start, end = self.styles[lasttype]
|
||||
outfile.write(''.join((start, lastval, end)))
|
||||
|
||||
if self._mono:
|
||||
outfile.write('[/font]')
|
||||
if self._code:
|
||||
outfile.write('[/code]')
|
||||
if self._code or self._mono:
|
||||
outfile.write('\n')
|
|
@ -0,0 +1,821 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.html
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for HTML output.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import os.path
|
||||
import StringIO
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.token import Token, Text, STANDARD_TYPES
|
||||
from pygments.util import get_bool_opt, get_int_opt, get_list_opt, bytes
|
||||
|
||||
try:
|
||||
import ctags
|
||||
except ImportError:
|
||||
ctags = None
|
||||
|
||||
__all__ = ['HtmlFormatter']
|
||||
|
||||
|
||||
_escape_html_table = {
|
||||
ord('&'): u'&',
|
||||
ord('<'): u'<',
|
||||
ord('>'): u'>',
|
||||
ord('"'): u'"',
|
||||
ord("'"): u''',
|
||||
}
|
||||
|
||||
def escape_html(text, table=_escape_html_table):
|
||||
"""Escape &, <, > as well as single and double quotes for HTML."""
|
||||
return text.translate(table)
|
||||
|
||||
def get_random_id():
|
||||
"""Return a random id for javascript fields."""
|
||||
from random import random
|
||||
from time import time
|
||||
try:
|
||||
from hashlib import sha1 as sha
|
||||
except ImportError:
|
||||
import sha
|
||||
sha = sha.new
|
||||
return sha('%s|%s' % (random(), time())).hexdigest()
|
||||
|
||||
|
||||
def _get_ttype_class(ttype):
|
||||
fname = STANDARD_TYPES.get(ttype)
|
||||
if fname:
|
||||
return fname
|
||||
aname = ''
|
||||
while fname is None:
|
||||
aname = '-' + ttype[-1] + aname
|
||||
ttype = ttype.parent
|
||||
fname = STANDARD_TYPES.get(ttype)
|
||||
return fname + aname
|
||||
|
||||
|
||||
CSSFILE_TEMPLATE = '''\
|
||||
td.linenos { background-color: #f0f0f0; padding-right: 10px; }
|
||||
span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
|
||||
pre { line-height: 125%%; }
|
||||
%(styledefs)s
|
||||
'''
|
||||
|
||||
DOC_HEADER = '''\
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
||||
"http://www.w3.org/TR/html4/strict.dtd">
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<title>%(title)s</title>
|
||||
<meta http-equiv="content-type" content="text/html; charset=%(encoding)s">
|
||||
<style type="text/css">
|
||||
''' + CSSFILE_TEMPLATE + '''
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h2>%(title)s</h2>
|
||||
|
||||
'''
|
||||
|
||||
DOC_HEADER_EXTERNALCSS = '''\
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
||||
"http://www.w3.org/TR/html4/strict.dtd">
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<title>%(title)s</title>
|
||||
<meta http-equiv="content-type" content="text/html; charset=%(encoding)s">
|
||||
<link rel="stylesheet" href="%(cssfile)s" type="text/css">
|
||||
</head>
|
||||
<body>
|
||||
<h2>%(title)s</h2>
|
||||
|
||||
'''
|
||||
|
||||
DOC_FOOTER = '''\
|
||||
</body>
|
||||
</html>
|
||||
'''
|
||||
|
||||
|
||||
class HtmlFormatter(Formatter):
|
||||
r"""
|
||||
Format tokens as HTML 4 ``<span>`` tags within a ``<pre>`` tag, wrapped
|
||||
in a ``<div>`` tag. The ``<div>``'s CSS class can be set by the `cssclass`
|
||||
option.
|
||||
|
||||
If the `linenos` option is set to ``"table"``, the ``<pre>`` is
|
||||
additionally wrapped inside a ``<table>`` which has one row and two
|
||||
cells: one containing the line numbers and one containing the code.
|
||||
Example:
|
||||
|
||||
.. sourcecode:: html
|
||||
|
||||
<div class="highlight" >
|
||||
<table><tr>
|
||||
<td class="linenos" title="click to toggle"
|
||||
onclick="with (this.firstChild.style)
|
||||
{ display = (display == '') ? 'none' : '' }">
|
||||
<pre>1
|
||||
2</pre>
|
||||
</td>
|
||||
<td class="code">
|
||||
<pre><span class="Ke">def </span><span class="NaFu">foo</span>(bar):
|
||||
<span class="Ke">pass</span>
|
||||
</pre>
|
||||
</td>
|
||||
</tr></table></div>
|
||||
|
||||
(whitespace added to improve clarity).
|
||||
|
||||
Wrapping can be disabled using the `nowrap` option.
|
||||
|
||||
A list of lines can be specified using the `hl_lines` option to make these
|
||||
lines highlighted (as of Pygments 0.11).
|
||||
|
||||
With the `full` option, a complete HTML 4 document is output, including
|
||||
the style definitions inside a ``<style>`` tag, or in a separate file if
|
||||
the `cssfile` option is given.
|
||||
|
||||
When `tagsfile` is set to the path of a ctags index file, it is used to
|
||||
generate hyperlinks from names to their definition. You must enable
|
||||
`anchorlines` and run ctags with the `-n` option for this to work. The
|
||||
`python-ctags` module from PyPI must be installed to use this feature;
|
||||
otherwise a `RuntimeError` will be raised.
|
||||
|
||||
The `get_style_defs(arg='')` method of a `HtmlFormatter` returns a string
|
||||
containing CSS rules for the CSS classes used by the formatter. The
|
||||
argument `arg` can be used to specify additional CSS selectors that
|
||||
are prepended to the classes. A call `fmter.get_style_defs('td .code')`
|
||||
would result in the following CSS classes:
|
||||
|
||||
.. sourcecode:: css
|
||||
|
||||
td .code .kw { font-weight: bold; color: #00FF00 }
|
||||
td .code .cm { color: #999999 }
|
||||
...
|
||||
|
||||
If you have Pygments 0.6 or higher, you can also pass a list or tuple to the
|
||||
`get_style_defs()` method to request multiple prefixes for the tokens:
|
||||
|
||||
.. sourcecode:: python
|
||||
|
||||
formatter.get_style_defs(['div.syntax pre', 'pre.syntax'])
|
||||
|
||||
The output would then look like this:
|
||||
|
||||
.. sourcecode:: css
|
||||
|
||||
div.syntax pre .kw,
|
||||
pre.syntax .kw { font-weight: bold; color: #00FF00 }
|
||||
div.syntax pre .cm,
|
||||
pre.syntax .cm { color: #999999 }
|
||||
...
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`nowrap`
|
||||
If set to ``True``, don't wrap the tokens at all, not even inside a ``<pre>``
|
||||
tag. This disables most other options (default: ``False``).
|
||||
|
||||
`full`
|
||||
Tells the formatter to output a "full" document, i.e. a complete
|
||||
self-contained document (default: ``False``).
|
||||
|
||||
`title`
|
||||
If `full` is true, the title that should be used to caption the
|
||||
document (default: ``''``).
|
||||
|
||||
`style`
|
||||
The style to use, can be a string or a Style subclass (default:
|
||||
``'default'``). This option has no effect if the `cssfile`
|
||||
and `noclobber_cssfile` option are given and the file specified in
|
||||
`cssfile` exists.
|
||||
|
||||
`noclasses`
|
||||
If set to true, token ``<span>`` tags will not use CSS classes, but
|
||||
inline styles. This is not recommended for larger pieces of code since
|
||||
it increases output size by quite a bit (default: ``False``).
|
||||
|
||||
`classprefix`
|
||||
Since the token types use relatively short class names, they may clash
|
||||
with some of your own class names. In this case you can use the
|
||||
`classprefix` option to give a string to prepend to all Pygments-generated
|
||||
CSS class names for token types.
|
||||
Note that this option also affects the output of `get_style_defs()`.
|
||||
|
||||
`cssclass`
|
||||
CSS class for the wrapping ``<div>`` tag (default: ``'highlight'``).
|
||||
If you set this option, the default selector for `get_style_defs()`
|
||||
will be this class.
|
||||
|
||||
*New in Pygments 0.9:* If you select the ``'table'`` line numbers, the
|
||||
wrapping table will have a CSS class of this string plus ``'table'``,
|
||||
the default is accordingly ``'highlighttable'``.
|
||||
|
||||
`cssstyles`
|
||||
Inline CSS styles for the wrapping ``<div>`` tag (default: ``''``).
|
||||
|
||||
`prestyles`
|
||||
Inline CSS styles for the ``<pre>`` tag (default: ``''``). *New in
|
||||
Pygments 0.11.*
|
||||
|
||||
`cssfile`
|
||||
If the `full` option is true and this option is given, it must be the
|
||||
name of an external file. If the filename does not include an absolute
|
||||
path, the file's path will be assumed to be relative to the main output
|
||||
file's path, if the latter can be found. The stylesheet is then written
|
||||
to this file instead of the HTML file. *New in Pygments 0.6.*
|
||||
|
||||
`noclobber_cssfile`
|
||||
If `cssfile` is given and the specified file exists, the css file will
|
||||
not be overwritten. This allows the use of the `full` option in
|
||||
combination with a user specified css file. Default is ``False``.
|
||||
*New in Pygments 1.1.*
|
||||
|
||||
`linenos`
|
||||
If set to ``'table'``, output line numbers as a table with two cells,
|
||||
one containing the line numbers, the other the whole code. This is
|
||||
copy-and-paste-friendly, but may cause alignment problems with some
|
||||
browsers or fonts. If set to ``'inline'``, the line numbers will be
|
||||
integrated in the ``<pre>`` tag that contains the code (that setting
|
||||
is *new in Pygments 0.8*).
|
||||
|
||||
For compatibility with Pygments 0.7 and earlier, every true value
|
||||
except ``'inline'`` means the same as ``'table'`` (in particular, that
|
||||
means also ``True``).
|
||||
|
||||
The default value is ``False``, which means no line numbers at all.
|
||||
|
||||
**Note:** with the default ("table") line number mechanism, the line
|
||||
numbers and code can have different line heights in Internet Explorer
|
||||
unless you give the enclosing ``<pre>`` tags an explicit ``line-height``
|
||||
CSS property (you get the default line spacing with ``line-height:
|
||||
125%``).
|
||||
|
||||
`hl_lines`
|
||||
Specify a list of lines to be highlighted. *New in Pygments 0.11.*
|
||||
|
||||
`linenostart`
|
||||
The line number for the first line (default: ``1``).
|
||||
|
||||
`linenostep`
|
||||
If set to a number n > 1, only every nth line number is printed.
|
||||
|
||||
`linenospecial`
|
||||
If set to a number n > 0, every nth line number is given the CSS
|
||||
class ``"special"`` (default: ``0``).
|
||||
|
||||
`nobackground`
|
||||
If set to ``True``, the formatter won't output the background color
|
||||
for the wrapping element (this automatically defaults to ``False``
|
||||
when there is no wrapping element [eg: no argument for the
|
||||
`get_syntax_defs` method given]) (default: ``False``). *New in
|
||||
Pygments 0.6.*
|
||||
|
||||
`lineseparator`
|
||||
This string is output between lines of code. It defaults to ``"\n"``,
|
||||
which is enough to break a line inside ``<pre>`` tags, but you can
|
||||
e.g. set it to ``"<br>"`` to get HTML line breaks. *New in Pygments
|
||||
0.7.*
|
||||
|
||||
`lineanchors`
|
||||
If set to a nonempty string, e.g. ``foo``, the formatter will wrap each
|
||||
output line in an anchor tag with a ``name`` of ``foo-linenumber``.
|
||||
This allows easy linking to certain lines. *New in Pygments 0.9.*
|
||||
|
||||
`linespans`
|
||||
If set to a nonempty string, e.g. ``foo``, the formatter will wrap each
|
||||
output line in a span tag with an ``id`` of ``foo-linenumber``.
|
||||
This allows easy access to lines via javascript. *New in Pygments 1.6.*
|
||||
|
||||
`anchorlinenos`
|
||||
If set to `True`, will wrap line numbers in <a> tags. Used in
|
||||
combination with `linenos` and `lineanchors`.
|
||||
|
||||
`tagsfile`
|
||||
If set to the path of a ctags file, wrap names in anchor tags that
|
||||
link to their definitions. `lineanchors` should be used, and the
|
||||
tags file should specify line numbers (see the `-n` option to ctags).
|
||||
*New in Pygments 1.6.*
|
||||
|
||||
`tagurlformat`
|
||||
A string formatting pattern used to generate links to ctags definitions.
|
||||
Available variables are `%(path)s`, `%(fname)s` and `%(fext)s`.
|
||||
Defaults to an empty string, resulting in just `#prefix-number` links.
|
||||
*New in Pygments 1.6.*
|
||||
|
||||
|
||||
**Subclassing the HTML formatter**
|
||||
|
||||
*New in Pygments 0.7.*
|
||||
|
||||
The HTML formatter is now built in a way that allows easy subclassing, thus
|
||||
customizing the output HTML code. The `format()` method calls
|
||||
`self._format_lines()` which returns a generator that yields tuples of ``(1,
|
||||
line)``, where the ``1`` indicates that the ``line`` is a line of the
|
||||
formatted source code.
|
||||
|
||||
If the `nowrap` option is set, the generator is the iterated over and the
|
||||
resulting HTML is output.
|
||||
|
||||
Otherwise, `format()` calls `self.wrap()`, which wraps the generator with
|
||||
other generators. These may add some HTML code to the one generated by
|
||||
`_format_lines()`, either by modifying the lines generated by the latter,
|
||||
then yielding them again with ``(1, line)``, and/or by yielding other HTML
|
||||
code before or after the lines, with ``(0, html)``. The distinction between
|
||||
source lines and other code makes it possible to wrap the generator multiple
|
||||
times.
|
||||
|
||||
The default `wrap()` implementation adds a ``<div>`` and a ``<pre>`` tag.
|
||||
|
||||
A custom `HtmlFormatter` subclass could look like this:
|
||||
|
||||
.. sourcecode:: python
|
||||
|
||||
class CodeHtmlFormatter(HtmlFormatter):
|
||||
|
||||
def wrap(self, source, outfile):
|
||||
return self._wrap_code(source)
|
||||
|
||||
def _wrap_code(self, source):
|
||||
yield 0, '<code>'
|
||||
for i, t in source:
|
||||
if i == 1:
|
||||
# it's a line of formatted code
|
||||
t += '<br>'
|
||||
yield i, t
|
||||
yield 0, '</code>'
|
||||
|
||||
This results in wrapping the formatted lines with a ``<code>`` tag, where the
|
||||
source lines are broken using ``<br>`` tags.
|
||||
|
||||
After calling `wrap()`, the `format()` method also adds the "line numbers"
|
||||
and/or "full document" wrappers if the respective options are set. Then, all
|
||||
HTML yielded by the wrapped generator is output.
|
||||
"""
|
||||
|
||||
name = 'HTML'
|
||||
aliases = ['html']
|
||||
filenames = ['*.html', '*.htm']
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
self.title = self._decodeifneeded(self.title)
|
||||
self.nowrap = get_bool_opt(options, 'nowrap', False)
|
||||
self.noclasses = get_bool_opt(options, 'noclasses', False)
|
||||
self.classprefix = options.get('classprefix', '')
|
||||
self.cssclass = self._decodeifneeded(options.get('cssclass', 'highlight'))
|
||||
self.cssstyles = self._decodeifneeded(options.get('cssstyles', ''))
|
||||
self.prestyles = self._decodeifneeded(options.get('prestyles', ''))
|
||||
self.cssfile = self._decodeifneeded(options.get('cssfile', ''))
|
||||
self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile', False)
|
||||
self.tagsfile = self._decodeifneeded(options.get('tagsfile', ''))
|
||||
self.tagurlformat = self._decodeifneeded(options.get('tagurlformat', ''))
|
||||
|
||||
if self.tagsfile:
|
||||
if not ctags:
|
||||
raise RuntimeError('The "ctags" package must to be installed '
|
||||
'to be able to use the "tagsfile" feature.')
|
||||
self._ctags = ctags.CTags(self.tagsfile)
|
||||
|
||||
linenos = options.get('linenos', False)
|
||||
if linenos == 'inline':
|
||||
self.linenos = 2
|
||||
elif linenos:
|
||||
# compatibility with <= 0.7
|
||||
self.linenos = 1
|
||||
else:
|
||||
self.linenos = 0
|
||||
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
|
||||
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
|
||||
self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
|
||||
self.nobackground = get_bool_opt(options, 'nobackground', False)
|
||||
self.lineseparator = options.get('lineseparator', '\n')
|
||||
self.lineanchors = options.get('lineanchors', '')
|
||||
self.linespans = options.get('linespans', '')
|
||||
self.anchorlinenos = options.get('anchorlinenos', False)
|
||||
self.hl_lines = set()
|
||||
for lineno in get_list_opt(options, 'hl_lines', []):
|
||||
try:
|
||||
self.hl_lines.add(int(lineno))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
self._create_stylesheet()
|
||||
|
||||
def _get_css_class(self, ttype):
|
||||
"""Return the css class of this token type prefixed with
|
||||
the classprefix option."""
|
||||
ttypeclass = _get_ttype_class(ttype)
|
||||
if ttypeclass:
|
||||
return self.classprefix + ttypeclass
|
||||
return ''
|
||||
|
||||
def _create_stylesheet(self):
|
||||
t2c = self.ttype2class = {Token: ''}
|
||||
c2s = self.class2style = {}
|
||||
for ttype, ndef in self.style:
|
||||
name = self._get_css_class(ttype)
|
||||
style = ''
|
||||
if ndef['color']:
|
||||
style += 'color: #%s; ' % ndef['color']
|
||||
if ndef['bold']:
|
||||
style += 'font-weight: bold; '
|
||||
if ndef['italic']:
|
||||
style += 'font-style: italic; '
|
||||
if ndef['underline']:
|
||||
style += 'text-decoration: underline; '
|
||||
if ndef['bgcolor']:
|
||||
style += 'background-color: #%s; ' % ndef['bgcolor']
|
||||
if ndef['border']:
|
||||
style += 'border: 1px solid #%s; ' % ndef['border']
|
||||
if style:
|
||||
t2c[ttype] = name
|
||||
# save len(ttype) to enable ordering the styles by
|
||||
# hierarchy (necessary for CSS cascading rules!)
|
||||
c2s[name] = (style[:-2], ttype, len(ttype))
|
||||
|
||||
def get_style_defs(self, arg=None):
|
||||
"""
|
||||
Return CSS style definitions for the classes produced by the current
|
||||
highlighting style. ``arg`` can be a string or list of selectors to
|
||||
insert before the token type classes.
|
||||
"""
|
||||
if arg is None:
|
||||
arg = ('cssclass' in self.options and '.'+self.cssclass or '')
|
||||
if isinstance(arg, basestring):
|
||||
args = [arg]
|
||||
else:
|
||||
args = list(arg)
|
||||
|
||||
def prefix(cls):
|
||||
if cls:
|
||||
cls = '.' + cls
|
||||
tmp = []
|
||||
for arg in args:
|
||||
tmp.append((arg and arg + ' ' or '') + cls)
|
||||
return ', '.join(tmp)
|
||||
|
||||
styles = [(level, ttype, cls, style)
|
||||
for cls, (style, ttype, level) in self.class2style.iteritems()
|
||||
if cls and style]
|
||||
styles.sort()
|
||||
lines = ['%s { %s } /* %s */' % (prefix(cls), style, repr(ttype)[6:])
|
||||
for (level, ttype, cls, style) in styles]
|
||||
if arg and not self.nobackground and \
|
||||
self.style.background_color is not None:
|
||||
text_style = ''
|
||||
if Text in self.ttype2class:
|
||||
text_style = ' ' + self.class2style[self.ttype2class[Text]][0]
|
||||
lines.insert(0, '%s { background: %s;%s }' %
|
||||
(prefix(''), self.style.background_color, text_style))
|
||||
if self.style.highlight_color is not None:
|
||||
lines.insert(0, '%s.hll { background-color: %s }' %
|
||||
(prefix(''), self.style.highlight_color))
|
||||
return '\n'.join(lines)
|
||||
|
||||
def _decodeifneeded(self, value):
|
||||
if isinstance(value, bytes):
|
||||
if self.encoding:
|
||||
return value.decode(self.encoding)
|
||||
return value.decode()
|
||||
return value
|
||||
|
||||
def _wrap_full(self, inner, outfile):
|
||||
if self.cssfile:
|
||||
if os.path.isabs(self.cssfile):
|
||||
# it's an absolute filename
|
||||
cssfilename = self.cssfile
|
||||
else:
|
||||
try:
|
||||
filename = outfile.name
|
||||
if not filename or filename[0] == '<':
|
||||
# pseudo files, e.g. name == '<fdopen>'
|
||||
raise AttributeError
|
||||
cssfilename = os.path.join(os.path.dirname(filename),
|
||||
self.cssfile)
|
||||
except AttributeError:
|
||||
print >>sys.stderr, 'Note: Cannot determine output file name, ' \
|
||||
'using current directory as base for the CSS file name'
|
||||
cssfilename = self.cssfile
|
||||
# write CSS file only if noclobber_cssfile isn't given as an option.
|
||||
try:
|
||||
if not os.path.exists(cssfilename) or not self.noclobber_cssfile:
|
||||
cf = open(cssfilename, "w")
|
||||
cf.write(CSSFILE_TEMPLATE %
|
||||
{'styledefs': self.get_style_defs('body')})
|
||||
cf.close()
|
||||
except IOError, err:
|
||||
err.strerror = 'Error writing CSS file: ' + err.strerror
|
||||
raise
|
||||
|
||||
yield 0, (DOC_HEADER_EXTERNALCSS %
|
||||
dict(title = self.title,
|
||||
cssfile = self.cssfile,
|
||||
encoding = self.encoding))
|
||||
else:
|
||||
yield 0, (DOC_HEADER %
|
||||
dict(title = self.title,
|
||||
styledefs = self.get_style_defs('body'),
|
||||
encoding = self.encoding))
|
||||
|
||||
for t, line in inner:
|
||||
yield t, line
|
||||
yield 0, DOC_FOOTER
|
||||
|
||||
def _wrap_tablelinenos(self, inner):
|
||||
dummyoutfile = StringIO.StringIO()
|
||||
lncount = 0
|
||||
for t, line in inner:
|
||||
if t:
|
||||
lncount += 1
|
||||
dummyoutfile.write(line)
|
||||
|
||||
fl = self.linenostart
|
||||
mw = len(str(lncount + fl - 1))
|
||||
sp = self.linenospecial
|
||||
st = self.linenostep
|
||||
la = self.lineanchors
|
||||
aln = self.anchorlinenos
|
||||
nocls = self.noclasses
|
||||
if sp:
|
||||
lines = []
|
||||
|
||||
for i in range(fl, fl+lncount):
|
||||
if i % st == 0:
|
||||
if i % sp == 0:
|
||||
if aln:
|
||||
lines.append('<a href="#%s-%d" class="special">%*d</a>' %
|
||||
(la, i, mw, i))
|
||||
else:
|
||||
lines.append('<span class="special">%*d</span>' % (mw, i))
|
||||
else:
|
||||
if aln:
|
||||
lines.append('<a href="#%s-%d">%*d</a>' % (la, i, mw, i))
|
||||
else:
|
||||
lines.append('%*d' % (mw, i))
|
||||
else:
|
||||
lines.append('')
|
||||
ls = '\n'.join(lines)
|
||||
else:
|
||||
lines = []
|
||||
for i in range(fl, fl+lncount):
|
||||
if i % st == 0:
|
||||
if aln:
|
||||
lines.append('<a href="#%s-%d">%*d</a>' % (la, i, mw, i))
|
||||
else:
|
||||
lines.append('%*d' % (mw, i))
|
||||
else:
|
||||
lines.append('')
|
||||
ls = '\n'.join(lines)
|
||||
|
||||
# in case you wonder about the seemingly redundant <div> here: since the
|
||||
# content in the other cell also is wrapped in a div, some browsers in
|
||||
# some configurations seem to mess up the formatting...
|
||||
if nocls:
|
||||
yield 0, ('<table class="%stable">' % self.cssclass +
|
||||
'<tr><td><div class="linenodiv" '
|
||||
'style="background-color: #f0f0f0; padding-right: 10px">'
|
||||
'<pre style="line-height: 125%">' +
|
||||
ls + '</pre></div></td><td class="code">')
|
||||
else:
|
||||
yield 0, ('<table class="%stable">' % self.cssclass +
|
||||
'<tr><td class="linenos"><div class="linenodiv"><pre>' +
|
||||
ls + '</pre></div></td><td class="code">')
|
||||
yield 0, dummyoutfile.getvalue()
|
||||
yield 0, '</td></tr></table>'
|
||||
|
||||
def _wrap_inlinelinenos(self, inner):
|
||||
# need a list of lines since we need the width of a single number :(
|
||||
lines = list(inner)
|
||||
sp = self.linenospecial
|
||||
st = self.linenostep
|
||||
num = self.linenostart
|
||||
mw = len(str(len(lines) + num - 1))
|
||||
|
||||
if self.noclasses:
|
||||
if sp:
|
||||
for t, line in lines:
|
||||
if num%sp == 0:
|
||||
style = 'background-color: #ffffc0; padding: 0 5px 0 5px'
|
||||
else:
|
||||
style = 'background-color: #f0f0f0; padding: 0 5px 0 5px'
|
||||
yield 1, '<span style="%s">%*s</span> ' % (
|
||||
style, mw, (num%st and ' ' or num)) + line
|
||||
num += 1
|
||||
else:
|
||||
for t, line in lines:
|
||||
yield 1, ('<span style="background-color: #f0f0f0; '
|
||||
'padding: 0 5px 0 5px">%*s</span> ' % (
|
||||
mw, (num%st and ' ' or num)) + line)
|
||||
num += 1
|
||||
elif sp:
|
||||
for t, line in lines:
|
||||
yield 1, '<span class="lineno%s">%*s</span> ' % (
|
||||
num%sp == 0 and ' special' or '', mw,
|
||||
(num%st and ' ' or num)) + line
|
||||
num += 1
|
||||
else:
|
||||
for t, line in lines:
|
||||
yield 1, '<span class="lineno">%*s</span> ' % (
|
||||
mw, (num%st and ' ' or num)) + line
|
||||
num += 1
|
||||
|
||||
def _wrap_lineanchors(self, inner):
|
||||
s = self.lineanchors
|
||||
i = self.linenostart - 1 # subtract 1 since we have to increment i
|
||||
# *before* yielding
|
||||
for t, line in inner:
|
||||
if t:
|
||||
i += 1
|
||||
yield 1, '<a name="%s-%d"></a>' % (s, i) + line
|
||||
else:
|
||||
yield 0, line
|
||||
|
||||
def _wrap_linespans(self, inner):
|
||||
s = self.linespans
|
||||
i = self.linenostart - 1
|
||||
for t, line in inner:
|
||||
if t:
|
||||
i += 1
|
||||
yield 1, '<span id="%s-%d">%s</span>' % (s, i, line)
|
||||
else:
|
||||
yield 0, line
|
||||
|
||||
def _wrap_div(self, inner):
|
||||
style = []
|
||||
if (self.noclasses and not self.nobackground and
|
||||
self.style.background_color is not None):
|
||||
style.append('background: %s' % (self.style.background_color,))
|
||||
if self.cssstyles:
|
||||
style.append(self.cssstyles)
|
||||
style = '; '.join(style)
|
||||
|
||||
yield 0, ('<div' + (self.cssclass and ' class="%s"' % self.cssclass)
|
||||
+ (style and (' style="%s"' % style)) + '>')
|
||||
for tup in inner:
|
||||
yield tup
|
||||
yield 0, '</div>\n'
|
||||
|
||||
def _wrap_pre(self, inner):
|
||||
style = []
|
||||
if self.prestyles:
|
||||
style.append(self.prestyles)
|
||||
if self.noclasses:
|
||||
style.append('line-height: 125%')
|
||||
style = '; '.join(style)
|
||||
|
||||
yield 0, ('<pre' + (style and ' style="%s"' % style) + '>')
|
||||
for tup in inner:
|
||||
yield tup
|
||||
yield 0, '</pre>'
|
||||
|
||||
def _format_lines(self, tokensource):
|
||||
"""
|
||||
Just format the tokens, without any wrapping tags.
|
||||
Yield individual lines.
|
||||
"""
|
||||
nocls = self.noclasses
|
||||
lsep = self.lineseparator
|
||||
# for <span style=""> lookup only
|
||||
getcls = self.ttype2class.get
|
||||
c2s = self.class2style
|
||||
escape_table = _escape_html_table
|
||||
tagsfile = self.tagsfile
|
||||
|
||||
lspan = ''
|
||||
line = ''
|
||||
for ttype, value in tokensource:
|
||||
if nocls:
|
||||
cclass = getcls(ttype)
|
||||
while cclass is None:
|
||||
ttype = ttype.parent
|
||||
cclass = getcls(ttype)
|
||||
cspan = cclass and '<span style="%s">' % c2s[cclass][0] or ''
|
||||
else:
|
||||
cls = self._get_css_class(ttype)
|
||||
cspan = cls and '<span class="%s">' % cls or ''
|
||||
|
||||
parts = value.translate(escape_table).split('\n')
|
||||
|
||||
if tagsfile and ttype in Token.Name:
|
||||
filename, linenumber = self._lookup_ctag(value)
|
||||
if linenumber:
|
||||
base, filename = os.path.split(filename)
|
||||
if base:
|
||||
base += '/'
|
||||
filename, extension = os.path.splitext(filename)
|
||||
url = self.tagurlformat % {'path': base, 'fname': filename,
|
||||
'fext': extension}
|
||||
parts[0] = "<a href=\"%s#%s-%d\">%s" % \
|
||||
(url, self.lineanchors, linenumber, parts[0])
|
||||
parts[-1] = parts[-1] + "</a>"
|
||||
|
||||
# for all but the last line
|
||||
for part in parts[:-1]:
|
||||
if line:
|
||||
if lspan != cspan:
|
||||
line += (lspan and '</span>') + cspan + part + \
|
||||
(cspan and '</span>') + lsep
|
||||
else: # both are the same
|
||||
line += part + (lspan and '</span>') + lsep
|
||||
yield 1, line
|
||||
line = ''
|
||||
elif part:
|
||||
yield 1, cspan + part + (cspan and '</span>') + lsep
|
||||
else:
|
||||
yield 1, lsep
|
||||
# for the last line
|
||||
if line and parts[-1]:
|
||||
if lspan != cspan:
|
||||
line += (lspan and '</span>') + cspan + parts[-1]
|
||||
lspan = cspan
|
||||
else:
|
||||
line += parts[-1]
|
||||
elif parts[-1]:
|
||||
line = cspan + parts[-1]
|
||||
lspan = cspan
|
||||
# else we neither have to open a new span nor set lspan
|
||||
|
||||
if line:
|
||||
yield 1, line + (lspan and '</span>') + lsep
|
||||
|
||||
def _lookup_ctag(self, token):
|
||||
entry = ctags.TagEntry()
|
||||
if self._ctags.find(entry, token, 0):
|
||||
return entry['file'], entry['lineNumber']
|
||||
else:
|
||||
return None, None
|
||||
|
||||
def _highlight_lines(self, tokensource):
|
||||
"""
|
||||
Highlighted the lines specified in the `hl_lines` option by
|
||||
post-processing the token stream coming from `_format_lines`.
|
||||
"""
|
||||
hls = self.hl_lines
|
||||
|
||||
for i, (t, value) in enumerate(tokensource):
|
||||
if t != 1:
|
||||
yield t, value
|
||||
if i + 1 in hls: # i + 1 because Python indexes start at 0
|
||||
if self.noclasses:
|
||||
style = ''
|
||||
if self.style.highlight_color is not None:
|
||||
style = (' style="background-color: %s"' %
|
||||
(self.style.highlight_color,))
|
||||
yield 1, '<span%s>%s</span>' % (style, value)
|
||||
else:
|
||||
yield 1, '<span class="hll">%s</span>' % value
|
||||
else:
|
||||
yield 1, value
|
||||
|
||||
def wrap(self, source, outfile):
|
||||
"""
|
||||
Wrap the ``source``, which is a generator yielding
|
||||
individual lines, in custom generators. See docstring
|
||||
for `format`. Can be overridden.
|
||||
"""
|
||||
return self._wrap_div(self._wrap_pre(source))
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
"""
|
||||
The formatting process uses several nested generators; which of
|
||||
them are used is determined by the user's options.
|
||||
|
||||
Each generator should take at least one argument, ``inner``,
|
||||
and wrap the pieces of text generated by this.
|
||||
|
||||
Always yield 2-tuples: (code, text). If "code" is 1, the text
|
||||
is part of the original tokensource being highlighted, if it's
|
||||
0, the text is some piece of wrapping. This makes it possible to
|
||||
use several different wrappers that process the original source
|
||||
linewise, e.g. line number generators.
|
||||
"""
|
||||
source = self._format_lines(tokensource)
|
||||
if self.hl_lines:
|
||||
source = self._highlight_lines(source)
|
||||
if not self.nowrap:
|
||||
if self.linenos == 2:
|
||||
source = self._wrap_inlinelinenos(source)
|
||||
if self.lineanchors:
|
||||
source = self._wrap_lineanchors(source)
|
||||
if self.linespans:
|
||||
source = self._wrap_linespans(source)
|
||||
source = self.wrap(source, outfile)
|
||||
if self.linenos == 1:
|
||||
source = self._wrap_tablelinenos(source)
|
||||
if self.full:
|
||||
source = self._wrap_full(source, outfile)
|
||||
|
||||
for t, piece in source:
|
||||
outfile.write(piece)
|
|
@ -0,0 +1,553 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.img
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for Pixmap output.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.util import get_bool_opt, get_int_opt, \
|
||||
get_list_opt, get_choice_opt
|
||||
|
||||
# Import this carefully
|
||||
try:
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
pil_available = True
|
||||
except ImportError:
|
||||
pil_available = False
|
||||
|
||||
try:
|
||||
import _winreg
|
||||
except ImportError:
|
||||
_winreg = None
|
||||
|
||||
__all__ = ['ImageFormatter', 'GifImageFormatter', 'JpgImageFormatter',
|
||||
'BmpImageFormatter']
|
||||
|
||||
|
||||
# For some unknown reason every font calls it something different
|
||||
STYLES = {
|
||||
'NORMAL': ['', 'Roman', 'Book', 'Normal', 'Regular', 'Medium'],
|
||||
'ITALIC': ['Oblique', 'Italic'],
|
||||
'BOLD': ['Bold'],
|
||||
'BOLDITALIC': ['Bold Oblique', 'Bold Italic'],
|
||||
}
|
||||
|
||||
# A sane default for modern systems
|
||||
DEFAULT_FONT_NAME_NIX = 'Bitstream Vera Sans Mono'
|
||||
DEFAULT_FONT_NAME_WIN = 'Courier New'
|
||||
|
||||
|
||||
class PilNotAvailable(ImportError):
|
||||
"""When Python imaging library is not available"""
|
||||
|
||||
|
||||
class FontNotFound(Exception):
|
||||
"""When there are no usable fonts specified"""
|
||||
|
||||
|
||||
class FontManager(object):
|
||||
"""
|
||||
Manages a set of fonts: normal, italic, bold, etc...
|
||||
"""
|
||||
|
||||
def __init__(self, font_name, font_size=14):
|
||||
self.font_name = font_name
|
||||
self.font_size = font_size
|
||||
self.fonts = {}
|
||||
self.encoding = None
|
||||
if sys.platform.startswith('win'):
|
||||
if not font_name:
|
||||
self.font_name = DEFAULT_FONT_NAME_WIN
|
||||
self._create_win()
|
||||
else:
|
||||
if not font_name:
|
||||
self.font_name = DEFAULT_FONT_NAME_NIX
|
||||
self._create_nix()
|
||||
|
||||
def _get_nix_font_path(self, name, style):
|
||||
from commands import getstatusoutput
|
||||
exit, out = getstatusoutput('fc-list "%s:style=%s" file' %
|
||||
(name, style))
|
||||
if not exit:
|
||||
lines = out.splitlines()
|
||||
if lines:
|
||||
path = lines[0].strip().strip(':')
|
||||
return path
|
||||
|
||||
def _create_nix(self):
|
||||
for name in STYLES['NORMAL']:
|
||||
path = self._get_nix_font_path(self.font_name, name)
|
||||
if path is not None:
|
||||
self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size)
|
||||
break
|
||||
else:
|
||||
raise FontNotFound('No usable fonts named: "%s"' %
|
||||
self.font_name)
|
||||
for style in ('ITALIC', 'BOLD', 'BOLDITALIC'):
|
||||
for stylename in STYLES[style]:
|
||||
path = self._get_nix_font_path(self.font_name, stylename)
|
||||
if path is not None:
|
||||
self.fonts[style] = ImageFont.truetype(path, self.font_size)
|
||||
break
|
||||
else:
|
||||
if style == 'BOLDITALIC':
|
||||
self.fonts[style] = self.fonts['BOLD']
|
||||
else:
|
||||
self.fonts[style] = self.fonts['NORMAL']
|
||||
|
||||
def _lookup_win(self, key, basename, styles, fail=False):
|
||||
for suffix in ('', ' (TrueType)'):
|
||||
for style in styles:
|
||||
try:
|
||||
valname = '%s%s%s' % (basename, style and ' '+style, suffix)
|
||||
val, _ = _winreg.QueryValueEx(key, valname)
|
||||
return val
|
||||
except EnvironmentError:
|
||||
continue
|
||||
else:
|
||||
if fail:
|
||||
raise FontNotFound('Font %s (%s) not found in registry' %
|
||||
(basename, styles[0]))
|
||||
return None
|
||||
|
||||
def _create_win(self):
|
||||
try:
|
||||
key = _winreg.OpenKey(
|
||||
_winreg.HKEY_LOCAL_MACHINE,
|
||||
r'Software\Microsoft\Windows NT\CurrentVersion\Fonts')
|
||||
except EnvironmentError:
|
||||
try:
|
||||
key = _winreg.OpenKey(
|
||||
_winreg.HKEY_LOCAL_MACHINE,
|
||||
r'Software\Microsoft\Windows\CurrentVersion\Fonts')
|
||||
except EnvironmentError:
|
||||
raise FontNotFound('Can\'t open Windows font registry key')
|
||||
try:
|
||||
path = self._lookup_win(key, self.font_name, STYLES['NORMAL'], True)
|
||||
self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size)
|
||||
for style in ('ITALIC', 'BOLD', 'BOLDITALIC'):
|
||||
path = self._lookup_win(key, self.font_name, STYLES[style])
|
||||
if path:
|
||||
self.fonts[style] = ImageFont.truetype(path, self.font_size)
|
||||
else:
|
||||
if style == 'BOLDITALIC':
|
||||
self.fonts[style] = self.fonts['BOLD']
|
||||
else:
|
||||
self.fonts[style] = self.fonts['NORMAL']
|
||||
finally:
|
||||
_winreg.CloseKey(key)
|
||||
|
||||
def get_char_size(self):
|
||||
"""
|
||||
Get the character size.
|
||||
"""
|
||||
return self.fonts['NORMAL'].getsize('M')
|
||||
|
||||
def get_font(self, bold, oblique):
|
||||
"""
|
||||
Get the font based on bold and italic flags.
|
||||
"""
|
||||
if bold and oblique:
|
||||
return self.fonts['BOLDITALIC']
|
||||
elif bold:
|
||||
return self.fonts['BOLD']
|
||||
elif oblique:
|
||||
return self.fonts['ITALIC']
|
||||
else:
|
||||
return self.fonts['NORMAL']
|
||||
|
||||
|
||||
class ImageFormatter(Formatter):
|
||||
"""
|
||||
Create a PNG image from source code. This uses the Python Imaging Library to
|
||||
generate a pixmap from the source code.
|
||||
|
||||
*New in Pygments 0.10.*
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`image_format`
|
||||
An image format to output to that is recognised by PIL, these include:
|
||||
|
||||
* "PNG" (default)
|
||||
* "JPEG"
|
||||
* "BMP"
|
||||
* "GIF"
|
||||
|
||||
`line_pad`
|
||||
The extra spacing (in pixels) between each line of text.
|
||||
|
||||
Default: 2
|
||||
|
||||
`font_name`
|
||||
The font name to be used as the base font from which others, such as
|
||||
bold and italic fonts will be generated. This really should be a
|
||||
monospace font to look sane.
|
||||
|
||||
Default: "Bitstream Vera Sans Mono"
|
||||
|
||||
`font_size`
|
||||
The font size in points to be used.
|
||||
|
||||
Default: 14
|
||||
|
||||
`image_pad`
|
||||
The padding, in pixels to be used at each edge of the resulting image.
|
||||
|
||||
Default: 10
|
||||
|
||||
`line_numbers`
|
||||
Whether line numbers should be shown: True/False
|
||||
|
||||
Default: True
|
||||
|
||||
`line_number_start`
|
||||
The line number of the first line.
|
||||
|
||||
Default: 1
|
||||
|
||||
`line_number_step`
|
||||
The step used when printing line numbers.
|
||||
|
||||
Default: 1
|
||||
|
||||
`line_number_bg`
|
||||
The background colour (in "#123456" format) of the line number bar, or
|
||||
None to use the style background color.
|
||||
|
||||
Default: "#eed"
|
||||
|
||||
`line_number_fg`
|
||||
The text color of the line numbers (in "#123456"-like format).
|
||||
|
||||
Default: "#886"
|
||||
|
||||
`line_number_chars`
|
||||
The number of columns of line numbers allowable in the line number
|
||||
margin.
|
||||
|
||||
Default: 2
|
||||
|
||||
`line_number_bold`
|
||||
Whether line numbers will be bold: True/False
|
||||
|
||||
Default: False
|
||||
|
||||
`line_number_italic`
|
||||
Whether line numbers will be italicized: True/False
|
||||
|
||||
Default: False
|
||||
|
||||
`line_number_separator`
|
||||
Whether a line will be drawn between the line number area and the
|
||||
source code area: True/False
|
||||
|
||||
Default: True
|
||||
|
||||
`line_number_pad`
|
||||
The horizontal padding (in pixels) between the line number margin, and
|
||||
the source code area.
|
||||
|
||||
Default: 6
|
||||
|
||||
`hl_lines`
|
||||
Specify a list of lines to be highlighted. *New in Pygments 1.2.*
|
||||
|
||||
Default: empty list
|
||||
|
||||
`hl_color`
|
||||
Specify the color for highlighting lines. *New in Pygments 1.2.*
|
||||
|
||||
Default: highlight color of the selected style
|
||||
"""
|
||||
|
||||
# Required by the pygments mapper
|
||||
name = 'img'
|
||||
aliases = ['img', 'IMG', 'png']
|
||||
filenames = ['*.png']
|
||||
|
||||
unicodeoutput = False
|
||||
|
||||
default_image_format = 'png'
|
||||
|
||||
def __init__(self, **options):
|
||||
"""
|
||||
See the class docstring for explanation of options.
|
||||
"""
|
||||
if not pil_available:
|
||||
raise PilNotAvailable(
|
||||
'Python Imaging Library is required for this formatter')
|
||||
Formatter.__init__(self, **options)
|
||||
# Read the style
|
||||
self.styles = dict(self.style)
|
||||
if self.style.background_color is None:
|
||||
self.background_color = '#fff'
|
||||
else:
|
||||
self.background_color = self.style.background_color
|
||||
# Image options
|
||||
self.image_format = get_choice_opt(
|
||||
options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'],
|
||||
self.default_image_format, normcase=True)
|
||||
self.image_pad = get_int_opt(options, 'image_pad', 10)
|
||||
self.line_pad = get_int_opt(options, 'line_pad', 2)
|
||||
# The fonts
|
||||
fontsize = get_int_opt(options, 'font_size', 14)
|
||||
self.fonts = FontManager(options.get('font_name', ''), fontsize)
|
||||
self.fontw, self.fonth = self.fonts.get_char_size()
|
||||
# Line number options
|
||||
self.line_number_fg = options.get('line_number_fg', '#886')
|
||||
self.line_number_bg = options.get('line_number_bg', '#eed')
|
||||
self.line_number_chars = get_int_opt(options,
|
||||
'line_number_chars', 2)
|
||||
self.line_number_bold = get_bool_opt(options,
|
||||
'line_number_bold', False)
|
||||
self.line_number_italic = get_bool_opt(options,
|
||||
'line_number_italic', False)
|
||||
self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
|
||||
self.line_numbers = get_bool_opt(options, 'line_numbers', True)
|
||||
self.line_number_separator = get_bool_opt(options,
|
||||
'line_number_separator', True)
|
||||
self.line_number_step = get_int_opt(options, 'line_number_step', 1)
|
||||
self.line_number_start = get_int_opt(options, 'line_number_start', 1)
|
||||
if self.line_numbers:
|
||||
self.line_number_width = (self.fontw * self.line_number_chars +
|
||||
self.line_number_pad * 2)
|
||||
else:
|
||||
self.line_number_width = 0
|
||||
self.hl_lines = []
|
||||
hl_lines_str = get_list_opt(options, 'hl_lines', [])
|
||||
for line in hl_lines_str:
|
||||
try:
|
||||
self.hl_lines.append(int(line))
|
||||
except ValueError:
|
||||
pass
|
||||
self.hl_color = options.get('hl_color',
|
||||
self.style.highlight_color) or '#f90'
|
||||
self.drawables = []
|
||||
|
||||
def get_style_defs(self, arg=''):
|
||||
raise NotImplementedError('The -S option is meaningless for the image '
|
||||
'formatter. Use -O style=<stylename> instead.')
|
||||
|
||||
def _get_line_height(self):
|
||||
"""
|
||||
Get the height of a line.
|
||||
"""
|
||||
return self.fonth + self.line_pad
|
||||
|
||||
def _get_line_y(self, lineno):
|
||||
"""
|
||||
Get the Y coordinate of a line number.
|
||||
"""
|
||||
return lineno * self._get_line_height() + self.image_pad
|
||||
|
||||
def _get_char_width(self):
|
||||
"""
|
||||
Get the width of a character.
|
||||
"""
|
||||
return self.fontw
|
||||
|
||||
def _get_char_x(self, charno):
|
||||
"""
|
||||
Get the X coordinate of a character position.
|
||||
"""
|
||||
return charno * self.fontw + self.image_pad + self.line_number_width
|
||||
|
||||
def _get_text_pos(self, charno, lineno):
|
||||
"""
|
||||
Get the actual position for a character and line position.
|
||||
"""
|
||||
return self._get_char_x(charno), self._get_line_y(lineno)
|
||||
|
||||
def _get_linenumber_pos(self, lineno):
|
||||
"""
|
||||
Get the actual position for the start of a line number.
|
||||
"""
|
||||
return (self.image_pad, self._get_line_y(lineno))
|
||||
|
||||
def _get_text_color(self, style):
|
||||
"""
|
||||
Get the correct color for the token from the style.
|
||||
"""
|
||||
if style['color'] is not None:
|
||||
fill = '#' + style['color']
|
||||
else:
|
||||
fill = '#000'
|
||||
return fill
|
||||
|
||||
def _get_style_font(self, style):
|
||||
"""
|
||||
Get the correct font for the style.
|
||||
"""
|
||||
return self.fonts.get_font(style['bold'], style['italic'])
|
||||
|
||||
def _get_image_size(self, maxcharno, maxlineno):
|
||||
"""
|
||||
Get the required image size.
|
||||
"""
|
||||
return (self._get_char_x(maxcharno) + self.image_pad,
|
||||
self._get_line_y(maxlineno + 0) + self.image_pad)
|
||||
|
||||
def _draw_linenumber(self, posno, lineno):
|
||||
"""
|
||||
Remember a line number drawable to paint later.
|
||||
"""
|
||||
self._draw_text(
|
||||
self._get_linenumber_pos(posno),
|
||||
str(lineno).rjust(self.line_number_chars),
|
||||
font=self.fonts.get_font(self.line_number_bold,
|
||||
self.line_number_italic),
|
||||
fill=self.line_number_fg,
|
||||
)
|
||||
|
||||
def _draw_text(self, pos, text, font, **kw):
|
||||
"""
|
||||
Remember a single drawable tuple to paint later.
|
||||
"""
|
||||
self.drawables.append((pos, text, font, kw))
|
||||
|
||||
def _create_drawables(self, tokensource):
|
||||
"""
|
||||
Create drawables for the token content.
|
||||
"""
|
||||
lineno = charno = maxcharno = 0
|
||||
for ttype, value in tokensource:
|
||||
while ttype not in self.styles:
|
||||
ttype = ttype.parent
|
||||
style = self.styles[ttype]
|
||||
# TODO: make sure tab expansion happens earlier in the chain. It
|
||||
# really ought to be done on the input, as to do it right here is
|
||||
# quite complex.
|
||||
value = value.expandtabs(4)
|
||||
lines = value.splitlines(True)
|
||||
#print lines
|
||||
for i, line in enumerate(lines):
|
||||
temp = line.rstrip('\n')
|
||||
if temp:
|
||||
self._draw_text(
|
||||
self._get_text_pos(charno, lineno),
|
||||
temp,
|
||||
font = self._get_style_font(style),
|
||||
fill = self._get_text_color(style)
|
||||
)
|
||||
charno += len(temp)
|
||||
maxcharno = max(maxcharno, charno)
|
||||
if line.endswith('\n'):
|
||||
# add a line for each extra line in the value
|
||||
charno = 0
|
||||
lineno += 1
|
||||
self.maxcharno = maxcharno
|
||||
self.maxlineno = lineno
|
||||
|
||||
def _draw_line_numbers(self):
|
||||
"""
|
||||
Create drawables for the line numbers.
|
||||
"""
|
||||
if not self.line_numbers:
|
||||
return
|
||||
for p in xrange(self.maxlineno):
|
||||
n = p + self.line_number_start
|
||||
if (n % self.line_number_step) == 0:
|
||||
self._draw_linenumber(p, n)
|
||||
|
||||
def _paint_line_number_bg(self, im):
|
||||
"""
|
||||
Paint the line number background on the image.
|
||||
"""
|
||||
if not self.line_numbers:
|
||||
return
|
||||
if self.line_number_fg is None:
|
||||
return
|
||||
draw = ImageDraw.Draw(im)
|
||||
recth = im.size[-1]
|
||||
rectw = self.image_pad + self.line_number_width - self.line_number_pad
|
||||
draw.rectangle([(0, 0),
|
||||
(rectw, recth)],
|
||||
fill=self.line_number_bg)
|
||||
draw.line([(rectw, 0), (rectw, recth)], fill=self.line_number_fg)
|
||||
del draw
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
"""
|
||||
Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
|
||||
tuples and write it into ``outfile``.
|
||||
|
||||
This implementation calculates where it should draw each token on the
|
||||
pixmap, then calculates the required pixmap size and draws the items.
|
||||
"""
|
||||
self._create_drawables(tokensource)
|
||||
self._draw_line_numbers()
|
||||
im = Image.new(
|
||||
'RGB',
|
||||
self._get_image_size(self.maxcharno, self.maxlineno),
|
||||
self.background_color
|
||||
)
|
||||
self._paint_line_number_bg(im)
|
||||
draw = ImageDraw.Draw(im)
|
||||
# Highlight
|
||||
if self.hl_lines:
|
||||
x = self.image_pad + self.line_number_width - self.line_number_pad + 1
|
||||
recth = self._get_line_height()
|
||||
rectw = im.size[0] - x
|
||||
for linenumber in self.hl_lines:
|
||||
y = self._get_line_y(linenumber - 1)
|
||||
draw.rectangle([(x, y), (x + rectw, y + recth)],
|
||||
fill=self.hl_color)
|
||||
for pos, value, font, kw in self.drawables:
|
||||
draw.text(pos, value, font=font, **kw)
|
||||
im.save(outfile, self.image_format.upper())
|
||||
|
||||
|
||||
# Add one formatter per format, so that the "-f gif" option gives the correct result
|
||||
# when used in pygmentize.
|
||||
|
||||
class GifImageFormatter(ImageFormatter):
|
||||
"""
|
||||
Create a GIF image from source code. This uses the Python Imaging Library to
|
||||
generate a pixmap from the source code.
|
||||
|
||||
*New in Pygments 1.0.* (You could create GIF images before by passing a
|
||||
suitable `image_format` option to the `ImageFormatter`.)
|
||||
"""
|
||||
|
||||
name = 'img_gif'
|
||||
aliases = ['gif']
|
||||
filenames = ['*.gif']
|
||||
default_image_format = 'gif'
|
||||
|
||||
|
||||
class JpgImageFormatter(ImageFormatter):
|
||||
"""
|
||||
Create a JPEG image from source code. This uses the Python Imaging Library to
|
||||
generate a pixmap from the source code.
|
||||
|
||||
*New in Pygments 1.0.* (You could create JPEG images before by passing a
|
||||
suitable `image_format` option to the `ImageFormatter`.)
|
||||
"""
|
||||
|
||||
name = 'img_jpg'
|
||||
aliases = ['jpg', 'jpeg']
|
||||
filenames = ['*.jpg']
|
||||
default_image_format = 'jpeg'
|
||||
|
||||
|
||||
class BmpImageFormatter(ImageFormatter):
|
||||
"""
|
||||
Create a bitmap image from source code. This uses the Python Imaging Library to
|
||||
generate a pixmap from the source code.
|
||||
|
||||
*New in Pygments 1.0.* (You could create bitmap images before by passing a
|
||||
suitable `image_format` option to the `ImageFormatter`.)
|
||||
"""
|
||||
|
||||
name = 'img_bmp'
|
||||
aliases = ['bmp', 'bitmap']
|
||||
filenames = ['*.bmp']
|
||||
default_image_format = 'bmp'
|
|
@ -0,0 +1,378 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.latex
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for LaTeX fancyvrb output.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.token import Token, STANDARD_TYPES
|
||||
from pygments.util import get_bool_opt, get_int_opt, StringIO
|
||||
|
||||
|
||||
__all__ = ['LatexFormatter']
|
||||
|
||||
|
||||
def escape_tex(text, commandprefix):
|
||||
return text.replace('\\', '\x00'). \
|
||||
replace('{', '\x01'). \
|
||||
replace('}', '\x02'). \
|
||||
replace('\x00', r'\%sZbs{}' % commandprefix). \
|
||||
replace('\x01', r'\%sZob{}' % commandprefix). \
|
||||
replace('\x02', r'\%sZcb{}' % commandprefix). \
|
||||
replace('^', r'\%sZca{}' % commandprefix). \
|
||||
replace('_', r'\%sZus{}' % commandprefix). \
|
||||
replace('&', r'\%sZam{}' % commandprefix). \
|
||||
replace('<', r'\%sZlt{}' % commandprefix). \
|
||||
replace('>', r'\%sZgt{}' % commandprefix). \
|
||||
replace('#', r'\%sZsh{}' % commandprefix). \
|
||||
replace('%', r'\%sZpc{}' % commandprefix). \
|
||||
replace('$', r'\%sZdl{}' % commandprefix). \
|
||||
replace('-', r'\%sZhy{}' % commandprefix). \
|
||||
replace("'", r'\%sZsq{}' % commandprefix). \
|
||||
replace('"', r'\%sZdq{}' % commandprefix). \
|
||||
replace('~', r'\%sZti{}' % commandprefix)
|
||||
|
||||
|
||||
DOC_TEMPLATE = r'''
|
||||
\documentclass{%(docclass)s}
|
||||
\usepackage{fancyvrb}
|
||||
\usepackage{color}
|
||||
\usepackage[%(encoding)s]{inputenc}
|
||||
%(preamble)s
|
||||
|
||||
%(styledefs)s
|
||||
|
||||
\begin{document}
|
||||
|
||||
\section*{%(title)s}
|
||||
|
||||
%(code)s
|
||||
\end{document}
|
||||
'''
|
||||
|
||||
## Small explanation of the mess below :)
|
||||
#
|
||||
# The previous version of the LaTeX formatter just assigned a command to
|
||||
# each token type defined in the current style. That obviously is
|
||||
# problematic if the highlighted code is produced for a different style
|
||||
# than the style commands themselves.
|
||||
#
|
||||
# This version works much like the HTML formatter which assigns multiple
|
||||
# CSS classes to each <span> tag, from the most specific to the least
|
||||
# specific token type, thus falling back to the parent token type if one
|
||||
# is not defined. Here, the classes are there too and use the same short
|
||||
# forms given in token.STANDARD_TYPES.
|
||||
#
|
||||
# Highlighted code now only uses one custom command, which by default is
|
||||
# \PY and selectable by the commandprefix option (and in addition the
|
||||
# escapes \PYZat, \PYZlb and \PYZrb which haven't been renamed for
|
||||
# backwards compatibility purposes).
|
||||
#
|
||||
# \PY has two arguments: the classes, separated by +, and the text to
|
||||
# render in that style. The classes are resolved into the respective
|
||||
# style commands by magic, which serves to ignore unknown classes.
|
||||
#
|
||||
# The magic macros are:
|
||||
# * \PY@it, \PY@bf, etc. are unconditionally wrapped around the text
|
||||
# to render in \PY@do. Their definition determines the style.
|
||||
# * \PY@reset resets \PY@it etc. to do nothing.
|
||||
# * \PY@toks parses the list of classes, using magic inspired by the
|
||||
# keyval package (but modified to use plusses instead of commas
|
||||
# because fancyvrb redefines commas inside its environments).
|
||||
# * \PY@tok processes one class, calling the \PY@tok@classname command
|
||||
# if it exists.
|
||||
# * \PY@tok@classname sets the \PY@it etc. to reflect the chosen style
|
||||
# for its class.
|
||||
# * \PY resets the style, parses the classnames and then calls \PY@do.
|
||||
#
|
||||
# Tip: to read this code, print it out in substituted form using e.g.
|
||||
# >>> print STYLE_TEMPLATE % {'cp': 'PY'}
|
||||
|
||||
STYLE_TEMPLATE = r'''
|
||||
\makeatletter
|
||||
\def\%(cp)s@reset{\let\%(cp)s@it=\relax \let\%(cp)s@bf=\relax%%
|
||||
\let\%(cp)s@ul=\relax \let\%(cp)s@tc=\relax%%
|
||||
\let\%(cp)s@bc=\relax \let\%(cp)s@ff=\relax}
|
||||
\def\%(cp)s@tok#1{\csname %(cp)s@tok@#1\endcsname}
|
||||
\def\%(cp)s@toks#1+{\ifx\relax#1\empty\else%%
|
||||
\%(cp)s@tok{#1}\expandafter\%(cp)s@toks\fi}
|
||||
\def\%(cp)s@do#1{\%(cp)s@bc{\%(cp)s@tc{\%(cp)s@ul{%%
|
||||
\%(cp)s@it{\%(cp)s@bf{\%(cp)s@ff{#1}}}}}}}
|
||||
\def\%(cp)s#1#2{\%(cp)s@reset\%(cp)s@toks#1+\relax+\%(cp)s@do{#2}}
|
||||
|
||||
%(styles)s
|
||||
|
||||
\def\%(cp)sZbs{\char`\\}
|
||||
\def\%(cp)sZus{\char`\_}
|
||||
\def\%(cp)sZob{\char`\{}
|
||||
\def\%(cp)sZcb{\char`\}}
|
||||
\def\%(cp)sZca{\char`\^}
|
||||
\def\%(cp)sZam{\char`\&}
|
||||
\def\%(cp)sZlt{\char`\<}
|
||||
\def\%(cp)sZgt{\char`\>}
|
||||
\def\%(cp)sZsh{\char`\#}
|
||||
\def\%(cp)sZpc{\char`\%%}
|
||||
\def\%(cp)sZdl{\char`\$}
|
||||
\def\%(cp)sZhy{\char`\-}
|
||||
\def\%(cp)sZsq{\char`\'}
|
||||
\def\%(cp)sZdq{\char`\"}
|
||||
\def\%(cp)sZti{\char`\~}
|
||||
%% for compatibility with earlier versions
|
||||
\def\%(cp)sZat{@}
|
||||
\def\%(cp)sZlb{[}
|
||||
\def\%(cp)sZrb{]}
|
||||
\makeatother
|
||||
'''
|
||||
|
||||
|
||||
def _get_ttype_name(ttype):
|
||||
fname = STANDARD_TYPES.get(ttype)
|
||||
if fname:
|
||||
return fname
|
||||
aname = ''
|
||||
while fname is None:
|
||||
aname = ttype[-1] + aname
|
||||
ttype = ttype.parent
|
||||
fname = STANDARD_TYPES.get(ttype)
|
||||
return fname + aname
|
||||
|
||||
|
||||
class LatexFormatter(Formatter):
|
||||
r"""
|
||||
Format tokens as LaTeX code. This needs the `fancyvrb` and `color`
|
||||
standard packages.
|
||||
|
||||
Without the `full` option, code is formatted as one ``Verbatim``
|
||||
environment, like this:
|
||||
|
||||
.. sourcecode:: latex
|
||||
|
||||
\begin{Verbatim}[commandchars=\\{\}]
|
||||
\PY{k}{def }\PY{n+nf}{foo}(\PY{n}{bar}):
|
||||
\PY{k}{pass}
|
||||
\end{Verbatim}
|
||||
|
||||
The special command used here (``\PY``) and all the other macros it needs
|
||||
are output by the `get_style_defs` method.
|
||||
|
||||
With the `full` option, a complete LaTeX document is output, including
|
||||
the command definitions in the preamble.
|
||||
|
||||
The `get_style_defs()` method of a `LatexFormatter` returns a string
|
||||
containing ``\def`` commands defining the macros needed inside the
|
||||
``Verbatim`` environments.
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`style`
|
||||
The style to use, can be a string or a Style subclass (default:
|
||||
``'default'``).
|
||||
|
||||
`full`
|
||||
Tells the formatter to output a "full" document, i.e. a complete
|
||||
self-contained document (default: ``False``).
|
||||
|
||||
`title`
|
||||
If `full` is true, the title that should be used to caption the
|
||||
document (default: ``''``).
|
||||
|
||||
`docclass`
|
||||
If the `full` option is enabled, this is the document class to use
|
||||
(default: ``'article'``).
|
||||
|
||||
`preamble`
|
||||
If the `full` option is enabled, this can be further preamble commands,
|
||||
e.g. ``\usepackage`` (default: ``''``).
|
||||
|
||||
`linenos`
|
||||
If set to ``True``, output line numbers (default: ``False``).
|
||||
|
||||
`linenostart`
|
||||
The line number for the first line (default: ``1``).
|
||||
|
||||
`linenostep`
|
||||
If set to a number n > 1, only every nth line number is printed.
|
||||
|
||||
`verboptions`
|
||||
Additional options given to the Verbatim environment (see the *fancyvrb*
|
||||
docs for possible values) (default: ``''``).
|
||||
|
||||
`commandprefix`
|
||||
The LaTeX commands used to produce colored output are constructed
|
||||
using this prefix and some letters (default: ``'PY'``).
|
||||
*New in Pygments 0.7.*
|
||||
|
||||
*New in Pygments 0.10:* the default is now ``'PY'`` instead of ``'C'``.
|
||||
|
||||
`texcomments`
|
||||
If set to ``True``, enables LaTeX comment lines. That is, LaTex markup
|
||||
in comment tokens is not escaped so that LaTeX can render it (default:
|
||||
``False``). *New in Pygments 1.2.*
|
||||
|
||||
`mathescape`
|
||||
If set to ``True``, enables LaTeX math mode escape in comments. That
|
||||
is, ``'$...$'`` inside a comment will trigger math mode (default:
|
||||
``False``). *New in Pygments 1.2.*
|
||||
"""
|
||||
name = 'LaTeX'
|
||||
aliases = ['latex', 'tex']
|
||||
filenames = ['*.tex']
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
self.docclass = options.get('docclass', 'article')
|
||||
self.preamble = options.get('preamble', '')
|
||||
self.linenos = get_bool_opt(options, 'linenos', False)
|
||||
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
|
||||
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
|
||||
self.verboptions = options.get('verboptions', '')
|
||||
self.nobackground = get_bool_opt(options, 'nobackground', False)
|
||||
self.commandprefix = options.get('commandprefix', 'PY')
|
||||
self.texcomments = get_bool_opt(options, 'texcomments', False)
|
||||
self.mathescape = get_bool_opt(options, 'mathescape', False)
|
||||
|
||||
self._create_stylesheet()
|
||||
|
||||
|
||||
def _create_stylesheet(self):
|
||||
t2n = self.ttype2name = {Token: ''}
|
||||
c2d = self.cmd2def = {}
|
||||
cp = self.commandprefix
|
||||
|
||||
def rgbcolor(col):
|
||||
if col:
|
||||
return ','.join(['%.2f' %(int(col[i] + col[i + 1], 16) / 255.0)
|
||||
for i in (0, 2, 4)])
|
||||
else:
|
||||
return '1,1,1'
|
||||
|
||||
for ttype, ndef in self.style:
|
||||
name = _get_ttype_name(ttype)
|
||||
cmndef = ''
|
||||
if ndef['bold']:
|
||||
cmndef += r'\let\$$@bf=\textbf'
|
||||
if ndef['italic']:
|
||||
cmndef += r'\let\$$@it=\textit'
|
||||
if ndef['underline']:
|
||||
cmndef += r'\let\$$@ul=\underline'
|
||||
if ndef['roman']:
|
||||
cmndef += r'\let\$$@ff=\textrm'
|
||||
if ndef['sans']:
|
||||
cmndef += r'\let\$$@ff=\textsf'
|
||||
if ndef['mono']:
|
||||
cmndef += r'\let\$$@ff=\textsf'
|
||||
if ndef['color']:
|
||||
cmndef += (r'\def\$$@tc##1{\textcolor[rgb]{%s}{##1}}' %
|
||||
rgbcolor(ndef['color']))
|
||||
if ndef['border']:
|
||||
cmndef += (r'\def\$$@bc##1{\setlength{\fboxsep}{0pt}'
|
||||
r'\fcolorbox[rgb]{%s}{%s}{\strut ##1}}' %
|
||||
(rgbcolor(ndef['border']),
|
||||
rgbcolor(ndef['bgcolor'])))
|
||||
elif ndef['bgcolor']:
|
||||
cmndef += (r'\def\$$@bc##1{\setlength{\fboxsep}{0pt}'
|
||||
r'\colorbox[rgb]{%s}{\strut ##1}}' %
|
||||
rgbcolor(ndef['bgcolor']))
|
||||
if cmndef == '':
|
||||
continue
|
||||
cmndef = cmndef.replace('$$', cp)
|
||||
t2n[ttype] = name
|
||||
c2d[name] = cmndef
|
||||
|
||||
def get_style_defs(self, arg=''):
|
||||
"""
|
||||
Return the command sequences needed to define the commands
|
||||
used to format text in the verbatim environment. ``arg`` is ignored.
|
||||
"""
|
||||
cp = self.commandprefix
|
||||
styles = []
|
||||
for name, definition in self.cmd2def.iteritems():
|
||||
styles.append(r'\expandafter\def\csname %s@tok@%s\endcsname{%s}' %
|
||||
(cp, name, definition))
|
||||
return STYLE_TEMPLATE % {'cp': self.commandprefix,
|
||||
'styles': '\n'.join(styles)}
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
# TODO: add support for background colors
|
||||
t2n = self.ttype2name
|
||||
cp = self.commandprefix
|
||||
|
||||
if self.full:
|
||||
realoutfile = outfile
|
||||
outfile = StringIO()
|
||||
|
||||
outfile.write(ur'\begin{Verbatim}[commandchars=\\\{\}')
|
||||
if self.linenos:
|
||||
start, step = self.linenostart, self.linenostep
|
||||
outfile.write(u',numbers=left' +
|
||||
(start and u',firstnumber=%d' % start or u'') +
|
||||
(step and u',stepnumber=%d' % step or u''))
|
||||
if self.mathescape or self.texcomments:
|
||||
outfile.write(ur',codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8}')
|
||||
if self.verboptions:
|
||||
outfile.write(u',' + self.verboptions)
|
||||
outfile.write(u']\n')
|
||||
|
||||
for ttype, value in tokensource:
|
||||
if ttype in Token.Comment:
|
||||
if self.texcomments:
|
||||
# Try to guess comment starting lexeme and escape it ...
|
||||
start = value[0:1]
|
||||
for i in xrange(1, len(value)):
|
||||
if start[0] != value[i]:
|
||||
break
|
||||
start += value[i]
|
||||
|
||||
value = value[len(start):]
|
||||
start = escape_tex(start, self.commandprefix)
|
||||
|
||||
# ... but do not escape inside comment.
|
||||
value = start + value
|
||||
elif self.mathescape:
|
||||
# Only escape parts not inside a math environment.
|
||||
parts = value.split('$')
|
||||
in_math = False
|
||||
for i, part in enumerate(parts):
|
||||
if not in_math:
|
||||
parts[i] = escape_tex(part, self.commandprefix)
|
||||
in_math = not in_math
|
||||
value = '$'.join(parts)
|
||||
else:
|
||||
value = escape_tex(value, self.commandprefix)
|
||||
else:
|
||||
value = escape_tex(value, self.commandprefix)
|
||||
styles = []
|
||||
while ttype is not Token:
|
||||
try:
|
||||
styles.append(t2n[ttype])
|
||||
except KeyError:
|
||||
# not in current style
|
||||
styles.append(_get_ttype_name(ttype))
|
||||
ttype = ttype.parent
|
||||
styleval = '+'.join(reversed(styles))
|
||||
if styleval:
|
||||
spl = value.split('\n')
|
||||
for line in spl[:-1]:
|
||||
if line:
|
||||
outfile.write("\\%s{%s}{%s}" % (cp, styleval, line))
|
||||
outfile.write('\n')
|
||||
if spl[-1]:
|
||||
outfile.write("\\%s{%s}{%s}" % (cp, styleval, spl[-1]))
|
||||
else:
|
||||
outfile.write(value)
|
||||
|
||||
outfile.write(u'\\end{Verbatim}\n')
|
||||
|
||||
if self.full:
|
||||
realoutfile.write(DOC_TEMPLATE %
|
||||
dict(docclass = self.docclass,
|
||||
preamble = self.preamble,
|
||||
title = self.title,
|
||||
encoding = self.encoding or 'latin1',
|
||||
styledefs = self.get_style_defs(),
|
||||
code = outfile.getvalue()))
|
|
@ -0,0 +1,115 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.other
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Other formatters: NullFormatter, RawTokenFormatter.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.util import OptionError, get_choice_opt, b
|
||||
from pygments.token import Token
|
||||
from pygments.console import colorize
|
||||
|
||||
__all__ = ['NullFormatter', 'RawTokenFormatter']
|
||||
|
||||
|
||||
class NullFormatter(Formatter):
|
||||
"""
|
||||
Output the text unchanged without any formatting.
|
||||
"""
|
||||
name = 'Text only'
|
||||
aliases = ['text', 'null']
|
||||
filenames = ['*.txt']
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
enc = self.encoding
|
||||
for ttype, value in tokensource:
|
||||
if enc:
|
||||
outfile.write(value.encode(enc))
|
||||
else:
|
||||
outfile.write(value)
|
||||
|
||||
|
||||
class RawTokenFormatter(Formatter):
|
||||
r"""
|
||||
Format tokens as a raw representation for storing token streams.
|
||||
|
||||
The format is ``tokentype<TAB>repr(tokenstring)\n``. The output can later
|
||||
be converted to a token stream with the `RawTokenLexer`, described in the
|
||||
`lexer list <lexers.txt>`_.
|
||||
|
||||
Only two options are accepted:
|
||||
|
||||
`compress`
|
||||
If set to ``'gz'`` or ``'bz2'``, compress the output with the given
|
||||
compression algorithm after encoding (default: ``''``).
|
||||
`error_color`
|
||||
If set to a color name, highlight error tokens using that color. If
|
||||
set but with no value, defaults to ``'red'``.
|
||||
*New in Pygments 0.11.*
|
||||
|
||||
"""
|
||||
name = 'Raw tokens'
|
||||
aliases = ['raw', 'tokens']
|
||||
filenames = ['*.raw']
|
||||
|
||||
unicodeoutput = False
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
if self.encoding:
|
||||
raise OptionError('the raw formatter does not support the '
|
||||
'encoding option')
|
||||
self.encoding = 'ascii' # let pygments.format() do the right thing
|
||||
self.compress = get_choice_opt(options, 'compress',
|
||||
['', 'none', 'gz', 'bz2'], '')
|
||||
self.error_color = options.get('error_color', None)
|
||||
if self.error_color is True:
|
||||
self.error_color = 'red'
|
||||
if self.error_color is not None:
|
||||
try:
|
||||
colorize(self.error_color, '')
|
||||
except KeyError:
|
||||
raise ValueError("Invalid color %r specified" %
|
||||
self.error_color)
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
try:
|
||||
outfile.write(b(''))
|
||||
except TypeError:
|
||||
raise TypeError('The raw tokens formatter needs a binary '
|
||||
'output file')
|
||||
if self.compress == 'gz':
|
||||
import gzip
|
||||
outfile = gzip.GzipFile('', 'wb', 9, outfile)
|
||||
def write(text):
|
||||
outfile.write(text.encode())
|
||||
flush = outfile.flush
|
||||
elif self.compress == 'bz2':
|
||||
import bz2
|
||||
compressor = bz2.BZ2Compressor(9)
|
||||
def write(text):
|
||||
outfile.write(compressor.compress(text.encode()))
|
||||
def flush():
|
||||
outfile.write(compressor.flush())
|
||||
outfile.flush()
|
||||
else:
|
||||
def write(text):
|
||||
outfile.write(text.encode())
|
||||
flush = outfile.flush
|
||||
|
||||
if self.error_color:
|
||||
for ttype, value in tokensource:
|
||||
line = "%s\t%r\n" % (ttype, value)
|
||||
if ttype is Token.Error:
|
||||
write(colorize(self.error_color, line))
|
||||
else:
|
||||
write(line)
|
||||
else:
|
||||
for ttype, value in tokensource:
|
||||
write("%s\t%r\n" % (ttype, value))
|
||||
flush()
|
|
@ -0,0 +1,136 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.rtf
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A formatter that generates RTF files.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
|
||||
|
||||
__all__ = ['RtfFormatter']
|
||||
|
||||
|
||||
class RtfFormatter(Formatter):
|
||||
"""
|
||||
Format tokens as RTF markup. This formatter automatically outputs full RTF
|
||||
documents with color information and other useful stuff. Perfect for Copy and
|
||||
Paste into Microsoft® Word® documents.
|
||||
|
||||
*New in Pygments 0.6.*
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`style`
|
||||
The style to use, can be a string or a Style subclass (default:
|
||||
``'default'``).
|
||||
|
||||
`fontface`
|
||||
The used font famliy, for example ``Bitstream Vera Sans``. Defaults to
|
||||
some generic font which is supposed to have fixed width.
|
||||
"""
|
||||
name = 'RTF'
|
||||
aliases = ['rtf']
|
||||
filenames = ['*.rtf']
|
||||
|
||||
unicodeoutput = False
|
||||
|
||||
def __init__(self, **options):
|
||||
"""
|
||||
Additional options accepted:
|
||||
|
||||
``fontface``
|
||||
Name of the font used. Could for example be ``'Courier New'``
|
||||
to further specify the default which is ``'\fmodern'``. The RTF
|
||||
specification claims that ``\fmodern`` are "Fixed-pitch serif
|
||||
and sans serif fonts". Hope every RTF implementation thinks
|
||||
the same about modern...
|
||||
"""
|
||||
Formatter.__init__(self, **options)
|
||||
self.fontface = options.get('fontface') or ''
|
||||
|
||||
def _escape(self, text):
|
||||
return text.replace('\\', '\\\\') \
|
||||
.replace('{', '\\{') \
|
||||
.replace('}', '\\}')
|
||||
|
||||
def _escape_text(self, text):
|
||||
# empty strings, should give a small performance improvment
|
||||
if not text:
|
||||
return ''
|
||||
|
||||
# escape text
|
||||
text = self._escape(text)
|
||||
if self.encoding in ('utf-8', 'utf-16', 'utf-32'):
|
||||
encoding = 'iso-8859-15'
|
||||
else:
|
||||
encoding = self.encoding or 'iso-8859-15'
|
||||
|
||||
buf = []
|
||||
for c in text:
|
||||
if ord(c) > 128:
|
||||
ansic = c.encode(encoding, 'ignore') or '?'
|
||||
if ord(ansic) > 128:
|
||||
ansic = '\\\'%x' % ord(ansic)
|
||||
else:
|
||||
ansic = c
|
||||
buf.append(r'\ud{\u%d%s}' % (ord(c), ansic))
|
||||
else:
|
||||
buf.append(str(c))
|
||||
|
||||
return ''.join(buf).replace('\n', '\\par\n')
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
# rtf 1.8 header
|
||||
outfile.write(r'{\rtf1\ansi\deff0'
|
||||
r'{\fonttbl{\f0\fmodern\fprq1\fcharset0%s;}}'
|
||||
r'{\colortbl;' % (self.fontface and
|
||||
' ' + self._escape(self.fontface) or
|
||||
''))
|
||||
|
||||
# convert colors and save them in a mapping to access them later.
|
||||
color_mapping = {}
|
||||
offset = 1
|
||||
for _, style in self.style:
|
||||
for color in style['color'], style['bgcolor'], style['border']:
|
||||
if color and color not in color_mapping:
|
||||
color_mapping[color] = offset
|
||||
outfile.write(r'\red%d\green%d\blue%d;' % (
|
||||
int(color[0:2], 16),
|
||||
int(color[2:4], 16),
|
||||
int(color[4:6], 16)
|
||||
))
|
||||
offset += 1
|
||||
outfile.write(r'}\f0')
|
||||
|
||||
# highlight stream
|
||||
for ttype, value in tokensource:
|
||||
while not self.style.styles_token(ttype) and ttype.parent:
|
||||
ttype = ttype.parent
|
||||
style = self.style.style_for_token(ttype)
|
||||
buf = []
|
||||
if style['bgcolor']:
|
||||
buf.append(r'\cb%d' % color_mapping[style['bgcolor']])
|
||||
if style['color']:
|
||||
buf.append(r'\cf%d' % color_mapping[style['color']])
|
||||
if style['bold']:
|
||||
buf.append(r'\b')
|
||||
if style['italic']:
|
||||
buf.append(r'\i')
|
||||
if style['underline']:
|
||||
buf.append(r'\ul')
|
||||
if style['border']:
|
||||
buf.append(r'\chbrdr\chcfpat%d' %
|
||||
color_mapping[style['border']])
|
||||
start = ''.join(buf)
|
||||
if start:
|
||||
outfile.write('{%s ' % start)
|
||||
outfile.write(self._escape_text(value))
|
||||
if start:
|
||||
outfile.write('}')
|
||||
|
||||
outfile.write('}')
|
|
@ -0,0 +1,154 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.svg
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for SVG output.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.util import get_bool_opt, get_int_opt
|
||||
|
||||
__all__ = ['SvgFormatter']
|
||||
|
||||
|
||||
def escape_html(text):
|
||||
"""Escape &, <, > as well as single and double quotes for HTML."""
|
||||
return text.replace('&', '&'). \
|
||||
replace('<', '<'). \
|
||||
replace('>', '>'). \
|
||||
replace('"', '"'). \
|
||||
replace("'", ''')
|
||||
|
||||
|
||||
class2style = {}
|
||||
|
||||
class SvgFormatter(Formatter):
|
||||
"""
|
||||
Format tokens as an SVG graphics file. This formatter is still experimental.
|
||||
Each line of code is a ``<text>`` element with explicit ``x`` and ``y``
|
||||
coordinates containing ``<tspan>`` elements with the individual token styles.
|
||||
|
||||
By default, this formatter outputs a full SVG document including doctype
|
||||
declaration and the ``<svg>`` root element.
|
||||
|
||||
*New in Pygments 0.9.*
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`nowrap`
|
||||
Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and
|
||||
don't add a XML declaration and a doctype. If true, the `fontfamily`
|
||||
and `fontsize` options are ignored. Defaults to ``False``.
|
||||
|
||||
`fontfamily`
|
||||
The value to give the wrapping ``<g>`` element's ``font-family``
|
||||
attribute, defaults to ``"monospace"``.
|
||||
|
||||
`fontsize`
|
||||
The value to give the wrapping ``<g>`` element's ``font-size``
|
||||
attribute, defaults to ``"14px"``.
|
||||
|
||||
`xoffset`
|
||||
Starting offset in X direction, defaults to ``0``.
|
||||
|
||||
`yoffset`
|
||||
Starting offset in Y direction, defaults to the font size if it is given
|
||||
in pixels, or ``20`` else. (This is necessary since text coordinates
|
||||
refer to the text baseline, not the top edge.)
|
||||
|
||||
`ystep`
|
||||
Offset to add to the Y coordinate for each subsequent line. This should
|
||||
roughly be the text size plus 5. It defaults to that value if the text
|
||||
size is given in pixels, or ``25`` else.
|
||||
|
||||
`spacehack`
|
||||
Convert spaces in the source to `` ``, which are non-breaking
|
||||
spaces. SVG provides the ``xml:space`` attribute to control how
|
||||
whitespace inside tags is handled, in theory, the ``preserve`` value
|
||||
could be used to keep all whitespace as-is. However, many current SVG
|
||||
viewers don't obey that rule, so this option is provided as a workaround
|
||||
and defaults to ``True``.
|
||||
"""
|
||||
name = 'SVG'
|
||||
aliases = ['svg']
|
||||
filenames = ['*.svg']
|
||||
|
||||
def __init__(self, **options):
|
||||
# XXX outencoding
|
||||
Formatter.__init__(self, **options)
|
||||
self.nowrap = get_bool_opt(options, 'nowrap', False)
|
||||
self.fontfamily = options.get('fontfamily', 'monospace')
|
||||
self.fontsize = options.get('fontsize', '14px')
|
||||
self.xoffset = get_int_opt(options, 'xoffset', 0)
|
||||
fs = self.fontsize.strip()
|
||||
if fs.endswith('px'): fs = fs[:-2].strip()
|
||||
try:
|
||||
int_fs = int(fs)
|
||||
except:
|
||||
int_fs = 20
|
||||
self.yoffset = get_int_opt(options, 'yoffset', int_fs)
|
||||
self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
|
||||
self.spacehack = get_bool_opt(options, 'spacehack', True)
|
||||
self._stylecache = {}
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
"""
|
||||
Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
|
||||
tuples and write it into ``outfile``.
|
||||
|
||||
For our implementation we put all lines in their own 'line group'.
|
||||
"""
|
||||
x = self.xoffset
|
||||
y = self.yoffset
|
||||
if not self.nowrap:
|
||||
if self.encoding:
|
||||
outfile.write('<?xml version="1.0" encoding="%s"?>\n' %
|
||||
self.encoding)
|
||||
else:
|
||||
outfile.write('<?xml version="1.0"?>\n')
|
||||
outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" '
|
||||
'"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/'
|
||||
'svg10.dtd">\n')
|
||||
outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
|
||||
outfile.write('<g font-family="%s" font-size="%s">\n' %
|
||||
(self.fontfamily, self.fontsize))
|
||||
outfile.write('<text x="%s" y="%s" xml:space="preserve">' % (x, y))
|
||||
for ttype, value in tokensource:
|
||||
style = self._get_style(ttype)
|
||||
tspan = style and '<tspan' + style + '>' or ''
|
||||
tspanend = tspan and '</tspan>' or ''
|
||||
value = escape_html(value)
|
||||
if self.spacehack:
|
||||
value = value.expandtabs().replace(' ', ' ')
|
||||
parts = value.split('\n')
|
||||
for part in parts[:-1]:
|
||||
outfile.write(tspan + part + tspanend)
|
||||
y += self.ystep
|
||||
outfile.write('</text>\n<text x="%s" y="%s" '
|
||||
'xml:space="preserve">' % (x, y))
|
||||
outfile.write(tspan + parts[-1] + tspanend)
|
||||
outfile.write('</text>')
|
||||
|
||||
if not self.nowrap:
|
||||
outfile.write('</g></svg>\n')
|
||||
|
||||
def _get_style(self, tokentype):
|
||||
if tokentype in self._stylecache:
|
||||
return self._stylecache[tokentype]
|
||||
otokentype = tokentype
|
||||
while not self.style.styles_token(tokentype):
|
||||
tokentype = tokentype.parent
|
||||
value = self.style.style_for_token(tokentype)
|
||||
result = ''
|
||||
if value['color']:
|
||||
result = ' fill="#' + value['color'] + '"'
|
||||
if value['bold']:
|
||||
result += ' font-weight="bold"'
|
||||
if value['italic']:
|
||||
result += ' font-style="italic"'
|
||||
self._stylecache[otokentype] = result
|
||||
return result
|
|
@ -0,0 +1,112 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.terminal
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for terminal output with ANSI sequences.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Token, Whitespace
|
||||
from pygments.console import ansiformat
|
||||
from pygments.util import get_choice_opt
|
||||
|
||||
|
||||
__all__ = ['TerminalFormatter']
|
||||
|
||||
|
||||
#: Map token types to a tuple of color values for light and dark
|
||||
#: backgrounds.
|
||||
TERMINAL_COLORS = {
|
||||
Token: ('', ''),
|
||||
|
||||
Whitespace: ('lightgray', 'darkgray'),
|
||||
Comment: ('lightgray', 'darkgray'),
|
||||
Comment.Preproc: ('teal', 'turquoise'),
|
||||
Keyword: ('darkblue', 'blue'),
|
||||
Keyword.Type: ('teal', 'turquoise'),
|
||||
Operator.Word: ('purple', 'fuchsia'),
|
||||
Name.Builtin: ('teal', 'turquoise'),
|
||||
Name.Function: ('darkgreen', 'green'),
|
||||
Name.Namespace: ('_teal_', '_turquoise_'),
|
||||
Name.Class: ('_darkgreen_', '_green_'),
|
||||
Name.Exception: ('teal', 'turquoise'),
|
||||
Name.Decorator: ('darkgray', 'lightgray'),
|
||||
Name.Variable: ('darkred', 'red'),
|
||||
Name.Constant: ('darkred', 'red'),
|
||||
Name.Attribute: ('teal', 'turquoise'),
|
||||
Name.Tag: ('blue', 'blue'),
|
||||
String: ('brown', 'brown'),
|
||||
Number: ('darkblue', 'blue'),
|
||||
|
||||
Generic.Deleted: ('red', 'red'),
|
||||
Generic.Inserted: ('darkgreen', 'green'),
|
||||
Generic.Heading: ('**', '**'),
|
||||
Generic.Subheading: ('*purple*', '*fuchsia*'),
|
||||
Generic.Error: ('red', 'red'),
|
||||
|
||||
Error: ('_red_', '_red_'),
|
||||
}
|
||||
|
||||
|
||||
class TerminalFormatter(Formatter):
|
||||
r"""
|
||||
Format tokens with ANSI color sequences, for output in a text console.
|
||||
Color sequences are terminated at newlines, so that paging the output
|
||||
works correctly.
|
||||
|
||||
The `get_style_defs()` method doesn't do anything special since there is
|
||||
no support for common styles.
|
||||
|
||||
Options accepted:
|
||||
|
||||
`bg`
|
||||
Set to ``"light"`` or ``"dark"`` depending on the terminal's background
|
||||
(default: ``"light"``).
|
||||
|
||||
`colorscheme`
|
||||
A dictionary mapping token types to (lightbg, darkbg) color names or
|
||||
``None`` (default: ``None`` = use builtin colorscheme).
|
||||
"""
|
||||
name = 'Terminal'
|
||||
aliases = ['terminal', 'console']
|
||||
filenames = []
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
self.darkbg = get_choice_opt(options, 'bg',
|
||||
['light', 'dark'], 'light') == 'dark'
|
||||
self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
# hack: if the output is a terminal and has an encoding set,
|
||||
# use that to avoid unicode encode problems
|
||||
if not self.encoding and hasattr(outfile, "encoding") and \
|
||||
hasattr(outfile, "isatty") and outfile.isatty() and \
|
||||
sys.version_info < (3,):
|
||||
self.encoding = outfile.encoding
|
||||
return Formatter.format(self, tokensource, outfile)
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
for ttype, value in tokensource:
|
||||
color = self.colorscheme.get(ttype)
|
||||
while color is None:
|
||||
ttype = ttype[:-1]
|
||||
color = self.colorscheme.get(ttype)
|
||||
if color:
|
||||
color = color[self.darkbg]
|
||||
spl = value.split('\n')
|
||||
for line in spl[:-1]:
|
||||
if line:
|
||||
outfile.write(ansiformat(color, line))
|
||||
outfile.write('\n')
|
||||
if spl[-1]:
|
||||
outfile.write(ansiformat(color, spl[-1]))
|
||||
else:
|
||||
outfile.write(value)
|
|
@ -0,0 +1,222 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.formatters.terminal256
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Formatter for 256-color terminal output with ANSI sequences.
|
||||
|
||||
RGB-to-XTERM color conversion routines adapted from xterm256-conv
|
||||
tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2)
|
||||
by Wolfgang Frisch.
|
||||
|
||||
Formatter version 1.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
# TODO:
|
||||
# - Options to map style's bold/underline/italic/border attributes
|
||||
# to some ANSI attrbutes (something like 'italic=underline')
|
||||
# - An option to output "style RGB to xterm RGB/index" conversion table
|
||||
# - An option to indicate that we are running in "reverse background"
|
||||
# xterm. This means that default colors are white-on-black, not
|
||||
# black-on-while, so colors like "white background" need to be converted
|
||||
# to "white background, black foreground", etc...
|
||||
|
||||
import sys
|
||||
|
||||
from pygments.formatter import Formatter
|
||||
|
||||
|
||||
__all__ = ['Terminal256Formatter']
|
||||
|
||||
|
||||
class EscapeSequence:
|
||||
def __init__(self, fg=None, bg=None, bold=False, underline=False):
|
||||
self.fg = fg
|
||||
self.bg = bg
|
||||
self.bold = bold
|
||||
self.underline = underline
|
||||
|
||||
def escape(self, attrs):
|
||||
if len(attrs):
|
||||
return "\x1b[" + ";".join(attrs) + "m"
|
||||
return ""
|
||||
|
||||
def color_string(self):
|
||||
attrs = []
|
||||
if self.fg is not None:
|
||||
attrs.extend(("38", "5", "%i" % self.fg))
|
||||
if self.bg is not None:
|
||||
attrs.extend(("48", "5", "%i" % self.bg))
|
||||
if self.bold:
|
||||
attrs.append("01")
|
||||
if self.underline:
|
||||
attrs.append("04")
|
||||
return self.escape(attrs)
|
||||
|
||||
def reset_string(self):
|
||||
attrs = []
|
||||
if self.fg is not None:
|
||||
attrs.append("39")
|
||||
if self.bg is not None:
|
||||
attrs.append("49")
|
||||
if self.bold or self.underline:
|
||||
attrs.append("00")
|
||||
return self.escape(attrs)
|
||||
|
||||
class Terminal256Formatter(Formatter):
|
||||
r"""
|
||||
Format tokens with ANSI color sequences, for output in a 256-color
|
||||
terminal or console. Like in `TerminalFormatter` color sequences
|
||||
are terminated at newlines, so that paging the output works correctly.
|
||||
|
||||
The formatter takes colors from a style defined by the `style` option
|
||||
and converts them to nearest ANSI 256-color escape sequences. Bold and
|
||||
underline attributes from the style are preserved (and displayed).
|
||||
|
||||
*New in Pygments 0.9.*
|
||||
|
||||
Options accepted:
|
||||
|
||||
`style`
|
||||
The style to use, can be a string or a Style subclass (default:
|
||||
``'default'``).
|
||||
"""
|
||||
name = 'Terminal256'
|
||||
aliases = ['terminal256', 'console256', '256']
|
||||
filenames = []
|
||||
|
||||
def __init__(self, **options):
|
||||
Formatter.__init__(self, **options)
|
||||
|
||||
self.xterm_colors = []
|
||||
self.best_match = {}
|
||||
self.style_string = {}
|
||||
|
||||
self.usebold = 'nobold' not in options
|
||||
self.useunderline = 'nounderline' not in options
|
||||
|
||||
self._build_color_table() # build an RGB-to-256 color conversion table
|
||||
self._setup_styles() # convert selected style's colors to term. colors
|
||||
|
||||
def _build_color_table(self):
|
||||
# colors 0..15: 16 basic colors
|
||||
|
||||
self.xterm_colors.append((0x00, 0x00, 0x00)) # 0
|
||||
self.xterm_colors.append((0xcd, 0x00, 0x00)) # 1
|
||||
self.xterm_colors.append((0x00, 0xcd, 0x00)) # 2
|
||||
self.xterm_colors.append((0xcd, 0xcd, 0x00)) # 3
|
||||
self.xterm_colors.append((0x00, 0x00, 0xee)) # 4
|
||||
self.xterm_colors.append((0xcd, 0x00, 0xcd)) # 5
|
||||
self.xterm_colors.append((0x00, 0xcd, 0xcd)) # 6
|
||||
self.xterm_colors.append((0xe5, 0xe5, 0xe5)) # 7
|
||||
self.xterm_colors.append((0x7f, 0x7f, 0x7f)) # 8
|
||||
self.xterm_colors.append((0xff, 0x00, 0x00)) # 9
|
||||
self.xterm_colors.append((0x00, 0xff, 0x00)) # 10
|
||||
self.xterm_colors.append((0xff, 0xff, 0x00)) # 11
|
||||
self.xterm_colors.append((0x5c, 0x5c, 0xff)) # 12
|
||||
self.xterm_colors.append((0xff, 0x00, 0xff)) # 13
|
||||
self.xterm_colors.append((0x00, 0xff, 0xff)) # 14
|
||||
self.xterm_colors.append((0xff, 0xff, 0xff)) # 15
|
||||
|
||||
# colors 16..232: the 6x6x6 color cube
|
||||
|
||||
valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff)
|
||||
|
||||
for i in range(217):
|
||||
r = valuerange[(i // 36) % 6]
|
||||
g = valuerange[(i // 6) % 6]
|
||||
b = valuerange[i % 6]
|
||||
self.xterm_colors.append((r, g, b))
|
||||
|
||||
# colors 233..253: grayscale
|
||||
|
||||
for i in range(1, 22):
|
||||
v = 8 + i * 10
|
||||
self.xterm_colors.append((v, v, v))
|
||||
|
||||
def _closest_color(self, r, g, b):
|
||||
distance = 257*257*3 # "infinity" (>distance from #000000 to #ffffff)
|
||||
match = 0
|
||||
|
||||
for i in range(0, 254):
|
||||
values = self.xterm_colors[i]
|
||||
|
||||
rd = r - values[0]
|
||||
gd = g - values[1]
|
||||
bd = b - values[2]
|
||||
d = rd*rd + gd*gd + bd*bd
|
||||
|
||||
if d < distance:
|
||||
match = i
|
||||
distance = d
|
||||
return match
|
||||
|
||||
def _color_index(self, color):
|
||||
index = self.best_match.get(color, None)
|
||||
if index is None:
|
||||
try:
|
||||
rgb = int(str(color), 16)
|
||||
except ValueError:
|
||||
rgb = 0
|
||||
|
||||
r = (rgb >> 16) & 0xff
|
||||
g = (rgb >> 8) & 0xff
|
||||
b = rgb & 0xff
|
||||
index = self._closest_color(r, g, b)
|
||||
self.best_match[color] = index
|
||||
return index
|
||||
|
||||
def _setup_styles(self):
|
||||
for ttype, ndef in self.style:
|
||||
escape = EscapeSequence()
|
||||
if ndef['color']:
|
||||
escape.fg = self._color_index(ndef['color'])
|
||||
if ndef['bgcolor']:
|
||||
escape.bg = self._color_index(ndef['bgcolor'])
|
||||
if self.usebold and ndef['bold']:
|
||||
escape.bold = True
|
||||
if self.useunderline and ndef['underline']:
|
||||
escape.underline = True
|
||||
self.style_string[str(ttype)] = (escape.color_string(),
|
||||
escape.reset_string())
|
||||
|
||||
def format(self, tokensource, outfile):
|
||||
# hack: if the output is a terminal and has an encoding set,
|
||||
# use that to avoid unicode encode problems
|
||||
if not self.encoding and hasattr(outfile, "encoding") and \
|
||||
hasattr(outfile, "isatty") and outfile.isatty() and \
|
||||
sys.version_info < (3,):
|
||||
self.encoding = outfile.encoding
|
||||
return Formatter.format(self, tokensource, outfile)
|
||||
|
||||
def format_unencoded(self, tokensource, outfile):
|
||||
for ttype, value in tokensource:
|
||||
not_found = True
|
||||
while ttype and not_found:
|
||||
try:
|
||||
#outfile.write( "<" + str(ttype) + ">" )
|
||||
on, off = self.style_string[str(ttype)]
|
||||
|
||||
# Like TerminalFormatter, add "reset colors" escape sequence
|
||||
# on newline.
|
||||
spl = value.split('\n')
|
||||
for line in spl[:-1]:
|
||||
if line:
|
||||
outfile.write(on + line + off)
|
||||
outfile.write('\n')
|
||||
if spl[-1]:
|
||||
outfile.write(on + spl[-1] + off)
|
||||
|
||||
not_found = False
|
||||
#outfile.write( '#' + str(ttype) + '#' )
|
||||
|
||||
except KeyError:
|
||||
#ottype = ttype
|
||||
ttype = ttype[:-1]
|
||||
#outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' )
|
||||
|
||||
if not_found:
|
||||
outfile.write(value)
|
|
@ -0,0 +1,765 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexer
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
Base lexer classes.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
import re, itertools
|
||||
|
||||
from pygments.filter import apply_filters, Filter
|
||||
from pygments.filters import get_filter_by_name
|
||||
from pygments.token import Error, Text, Other, _TokenType
|
||||
from pygments.util import get_bool_opt, get_int_opt, get_list_opt, \
|
||||
make_analysator
|
||||
|
||||
|
||||
__all__ = ['Lexer', 'RegexLexer', 'ExtendedRegexLexer', 'DelegatingLexer',
|
||||
'LexerContext', 'include', 'inherit', 'bygroups', 'using', 'this']
|
||||
|
||||
|
||||
_encoding_map = [('\xef\xbb\xbf', 'utf-8'),
|
||||
('\xff\xfe\0\0', 'utf-32'),
|
||||
('\0\0\xfe\xff', 'utf-32be'),
|
||||
('\xff\xfe', 'utf-16'),
|
||||
('\xfe\xff', 'utf-16be')]
|
||||
|
||||
_default_analyse = staticmethod(lambda x: 0.0)
|
||||
|
||||
|
||||
class LexerMeta(type):
|
||||
"""
|
||||
This metaclass automagically converts ``analyse_text`` methods into
|
||||
static methods which always return float values.
|
||||
"""
|
||||
|
||||
def __new__(cls, name, bases, d):
|
||||
if 'analyse_text' in d:
|
||||
d['analyse_text'] = make_analysator(d['analyse_text'])
|
||||
return type.__new__(cls, name, bases, d)
|
||||
|
||||
|
||||
class Lexer(object):
|
||||
"""
|
||||
Lexer for a specific language.
|
||||
|
||||
Basic options recognized:
|
||||
``stripnl``
|
||||
Strip leading and trailing newlines from the input (default: True).
|
||||
``stripall``
|
||||
Strip all leading and trailing whitespace from the input
|
||||
(default: False).
|
||||
``ensurenl``
|
||||
Make sure that the input ends with a newline (default: True). This
|
||||
is required for some lexers that consume input linewise.
|
||||
*New in Pygments 1.3.*
|
||||
``tabsize``
|
||||
If given and greater than 0, expand tabs in the input (default: 0).
|
||||
``encoding``
|
||||
If given, must be an encoding name. This encoding will be used to
|
||||
convert the input string to Unicode, if it is not already a Unicode
|
||||
string (default: ``'latin1'``).
|
||||
Can also be ``'guess'`` to use a simple UTF-8 / Latin1 detection, or
|
||||
``'chardet'`` to use the chardet library, if it is installed.
|
||||
"""
|
||||
|
||||
#: Name of the lexer
|
||||
name = None
|
||||
|
||||
#: Shortcuts for the lexer
|
||||
aliases = []
|
||||
|
||||
#: File name globs
|
||||
filenames = []
|
||||
|
||||
#: Secondary file name globs
|
||||
alias_filenames = []
|
||||
|
||||
#: MIME types
|
||||
mimetypes = []
|
||||
|
||||
#: Priority, should multiple lexers match and no content is provided
|
||||
priority = 0
|
||||
|
||||
__metaclass__ = LexerMeta
|
||||
|
||||
def __init__(self, **options):
|
||||
self.options = options
|
||||
self.stripnl = get_bool_opt(options, 'stripnl', True)
|
||||
self.stripall = get_bool_opt(options, 'stripall', False)
|
||||
self.ensurenl = get_bool_opt(options, 'ensurenl', True)
|
||||
self.tabsize = get_int_opt(options, 'tabsize', 0)
|
||||
self.encoding = options.get('encoding', 'latin1')
|
||||
# self.encoding = options.get('inencoding', None) or self.encoding
|
||||
self.filters = []
|
||||
for filter_ in get_list_opt(options, 'filters', ()):
|
||||
self.add_filter(filter_)
|
||||
|
||||
def __repr__(self):
|
||||
if self.options:
|
||||
return '<pygments.lexers.%s with %r>' % (self.__class__.__name__,
|
||||
self.options)
|
||||
else:
|
||||
return '<pygments.lexers.%s>' % self.__class__.__name__
|
||||
|
||||
def add_filter(self, filter_, **options):
|
||||
"""
|
||||
Add a new stream filter to this lexer.
|
||||
"""
|
||||
if not isinstance(filter_, Filter):
|
||||
filter_ = get_filter_by_name(filter_, **options)
|
||||
self.filters.append(filter_)
|
||||
|
||||
def analyse_text(text):
|
||||
"""
|
||||
Has to return a float between ``0`` and ``1`` that indicates
|
||||
if a lexer wants to highlight this text. Used by ``guess_lexer``.
|
||||
If this method returns ``0`` it won't highlight it in any case, if
|
||||
it returns ``1`` highlighting with this lexer is guaranteed.
|
||||
|
||||
The `LexerMeta` metaclass automatically wraps this function so
|
||||
that it works like a static method (no ``self`` or ``cls``
|
||||
parameter) and the return value is automatically converted to
|
||||
`float`. If the return value is an object that is boolean `False`
|
||||
it's the same as if the return values was ``0.0``.
|
||||
"""
|
||||
|
||||
def get_tokens(self, text, unfiltered=False):
|
||||
"""
|
||||
Return an iterable of (tokentype, value) pairs generated from
|
||||
`text`. If `unfiltered` is set to `True`, the filtering mechanism
|
||||
is bypassed even if filters are defined.
|
||||
|
||||
Also preprocess the text, i.e. expand tabs and strip it if
|
||||
wanted and applies registered filters.
|
||||
"""
|
||||
if not isinstance(text, unicode):
|
||||
if self.encoding == 'guess':
|
||||
try:
|
||||
text = text.decode('utf-8')
|
||||
if text.startswith(u'\ufeff'):
|
||||
text = text[len(u'\ufeff'):]
|
||||
except UnicodeDecodeError:
|
||||
text = text.decode('latin1')
|
||||
elif self.encoding == 'chardet':
|
||||
try:
|
||||
import chardet
|
||||
except ImportError:
|
||||
raise ImportError('To enable chardet encoding guessing, '
|
||||
'please install the chardet library '
|
||||
'from http://chardet.feedparser.org/')
|
||||
# check for BOM first
|
||||
decoded = None
|
||||
for bom, encoding in _encoding_map:
|
||||
if text.startswith(bom):
|
||||
decoded = unicode(text[len(bom):], encoding,
|
||||
errors='replace')
|
||||
break
|
||||
# no BOM found, so use chardet
|
||||
if decoded is None:
|
||||
enc = chardet.detect(text[:1024]) # Guess using first 1KB
|
||||
decoded = unicode(text, enc.get('encoding') or 'utf-8',
|
||||
errors='replace')
|
||||
text = decoded
|
||||
else:
|
||||
text = text.decode(self.encoding)
|
||||
else:
|
||||
if text.startswith(u'\ufeff'):
|
||||
text = text[len(u'\ufeff'):]
|
||||
|
||||
# text now *is* a unicode string
|
||||
text = text.replace('\r\n', '\n')
|
||||
text = text.replace('\r', '\n')
|
||||
if self.stripall:
|
||||
text = text.strip()
|
||||
elif self.stripnl:
|
||||
text = text.strip('\n')
|
||||
if self.tabsize > 0:
|
||||
text = text.expandtabs(self.tabsize)
|
||||
if self.ensurenl and not text.endswith('\n'):
|
||||
text += '\n'
|
||||
|
||||
def streamer():
|
||||
for i, t, v in self.get_tokens_unprocessed(text):
|
||||
yield t, v
|
||||
stream = streamer()
|
||||
if not unfiltered:
|
||||
stream = apply_filters(stream, self.filters, self)
|
||||
return stream
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
"""
|
||||
Return an iterable of (tokentype, value) pairs.
|
||||
In subclasses, implement this method as a generator to
|
||||
maximize effectiveness.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class DelegatingLexer(Lexer):
|
||||
"""
|
||||
This lexer takes two lexer as arguments. A root lexer and
|
||||
a language lexer. First everything is scanned using the language
|
||||
lexer, afterwards all ``Other`` tokens are lexed using the root
|
||||
lexer.
|
||||
|
||||
The lexers from the ``template`` lexer package use this base lexer.
|
||||
"""
|
||||
|
||||
def __init__(self, _root_lexer, _language_lexer, _needle=Other, **options):
|
||||
self.root_lexer = _root_lexer(**options)
|
||||
self.language_lexer = _language_lexer(**options)
|
||||
self.needle = _needle
|
||||
Lexer.__init__(self, **options)
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
buffered = ''
|
||||
insertions = []
|
||||
lng_buffer = []
|
||||
for i, t, v in self.language_lexer.get_tokens_unprocessed(text):
|
||||
if t is self.needle:
|
||||
if lng_buffer:
|
||||
insertions.append((len(buffered), lng_buffer))
|
||||
lng_buffer = []
|
||||
buffered += v
|
||||
else:
|
||||
lng_buffer.append((i, t, v))
|
||||
if lng_buffer:
|
||||
insertions.append((len(buffered), lng_buffer))
|
||||
return do_insertions(insertions,
|
||||
self.root_lexer.get_tokens_unprocessed(buffered))
|
||||
|
||||
|
||||
#-------------------------------------------------------------------------------
|
||||
# RegexLexer and ExtendedRegexLexer
|
||||
#
|
||||
|
||||
|
||||
class include(str):
|
||||
"""
|
||||
Indicates that a state should include rules from another state.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class _inherit(object):
|
||||
"""
|
||||
Indicates the a state should inherit from its superclass.
|
||||
"""
|
||||
def __repr__(self):
|
||||
return 'inherit'
|
||||
|
||||
inherit = _inherit()
|
||||
|
||||
|
||||
class combined(tuple):
|
||||
"""
|
||||
Indicates a state combined from multiple states.
|
||||
"""
|
||||
|
||||
def __new__(cls, *args):
|
||||
return tuple.__new__(cls, args)
|
||||
|
||||
def __init__(self, *args):
|
||||
# tuple.__init__ doesn't do anything
|
||||
pass
|
||||
|
||||
|
||||
class _PseudoMatch(object):
|
||||
"""
|
||||
A pseudo match object constructed from a string.
|
||||
"""
|
||||
|
||||
def __init__(self, start, text):
|
||||
self._text = text
|
||||
self._start = start
|
||||
|
||||
def start(self, arg=None):
|
||||
return self._start
|
||||
|
||||
def end(self, arg=None):
|
||||
return self._start + len(self._text)
|
||||
|
||||
def group(self, arg=None):
|
||||
if arg:
|
||||
raise IndexError('No such group')
|
||||
return self._text
|
||||
|
||||
def groups(self):
|
||||
return (self._text,)
|
||||
|
||||
def groupdict(self):
|
||||
return {}
|
||||
|
||||
|
||||
def bygroups(*args):
|
||||
"""
|
||||
Callback that yields multiple actions for each group in the match.
|
||||
"""
|
||||
def callback(lexer, match, ctx=None):
|
||||
for i, action in enumerate(args):
|
||||
if action is None:
|
||||
continue
|
||||
elif type(action) is _TokenType:
|
||||
data = match.group(i + 1)
|
||||
if data:
|
||||
yield match.start(i + 1), action, data
|
||||
else:
|
||||
data = match.group(i + 1)
|
||||
if data is not None:
|
||||
if ctx:
|
||||
ctx.pos = match.start(i + 1)
|
||||
for item in action(lexer, _PseudoMatch(match.start(i + 1),
|
||||
data), ctx):
|
||||
if item:
|
||||
yield item
|
||||
if ctx:
|
||||
ctx.pos = match.end()
|
||||
return callback
|
||||
|
||||
|
||||
class _This(object):
|
||||
"""
|
||||
Special singleton used for indicating the caller class.
|
||||
Used by ``using``.
|
||||
"""
|
||||
this = _This()
|
||||
|
||||
|
||||
def using(_other, **kwargs):
|
||||
"""
|
||||
Callback that processes the match with a different lexer.
|
||||
|
||||
The keyword arguments are forwarded to the lexer, except `state` which
|
||||
is handled separately.
|
||||
|
||||
`state` specifies the state that the new lexer will start in, and can
|
||||
be an enumerable such as ('root', 'inline', 'string') or a simple
|
||||
string which is assumed to be on top of the root state.
|
||||
|
||||
Note: For that to work, `_other` must not be an `ExtendedRegexLexer`.
|
||||
"""
|
||||
gt_kwargs = {}
|
||||
if 'state' in kwargs:
|
||||
s = kwargs.pop('state')
|
||||
if isinstance(s, (list, tuple)):
|
||||
gt_kwargs['stack'] = s
|
||||
else:
|
||||
gt_kwargs['stack'] = ('root', s)
|
||||
|
||||
if _other is this:
|
||||
def callback(lexer, match, ctx=None):
|
||||
# if keyword arguments are given the callback
|
||||
# function has to create a new lexer instance
|
||||
if kwargs:
|
||||
# XXX: cache that somehow
|
||||
kwargs.update(lexer.options)
|
||||
lx = lexer.__class__(**kwargs)
|
||||
else:
|
||||
lx = lexer
|
||||
s = match.start()
|
||||
for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs):
|
||||
yield i + s, t, v
|
||||
if ctx:
|
||||
ctx.pos = match.end()
|
||||
else:
|
||||
def callback(lexer, match, ctx=None):
|
||||
# XXX: cache that somehow
|
||||
kwargs.update(lexer.options)
|
||||
lx = _other(**kwargs)
|
||||
|
||||
s = match.start()
|
||||
for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs):
|
||||
yield i + s, t, v
|
||||
if ctx:
|
||||
ctx.pos = match.end()
|
||||
return callback
|
||||
|
||||
|
||||
class RegexLexerMeta(LexerMeta):
|
||||
"""
|
||||
Metaclass for RegexLexer, creates the self._tokens attribute from
|
||||
self.tokens on the first instantiation.
|
||||
"""
|
||||
|
||||
def _process_regex(cls, regex, rflags):
|
||||
"""Preprocess the regular expression component of a token definition."""
|
||||
return re.compile(regex, rflags).match
|
||||
|
||||
def _process_token(cls, token):
|
||||
"""Preprocess the token component of a token definition."""
|
||||
assert type(token) is _TokenType or callable(token), \
|
||||
'token type must be simple type or callable, not %r' % (token,)
|
||||
return token
|
||||
|
||||
def _process_new_state(cls, new_state, unprocessed, processed):
|
||||
"""Preprocess the state transition action of a token definition."""
|
||||
if isinstance(new_state, str):
|
||||
# an existing state
|
||||
if new_state == '#pop':
|
||||
return -1
|
||||
elif new_state in unprocessed:
|
||||
return (new_state,)
|
||||
elif new_state == '#push':
|
||||
return new_state
|
||||
elif new_state[:5] == '#pop:':
|
||||
return -int(new_state[5:])
|
||||
else:
|
||||
assert False, 'unknown new state %r' % new_state
|
||||
elif isinstance(new_state, combined):
|
||||
# combine a new state from existing ones
|
||||
tmp_state = '_tmp_%d' % cls._tmpname
|
||||
cls._tmpname += 1
|
||||
itokens = []
|
||||
for istate in new_state:
|
||||
assert istate != new_state, 'circular state ref %r' % istate
|
||||
itokens.extend(cls._process_state(unprocessed,
|
||||
processed, istate))
|
||||
processed[tmp_state] = itokens
|
||||
return (tmp_state,)
|
||||
elif isinstance(new_state, tuple):
|
||||
# push more than one state
|
||||
for istate in new_state:
|
||||
assert (istate in unprocessed or
|
||||
istate in ('#pop', '#push')), \
|
||||
'unknown new state ' + istate
|
||||
return new_state
|
||||
else:
|
||||
assert False, 'unknown new state def %r' % new_state
|
||||
|
||||
def _process_state(cls, unprocessed, processed, state):
|
||||
"""Preprocess a single state definition."""
|
||||
assert type(state) is str, "wrong state name %r" % state
|
||||
assert state[0] != '#', "invalid state name %r" % state
|
||||
if state in processed:
|
||||
return processed[state]
|
||||
tokens = processed[state] = []
|
||||
rflags = cls.flags
|
||||
for tdef in unprocessed[state]:
|
||||
if isinstance(tdef, include):
|
||||
# it's a state reference
|
||||
assert tdef != state, "circular state reference %r" % state
|
||||
tokens.extend(cls._process_state(unprocessed, processed,
|
||||
str(tdef)))
|
||||
continue
|
||||
if isinstance(tdef, _inherit):
|
||||
# processed already
|
||||
continue
|
||||
|
||||
assert type(tdef) is tuple, "wrong rule def %r" % tdef
|
||||
|
||||
try:
|
||||
rex = cls._process_regex(tdef[0], rflags)
|
||||
except Exception, err:
|
||||
raise ValueError("uncompilable regex %r in state %r of %r: %s" %
|
||||
(tdef[0], state, cls, err))
|
||||
|
||||
token = cls._process_token(tdef[1])
|
||||
|
||||
if len(tdef) == 2:
|
||||
new_state = None
|
||||
else:
|
||||
new_state = cls._process_new_state(tdef[2],
|
||||
unprocessed, processed)
|
||||
|
||||
tokens.append((rex, token, new_state))
|
||||
return tokens
|
||||
|
||||
def process_tokendef(cls, name, tokendefs=None):
|
||||
"""Preprocess a dictionary of token definitions."""
|
||||
processed = cls._all_tokens[name] = {}
|
||||
tokendefs = tokendefs or cls.tokens[name]
|
||||
for state in tokendefs.keys():
|
||||
cls._process_state(tokendefs, processed, state)
|
||||
return processed
|
||||
|
||||
def get_tokendefs(cls):
|
||||
"""
|
||||
Merge tokens from superclasses in MRO order, returning a single tokendef
|
||||
dictionary.
|
||||
|
||||
Any state that is not defined by a subclass will be inherited
|
||||
automatically. States that *are* defined by subclasses will, by
|
||||
default, override that state in the superclass. If a subclass wishes to
|
||||
inherit definitions from a superclass, it can use the special value
|
||||
"inherit", which will cause the superclass' state definition to be
|
||||
included at that point in the state.
|
||||
"""
|
||||
tokens = {}
|
||||
inheritable = {}
|
||||
for c in itertools.chain((cls,), cls.__mro__):
|
||||
toks = c.__dict__.get('tokens', {})
|
||||
|
||||
for state, items in toks.iteritems():
|
||||
curitems = tokens.get(state)
|
||||
if curitems is None:
|
||||
tokens[state] = items
|
||||
try:
|
||||
inherit_ndx = items.index(inherit)
|
||||
except ValueError:
|
||||
continue
|
||||
inheritable[state] = inherit_ndx
|
||||
continue
|
||||
|
||||
inherit_ndx = inheritable.pop(state, None)
|
||||
if inherit_ndx is None:
|
||||
continue
|
||||
|
||||
# Replace the "inherit" value with the items
|
||||
curitems[inherit_ndx:inherit_ndx+1] = items
|
||||
try:
|
||||
new_inh_ndx = items.index(inherit)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
inheritable[state] = inherit_ndx + new_inh_ndx
|
||||
|
||||
return tokens
|
||||
|
||||
def __call__(cls, *args, **kwds):
|
||||
"""Instantiate cls after preprocessing its token definitions."""
|
||||
if '_tokens' not in cls.__dict__:
|
||||
cls._all_tokens = {}
|
||||
cls._tmpname = 0
|
||||
if hasattr(cls, 'token_variants') and cls.token_variants:
|
||||
# don't process yet
|
||||
pass
|
||||
else:
|
||||
cls._tokens = cls.process_tokendef('', cls.get_tokendefs())
|
||||
|
||||
return type.__call__(cls, *args, **kwds)
|
||||
|
||||
|
||||
class RegexLexer(Lexer):
|
||||
"""
|
||||
Base for simple stateful regular expression-based lexers.
|
||||
Simplifies the lexing process so that you need only
|
||||
provide a list of states and regular expressions.
|
||||
"""
|
||||
__metaclass__ = RegexLexerMeta
|
||||
|
||||
#: Flags for compiling the regular expressions.
|
||||
#: Defaults to MULTILINE.
|
||||
flags = re.MULTILINE
|
||||
|
||||
#: Dict of ``{'state': [(regex, tokentype, new_state), ...], ...}``
|
||||
#:
|
||||
#: The initial state is 'root'.
|
||||
#: ``new_state`` can be omitted to signify no state transition.
|
||||
#: If it is a string, the state is pushed on the stack and changed.
|
||||
#: If it is a tuple of strings, all states are pushed on the stack and
|
||||
#: the current state will be the topmost.
|
||||
#: It can also be ``combined('state1', 'state2', ...)``
|
||||
#: to signify a new, anonymous state combined from the rules of two
|
||||
#: or more existing ones.
|
||||
#: Furthermore, it can be '#pop' to signify going back one step in
|
||||
#: the state stack, or '#push' to push the current state on the stack
|
||||
#: again.
|
||||
#:
|
||||
#: The tuple can also be replaced with ``include('state')``, in which
|
||||
#: case the rules from the state named by the string are included in the
|
||||
#: current one.
|
||||
tokens = {}
|
||||
|
||||
def get_tokens_unprocessed(self, text, stack=('root',)):
|
||||
"""
|
||||
Split ``text`` into (tokentype, text) pairs.
|
||||
|
||||
``stack`` is the inital stack (default: ``['root']``)
|
||||
"""
|
||||
pos = 0
|
||||
tokendefs = self._tokens
|
||||
statestack = list(stack)
|
||||
statetokens = tokendefs[statestack[-1]]
|
||||
while 1:
|
||||
for rexmatch, action, new_state in statetokens:
|
||||
m = rexmatch(text, pos)
|
||||
if m:
|
||||
if type(action) is _TokenType:
|
||||
yield pos, action, m.group()
|
||||
else:
|
||||
for item in action(self, m):
|
||||
yield item
|
||||
pos = m.end()
|
||||
if new_state is not None:
|
||||
# state transition
|
||||
if isinstance(new_state, tuple):
|
||||
for state in new_state:
|
||||
if state == '#pop':
|
||||
statestack.pop()
|
||||
elif state == '#push':
|
||||
statestack.append(statestack[-1])
|
||||
else:
|
||||
statestack.append(state)
|
||||
elif isinstance(new_state, int):
|
||||
# pop
|
||||
del statestack[new_state:]
|
||||
elif new_state == '#push':
|
||||
statestack.append(statestack[-1])
|
||||
else:
|
||||
assert False, "wrong state def: %r" % new_state
|
||||
statetokens = tokendefs[statestack[-1]]
|
||||
break
|
||||
else:
|
||||
try:
|
||||
if text[pos] == '\n':
|
||||
# at EOL, reset state to "root"
|
||||
statestack = ['root']
|
||||
statetokens = tokendefs['root']
|
||||
yield pos, Text, u'\n'
|
||||
pos += 1
|
||||
continue
|
||||
yield pos, Error, text[pos]
|
||||
pos += 1
|
||||
except IndexError:
|
||||
break
|
||||
|
||||
|
||||
class LexerContext(object):
|
||||
"""
|
||||
A helper object that holds lexer position data.
|
||||
"""
|
||||
|
||||
def __init__(self, text, pos, stack=None, end=None):
|
||||
self.text = text
|
||||
self.pos = pos
|
||||
self.end = end or len(text) # end=0 not supported ;-)
|
||||
self.stack = stack or ['root']
|
||||
|
||||
def __repr__(self):
|
||||
return 'LexerContext(%r, %r, %r)' % (
|
||||
self.text, self.pos, self.stack)
|
||||
|
||||
|
||||
class ExtendedRegexLexer(RegexLexer):
|
||||
"""
|
||||
A RegexLexer that uses a context object to store its state.
|
||||
"""
|
||||
|
||||
def get_tokens_unprocessed(self, text=None, context=None):
|
||||
"""
|
||||
Split ``text`` into (tokentype, text) pairs.
|
||||
If ``context`` is given, use this lexer context instead.
|
||||
"""
|
||||
tokendefs = self._tokens
|
||||
if not context:
|
||||
ctx = LexerContext(text, 0)
|
||||
statetokens = tokendefs['root']
|
||||
else:
|
||||
ctx = context
|
||||
statetokens = tokendefs[ctx.stack[-1]]
|
||||
text = ctx.text
|
||||
while 1:
|
||||
for rexmatch, action, new_state in statetokens:
|
||||
m = rexmatch(text, ctx.pos, ctx.end)
|
||||
if m:
|
||||
if type(action) is _TokenType:
|
||||
yield ctx.pos, action, m.group()
|
||||
ctx.pos = m.end()
|
||||
else:
|
||||
for item in action(self, m, ctx):
|
||||
yield item
|
||||
if not new_state:
|
||||
# altered the state stack?
|
||||
statetokens = tokendefs[ctx.stack[-1]]
|
||||
# CAUTION: callback must set ctx.pos!
|
||||
if new_state is not None:
|
||||
# state transition
|
||||
if isinstance(new_state, tuple):
|
||||
for state in new_state:
|
||||
if state == '#pop':
|
||||
ctx.stack.pop()
|
||||
elif state == '#push':
|
||||
ctx.stack.append(statestack[-1])
|
||||
else:
|
||||
ctx.stack.append(state)
|
||||
elif isinstance(new_state, int):
|
||||
# pop
|
||||
del ctx.stack[new_state:]
|
||||
elif new_state == '#push':
|
||||
ctx.stack.append(ctx.stack[-1])
|
||||
else:
|
||||
assert False, "wrong state def: %r" % new_state
|
||||
statetokens = tokendefs[ctx.stack[-1]]
|
||||
break
|
||||
else:
|
||||
try:
|
||||
if ctx.pos >= ctx.end:
|
||||
break
|
||||
if text[ctx.pos] == '\n':
|
||||
# at EOL, reset state to "root"
|
||||
ctx.stack = ['root']
|
||||
statetokens = tokendefs['root']
|
||||
yield ctx.pos, Text, u'\n'
|
||||
ctx.pos += 1
|
||||
continue
|
||||
yield ctx.pos, Error, text[ctx.pos]
|
||||
ctx.pos += 1
|
||||
except IndexError:
|
||||
break
|
||||
|
||||
|
||||
def do_insertions(insertions, tokens):
|
||||
"""
|
||||
Helper for lexers which must combine the results of several
|
||||
sublexers.
|
||||
|
||||
``insertions`` is a list of ``(index, itokens)`` pairs.
|
||||
Each ``itokens`` iterable should be inserted at position
|
||||
``index`` into the token stream given by the ``tokens``
|
||||
argument.
|
||||
|
||||
The result is a combined token stream.
|
||||
|
||||
TODO: clean up the code here.
|
||||
"""
|
||||
insertions = iter(insertions)
|
||||
try:
|
||||
index, itokens = insertions.next()
|
||||
except StopIteration:
|
||||
# no insertions
|
||||
for item in tokens:
|
||||
yield item
|
||||
return
|
||||
|
||||
realpos = None
|
||||
insleft = True
|
||||
|
||||
# iterate over the token stream where we want to insert
|
||||
# the tokens from the insertion list.
|
||||
for i, t, v in tokens:
|
||||
# first iteration. store the postition of first item
|
||||
if realpos is None:
|
||||
realpos = i
|
||||
oldi = 0
|
||||
while insleft and i + len(v) >= index:
|
||||
tmpval = v[oldi:index - i]
|
||||
yield realpos, t, tmpval
|
||||
realpos += len(tmpval)
|
||||
for it_index, it_token, it_value in itokens:
|
||||
yield realpos, it_token, it_value
|
||||
realpos += len(it_value)
|
||||
oldi = index - i
|
||||
try:
|
||||
index, itokens = insertions.next()
|
||||
except StopIteration:
|
||||
insleft = False
|
||||
break # not strictly necessary
|
||||
yield realpos, t, v[oldi:]
|
||||
realpos += len(v) - oldi
|
||||
|
||||
# leftover tokens
|
||||
while insleft:
|
||||
# no normal tokens, set realpos to zero
|
||||
realpos = realpos or 0
|
||||
for p, t, v in itokens:
|
||||
yield realpos, t, v
|
||||
realpos += len(v)
|
||||
try:
|
||||
index, itokens = insertions.next()
|
||||
except StopIteration:
|
||||
insleft = False
|
||||
break # not strictly necessary
|
|
@ -0,0 +1,240 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers
|
||||
~~~~~~~~~~~~~~~
|
||||
|
||||
Pygments lexers.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import types
|
||||
import fnmatch
|
||||
from os.path import basename
|
||||
|
||||
from pygments.lexers._mapping import LEXERS
|
||||
from pygments.modeline import get_filetype_from_buffer
|
||||
from pygments.plugin import find_plugin_lexers
|
||||
from pygments.util import ClassNotFound, bytes
|
||||
|
||||
|
||||
__all__ = ['get_lexer_by_name', 'get_lexer_for_filename', 'find_lexer_class',
|
||||
'guess_lexer'] + LEXERS.keys()
|
||||
|
||||
_lexer_cache = {}
|
||||
|
||||
|
||||
def _load_lexers(module_name):
|
||||
"""
|
||||
Load a lexer (and all others in the module too).
|
||||
"""
|
||||
mod = __import__(module_name, None, None, ['__all__'])
|
||||
for lexer_name in mod.__all__:
|
||||
cls = getattr(mod, lexer_name)
|
||||
_lexer_cache[cls.name] = cls
|
||||
|
||||
|
||||
def get_all_lexers():
|
||||
"""
|
||||
Return a generator of tuples in the form ``(name, aliases,
|
||||
filenames, mimetypes)`` of all know lexers.
|
||||
"""
|
||||
for item in LEXERS.itervalues():
|
||||
yield item[1:]
|
||||
for lexer in find_plugin_lexers():
|
||||
yield lexer.name, lexer.aliases, lexer.filenames, lexer.mimetypes
|
||||
|
||||
|
||||
def find_lexer_class(name):
|
||||
"""
|
||||
Lookup a lexer class by name. Return None if not found.
|
||||
"""
|
||||
if name in _lexer_cache:
|
||||
return _lexer_cache[name]
|
||||
# lookup builtin lexers
|
||||
for module_name, lname, aliases, _, _ in LEXERS.itervalues():
|
||||
if name == lname:
|
||||
_load_lexers(module_name)
|
||||
return _lexer_cache[name]
|
||||
# continue with lexers from setuptools entrypoints
|
||||
for cls in find_plugin_lexers():
|
||||
if cls.name == name:
|
||||
return cls
|
||||
|
||||
|
||||
def get_lexer_by_name(_alias, **options):
|
||||
"""
|
||||
Get a lexer by an alias.
|
||||
"""
|
||||
# lookup builtin lexers
|
||||
for module_name, name, aliases, _, _ in LEXERS.itervalues():
|
||||
if _alias in aliases:
|
||||
if name not in _lexer_cache:
|
||||
_load_lexers(module_name)
|
||||
return _lexer_cache[name](**options)
|
||||
# continue with lexers from setuptools entrypoints
|
||||
for cls in find_plugin_lexers():
|
||||
if _alias in cls.aliases:
|
||||
return cls(**options)
|
||||
raise ClassNotFound('no lexer for alias %r found' % _alias)
|
||||
|
||||
|
||||
def get_lexer_for_filename(_fn, code=None, **options):
|
||||
"""
|
||||
Get a lexer for a filename. If multiple lexers match the filename
|
||||
pattern, use ``analyze_text()`` to figure out which one is more
|
||||
appropriate.
|
||||
"""
|
||||
matches = []
|
||||
fn = basename(_fn)
|
||||
for modname, name, _, filenames, _ in LEXERS.itervalues():
|
||||
for filename in filenames:
|
||||
if fnmatch.fnmatch(fn, filename):
|
||||
if name not in _lexer_cache:
|
||||
_load_lexers(modname)
|
||||
matches.append((_lexer_cache[name], filename))
|
||||
for cls in find_plugin_lexers():
|
||||
for filename in cls.filenames:
|
||||
if fnmatch.fnmatch(fn, filename):
|
||||
matches.append((cls, filename))
|
||||
|
||||
if sys.version_info > (3,) and isinstance(code, bytes):
|
||||
# decode it, since all analyse_text functions expect unicode
|
||||
code = code.decode('latin1')
|
||||
|
||||
def get_rating(info):
|
||||
cls, filename = info
|
||||
# explicit patterns get a bonus
|
||||
bonus = '*' not in filename and 0.5 or 0
|
||||
# The class _always_ defines analyse_text because it's included in
|
||||
# the Lexer class. The default implementation returns None which
|
||||
# gets turned into 0.0. Run scripts/detect_missing_analyse_text.py
|
||||
# to find lexers which need it overridden.
|
||||
if code:
|
||||
return cls.analyse_text(code) + bonus
|
||||
return cls.priority + bonus
|
||||
|
||||
if matches:
|
||||
matches.sort(key=get_rating)
|
||||
#print "Possible lexers, after sort:", matches
|
||||
return matches[-1][0](**options)
|
||||
raise ClassNotFound('no lexer for filename %r found' % _fn)
|
||||
|
||||
|
||||
def get_lexer_for_mimetype(_mime, **options):
|
||||
"""
|
||||
Get a lexer for a mimetype.
|
||||
"""
|
||||
for modname, name, _, _, mimetypes in LEXERS.itervalues():
|
||||
if _mime in mimetypes:
|
||||
if name not in _lexer_cache:
|
||||
_load_lexers(modname)
|
||||
return _lexer_cache[name](**options)
|
||||
for cls in find_plugin_lexers():
|
||||
if _mime in cls.mimetypes:
|
||||
return cls(**options)
|
||||
raise ClassNotFound('no lexer for mimetype %r found' % _mime)
|
||||
|
||||
|
||||
def _iter_lexerclasses():
|
||||
"""
|
||||
Return an iterator over all lexer classes.
|
||||
"""
|
||||
for key in sorted(LEXERS):
|
||||
module_name, name = LEXERS[key][:2]
|
||||
if name not in _lexer_cache:
|
||||
_load_lexers(module_name)
|
||||
yield _lexer_cache[name]
|
||||
for lexer in find_plugin_lexers():
|
||||
yield lexer
|
||||
|
||||
|
||||
def guess_lexer_for_filename(_fn, _text, **options):
|
||||
"""
|
||||
Lookup all lexers that handle those filenames primary (``filenames``)
|
||||
or secondary (``alias_filenames``). Then run a text analysis for those
|
||||
lexers and choose the best result.
|
||||
|
||||
usage::
|
||||
|
||||
>>> from pygments.lexers import guess_lexer_for_filename
|
||||
>>> guess_lexer_for_filename('hello.html', '<%= @foo %>')
|
||||
<pygments.lexers.templates.RhtmlLexer object at 0xb7d2f32c>
|
||||
>>> guess_lexer_for_filename('hello.html', '<h1>{{ title|e }}</h1>')
|
||||
<pygments.lexers.templates.HtmlDjangoLexer object at 0xb7d2f2ac>
|
||||
>>> guess_lexer_for_filename('style.css', 'a { color: <?= $link ?> }')
|
||||
<pygments.lexers.templates.CssPhpLexer object at 0xb7ba518c>
|
||||
"""
|
||||
fn = basename(_fn)
|
||||
primary = None
|
||||
matching_lexers = set()
|
||||
for lexer in _iter_lexerclasses():
|
||||
for filename in lexer.filenames:
|
||||
if fnmatch.fnmatch(fn, filename):
|
||||
matching_lexers.add(lexer)
|
||||
primary = lexer
|
||||
for filename in lexer.alias_filenames:
|
||||
if fnmatch.fnmatch(fn, filename):
|
||||
matching_lexers.add(lexer)
|
||||
if not matching_lexers:
|
||||
raise ClassNotFound('no lexer for filename %r found' % fn)
|
||||
if len(matching_lexers) == 1:
|
||||
return matching_lexers.pop()(**options)
|
||||
result = []
|
||||
for lexer in matching_lexers:
|
||||
rv = lexer.analyse_text(_text)
|
||||
if rv == 1.0:
|
||||
return lexer(**options)
|
||||
result.append((rv, lexer))
|
||||
result.sort()
|
||||
if not result[-1][0] and primary is not None:
|
||||
return primary(**options)
|
||||
return result[-1][1](**options)
|
||||
|
||||
|
||||
def guess_lexer(_text, **options):
|
||||
"""
|
||||
Guess a lexer by strong distinctions in the text (eg, shebang).
|
||||
"""
|
||||
|
||||
# try to get a vim modeline first
|
||||
ft = get_filetype_from_buffer(_text)
|
||||
|
||||
if ft is not None:
|
||||
try:
|
||||
return get_lexer_by_name(ft, **options)
|
||||
except ClassNotFound:
|
||||
pass
|
||||
|
||||
best_lexer = [0.0, None]
|
||||
for lexer in _iter_lexerclasses():
|
||||
rv = lexer.analyse_text(_text)
|
||||
if rv == 1.0:
|
||||
return lexer(**options)
|
||||
if rv > best_lexer[0]:
|
||||
best_lexer[:] = (rv, lexer)
|
||||
if not best_lexer[0] or best_lexer[1] is None:
|
||||
raise ClassNotFound('no lexer matching the text found')
|
||||
return best_lexer[1](**options)
|
||||
|
||||
|
||||
class _automodule(types.ModuleType):
|
||||
"""Automatically import lexers."""
|
||||
|
||||
def __getattr__(self, name):
|
||||
info = LEXERS.get(name)
|
||||
if info:
|
||||
_load_lexers(info[0])
|
||||
cls = _lexer_cache[info[1]]
|
||||
setattr(self, name, cls)
|
||||
return cls
|
||||
raise AttributeError(name)
|
||||
|
||||
|
||||
oldmod = sys.modules['pygments.lexers']
|
||||
newmod = _automodule('pygments.lexers')
|
||||
newmod.__dict__.update(oldmod.__dict__)
|
||||
sys.modules['pygments.lexers'] = newmod
|
||||
del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,232 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._clbuiltins
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
ANSI Common Lisp builtins.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
BUILTIN_FUNCTIONS = [ # 638 functions
|
||||
'<', '<=', '=', '>', '>=', '-', '/', '/=', '*', '+', '1-', '1+',
|
||||
'abort', 'abs', 'acons', 'acos', 'acosh', 'add-method', 'adjoin',
|
||||
'adjustable-array-p', 'adjust-array', 'allocate-instance',
|
||||
'alpha-char-p', 'alphanumericp', 'append', 'apply', 'apropos',
|
||||
'apropos-list', 'aref', 'arithmetic-error-operands',
|
||||
'arithmetic-error-operation', 'array-dimension', 'array-dimensions',
|
||||
'array-displacement', 'array-element-type', 'array-has-fill-pointer-p',
|
||||
'array-in-bounds-p', 'arrayp', 'array-rank', 'array-row-major-index',
|
||||
'array-total-size', 'ash', 'asin', 'asinh', 'assoc', 'assoc-if',
|
||||
'assoc-if-not', 'atan', 'atanh', 'atom', 'bit', 'bit-and', 'bit-andc1',
|
||||
'bit-andc2', 'bit-eqv', 'bit-ior', 'bit-nand', 'bit-nor', 'bit-not',
|
||||
'bit-orc1', 'bit-orc2', 'bit-vector-p', 'bit-xor', 'boole',
|
||||
'both-case-p', 'boundp', 'break', 'broadcast-stream-streams',
|
||||
'butlast', 'byte', 'byte-position', 'byte-size', 'caaaar', 'caaadr',
|
||||
'caaar', 'caadar', 'caaddr', 'caadr', 'caar', 'cadaar', 'cadadr',
|
||||
'cadar', 'caddar', 'cadddr', 'caddr', 'cadr', 'call-next-method', 'car',
|
||||
'cdaaar', 'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar',
|
||||
'cddaar', 'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 'cddr', 'cdr',
|
||||
'ceiling', 'cell-error-name', 'cerror', 'change-class', 'char', 'char<',
|
||||
'char<=', 'char=', 'char>', 'char>=', 'char/=', 'character',
|
||||
'characterp', 'char-code', 'char-downcase', 'char-equal',
|
||||
'char-greaterp', 'char-int', 'char-lessp', 'char-name',
|
||||
'char-not-equal', 'char-not-greaterp', 'char-not-lessp', 'char-upcase',
|
||||
'cis', 'class-name', 'class-of', 'clear-input', 'clear-output',
|
||||
'close', 'clrhash', 'code-char', 'coerce', 'compile',
|
||||
'compiled-function-p', 'compile-file', 'compile-file-pathname',
|
||||
'compiler-macro-function', 'complement', 'complex', 'complexp',
|
||||
'compute-applicable-methods', 'compute-restarts', 'concatenate',
|
||||
'concatenated-stream-streams', 'conjugate', 'cons', 'consp',
|
||||
'constantly', 'constantp', 'continue', 'copy-alist', 'copy-list',
|
||||
'copy-pprint-dispatch', 'copy-readtable', 'copy-seq', 'copy-structure',
|
||||
'copy-symbol', 'copy-tree', 'cos', 'cosh', 'count', 'count-if',
|
||||
'count-if-not', 'decode-float', 'decode-universal-time', 'delete',
|
||||
'delete-duplicates', 'delete-file', 'delete-if', 'delete-if-not',
|
||||
'delete-package', 'denominator', 'deposit-field', 'describe',
|
||||
'describe-object', 'digit-char', 'digit-char-p', 'directory',
|
||||
'directory-namestring', 'disassemble', 'documentation', 'dpb',
|
||||
'dribble', 'echo-stream-input-stream', 'echo-stream-output-stream',
|
||||
'ed', 'eighth', 'elt', 'encode-universal-time', 'endp',
|
||||
'enough-namestring', 'ensure-directories-exist',
|
||||
'ensure-generic-function', 'eq', 'eql', 'equal', 'equalp', 'error',
|
||||
'eval', 'evenp', 'every', 'exp', 'export', 'expt', 'fboundp',
|
||||
'fceiling', 'fdefinition', 'ffloor', 'fifth', 'file-author',
|
||||
'file-error-pathname', 'file-length', 'file-namestring',
|
||||
'file-position', 'file-string-length', 'file-write-date',
|
||||
'fill', 'fill-pointer', 'find', 'find-all-symbols', 'find-class',
|
||||
'find-if', 'find-if-not', 'find-method', 'find-package', 'find-restart',
|
||||
'find-symbol', 'finish-output', 'first', 'float', 'float-digits',
|
||||
'floatp', 'float-precision', 'float-radix', 'float-sign', 'floor',
|
||||
'fmakunbound', 'force-output', 'format', 'fourth', 'fresh-line',
|
||||
'fround', 'ftruncate', 'funcall', 'function-keywords',
|
||||
'function-lambda-expression', 'functionp', 'gcd', 'gensym', 'gentemp',
|
||||
'get', 'get-decoded-time', 'get-dispatch-macro-character', 'getf',
|
||||
'gethash', 'get-internal-real-time', 'get-internal-run-time',
|
||||
'get-macro-character', 'get-output-stream-string', 'get-properties',
|
||||
'get-setf-expansion', 'get-universal-time', 'graphic-char-p',
|
||||
'hash-table-count', 'hash-table-p', 'hash-table-rehash-size',
|
||||
'hash-table-rehash-threshold', 'hash-table-size', 'hash-table-test',
|
||||
'host-namestring', 'identity', 'imagpart', 'import',
|
||||
'initialize-instance', 'input-stream-p', 'inspect',
|
||||
'integer-decode-float', 'integer-length', 'integerp',
|
||||
'interactive-stream-p', 'intern', 'intersection',
|
||||
'invalid-method-error', 'invoke-debugger', 'invoke-restart',
|
||||
'invoke-restart-interactively', 'isqrt', 'keywordp', 'last', 'lcm',
|
||||
'ldb', 'ldb-test', 'ldiff', 'length', 'lisp-implementation-type',
|
||||
'lisp-implementation-version', 'list', 'list*', 'list-all-packages',
|
||||
'listen', 'list-length', 'listp', 'load',
|
||||
'load-logical-pathname-translations', 'log', 'logand', 'logandc1',
|
||||
'logandc2', 'logbitp', 'logcount', 'logeqv', 'logical-pathname',
|
||||
'logical-pathname-translations', 'logior', 'lognand', 'lognor',
|
||||
'lognot', 'logorc1', 'logorc2', 'logtest', 'logxor', 'long-site-name',
|
||||
'lower-case-p', 'machine-instance', 'machine-type', 'machine-version',
|
||||
'macroexpand', 'macroexpand-1', 'macro-function', 'make-array',
|
||||
'make-broadcast-stream', 'make-concatenated-stream', 'make-condition',
|
||||
'make-dispatch-macro-character', 'make-echo-stream', 'make-hash-table',
|
||||
'make-instance', 'make-instances-obsolete', 'make-list',
|
||||
'make-load-form', 'make-load-form-saving-slots', 'make-package',
|
||||
'make-pathname', 'make-random-state', 'make-sequence', 'make-string',
|
||||
'make-string-input-stream', 'make-string-output-stream', 'make-symbol',
|
||||
'make-synonym-stream', 'make-two-way-stream', 'makunbound', 'map',
|
||||
'mapc', 'mapcan', 'mapcar', 'mapcon', 'maphash', 'map-into', 'mapl',
|
||||
'maplist', 'mask-field', 'max', 'member', 'member-if', 'member-if-not',
|
||||
'merge', 'merge-pathnames', 'method-combination-error',
|
||||
'method-qualifiers', 'min', 'minusp', 'mismatch', 'mod',
|
||||
'muffle-warning', 'name-char', 'namestring', 'nbutlast', 'nconc',
|
||||
'next-method-p', 'nintersection', 'ninth', 'no-applicable-method',
|
||||
'no-next-method', 'not', 'notany', 'notevery', 'nreconc', 'nreverse',
|
||||
'nset-difference', 'nset-exclusive-or', 'nstring-capitalize',
|
||||
'nstring-downcase', 'nstring-upcase', 'nsublis', 'nsubst', 'nsubst-if',
|
||||
'nsubst-if-not', 'nsubstitute', 'nsubstitute-if', 'nsubstitute-if-not',
|
||||
'nth', 'nthcdr', 'null', 'numberp', 'numerator', 'nunion', 'oddp',
|
||||
'open', 'open-stream-p', 'output-stream-p', 'package-error-package',
|
||||
'package-name', 'package-nicknames', 'packagep',
|
||||
'package-shadowing-symbols', 'package-used-by-list', 'package-use-list',
|
||||
'pairlis', 'parse-integer', 'parse-namestring', 'pathname',
|
||||
'pathname-device', 'pathname-directory', 'pathname-host',
|
||||
'pathname-match-p', 'pathname-name', 'pathnamep', 'pathname-type',
|
||||
'pathname-version', 'peek-char', 'phase', 'plusp', 'position',
|
||||
'position-if', 'position-if-not', 'pprint', 'pprint-dispatch',
|
||||
'pprint-fill', 'pprint-indent', 'pprint-linear', 'pprint-newline',
|
||||
'pprint-tab', 'pprint-tabular', 'prin1', 'prin1-to-string', 'princ',
|
||||
'princ-to-string', 'print', 'print-object', 'probe-file', 'proclaim',
|
||||
'provide', 'random', 'random-state-p', 'rassoc', 'rassoc-if',
|
||||
'rassoc-if-not', 'rational', 'rationalize', 'rationalp', 'read',
|
||||
'read-byte', 'read-char', 'read-char-no-hang', 'read-delimited-list',
|
||||
'read-from-string', 'read-line', 'read-preserving-whitespace',
|
||||
'read-sequence', 'readtable-case', 'readtablep', 'realp', 'realpart',
|
||||
'reduce', 'reinitialize-instance', 'rem', 'remhash', 'remove',
|
||||
'remove-duplicates', 'remove-if', 'remove-if-not', 'remove-method',
|
||||
'remprop', 'rename-file', 'rename-package', 'replace', 'require',
|
||||
'rest', 'restart-name', 'revappend', 'reverse', 'room', 'round',
|
||||
'row-major-aref', 'rplaca', 'rplacd', 'sbit', 'scale-float', 'schar',
|
||||
'search', 'second', 'set', 'set-difference',
|
||||
'set-dispatch-macro-character', 'set-exclusive-or',
|
||||
'set-macro-character', 'set-pprint-dispatch', 'set-syntax-from-char',
|
||||
'seventh', 'shadow', 'shadowing-import', 'shared-initialize',
|
||||
'short-site-name', 'signal', 'signum', 'simple-bit-vector-p',
|
||||
'simple-condition-format-arguments', 'simple-condition-format-control',
|
||||
'simple-string-p', 'simple-vector-p', 'sin', 'sinh', 'sixth', 'sleep',
|
||||
'slot-boundp', 'slot-exists-p', 'slot-makunbound', 'slot-missing',
|
||||
'slot-unbound', 'slot-value', 'software-type', 'software-version',
|
||||
'some', 'sort', 'special-operator-p', 'sqrt', 'stable-sort',
|
||||
'standard-char-p', 'store-value', 'stream-element-type',
|
||||
'stream-error-stream', 'stream-external-format', 'streamp', 'string',
|
||||
'string<', 'string<=', 'string=', 'string>', 'string>=', 'string/=',
|
||||
'string-capitalize', 'string-downcase', 'string-equal',
|
||||
'string-greaterp', 'string-left-trim', 'string-lessp',
|
||||
'string-not-equal', 'string-not-greaterp', 'string-not-lessp',
|
||||
'stringp', 'string-right-trim', 'string-trim', 'string-upcase',
|
||||
'sublis', 'subseq', 'subsetp', 'subst', 'subst-if', 'subst-if-not',
|
||||
'substitute', 'substitute-if', 'substitute-if-not', 'subtypep','svref',
|
||||
'sxhash', 'symbol-function', 'symbol-name', 'symbolp', 'symbol-package',
|
||||
'symbol-plist', 'symbol-value', 'synonym-stream-symbol', 'syntax:',
|
||||
'tailp', 'tan', 'tanh', 'tenth', 'terpri', 'third',
|
||||
'translate-logical-pathname', 'translate-pathname', 'tree-equal',
|
||||
'truename', 'truncate', 'two-way-stream-input-stream',
|
||||
'two-way-stream-output-stream', 'type-error-datum',
|
||||
'type-error-expected-type', 'type-of', 'typep', 'unbound-slot-instance',
|
||||
'unexport', 'unintern', 'union', 'unread-char', 'unuse-package',
|
||||
'update-instance-for-different-class',
|
||||
'update-instance-for-redefined-class', 'upgraded-array-element-type',
|
||||
'upgraded-complex-part-type', 'upper-case-p', 'use-package',
|
||||
'user-homedir-pathname', 'use-value', 'values', 'values-list', 'vector',
|
||||
'vectorp', 'vector-pop', 'vector-push', 'vector-push-extend', 'warn',
|
||||
'wild-pathname-p', 'write', 'write-byte', 'write-char', 'write-line',
|
||||
'write-sequence', 'write-string', 'write-to-string', 'yes-or-no-p',
|
||||
'y-or-n-p', 'zerop',
|
||||
]
|
||||
|
||||
SPECIAL_FORMS = [
|
||||
'block', 'catch', 'declare', 'eval-when', 'flet', 'function', 'go', 'if',
|
||||
'labels', 'lambda', 'let', 'let*', 'load-time-value', 'locally', 'macrolet',
|
||||
'multiple-value-call', 'multiple-value-prog1', 'progn', 'progv', 'quote',
|
||||
'return-from', 'setq', 'symbol-macrolet', 'tagbody', 'the', 'throw',
|
||||
'unwind-protect',
|
||||
]
|
||||
|
||||
MACROS = [
|
||||
'and', 'assert', 'call-method', 'case', 'ccase', 'check-type', 'cond',
|
||||
'ctypecase', 'decf', 'declaim', 'defclass', 'defconstant', 'defgeneric',
|
||||
'define-compiler-macro', 'define-condition', 'define-method-combination',
|
||||
'define-modify-macro', 'define-setf-expander', 'define-symbol-macro',
|
||||
'defmacro', 'defmethod', 'defpackage', 'defparameter', 'defsetf',
|
||||
'defstruct', 'deftype', 'defun', 'defvar', 'destructuring-bind', 'do',
|
||||
'do*', 'do-all-symbols', 'do-external-symbols', 'dolist', 'do-symbols',
|
||||
'dotimes', 'ecase', 'etypecase', 'formatter', 'handler-bind',
|
||||
'handler-case', 'ignore-errors', 'incf', 'in-package', 'lambda', 'loop',
|
||||
'loop-finish', 'make-method', 'multiple-value-bind', 'multiple-value-list',
|
||||
'multiple-value-setq', 'nth-value', 'or', 'pop',
|
||||
'pprint-exit-if-list-exhausted', 'pprint-logical-block', 'pprint-pop',
|
||||
'print-unreadable-object', 'prog', 'prog*', 'prog1', 'prog2', 'psetf',
|
||||
'psetq', 'push', 'pushnew', 'remf', 'restart-bind', 'restart-case',
|
||||
'return', 'rotatef', 'setf', 'shiftf', 'step', 'time', 'trace', 'typecase',
|
||||
'unless', 'untrace', 'when', 'with-accessors', 'with-compilation-unit',
|
||||
'with-condition-restarts', 'with-hash-table-iterator',
|
||||
'with-input-from-string', 'with-open-file', 'with-open-stream',
|
||||
'with-output-to-string', 'with-package-iterator', 'with-simple-restart',
|
||||
'with-slots', 'with-standard-io-syntax',
|
||||
]
|
||||
|
||||
LAMBDA_LIST_KEYWORDS = [
|
||||
'&allow-other-keys', '&aux', '&body', '&environment', '&key', '&optional',
|
||||
'&rest', '&whole',
|
||||
]
|
||||
|
||||
DECLARATIONS = [
|
||||
'dynamic-extent', 'ignore', 'optimize', 'ftype', 'inline', 'special',
|
||||
'ignorable', 'notinline', 'type',
|
||||
]
|
||||
|
||||
BUILTIN_TYPES = [
|
||||
'atom', 'boolean', 'base-char', 'base-string', 'bignum', 'bit',
|
||||
'compiled-function', 'extended-char', 'fixnum', 'keyword', 'nil',
|
||||
'signed-byte', 'short-float', 'single-float', 'double-float', 'long-float',
|
||||
'simple-array', 'simple-base-string', 'simple-bit-vector', 'simple-string',
|
||||
'simple-vector', 'standard-char', 'unsigned-byte',
|
||||
|
||||
# Condition Types
|
||||
'arithmetic-error', 'cell-error', 'condition', 'control-error',
|
||||
'division-by-zero', 'end-of-file', 'error', 'file-error',
|
||||
'floating-point-inexact', 'floating-point-overflow',
|
||||
'floating-point-underflow', 'floating-point-invalid-operation',
|
||||
'parse-error', 'package-error', 'print-not-readable', 'program-error',
|
||||
'reader-error', 'serious-condition', 'simple-condition', 'simple-error',
|
||||
'simple-type-error', 'simple-warning', 'stream-error', 'storage-condition',
|
||||
'style-warning', 'type-error', 'unbound-variable', 'unbound-slot',
|
||||
'undefined-function', 'warning',
|
||||
]
|
||||
|
||||
BUILTIN_CLASSES = [
|
||||
'array', 'broadcast-stream', 'bit-vector', 'built-in-class', 'character',
|
||||
'class', 'complex', 'concatenated-stream', 'cons', 'echo-stream',
|
||||
'file-stream', 'float', 'function', 'generic-function', 'hash-table',
|
||||
'integer', 'list', 'logical-pathname', 'method-combination', 'method',
|
||||
'null', 'number', 'package', 'pathname', 'ratio', 'rational', 'readtable',
|
||||
'real', 'random-state', 'restart', 'sequence', 'standard-class',
|
||||
'standard-generic-function', 'standard-method', 'standard-object',
|
||||
'string-stream', 'stream', 'string', 'structure-class', 'structure-object',
|
||||
'symbol', 'synonym-stream', 't', 'two-way-stream', 'vector',
|
||||
]
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,249 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._luabuiltins
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
This file contains the names and modules of lua functions
|
||||
It is able to re-generate itself, but for adding new functions you
|
||||
probably have to add some callbacks (see function module_callbacks).
|
||||
|
||||
Do not edit the MODULES dict by hand.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
MODULES = {'basic': ['_G',
|
||||
'_VERSION',
|
||||
'assert',
|
||||
'collectgarbage',
|
||||
'dofile',
|
||||
'error',
|
||||
'getfenv',
|
||||
'getmetatable',
|
||||
'ipairs',
|
||||
'load',
|
||||
'loadfile',
|
||||
'loadstring',
|
||||
'next',
|
||||
'pairs',
|
||||
'pcall',
|
||||
'print',
|
||||
'rawequal',
|
||||
'rawget',
|
||||
'rawset',
|
||||
'select',
|
||||
'setfenv',
|
||||
'setmetatable',
|
||||
'tonumber',
|
||||
'tostring',
|
||||
'type',
|
||||
'unpack',
|
||||
'xpcall'],
|
||||
'coroutine': ['coroutine.create',
|
||||
'coroutine.resume',
|
||||
'coroutine.running',
|
||||
'coroutine.status',
|
||||
'coroutine.wrap',
|
||||
'coroutine.yield'],
|
||||
'debug': ['debug.debug',
|
||||
'debug.getfenv',
|
||||
'debug.gethook',
|
||||
'debug.getinfo',
|
||||
'debug.getlocal',
|
||||
'debug.getmetatable',
|
||||
'debug.getregistry',
|
||||
'debug.getupvalue',
|
||||
'debug.setfenv',
|
||||
'debug.sethook',
|
||||
'debug.setlocal',
|
||||
'debug.setmetatable',
|
||||
'debug.setupvalue',
|
||||
'debug.traceback'],
|
||||
'io': ['io.close',
|
||||
'io.flush',
|
||||
'io.input',
|
||||
'io.lines',
|
||||
'io.open',
|
||||
'io.output',
|
||||
'io.popen',
|
||||
'io.read',
|
||||
'io.tmpfile',
|
||||
'io.type',
|
||||
'io.write'],
|
||||
'math': ['math.abs',
|
||||
'math.acos',
|
||||
'math.asin',
|
||||
'math.atan2',
|
||||
'math.atan',
|
||||
'math.ceil',
|
||||
'math.cosh',
|
||||
'math.cos',
|
||||
'math.deg',
|
||||
'math.exp',
|
||||
'math.floor',
|
||||
'math.fmod',
|
||||
'math.frexp',
|
||||
'math.huge',
|
||||
'math.ldexp',
|
||||
'math.log10',
|
||||
'math.log',
|
||||
'math.max',
|
||||
'math.min',
|
||||
'math.modf',
|
||||
'math.pi',
|
||||
'math.pow',
|
||||
'math.rad',
|
||||
'math.random',
|
||||
'math.randomseed',
|
||||
'math.sinh',
|
||||
'math.sin',
|
||||
'math.sqrt',
|
||||
'math.tanh',
|
||||
'math.tan'],
|
||||
'modules': ['module',
|
||||
'require',
|
||||
'package.cpath',
|
||||
'package.loaded',
|
||||
'package.loadlib',
|
||||
'package.path',
|
||||
'package.preload',
|
||||
'package.seeall'],
|
||||
'os': ['os.clock',
|
||||
'os.date',
|
||||
'os.difftime',
|
||||
'os.execute',
|
||||
'os.exit',
|
||||
'os.getenv',
|
||||
'os.remove',
|
||||
'os.rename',
|
||||
'os.setlocale',
|
||||
'os.time',
|
||||
'os.tmpname'],
|
||||
'string': ['string.byte',
|
||||
'string.char',
|
||||
'string.dump',
|
||||
'string.find',
|
||||
'string.format',
|
||||
'string.gmatch',
|
||||
'string.gsub',
|
||||
'string.len',
|
||||
'string.lower',
|
||||
'string.match',
|
||||
'string.rep',
|
||||
'string.reverse',
|
||||
'string.sub',
|
||||
'string.upper'],
|
||||
'table': ['table.concat',
|
||||
'table.insert',
|
||||
'table.maxn',
|
||||
'table.remove',
|
||||
'table.sort']}
|
||||
|
||||
if __name__ == '__main__':
|
||||
import re
|
||||
import urllib
|
||||
import pprint
|
||||
|
||||
# you can't generally find out what module a function belongs to if you
|
||||
# have only its name. Because of this, here are some callback functions
|
||||
# that recognize if a gioven function belongs to a specific module
|
||||
def module_callbacks():
|
||||
def is_in_coroutine_module(name):
|
||||
return name.startswith('coroutine.')
|
||||
|
||||
def is_in_modules_module(name):
|
||||
if name in ['require', 'module'] or name.startswith('package'):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def is_in_string_module(name):
|
||||
return name.startswith('string.')
|
||||
|
||||
def is_in_table_module(name):
|
||||
return name.startswith('table.')
|
||||
|
||||
def is_in_math_module(name):
|
||||
return name.startswith('math')
|
||||
|
||||
def is_in_io_module(name):
|
||||
return name.startswith('io.')
|
||||
|
||||
def is_in_os_module(name):
|
||||
return name.startswith('os.')
|
||||
|
||||
def is_in_debug_module(name):
|
||||
return name.startswith('debug.')
|
||||
|
||||
return {'coroutine': is_in_coroutine_module,
|
||||
'modules': is_in_modules_module,
|
||||
'string': is_in_string_module,
|
||||
'table': is_in_table_module,
|
||||
'math': is_in_math_module,
|
||||
'io': is_in_io_module,
|
||||
'os': is_in_os_module,
|
||||
'debug': is_in_debug_module}
|
||||
|
||||
|
||||
|
||||
def get_newest_version():
|
||||
f = urllib.urlopen('http://www.lua.org/manual/')
|
||||
r = re.compile(r'^<A HREF="(\d\.\d)/">Lua \1</A>')
|
||||
for line in f:
|
||||
m = r.match(line)
|
||||
if m is not None:
|
||||
return m.groups()[0]
|
||||
|
||||
def get_lua_functions(version):
|
||||
f = urllib.urlopen('http://www.lua.org/manual/%s/' % version)
|
||||
r = re.compile(r'^<A HREF="manual.html#pdf-(.+)">\1</A>')
|
||||
functions = []
|
||||
for line in f:
|
||||
m = r.match(line)
|
||||
if m is not None:
|
||||
functions.append(m.groups()[0])
|
||||
return functions
|
||||
|
||||
def get_function_module(name):
|
||||
for mod, cb in module_callbacks().iteritems():
|
||||
if cb(name):
|
||||
return mod
|
||||
if '.' in name:
|
||||
return name.split('.')[0]
|
||||
else:
|
||||
return 'basic'
|
||||
|
||||
def regenerate(filename, modules):
|
||||
f = open(filename)
|
||||
try:
|
||||
content = f.read()
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
header = content[:content.find('MODULES = {')]
|
||||
footer = content[content.find("if __name__ == '__main__':"):]
|
||||
|
||||
|
||||
f = open(filename, 'w')
|
||||
f.write(header)
|
||||
f.write('MODULES = %s\n\n' % pprint.pformat(modules))
|
||||
f.write(footer)
|
||||
f.close()
|
||||
|
||||
def run():
|
||||
version = get_newest_version()
|
||||
print '> Downloading function index for Lua %s' % version
|
||||
functions = get_lua_functions(version)
|
||||
print '> %d functions found:' % len(functions)
|
||||
|
||||
modules = {}
|
||||
for full_function_name in functions:
|
||||
print '>> %s' % full_function_name
|
||||
m = get_function_module(full_function_name)
|
||||
modules.setdefault(m, []).append(full_function_name)
|
||||
|
||||
regenerate(__file__, modules)
|
||||
|
||||
|
||||
run()
|
|
@ -0,0 +1,350 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._mapping
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexer mapping defintions. This file is generated by itself. Everytime
|
||||
you change something on a builtin lexer defintion, run this script from
|
||||
the lexers folder to update it.
|
||||
|
||||
Do not alter the LEXERS dictionary by hand.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
LEXERS = {
|
||||
'ABAPLexer': ('pygments.lexers.other', 'ABAP', ('abap',), ('*.abap',), ('text/x-abap',)),
|
||||
'ActionScript3Lexer': ('pygments.lexers.web', 'ActionScript 3', ('as3', 'actionscript3'), ('*.as',), ('application/x-actionscript', 'text/x-actionscript', 'text/actionscript')),
|
||||
'ActionScriptLexer': ('pygments.lexers.web', 'ActionScript', ('as', 'actionscript'), ('*.as',), ('application/x-actionscript3', 'text/x-actionscript3', 'text/actionscript3')),
|
||||
'AdaLexer': ('pygments.lexers.compiled', 'Ada', ('ada', 'ada95ada2005'), ('*.adb', '*.ads', '*.ada'), ('text/x-ada',)),
|
||||
'AgdaLexer': ('pygments.lexers.functional', 'Agda', ('agda',), ('*.agda',), ('text/x-agda',)),
|
||||
'AntlrActionScriptLexer': ('pygments.lexers.parsers', 'ANTLR With ActionScript Target', ('antlr-as', 'antlr-actionscript'), ('*.G', '*.g'), ()),
|
||||
'AntlrCSharpLexer': ('pygments.lexers.parsers', 'ANTLR With C# Target', ('antlr-csharp', 'antlr-c#'), ('*.G', '*.g'), ()),
|
||||
'AntlrCppLexer': ('pygments.lexers.parsers', 'ANTLR With CPP Target', ('antlr-cpp',), ('*.G', '*.g'), ()),
|
||||
'AntlrJavaLexer': ('pygments.lexers.parsers', 'ANTLR With Java Target', ('antlr-java',), ('*.G', '*.g'), ()),
|
||||
'AntlrLexer': ('pygments.lexers.parsers', 'ANTLR', ('antlr',), (), ()),
|
||||
'AntlrObjectiveCLexer': ('pygments.lexers.parsers', 'ANTLR With ObjectiveC Target', ('antlr-objc',), ('*.G', '*.g'), ()),
|
||||
'AntlrPerlLexer': ('pygments.lexers.parsers', 'ANTLR With Perl Target', ('antlr-perl',), ('*.G', '*.g'), ()),
|
||||
'AntlrPythonLexer': ('pygments.lexers.parsers', 'ANTLR With Python Target', ('antlr-python',), ('*.G', '*.g'), ()),
|
||||
'AntlrRubyLexer': ('pygments.lexers.parsers', 'ANTLR With Ruby Target', ('antlr-ruby', 'antlr-rb'), ('*.G', '*.g'), ()),
|
||||
'ApacheConfLexer': ('pygments.lexers.text', 'ApacheConf', ('apacheconf', 'aconf', 'apache'), ('.htaccess', 'apache.conf', 'apache2.conf'), ('text/x-apacheconf',)),
|
||||
'AppleScriptLexer': ('pygments.lexers.other', 'AppleScript', ('applescript',), ('*.applescript',), ()),
|
||||
'AspectJLexer': ('pygments.lexers.jvm', 'AspectJ', ('aspectj',), ('*.aj',), ('text/x-aspectj',)),
|
||||
'AsymptoteLexer': ('pygments.lexers.other', 'Asymptote', ('asy', 'asymptote'), ('*.asy',), ('text/x-asymptote',)),
|
||||
'AutoItLexer': ('pygments.lexers.other', 'AutoIt', ('autoit', 'Autoit'), ('*.au3',), ('text/x-autoit',)),
|
||||
'AutohotkeyLexer': ('pygments.lexers.other', 'autohotkey', ('ahk', 'autohotkey'), ('*.ahk', '*.ahkl'), ('text/x-autohotkey',)),
|
||||
'AwkLexer': ('pygments.lexers.other', 'Awk', ('awk', 'gawk', 'mawk', 'nawk'), ('*.awk',), ('application/x-awk',)),
|
||||
'BBCodeLexer': ('pygments.lexers.text', 'BBCode', ('bbcode',), (), ('text/x-bbcode',)),
|
||||
'BaseMakefileLexer': ('pygments.lexers.text', 'Base Makefile', ('basemake',), (), ()),
|
||||
'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '.bashrc', 'bashrc', '.bash_*', 'bash_*'), ('application/x-sh', 'application/x-shellscript')),
|
||||
'BashSessionLexer': ('pygments.lexers.shell', 'Bash Session', ('console',), ('*.sh-session',), ('application/x-shell-session',)),
|
||||
'BatchLexer': ('pygments.lexers.shell', 'Batchfile', ('bat', 'dosbatch', 'winbatch'), ('*.bat', '*.cmd'), ('application/x-dos-batch',)),
|
||||
'BefungeLexer': ('pygments.lexers.other', 'Befunge', ('befunge',), ('*.befunge',), ('application/x-befunge',)),
|
||||
'BlitzBasicLexer': ('pygments.lexers.compiled', 'BlitzBasic', ('blitzbasic', 'b3d', 'bplus'), ('*.bb', '*.decls'), ('text/x-bb',)),
|
||||
'BlitzMaxLexer': ('pygments.lexers.compiled', 'BlitzMax', ('blitzmax', 'bmax'), ('*.bmx',), ('text/x-bmx',)),
|
||||
'BooLexer': ('pygments.lexers.dotnet', 'Boo', ('boo',), ('*.boo',), ('text/x-boo',)),
|
||||
'BrainfuckLexer': ('pygments.lexers.other', 'Brainfuck', ('brainfuck', 'bf'), ('*.bf', '*.b'), ('application/x-brainfuck',)),
|
||||
'BroLexer': ('pygments.lexers.other', 'Bro', ('bro',), ('*.bro',), ()),
|
||||
'BugsLexer': ('pygments.lexers.math', 'BUGS', ('bugs', 'winbugs', 'openbugs'), ('*.bug',), ()),
|
||||
'CLexer': ('pygments.lexers.compiled', 'C', ('c',), ('*.c', '*.h', '*.idc'), ('text/x-chdr', 'text/x-csrc')),
|
||||
'CMakeLexer': ('pygments.lexers.text', 'CMake', ('cmake',), ('*.cmake', 'CMakeLists.txt'), ('text/x-cmake',)),
|
||||
'CObjdumpLexer': ('pygments.lexers.asm', 'c-objdump', ('c-objdump',), ('*.c-objdump',), ('text/x-c-objdump',)),
|
||||
'CSharpAspxLexer': ('pygments.lexers.dotnet', 'aspx-cs', ('aspx-cs',), ('*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd'), ()),
|
||||
'CSharpLexer': ('pygments.lexers.dotnet', 'C#', ('csharp', 'c#'), ('*.cs',), ('text/x-csharp',)),
|
||||
'Ca65Lexer': ('pygments.lexers.asm', 'ca65', ('ca65',), ('*.s',), ()),
|
||||
'CbmBasicV2Lexer': ('pygments.lexers.other', 'CBM BASIC V2', ('cbmbas',), ('*.bas',), ()),
|
||||
'CeylonLexer': ('pygments.lexers.jvm', 'Ceylon', ('ceylon',), ('*.ceylon',), ('text/x-ceylon',)),
|
||||
'Cfengine3Lexer': ('pygments.lexers.other', 'CFEngine3', ('cfengine3', 'cf3'), ('*.cf',), ()),
|
||||
'CheetahHtmlLexer': ('pygments.lexers.templates', 'HTML+Cheetah', ('html+cheetah', 'html+spitfire', 'htmlcheetah'), (), ('text/html+cheetah', 'text/html+spitfire')),
|
||||
'CheetahJavascriptLexer': ('pygments.lexers.templates', 'JavaScript+Cheetah', ('js+cheetah', 'javascript+cheetah', 'js+spitfire', 'javascript+spitfire'), (), ('application/x-javascript+cheetah', 'text/x-javascript+cheetah', 'text/javascript+cheetah', 'application/x-javascript+spitfire', 'text/x-javascript+spitfire', 'text/javascript+spitfire')),
|
||||
'CheetahLexer': ('pygments.lexers.templates', 'Cheetah', ('cheetah', 'spitfire'), ('*.tmpl', '*.spt'), ('application/x-cheetah', 'application/x-spitfire')),
|
||||
'CheetahXmlLexer': ('pygments.lexers.templates', 'XML+Cheetah', ('xml+cheetah', 'xml+spitfire'), (), ('application/xml+cheetah', 'application/xml+spitfire')),
|
||||
'ClayLexer': ('pygments.lexers.compiled', 'Clay', ('clay',), ('*.clay',), ('text/x-clay',)),
|
||||
'ClojureLexer': ('pygments.lexers.jvm', 'Clojure', ('clojure', 'clj'), ('*.clj',), ('text/x-clojure', 'application/x-clojure')),
|
||||
'CobolFreeformatLexer': ('pygments.lexers.compiled', 'COBOLFree', ('cobolfree',), ('*.cbl', '*.CBL'), ()),
|
||||
'CobolLexer': ('pygments.lexers.compiled', 'COBOL', ('cobol',), ('*.cob', '*.COB', '*.cpy', '*.CPY'), ('text/x-cobol',)),
|
||||
'CoffeeScriptLexer': ('pygments.lexers.web', 'CoffeeScript', ('coffee-script', 'coffeescript', 'coffee'), ('*.coffee',), ('text/coffeescript',)),
|
||||
'ColdfusionHtmlLexer': ('pygments.lexers.templates', 'Coldfusion HTML', ('cfm',), ('*.cfm', '*.cfml', '*.cfc'), ('application/x-coldfusion',)),
|
||||
'ColdfusionLexer': ('pygments.lexers.templates', 'cfstatement', ('cfs',), (), ()),
|
||||
'CommonLispLexer': ('pygments.lexers.functional', 'Common Lisp', ('common-lisp', 'cl', 'lisp'), ('*.cl', '*.lisp', '*.el'), ('text/x-common-lisp',)),
|
||||
'CoqLexer': ('pygments.lexers.functional', 'Coq', ('coq',), ('*.v',), ('text/x-coq',)),
|
||||
'CppLexer': ('pygments.lexers.compiled', 'C++', ('cpp', 'c++'), ('*.cpp', '*.hpp', '*.c++', '*.h++', '*.cc', '*.hh', '*.cxx', '*.hxx', '*.C', '*.H', '*.cp', '*.CPP'), ('text/x-c++hdr', 'text/x-c++src')),
|
||||
'CppObjdumpLexer': ('pygments.lexers.asm', 'cpp-objdump', ('cpp-objdump', 'c++-objdumb', 'cxx-objdump'), ('*.cpp-objdump', '*.c++-objdump', '*.cxx-objdump'), ('text/x-cpp-objdump',)),
|
||||
'CrocLexer': ('pygments.lexers.agile', 'Croc', ('croc',), ('*.croc',), ('text/x-crocsrc',)),
|
||||
'CssDjangoLexer': ('pygments.lexers.templates', 'CSS+Django/Jinja', ('css+django', 'css+jinja'), (), ('text/css+django', 'text/css+jinja')),
|
||||
'CssErbLexer': ('pygments.lexers.templates', 'CSS+Ruby', ('css+erb', 'css+ruby'), (), ('text/css+ruby',)),
|
||||
'CssGenshiLexer': ('pygments.lexers.templates', 'CSS+Genshi Text', ('css+genshitext', 'css+genshi'), (), ('text/css+genshi',)),
|
||||
'CssLexer': ('pygments.lexers.web', 'CSS', ('css',), ('*.css',), ('text/css',)),
|
||||
'CssPhpLexer': ('pygments.lexers.templates', 'CSS+PHP', ('css+php',), (), ('text/css+php',)),
|
||||
'CssSmartyLexer': ('pygments.lexers.templates', 'CSS+Smarty', ('css+smarty',), (), ('text/css+smarty',)),
|
||||
'CudaLexer': ('pygments.lexers.compiled', 'CUDA', ('cuda', 'cu'), ('*.cu', '*.cuh'), ('text/x-cuda',)),
|
||||
'CythonLexer': ('pygments.lexers.compiled', 'Cython', ('cython', 'pyx', 'pyrex'), ('*.pyx', '*.pxd', '*.pxi'), ('text/x-cython', 'application/x-cython')),
|
||||
'DLexer': ('pygments.lexers.compiled', 'D', ('d',), ('*.d', '*.di'), ('text/x-dsrc',)),
|
||||
'DObjdumpLexer': ('pygments.lexers.asm', 'd-objdump', ('d-objdump',), ('*.d-objdump',), ('text/x-d-objdump',)),
|
||||
'DarcsPatchLexer': ('pygments.lexers.text', 'Darcs Patch', ('dpatch',), ('*.dpatch', '*.darcspatch'), ()),
|
||||
'DartLexer': ('pygments.lexers.web', 'Dart', ('dart',), ('*.dart',), ('text/x-dart',)),
|
||||
'DebianControlLexer': ('pygments.lexers.text', 'Debian Control file', ('control', 'debcontrol'), ('control',), ()),
|
||||
'DelphiLexer': ('pygments.lexers.compiled', 'Delphi', ('delphi', 'pas', 'pascal', 'objectpascal'), ('*.pas',), ('text/x-pascal',)),
|
||||
'DgLexer': ('pygments.lexers.agile', 'dg', ('dg',), ('*.dg',), ('text/x-dg',)),
|
||||
'DiffLexer': ('pygments.lexers.text', 'Diff', ('diff', 'udiff'), ('*.diff', '*.patch'), ('text/x-diff', 'text/x-patch')),
|
||||
'DjangoLexer': ('pygments.lexers.templates', 'Django/Jinja', ('django', 'jinja'), (), ('application/x-django-templating', 'application/x-jinja')),
|
||||
'DtdLexer': ('pygments.lexers.web', 'DTD', ('dtd',), ('*.dtd',), ('application/xml-dtd',)),
|
||||
'DuelLexer': ('pygments.lexers.web', 'Duel', ('duel', 'Duel Engine', 'Duel View', 'JBST', 'jbst', 'JsonML+BST'), ('*.duel', '*.jbst'), ('text/x-duel', 'text/x-jbst')),
|
||||
'DylanConsoleLexer': ('pygments.lexers.compiled', 'Dylan session', ('dylan-console', 'dylan-repl'), ('*.dylan-console',), ('text/x-dylan-console',)),
|
||||
'DylanLexer': ('pygments.lexers.compiled', 'Dylan', ('dylan',), ('*.dylan', '*.dyl', '*.intr'), ('text/x-dylan',)),
|
||||
'DylanLidLexer': ('pygments.lexers.compiled', 'DylanLID', ('dylan-lid', 'lid'), ('*.lid', '*.hdp'), ('text/x-dylan-lid',)),
|
||||
'ECLLexer': ('pygments.lexers.other', 'ECL', ('ecl',), ('*.ecl',), ('application/x-ecl',)),
|
||||
'ECLexer': ('pygments.lexers.compiled', 'eC', ('ec',), ('*.ec', '*.eh'), ('text/x-echdr', 'text/x-ecsrc')),
|
||||
'EbnfLexer': ('pygments.lexers.text', 'EBNF', ('ebnf',), ('*.ebnf',), ('text/x-ebnf',)),
|
||||
'ElixirConsoleLexer': ('pygments.lexers.functional', 'Elixir iex session', ('iex',), (), ('text/x-elixir-shellsession',)),
|
||||
'ElixirLexer': ('pygments.lexers.functional', 'Elixir', ('elixir', 'ex', 'exs'), ('*.ex', '*.exs'), ('text/x-elixir',)),
|
||||
'ErbLexer': ('pygments.lexers.templates', 'ERB', ('erb',), (), ('application/x-ruby-templating',)),
|
||||
'ErlangLexer': ('pygments.lexers.functional', 'Erlang', ('erlang',), ('*.erl', '*.hrl', '*.es', '*.escript'), ('text/x-erlang',)),
|
||||
'ErlangShellLexer': ('pygments.lexers.functional', 'Erlang erl session', ('erl',), ('*.erl-sh',), ('text/x-erl-shellsession',)),
|
||||
'EvoqueHtmlLexer': ('pygments.lexers.templates', 'HTML+Evoque', ('html+evoque',), ('*.html',), ('text/html+evoque',)),
|
||||
'EvoqueLexer': ('pygments.lexers.templates', 'Evoque', ('evoque',), ('*.evoque',), ('application/x-evoque',)),
|
||||
'EvoqueXmlLexer': ('pygments.lexers.templates', 'XML+Evoque', ('xml+evoque',), ('*.xml',), ('application/xml+evoque',)),
|
||||
'FSharpLexer': ('pygments.lexers.dotnet', 'FSharp', ('fsharp',), ('*.fs', '*.fsi'), ('text/x-fsharp',)),
|
||||
'FactorLexer': ('pygments.lexers.agile', 'Factor', ('factor',), ('*.factor',), ('text/x-factor',)),
|
||||
'FancyLexer': ('pygments.lexers.agile', 'Fancy', ('fancy', 'fy'), ('*.fy', '*.fancypack'), ('text/x-fancysrc',)),
|
||||
'FantomLexer': ('pygments.lexers.compiled', 'Fantom', ('fan',), ('*.fan',), ('application/x-fantom',)),
|
||||
'FelixLexer': ('pygments.lexers.compiled', 'Felix', ('felix', 'flx'), ('*.flx', '*.flxh'), ('text/x-felix',)),
|
||||
'FortranLexer': ('pygments.lexers.compiled', 'Fortran', ('fortran',), ('*.f', '*.f90', '*.F', '*.F90'), ('text/x-fortran',)),
|
||||
'FoxProLexer': ('pygments.lexers.foxpro', 'FoxPro', ('Clipper', 'XBase'), ('*.PRG', '*.prg'), ()),
|
||||
'GLShaderLexer': ('pygments.lexers.compiled', 'GLSL', ('glsl',), ('*.vert', '*.frag', '*.geo'), ('text/x-glslsrc',)),
|
||||
'GasLexer': ('pygments.lexers.asm', 'GAS', ('gas', 'asm'), ('*.s', '*.S'), ('text/x-gas',)),
|
||||
'GenshiLexer': ('pygments.lexers.templates', 'Genshi', ('genshi', 'kid', 'xml+genshi', 'xml+kid'), ('*.kid',), ('application/x-genshi', 'application/x-kid')),
|
||||
'GenshiTextLexer': ('pygments.lexers.templates', 'Genshi Text', ('genshitext',), (), ('application/x-genshi-text', 'text/x-genshi')),
|
||||
'GettextLexer': ('pygments.lexers.text', 'Gettext Catalog', ('pot', 'po'), ('*.pot', '*.po'), ('application/x-gettext', 'text/x-gettext', 'text/gettext')),
|
||||
'GherkinLexer': ('pygments.lexers.other', 'Gherkin', ('Cucumber', 'cucumber', 'Gherkin', 'gherkin'), ('*.feature',), ('text/x-gherkin',)),
|
||||
'GnuplotLexer': ('pygments.lexers.other', 'Gnuplot', ('gnuplot',), ('*.plot', '*.plt'), ('text/x-gnuplot',)),
|
||||
'GoLexer': ('pygments.lexers.compiled', 'Go', ('go',), ('*.go',), ('text/x-gosrc',)),
|
||||
'GoodDataCLLexer': ('pygments.lexers.other', 'GoodData-CL', ('gooddata-cl',), ('*.gdc',), ('text/x-gooddata-cl',)),
|
||||
'GosuLexer': ('pygments.lexers.jvm', 'Gosu', ('gosu',), ('*.gs', '*.gsx', '*.gsp', '*.vark'), ('text/x-gosu',)),
|
||||
'GosuTemplateLexer': ('pygments.lexers.jvm', 'Gosu Template', ('gst',), ('*.gst',), ('text/x-gosu-template',)),
|
||||
'GroffLexer': ('pygments.lexers.text', 'Groff', ('groff', 'nroff', 'man'), ('*.[1234567]', '*.man'), ('application/x-troff', 'text/troff')),
|
||||
'GroovyLexer': ('pygments.lexers.jvm', 'Groovy', ('groovy',), ('*.groovy',), ('text/x-groovy',)),
|
||||
'HamlLexer': ('pygments.lexers.web', 'Haml', ('haml', 'HAML'), ('*.haml',), ('text/x-haml',)),
|
||||
'HaskellLexer': ('pygments.lexers.functional', 'Haskell', ('haskell', 'hs'), ('*.hs',), ('text/x-haskell',)),
|
||||
'HaxeLexer': ('pygments.lexers.web', 'Haxe', ('hx', 'Haxe', 'haxe', 'haXe', 'hxsl'), ('*.hx', '*.hxsl'), ('text/haxe', 'text/x-haxe', 'text/x-hx')),
|
||||
'HtmlDjangoLexer': ('pygments.lexers.templates', 'HTML+Django/Jinja', ('html+django', 'html+jinja', 'htmldjango'), (), ('text/html+django', 'text/html+jinja')),
|
||||
'HtmlGenshiLexer': ('pygments.lexers.templates', 'HTML+Genshi', ('html+genshi', 'html+kid'), (), ('text/html+genshi',)),
|
||||
'HtmlLexer': ('pygments.lexers.web', 'HTML', ('html',), ('*.html', '*.htm', '*.xhtml', '*.xslt'), ('text/html', 'application/xhtml+xml')),
|
||||
'HtmlPhpLexer': ('pygments.lexers.templates', 'HTML+PHP', ('html+php',), ('*.phtml',), ('application/x-php', 'application/x-httpd-php', 'application/x-httpd-php3', 'application/x-httpd-php4', 'application/x-httpd-php5')),
|
||||
'HtmlSmartyLexer': ('pygments.lexers.templates', 'HTML+Smarty', ('html+smarty',), (), ('text/html+smarty',)),
|
||||
'HttpLexer': ('pygments.lexers.text', 'HTTP', ('http',), (), ()),
|
||||
'HxmlLexer': ('pygments.lexers.text', 'Hxml', ('haxeml', 'hxml'), ('*.hxml',), ()),
|
||||
'HybrisLexer': ('pygments.lexers.other', 'Hybris', ('hybris', 'hy'), ('*.hy', '*.hyb'), ('text/x-hybris', 'application/x-hybris')),
|
||||
'IDLLexer': ('pygments.lexers.math', 'IDL', ('idl',), ('*.pro',), ('text/idl',)),
|
||||
'IgorLexer': ('pygments.lexers.math', 'Igor', ('igor', 'igorpro'), ('*.ipf',), ('text/ipf',)),
|
||||
'IniLexer': ('pygments.lexers.text', 'INI', ('ini', 'cfg', 'dosini'), ('*.ini', '*.cfg'), ('text/x-ini',)),
|
||||
'IoLexer': ('pygments.lexers.agile', 'Io', ('io',), ('*.io',), ('text/x-iosrc',)),
|
||||
'IokeLexer': ('pygments.lexers.jvm', 'Ioke', ('ioke', 'ik'), ('*.ik',), ('text/x-iokesrc',)),
|
||||
'IrcLogsLexer': ('pygments.lexers.text', 'IRC logs', ('irc',), ('*.weechatlog',), ('text/x-irclog',)),
|
||||
'JadeLexer': ('pygments.lexers.web', 'Jade', ('jade', 'JADE'), ('*.jade',), ('text/x-jade',)),
|
||||
'JagsLexer': ('pygments.lexers.math', 'JAGS', ('jags',), ('*.jag', '*.bug'), ()),
|
||||
'JavaLexer': ('pygments.lexers.jvm', 'Java', ('java',), ('*.java',), ('text/x-java',)),
|
||||
'JavascriptDjangoLexer': ('pygments.lexers.templates', 'JavaScript+Django/Jinja', ('js+django', 'javascript+django', 'js+jinja', 'javascript+jinja'), (), ('application/x-javascript+django', 'application/x-javascript+jinja', 'text/x-javascript+django', 'text/x-javascript+jinja', 'text/javascript+django', 'text/javascript+jinja')),
|
||||
'JavascriptErbLexer': ('pygments.lexers.templates', 'JavaScript+Ruby', ('js+erb', 'javascript+erb', 'js+ruby', 'javascript+ruby'), (), ('application/x-javascript+ruby', 'text/x-javascript+ruby', 'text/javascript+ruby')),
|
||||
'JavascriptGenshiLexer': ('pygments.lexers.templates', 'JavaScript+Genshi Text', ('js+genshitext', 'js+genshi', 'javascript+genshitext', 'javascript+genshi'), (), ('application/x-javascript+genshi', 'text/x-javascript+genshi', 'text/javascript+genshi')),
|
||||
'JavascriptLexer': ('pygments.lexers.web', 'JavaScript', ('js', 'javascript'), ('*.js',), ('application/javascript', 'application/x-javascript', 'text/x-javascript', 'text/javascript')),
|
||||
'JavascriptPhpLexer': ('pygments.lexers.templates', 'JavaScript+PHP', ('js+php', 'javascript+php'), (), ('application/x-javascript+php', 'text/x-javascript+php', 'text/javascript+php')),
|
||||
'JavascriptSmartyLexer': ('pygments.lexers.templates', 'JavaScript+Smarty', ('js+smarty', 'javascript+smarty'), (), ('application/x-javascript+smarty', 'text/x-javascript+smarty', 'text/javascript+smarty')),
|
||||
'JsonLexer': ('pygments.lexers.web', 'JSON', ('json',), ('*.json',), ('application/json',)),
|
||||
'JspLexer': ('pygments.lexers.templates', 'Java Server Page', ('jsp',), ('*.jsp',), ('application/x-jsp',)),
|
||||
'JuliaConsoleLexer': ('pygments.lexers.math', 'Julia console', ('jlcon',), (), ()),
|
||||
'JuliaLexer': ('pygments.lexers.math', 'Julia', ('julia', 'jl'), ('*.jl',), ('text/x-julia', 'application/x-julia')),
|
||||
'KconfigLexer': ('pygments.lexers.other', 'Kconfig', ('kconfig', 'menuconfig', 'linux-config', 'kernel-config'), ('Kconfig', '*Config.in*', 'external.in*', 'standard-modules.in'), ('text/x-kconfig',)),
|
||||
'KokaLexer': ('pygments.lexers.functional', 'Koka', ('koka',), ('*.kk', '*.kki'), ('text/x-koka',)),
|
||||
'KotlinLexer': ('pygments.lexers.jvm', 'Kotlin', ('kotlin',), ('*.kt',), ('text/x-kotlin',)),
|
||||
'LassoCssLexer': ('pygments.lexers.templates', 'CSS+Lasso', ('css+lasso',), (), ('text/css+lasso',)),
|
||||
'LassoHtmlLexer': ('pygments.lexers.templates', 'HTML+Lasso', ('html+lasso',), (), ('text/html+lasso', 'application/x-httpd-lasso', 'application/x-httpd-lasso[89]')),
|
||||
'LassoJavascriptLexer': ('pygments.lexers.templates', 'JavaScript+Lasso', ('js+lasso', 'javascript+lasso'), (), ('application/x-javascript+lasso', 'text/x-javascript+lasso', 'text/javascript+lasso')),
|
||||
'LassoLexer': ('pygments.lexers.web', 'Lasso', ('lasso', 'lassoscript'), ('*.lasso', '*.lasso[89]'), ('text/x-lasso',)),
|
||||
'LassoXmlLexer': ('pygments.lexers.templates', 'XML+Lasso', ('xml+lasso',), (), ('application/xml+lasso',)),
|
||||
'LighttpdConfLexer': ('pygments.lexers.text', 'Lighttpd configuration file', ('lighty', 'lighttpd'), (), ('text/x-lighttpd-conf',)),
|
||||
'LiterateAgdaLexer': ('pygments.lexers.functional', 'Literate Agda', ('lagda', 'literate-agda'), ('*.lagda',), ('text/x-literate-agda',)),
|
||||
'LiterateHaskellLexer': ('pygments.lexers.functional', 'Literate Haskell', ('lhs', 'literate-haskell', 'lhaskell'), ('*.lhs',), ('text/x-literate-haskell',)),
|
||||
'LiveScriptLexer': ('pygments.lexers.web', 'LiveScript', ('live-script', 'livescript'), ('*.ls',), ('text/livescript',)),
|
||||
'LlvmLexer': ('pygments.lexers.asm', 'LLVM', ('llvm',), ('*.ll',), ('text/x-llvm',)),
|
||||
'LogosLexer': ('pygments.lexers.compiled', 'Logos', ('logos',), ('*.x', '*.xi', '*.xm', '*.xmi'), ('text/x-logos',)),
|
||||
'LogtalkLexer': ('pygments.lexers.other', 'Logtalk', ('logtalk',), ('*.lgt',), ('text/x-logtalk',)),
|
||||
'LuaLexer': ('pygments.lexers.agile', 'Lua', ('lua',), ('*.lua', '*.wlua'), ('text/x-lua', 'application/x-lua')),
|
||||
'MOOCodeLexer': ('pygments.lexers.other', 'MOOCode', ('moocode', 'moo'), ('*.moo',), ('text/x-moocode',)),
|
||||
'MakefileLexer': ('pygments.lexers.text', 'Makefile', ('make', 'makefile', 'mf', 'bsdmake'), ('*.mak', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'), ('text/x-makefile',)),
|
||||
'MakoCssLexer': ('pygments.lexers.templates', 'CSS+Mako', ('css+mako',), (), ('text/css+mako',)),
|
||||
'MakoHtmlLexer': ('pygments.lexers.templates', 'HTML+Mako', ('html+mako',), (), ('text/html+mako',)),
|
||||
'MakoJavascriptLexer': ('pygments.lexers.templates', 'JavaScript+Mako', ('js+mako', 'javascript+mako'), (), ('application/x-javascript+mako', 'text/x-javascript+mako', 'text/javascript+mako')),
|
||||
'MakoLexer': ('pygments.lexers.templates', 'Mako', ('mako',), ('*.mao',), ('application/x-mako',)),
|
||||
'MakoXmlLexer': ('pygments.lexers.templates', 'XML+Mako', ('xml+mako',), (), ('application/xml+mako',)),
|
||||
'MaqlLexer': ('pygments.lexers.other', 'MAQL', ('maql',), ('*.maql',), ('text/x-gooddata-maql', 'application/x-gooddata-maql')),
|
||||
'MasonLexer': ('pygments.lexers.templates', 'Mason', ('mason',), ('*.m', '*.mhtml', '*.mc', '*.mi', 'autohandler', 'dhandler'), ('application/x-mason',)),
|
||||
'MatlabLexer': ('pygments.lexers.math', 'Matlab', ('matlab',), ('*.m',), ('text/matlab',)),
|
||||
'MatlabSessionLexer': ('pygments.lexers.math', 'Matlab session', ('matlabsession',), (), ()),
|
||||
'MiniDLexer': ('pygments.lexers.agile', 'MiniD', ('minid',), ('*.md',), ('text/x-minidsrc',)),
|
||||
'ModelicaLexer': ('pygments.lexers.other', 'Modelica', ('modelica',), ('*.mo',), ('text/x-modelica',)),
|
||||
'Modula2Lexer': ('pygments.lexers.compiled', 'Modula-2', ('modula2', 'm2'), ('*.def', '*.mod'), ('text/x-modula2',)),
|
||||
'MoinWikiLexer': ('pygments.lexers.text', 'MoinMoin/Trac Wiki markup', ('trac-wiki', 'moin'), (), ('text/x-trac-wiki',)),
|
||||
'MonkeyLexer': ('pygments.lexers.compiled', 'Monkey', ('monkey',), ('*.monkey',), ('text/x-monkey',)),
|
||||
'MoonScriptLexer': ('pygments.lexers.agile', 'MoonScript', ('moon', 'moonscript'), ('*.moon',), ('text/x-moonscript', 'application/x-moonscript')),
|
||||
'MscgenLexer': ('pygments.lexers.other', 'Mscgen', ('mscgen', 'msc'), ('*.msc',), ()),
|
||||
'MuPADLexer': ('pygments.lexers.math', 'MuPAD', ('mupad',), ('*.mu',), ()),
|
||||
'MxmlLexer': ('pygments.lexers.web', 'MXML', ('mxml',), ('*.mxml',), ()),
|
||||
'MySqlLexer': ('pygments.lexers.sql', 'MySQL', ('mysql',), (), ('text/x-mysql',)),
|
||||
'MyghtyCssLexer': ('pygments.lexers.templates', 'CSS+Myghty', ('css+myghty',), (), ('text/css+myghty',)),
|
||||
'MyghtyHtmlLexer': ('pygments.lexers.templates', 'HTML+Myghty', ('html+myghty',), (), ('text/html+myghty',)),
|
||||
'MyghtyJavascriptLexer': ('pygments.lexers.templates', 'JavaScript+Myghty', ('js+myghty', 'javascript+myghty'), (), ('application/x-javascript+myghty', 'text/x-javascript+myghty', 'text/javascript+mygthy')),
|
||||
'MyghtyLexer': ('pygments.lexers.templates', 'Myghty', ('myghty',), ('*.myt', 'autodelegate'), ('application/x-myghty',)),
|
||||
'MyghtyXmlLexer': ('pygments.lexers.templates', 'XML+Myghty', ('xml+myghty',), (), ('application/xml+myghty',)),
|
||||
'NSISLexer': ('pygments.lexers.other', 'NSIS', ('nsis', 'nsi', 'nsh'), ('*.nsi', '*.nsh'), ('text/x-nsis',)),
|
||||
'NasmLexer': ('pygments.lexers.asm', 'NASM', ('nasm',), ('*.asm', '*.ASM'), ('text/x-nasm',)),
|
||||
'NemerleLexer': ('pygments.lexers.dotnet', 'Nemerle', ('nemerle',), ('*.n',), ('text/x-nemerle',)),
|
||||
'NesCLexer': ('pygments.lexers.compiled', 'nesC', ('nesc',), ('*.nc',), ('text/x-nescsrc',)),
|
||||
'NewLispLexer': ('pygments.lexers.functional', 'NewLisp', ('newlisp',), ('*.lsp', '*.nl'), ('text/x-newlisp', 'application/x-newlisp')),
|
||||
'NewspeakLexer': ('pygments.lexers.other', 'Newspeak', ('newspeak',), ('*.ns2',), ('text/x-newspeak',)),
|
||||
'NginxConfLexer': ('pygments.lexers.text', 'Nginx configuration file', ('nginx',), (), ('text/x-nginx-conf',)),
|
||||
'NimrodLexer': ('pygments.lexers.compiled', 'Nimrod', ('nimrod', 'nim'), ('*.nim', '*.nimrod'), ('text/x-nimrod',)),
|
||||
'NumPyLexer': ('pygments.lexers.math', 'NumPy', ('numpy',), (), ()),
|
||||
'ObjdumpLexer': ('pygments.lexers.asm', 'objdump', ('objdump',), ('*.objdump',), ('text/x-objdump',)),
|
||||
'ObjectiveCLexer': ('pygments.lexers.compiled', 'Objective-C', ('objective-c', 'objectivec', 'obj-c', 'objc'), ('*.m', '*.h'), ('text/x-objective-c',)),
|
||||
'ObjectiveCppLexer': ('pygments.lexers.compiled', 'Objective-C++', ('objective-c++', 'objectivec++', 'obj-c++', 'objc++'), ('*.mm', '*.hh'), ('text/x-objective-c++',)),
|
||||
'ObjectiveJLexer': ('pygments.lexers.web', 'Objective-J', ('objective-j', 'objectivej', 'obj-j', 'objj'), ('*.j',), ('text/x-objective-j',)),
|
||||
'OcamlLexer': ('pygments.lexers.functional', 'OCaml', ('ocaml',), ('*.ml', '*.mli', '*.mll', '*.mly'), ('text/x-ocaml',)),
|
||||
'OctaveLexer': ('pygments.lexers.math', 'Octave', ('octave',), ('*.m',), ('text/octave',)),
|
||||
'OocLexer': ('pygments.lexers.compiled', 'Ooc', ('ooc',), ('*.ooc',), ('text/x-ooc',)),
|
||||
'OpaLexer': ('pygments.lexers.functional', 'Opa', ('opa',), ('*.opa',), ('text/x-opa',)),
|
||||
'OpenEdgeLexer': ('pygments.lexers.other', 'OpenEdge ABL', ('openedge', 'abl', 'progress'), ('*.p', '*.cls'), ('text/x-openedge', 'application/x-openedge')),
|
||||
'Perl6Lexer': ('pygments.lexers.agile', 'Perl6', ('perl6', 'pl6'), ('*.pl', '*.pm', '*.nqp', '*.p6', '*.6pl', '*.p6l', '*.pl6', '*.6pm', '*.p6m', '*.pm6'), ('text/x-perl6', 'application/x-perl6')),
|
||||
'PerlLexer': ('pygments.lexers.agile', 'Perl', ('perl', 'pl'), ('*.pl', '*.pm'), ('text/x-perl', 'application/x-perl')),
|
||||
'PhpLexer': ('pygments.lexers.web', 'PHP', ('php', 'php3', 'php4', 'php5'), ('*.php', '*.php[345]', '*.inc'), ('text/x-php',)),
|
||||
'PlPgsqlLexer': ('pygments.lexers.sql', 'PL/pgSQL', ('plpgsql',), (), ('text/x-plpgsql',)),
|
||||
'PostScriptLexer': ('pygments.lexers.other', 'PostScript', ('postscript', 'postscr'), ('*.ps', '*.eps'), ('application/postscript',)),
|
||||
'PostgresConsoleLexer': ('pygments.lexers.sql', 'PostgreSQL console (psql)', ('psql', 'postgresql-console', 'postgres-console'), (), ('text/x-postgresql-psql',)),
|
||||
'PostgresLexer': ('pygments.lexers.sql', 'PostgreSQL SQL dialect', ('postgresql', 'postgres'), (), ('text/x-postgresql',)),
|
||||
'PovrayLexer': ('pygments.lexers.other', 'POVRay', ('pov',), ('*.pov', '*.inc'), ('text/x-povray',)),
|
||||
'PowerShellLexer': ('pygments.lexers.shell', 'PowerShell', ('powershell', 'posh', 'ps1', 'psm1'), ('*.ps1', '*.psm1'), ('text/x-powershell',)),
|
||||
'PrologLexer': ('pygments.lexers.compiled', 'Prolog', ('prolog',), ('*.prolog', '*.pro', '*.pl'), ('text/x-prolog',)),
|
||||
'PropertiesLexer': ('pygments.lexers.text', 'Properties', ('properties', 'jproperties'), ('*.properties',), ('text/x-java-properties',)),
|
||||
'ProtoBufLexer': ('pygments.lexers.other', 'Protocol Buffer', ('protobuf', 'proto'), ('*.proto',), ()),
|
||||
'PuppetLexer': ('pygments.lexers.other', 'Puppet', ('puppet',), ('*.pp',), ()),
|
||||
'PyPyLogLexer': ('pygments.lexers.text', 'PyPy Log', ('pypylog', 'pypy'), ('*.pypylog',), ('application/x-pypylog',)),
|
||||
'Python3Lexer': ('pygments.lexers.agile', 'Python 3', ('python3', 'py3'), (), ('text/x-python3', 'application/x-python3')),
|
||||
'Python3TracebackLexer': ('pygments.lexers.agile', 'Python 3.0 Traceback', ('py3tb',), ('*.py3tb',), ('text/x-python3-traceback',)),
|
||||
'PythonConsoleLexer': ('pygments.lexers.agile', 'Python console session', ('pycon',), (), ('text/x-python-doctest',)),
|
||||
'PythonLexer': ('pygments.lexers.agile', 'Python', ('python', 'py', 'sage'), ('*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac', '*.sage'), ('text/x-python', 'application/x-python')),
|
||||
'PythonTracebackLexer': ('pygments.lexers.agile', 'Python Traceback', ('pytb',), ('*.pytb',), ('text/x-python-traceback',)),
|
||||
'QmlLexer': ('pygments.lexers.web', 'QML', ('qml', 'Qt Meta Language', 'Qt modeling Language'), ('*.qml',), ('application/x-qml',)),
|
||||
'RConsoleLexer': ('pygments.lexers.math', 'RConsole', ('rconsole', 'rout'), ('*.Rout',), ()),
|
||||
'RPMSpecLexer': ('pygments.lexers.other', 'RPMSpec', ('spec',), ('*.spec',), ('text/x-rpm-spec',)),
|
||||
'RacketLexer': ('pygments.lexers.functional', 'Racket', ('racket', 'rkt'), ('*.rkt', '*.rktl'), ('text/x-racket', 'application/x-racket')),
|
||||
'RagelCLexer': ('pygments.lexers.parsers', 'Ragel in C Host', ('ragel-c',), ('*.rl',), ()),
|
||||
'RagelCppLexer': ('pygments.lexers.parsers', 'Ragel in CPP Host', ('ragel-cpp',), ('*.rl',), ()),
|
||||
'RagelDLexer': ('pygments.lexers.parsers', 'Ragel in D Host', ('ragel-d',), ('*.rl',), ()),
|
||||
'RagelEmbeddedLexer': ('pygments.lexers.parsers', 'Embedded Ragel', ('ragel-em',), ('*.rl',), ()),
|
||||
'RagelJavaLexer': ('pygments.lexers.parsers', 'Ragel in Java Host', ('ragel-java',), ('*.rl',), ()),
|
||||
'RagelLexer': ('pygments.lexers.parsers', 'Ragel', ('ragel',), (), ()),
|
||||
'RagelObjectiveCLexer': ('pygments.lexers.parsers', 'Ragel in Objective C Host', ('ragel-objc',), ('*.rl',), ()),
|
||||
'RagelRubyLexer': ('pygments.lexers.parsers', 'Ragel in Ruby Host', ('ragel-ruby', 'ragel-rb'), ('*.rl',), ()),
|
||||
'RawTokenLexer': ('pygments.lexers.special', 'Raw token data', ('raw',), (), ('application/x-pygments-tokens',)),
|
||||
'RdLexer': ('pygments.lexers.math', 'Rd', ('rd',), ('*.Rd',), ('text/x-r-doc',)),
|
||||
'RebolLexer': ('pygments.lexers.other', 'REBOL', ('rebol',), ('*.r', '*.r3'), ('text/x-rebol',)),
|
||||
'RedcodeLexer': ('pygments.lexers.other', 'Redcode', ('redcode',), ('*.cw',), ()),
|
||||
'RegeditLexer': ('pygments.lexers.text', 'reg', ('registry',), ('*.reg',), ('text/x-windows-registry',)),
|
||||
'RexxLexer': ('pygments.lexers.other', 'Rexx', ('rexx', 'ARexx', 'arexx'), ('*.rexx', '*.rex', '*.rx', '*.arexx'), ('text/x-rexx',)),
|
||||
'RhtmlLexer': ('pygments.lexers.templates', 'RHTML', ('rhtml', 'html+erb', 'html+ruby'), ('*.rhtml',), ('text/html+ruby',)),
|
||||
'RobotFrameworkLexer': ('pygments.lexers.other', 'RobotFramework', ('RobotFramework', 'robotframework'), ('*.txt', '*.robot'), ('text/x-robotframework',)),
|
||||
'RstLexer': ('pygments.lexers.text', 'reStructuredText', ('rst', 'rest', 'restructuredtext'), ('*.rst', '*.rest'), ('text/x-rst', 'text/prs.fallenstein.rst')),
|
||||
'RubyConsoleLexer': ('pygments.lexers.agile', 'Ruby irb session', ('rbcon', 'irb'), (), ('text/x-ruby-shellsession',)),
|
||||
'RubyLexer': ('pygments.lexers.agile', 'Ruby', ('rb', 'ruby', 'duby'), ('*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec', '*.rbx', '*.duby'), ('text/x-ruby', 'application/x-ruby')),
|
||||
'RustLexer': ('pygments.lexers.compiled', 'Rust', ('rust',), ('*.rs', '*.rc'), ('text/x-rustsrc',)),
|
||||
'SLexer': ('pygments.lexers.math', 'S', ('splus', 's', 'r'), ('*.S', '*.R', '.Rhistory', '.Rprofile'), ('text/S-plus', 'text/S', 'text/x-r-source', 'text/x-r', 'text/x-R', 'text/x-r-history', 'text/x-r-profile')),
|
||||
'SMLLexer': ('pygments.lexers.functional', 'Standard ML', ('sml',), ('*.sml', '*.sig', '*.fun'), ('text/x-standardml', 'application/x-standardml')),
|
||||
'SassLexer': ('pygments.lexers.web', 'Sass', ('sass', 'SASS'), ('*.sass',), ('text/x-sass',)),
|
||||
'ScalaLexer': ('pygments.lexers.jvm', 'Scala', ('scala',), ('*.scala',), ('text/x-scala',)),
|
||||
'ScamlLexer': ('pygments.lexers.web', 'Scaml', ('scaml', 'SCAML'), ('*.scaml',), ('text/x-scaml',)),
|
||||
'SchemeLexer': ('pygments.lexers.functional', 'Scheme', ('scheme', 'scm'), ('*.scm', '*.ss'), ('text/x-scheme', 'application/x-scheme')),
|
||||
'ScilabLexer': ('pygments.lexers.math', 'Scilab', ('scilab',), ('*.sci', '*.sce', '*.tst'), ('text/scilab',)),
|
||||
'ScssLexer': ('pygments.lexers.web', 'SCSS', ('scss',), ('*.scss',), ('text/x-scss',)),
|
||||
'ShellSessionLexer': ('pygments.lexers.shell', 'Shell Session', ('shell-session',), ('*.shell-session',), ('application/x-sh-session',)),
|
||||
'SmaliLexer': ('pygments.lexers.dalvik', 'Smali', ('smali',), ('*.smali',), ('text/smali',)),
|
||||
'SmalltalkLexer': ('pygments.lexers.other', 'Smalltalk', ('smalltalk', 'squeak', 'st'), ('*.st',), ('text/x-smalltalk',)),
|
||||
'SmartyLexer': ('pygments.lexers.templates', 'Smarty', ('smarty',), ('*.tpl',), ('application/x-smarty',)),
|
||||
'SnobolLexer': ('pygments.lexers.other', 'Snobol', ('snobol',), ('*.snobol',), ('text/x-snobol',)),
|
||||
'SourcePawnLexer': ('pygments.lexers.other', 'SourcePawn', ('sp',), ('*.sp',), ('text/x-sourcepawn',)),
|
||||
'SourcesListLexer': ('pygments.lexers.text', 'Debian Sourcelist', ('sourceslist', 'sources.list', 'debsources'), ('sources.list',), ()),
|
||||
'SqlLexer': ('pygments.lexers.sql', 'SQL', ('sql',), ('*.sql',), ('text/x-sql',)),
|
||||
'SqliteConsoleLexer': ('pygments.lexers.sql', 'sqlite3con', ('sqlite3',), ('*.sqlite3-console',), ('text/x-sqlite3-console',)),
|
||||
'SquidConfLexer': ('pygments.lexers.text', 'SquidConf', ('squidconf', 'squid.conf', 'squid'), ('squid.conf',), ('text/x-squidconf',)),
|
||||
'SspLexer': ('pygments.lexers.templates', 'Scalate Server Page', ('ssp',), ('*.ssp',), ('application/x-ssp',)),
|
||||
'StanLexer': ('pygments.lexers.math', 'Stan', ('stan',), ('*.stan',), ()),
|
||||
'SwigLexer': ('pygments.lexers.compiled', 'SWIG', ('Swig', 'swig'), ('*.swg', '*.i'), ('text/swig',)),
|
||||
'SystemVerilogLexer': ('pygments.lexers.hdl', 'systemverilog', ('systemverilog', 'sv'), ('*.sv', '*.svh'), ('text/x-systemverilog',)),
|
||||
'TclLexer': ('pygments.lexers.agile', 'Tcl', ('tcl',), ('*.tcl',), ('text/x-tcl', 'text/x-script.tcl', 'application/x-tcl')),
|
||||
'TcshLexer': ('pygments.lexers.shell', 'Tcsh', ('tcsh', 'csh'), ('*.tcsh', '*.csh'), ('application/x-csh',)),
|
||||
'TeaTemplateLexer': ('pygments.lexers.templates', 'Tea', ('tea',), ('*.tea',), ('text/x-tea',)),
|
||||
'TexLexer': ('pygments.lexers.text', 'TeX', ('tex', 'latex'), ('*.tex', '*.aux', '*.toc'), ('text/x-tex', 'text/x-latex')),
|
||||
'TextLexer': ('pygments.lexers.special', 'Text only', ('text',), ('*.txt',), ('text/plain',)),
|
||||
'TreetopLexer': ('pygments.lexers.parsers', 'Treetop', ('treetop',), ('*.treetop', '*.tt'), ()),
|
||||
'TypeScriptLexer': ('pygments.lexers.web', 'TypeScript', ('ts',), ('*.ts',), ('text/x-typescript',)),
|
||||
'UrbiscriptLexer': ('pygments.lexers.other', 'UrbiScript', ('urbiscript',), ('*.u',), ('application/x-urbiscript',)),
|
||||
'VGLLexer': ('pygments.lexers.other', 'VGL', ('vgl',), ('*.rpf',), ()),
|
||||
'ValaLexer': ('pygments.lexers.compiled', 'Vala', ('vala', 'vapi'), ('*.vala', '*.vapi'), ('text/x-vala',)),
|
||||
'VbNetAspxLexer': ('pygments.lexers.dotnet', 'aspx-vb', ('aspx-vb',), ('*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd'), ()),
|
||||
'VbNetLexer': ('pygments.lexers.dotnet', 'VB.net', ('vb.net', 'vbnet'), ('*.vb', '*.bas'), ('text/x-vbnet', 'text/x-vba')),
|
||||
'VelocityHtmlLexer': ('pygments.lexers.templates', 'HTML+Velocity', ('html+velocity',), (), ('text/html+velocity',)),
|
||||
'VelocityLexer': ('pygments.lexers.templates', 'Velocity', ('velocity',), ('*.vm', '*.fhtml'), ()),
|
||||
'VelocityXmlLexer': ('pygments.lexers.templates', 'XML+Velocity', ('xml+velocity',), (), ('application/xml+velocity',)),
|
||||
'VerilogLexer': ('pygments.lexers.hdl', 'verilog', ('verilog', 'v'), ('*.v',), ('text/x-verilog',)),
|
||||
'VhdlLexer': ('pygments.lexers.hdl', 'vhdl', ('vhdl',), ('*.vhdl', '*.vhd'), ('text/x-vhdl',)),
|
||||
'VimLexer': ('pygments.lexers.text', 'VimL', ('vim',), ('*.vim', '.vimrc', '.exrc', '.gvimrc', '_vimrc', '_exrc', '_gvimrc', 'vimrc', 'gvimrc'), ('text/x-vim',)),
|
||||
'XQueryLexer': ('pygments.lexers.web', 'XQuery', ('xquery', 'xqy', 'xq', 'xql', 'xqm'), ('*.xqy', '*.xquery', '*.xq', '*.xql', '*.xqm'), ('text/xquery', 'application/xquery')),
|
||||
'XmlDjangoLexer': ('pygments.lexers.templates', 'XML+Django/Jinja', ('xml+django', 'xml+jinja'), (), ('application/xml+django', 'application/xml+jinja')),
|
||||
'XmlErbLexer': ('pygments.lexers.templates', 'XML+Ruby', ('xml+erb', 'xml+ruby'), (), ('application/xml+ruby',)),
|
||||
'XmlLexer': ('pygments.lexers.web', 'XML', ('xml',), ('*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.wsf'), ('text/xml', 'application/xml', 'image/svg+xml', 'application/rss+xml', 'application/atom+xml')),
|
||||
'XmlPhpLexer': ('pygments.lexers.templates', 'XML+PHP', ('xml+php',), (), ('application/xml+php',)),
|
||||
'XmlSmartyLexer': ('pygments.lexers.templates', 'XML+Smarty', ('xml+smarty',), (), ('application/xml+smarty',)),
|
||||
'XsltLexer': ('pygments.lexers.web', 'XSLT', ('xslt',), ('*.xsl', '*.xslt', '*.xpl'), ('application/xsl+xml', 'application/xslt+xml')),
|
||||
'XtendLexer': ('pygments.lexers.jvm', 'Xtend', ('xtend',), ('*.xtend',), ('text/x-xtend',)),
|
||||
'YamlLexer': ('pygments.lexers.text', 'YAML', ('yaml',), ('*.yaml', '*.yml'), ('text/x-yaml',)),
|
||||
}
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
import os
|
||||
|
||||
# lookup lexers
|
||||
found_lexers = []
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
|
||||
for filename in os.listdir('.'):
|
||||
if filename.endswith('.py') and not filename.startswith('_'):
|
||||
module_name = 'pygments.lexers.%s' % filename[:-3]
|
||||
print module_name
|
||||
module = __import__(module_name, None, None, [''])
|
||||
for lexer_name in module.__all__:
|
||||
lexer = getattr(module, lexer_name)
|
||||
found_lexers.append(
|
||||
'%r: %r' % (lexer_name,
|
||||
(module_name,
|
||||
lexer.name,
|
||||
tuple(lexer.aliases),
|
||||
tuple(lexer.filenames),
|
||||
tuple(lexer.mimetypes))))
|
||||
# sort them, that should make the diff files for svn smaller
|
||||
found_lexers.sort()
|
||||
|
||||
# extract useful sourcecode from this file
|
||||
f = open(__file__)
|
||||
try:
|
||||
content = f.read()
|
||||
finally:
|
||||
f.close()
|
||||
header = content[:content.find('LEXERS = {')]
|
||||
footer = content[content.find("if __name__ == '__main__':"):]
|
||||
|
||||
# write new file
|
||||
f = open(__file__, 'wb')
|
||||
f.write(header)
|
||||
f.write('LEXERS = {\n %s,\n}\n\n' % ',\n '.join(found_lexers))
|
||||
f.write(footer)
|
||||
f.close()
|
|
@ -0,0 +1,562 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._openedgebuiltins
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Builtin list for the OpenEdgeLexer.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
OPENEDGEKEYWORDS = [
|
||||
'ABSOLUTE', 'ABS', 'ABSO', 'ABSOL', 'ABSOLU', 'ABSOLUT', 'ACCELERATOR',
|
||||
'ACCUM', 'ACCUMULATE', 'ACCUM', 'ACCUMU', 'ACCUMUL', 'ACCUMULA',
|
||||
'ACCUMULAT', 'ACTIVE-FORM', 'ACTIVE-WINDOW', 'ADD', 'ADD-BUFFER',
|
||||
'ADD-CALC-COLUMN', 'ADD-COLUMNS-FROM', 'ADD-EVENTS-PROCEDURE',
|
||||
'ADD-FIELDS-FROM', 'ADD-FIRST', 'ADD-INDEX-FIELD', 'ADD-LAST',
|
||||
'ADD-LIKE-COLUMN', 'ADD-LIKE-FIELD', 'ADD-LIKE-INDEX', 'ADD-NEW-FIELD',
|
||||
'ADD-NEW-INDEX', 'ADD-SCHEMA-LOCATION', 'ADD-SUPER-PROCEDURE', 'ADM-DATA',
|
||||
'ADVISE', 'ALERT-BOX', 'ALIAS', 'ALL', 'ALLOW-COLUMN-SEARCHING',
|
||||
'ALLOW-REPLICATION', 'ALTER', 'ALWAYS-ON-TOP', 'AMBIGUOUS', 'AMBIG',
|
||||
'AMBIGU', 'AMBIGUO', 'AMBIGUOU', 'ANALYZE', 'ANALYZ', 'AND', 'ANSI-ONLY',
|
||||
'ANY', 'ANYWHERE', 'APPEND', 'APPL-ALERT-BOXES', 'APPL-ALERT',
|
||||
'APPL-ALERT-', 'APPL-ALERT-B', 'APPL-ALERT-BO', 'APPL-ALERT-BOX',
|
||||
'APPL-ALERT-BOXE', 'APPL-CONTEXT-ID', 'APPLICATION', 'APPLY',
|
||||
'APPSERVER-INFO', 'APPSERVER-PASSWORD', 'APPSERVER-USERID', 'ARRAY-MESSAGE',
|
||||
'AS', 'ASC', 'ASCENDING', 'ASCE', 'ASCEN', 'ASCEND', 'ASCENDI', 'ASCENDIN',
|
||||
'ASK-OVERWRITE', 'ASSEMBLY', 'ASSIGN', 'ASYNCHRONOUS',
|
||||
'ASYNC-REQUEST-COUNT', 'ASYNC-REQUEST-HANDLE', 'AT', 'ATTACHED-PAIRLIST',
|
||||
'ATTR-SPACE', 'ATTR', 'ATTRI', 'ATTRIB', 'ATTRIBU', 'ATTRIBUT',
|
||||
'AUDIT-CONTROL', 'AUDIT-ENABLED', 'AUDIT-EVENT-CONTEXT', 'AUDIT-POLICY',
|
||||
'AUTHENTICATION-FAILED', 'AUTHORIZATION', 'AUTO-COMPLETION', 'AUTO-COMP',
|
||||
'AUTO-COMPL', 'AUTO-COMPLE', 'AUTO-COMPLET', 'AUTO-COMPLETI',
|
||||
'AUTO-COMPLETIO', 'AUTO-ENDKEY', 'AUTO-END-KEY', 'AUTO-GO', 'AUTO-INDENT',
|
||||
'AUTO-IND', 'AUTO-INDE', 'AUTO-INDEN', 'AUTOMATIC', 'AUTO-RESIZE',
|
||||
'AUTO-RETURN', 'AUTO-RET', 'AUTO-RETU', 'AUTO-RETUR', 'AUTO-SYNCHRONIZE',
|
||||
'AUTO-ZAP', 'AUTO-Z', 'AUTO-ZA', 'AVAILABLE', 'AVAIL', 'AVAILA', 'AVAILAB',
|
||||
'AVAILABL', 'AVAILABLE-FORMATS', 'AVERAGE', 'AVE', 'AVER', 'AVERA',
|
||||
'AVERAG', 'AVG', 'BACKGROUND', 'BACK', 'BACKG', 'BACKGR', 'BACKGRO',
|
||||
'BACKGROU', 'BACKGROUN', 'BACKWARDS', 'BACKWARD', 'BASE64-DECODE',
|
||||
'BASE64-ENCODE', 'BASE-ADE', 'BASE-KEY', 'BATCH-MODE', 'BATCH', 'BATCH-',
|
||||
'BATCH-M', 'BATCH-MO', 'BATCH-MOD', 'BATCH-SIZE', 'BEFORE-HIDE', 'BEFORE-H',
|
||||
'BEFORE-HI', 'BEFORE-HID', 'BEGIN-EVENT-GROUP', 'BEGINS', 'BELL', 'BETWEEN',
|
||||
'BGCOLOR', 'BGC', 'BGCO', 'BGCOL', 'BGCOLO', 'BIG-ENDIAN', 'BINARY', 'BIND',
|
||||
'BIND-WHERE', 'BLANK', 'BLOCK-ITERATION-DISPLAY', 'BORDER-BOTTOM-CHARS',
|
||||
'BORDER-B', 'BORDER-BO', 'BORDER-BOT', 'BORDER-BOTT', 'BORDER-BOTTO',
|
||||
'BORDER-BOTTOM-PIXELS', 'BORDER-BOTTOM-P', 'BORDER-BOTTOM-PI',
|
||||
'BORDER-BOTTOM-PIX', 'BORDER-BOTTOM-PIXE', 'BORDER-BOTTOM-PIXEL',
|
||||
'BORDER-LEFT-CHARS', 'BORDER-L', 'BORDER-LE', 'BORDER-LEF', 'BORDER-LEFT',
|
||||
'BORDER-LEFT-', 'BORDER-LEFT-C', 'BORDER-LEFT-CH', 'BORDER-LEFT-CHA',
|
||||
'BORDER-LEFT-CHAR', 'BORDER-LEFT-PIXELS', 'BORDER-LEFT-P', 'BORDER-LEFT-PI',
|
||||
'BORDER-LEFT-PIX', 'BORDER-LEFT-PIXE', 'BORDER-LEFT-PIXEL',
|
||||
'BORDER-RIGHT-CHARS', 'BORDER-R', 'BORDER-RI', 'BORDER-RIG', 'BORDER-RIGH',
|
||||
'BORDER-RIGHT', 'BORDER-RIGHT-', 'BORDER-RIGHT-C', 'BORDER-RIGHT-CH',
|
||||
'BORDER-RIGHT-CHA', 'BORDER-RIGHT-CHAR', 'BORDER-RIGHT-PIXELS',
|
||||
'BORDER-RIGHT-P', 'BORDER-RIGHT-PI', 'BORDER-RIGHT-PIX',
|
||||
'BORDER-RIGHT-PIXE', 'BORDER-RIGHT-PIXEL', 'BORDER-TOP-CHARS', 'BORDER-T',
|
||||
'BORDER-TO', 'BORDER-TOP', 'BORDER-TOP-', 'BORDER-TOP-C', 'BORDER-TOP-CH',
|
||||
'BORDER-TOP-CHA', 'BORDER-TOP-CHAR', 'BORDER-TOP-PIXELS', 'BORDER-TOP-P',
|
||||
'BORDER-TOP-PI', 'BORDER-TOP-PIX', 'BORDER-TOP-PIXE', 'BORDER-TOP-PIXEL',
|
||||
'BOX', 'BOX-SELECTABLE', 'BOX-SELECT', 'BOX-SELECTA', 'BOX-SELECTAB',
|
||||
'BOX-SELECTABL', 'BREAK', 'BROWSE', 'BUFFER', 'BUFFER-CHARS',
|
||||
'BUFFER-COMPARE', 'BUFFER-COPY', 'BUFFER-CREATE', 'BUFFER-DELETE',
|
||||
'BUFFER-FIELD', 'BUFFER-HANDLE', 'BUFFER-LINES', 'BUFFER-NAME',
|
||||
'BUFFER-RELEASE', 'BUFFER-VALUE', 'BUTTON', 'BUTTONS', 'BUTTON', 'BY',
|
||||
'BY-POINTER', 'BY-VARIANT-POINTER', 'CACHE', 'CACHE-SIZE', 'CALL',
|
||||
'CALL-NAME', 'CALL-TYPE', 'CANCEL-BREAK', 'CANCEL-BUTTON', 'CAN-CREATE',
|
||||
'CAN-DELETE', 'CAN-DO', 'CAN-FIND', 'CAN-QUERY', 'CAN-READ', 'CAN-SET',
|
||||
'CAN-WRITE', 'CAPS', 'CAREFUL-PAINT', 'CASE', 'CASE-SENSITIVE', 'CASE-SEN',
|
||||
'CASE-SENS', 'CASE-SENSI', 'CASE-SENSIT', 'CASE-SENSITI', 'CASE-SENSITIV',
|
||||
'CAST', 'CATCH', 'CDECL', 'CENTERED', 'CENTER', 'CENTERE', 'CHAINED',
|
||||
'CHARACTER_LENGTH', 'CHARSET', 'CHECK', 'CHECKED', 'CHOOSE', 'CHR', 'CLASS',
|
||||
'CLASS-TYPE', 'CLEAR', 'CLEAR-APPL-CONTEXT', 'CLEAR-LOG', 'CLEAR-SELECTION',
|
||||
'CLEAR-SELECT', 'CLEAR-SELECTI', 'CLEAR-SELECTIO', 'CLEAR-SORT-ARROWS',
|
||||
'CLEAR-SORT-ARROW', 'CLIENT-CONNECTION-ID', 'CLIENT-PRINCIPAL',
|
||||
'CLIENT-TTY', 'CLIENT-TYPE', 'CLIENT-WORKSTATION', 'CLIPBOARD', 'CLOSE',
|
||||
'CLOSE-LOG', 'CODE', 'CODEBASE-LOCATOR', 'CODEPAGE', 'CODEPAGE-CONVERT',
|
||||
'COLLATE', 'COL-OF', 'COLON', 'COLON-ALIGNED', 'COLON-ALIGN',
|
||||
'COLON-ALIGNE', 'COLOR', 'COLOR-TABLE', 'COLUMN', 'COL', 'COLU', 'COLUM',
|
||||
'COLUMN-BGCOLOR', 'COLUMN-DCOLOR', 'COLUMN-FGCOLOR', 'COLUMN-FONT',
|
||||
'COLUMN-LABEL', 'COLUMN-LAB', 'COLUMN-LABE', 'COLUMN-MOVABLE', 'COLUMN-OF',
|
||||
'COLUMN-PFCOLOR', 'COLUMN-READ-ONLY', 'COLUMN-RESIZABLE', 'COLUMNS',
|
||||
'COLUMN-SCROLLING', 'COMBO-BOX', 'COMMAND', 'COMPARES', 'COMPILE',
|
||||
'COMPILER', 'COMPLETE', 'COM-SELF', 'CONFIG-NAME', 'CONNECT', 'CONNECTED',
|
||||
'CONSTRUCTOR', 'CONTAINS', 'CONTENTS', 'CONTEXT', 'CONTEXT-HELP',
|
||||
'CONTEXT-HELP-FILE', 'CONTEXT-HELP-ID', 'CONTEXT-POPUP', 'CONTROL',
|
||||
'CONTROL-BOX', 'CONTROL-FRAME', 'CONVERT', 'CONVERT-3D-COLORS',
|
||||
'CONVERT-TO-OFFSET', 'CONVERT-TO-OFFS', 'CONVERT-TO-OFFSE', 'COPY-DATASET',
|
||||
'COPY-LOB', 'COPY-SAX-ATTRIBUTES', 'COPY-TEMP-TABLE', 'COUNT', 'COUNT-OF',
|
||||
'CPCASE', 'CPCOLL', 'CPINTERNAL', 'CPLOG', 'CPPRINT', 'CPRCODEIN',
|
||||
'CPRCODEOUT', 'CPSTREAM', 'CPTERM', 'CRC-VALUE', 'CREATE', 'CREATE-LIKE',
|
||||
'CREATE-LIKE-SEQUENTIAL', 'CREATE-NODE-NAMESPACE',
|
||||
'CREATE-RESULT-LIST-ENTRY', 'CREATE-TEST-FILE', 'CURRENT', 'CURRENT_DATE',
|
||||
'CURRENT_DATE', 'CURRENT-CHANGED', 'CURRENT-COLUMN', 'CURRENT-ENVIRONMENT',
|
||||
'CURRENT-ENV', 'CURRENT-ENVI', 'CURRENT-ENVIR', 'CURRENT-ENVIRO',
|
||||
'CURRENT-ENVIRON', 'CURRENT-ENVIRONM', 'CURRENT-ENVIRONME',
|
||||
'CURRENT-ENVIRONMEN', 'CURRENT-ITERATION', 'CURRENT-LANGUAGE',
|
||||
'CURRENT-LANG', 'CURRENT-LANGU', 'CURRENT-LANGUA', 'CURRENT-LANGUAG',
|
||||
'CURRENT-QUERY', 'CURRENT-RESULT-ROW', 'CURRENT-ROW-MODIFIED',
|
||||
'CURRENT-VALUE', 'CURRENT-WINDOW', 'CURSOR', 'CURS', 'CURSO', 'CURSOR-CHAR',
|
||||
'CURSOR-LINE', 'CURSOR-OFFSET', 'DATABASE', 'DATA-BIND',
|
||||
'DATA-ENTRY-RETURN', 'DATA-ENTRY-RET', 'DATA-ENTRY-RETU',
|
||||
'DATA-ENTRY-RETUR', 'DATA-RELATION', 'DATA-REL', 'DATA-RELA', 'DATA-RELAT',
|
||||
'DATA-RELATI', 'DATA-RELATIO', 'DATASERVERS', 'DATASET', 'DATASET-HANDLE',
|
||||
'DATA-SOURCE', 'DATA-SOURCE-COMPLETE-MAP', 'DATA-SOURCE-MODIFIED',
|
||||
'DATA-SOURCE-ROWID', 'DATA-TYPE', 'DATA-T', 'DATA-TY', 'DATA-TYP',
|
||||
'DATE-FORMAT', 'DATE-F', 'DATE-FO', 'DATE-FOR', 'DATE-FORM', 'DATE-FORMA',
|
||||
'DAY', 'DBCODEPAGE', 'DBCOLLATION', 'DBNAME', 'DBPARAM', 'DB-REFERENCES',
|
||||
'DBRESTRICTIONS', 'DBREST', 'DBRESTR', 'DBRESTRI', 'DBRESTRIC',
|
||||
'DBRESTRICT', 'DBRESTRICTI', 'DBRESTRICTIO', 'DBRESTRICTION', 'DBTASKID',
|
||||
'DBTYPE', 'DBVERSION', 'DBVERS', 'DBVERSI', 'DBVERSIO', 'DCOLOR', 'DDE',
|
||||
'DDE-ERROR', 'DDE-ID', 'DDE-I', 'DDE-ITEM', 'DDE-NAME', 'DDE-TOPIC',
|
||||
'DEBLANK', 'DEBUG', 'DEBU', 'DEBUG-ALERT', 'DEBUGGER', 'DEBUG-LIST',
|
||||
'DECIMALS', 'DECLARE', 'DECLARE-NAMESPACE', 'DECRYPT', 'DEFAULT',
|
||||
'DEFAULT-BUFFER-HANDLE', 'DEFAULT-BUTTON', 'DEFAUT-B', 'DEFAUT-BU',
|
||||
'DEFAUT-BUT', 'DEFAUT-BUTT', 'DEFAUT-BUTTO', 'DEFAULT-COMMIT',
|
||||
'DEFAULT-EXTENSION', 'DEFAULT-EX', 'DEFAULT-EXT', 'DEFAULT-EXTE',
|
||||
'DEFAULT-EXTEN', 'DEFAULT-EXTENS', 'DEFAULT-EXTENSI', 'DEFAULT-EXTENSIO',
|
||||
'DEFAULT-NOXLATE', 'DEFAULT-NOXL', 'DEFAULT-NOXLA', 'DEFAULT-NOXLAT',
|
||||
'DEFAULT-VALUE', 'DEFAULT-WINDOW', 'DEFINED', 'DEFINE-USER-EVENT-MANAGER',
|
||||
'DELETE', 'DEL', 'DELE', 'DELET', 'DELETE-CHARACTER', 'DELETE-CHAR',
|
||||
'DELETE-CHARA', 'DELETE-CHARAC', 'DELETE-CHARACT', 'DELETE-CHARACTE',
|
||||
'DELETE-CURRENT-ROW', 'DELETE-LINE', 'DELETE-RESULT-LIST-ENTRY',
|
||||
'DELETE-SELECTED-ROW', 'DELETE-SELECTED-ROWS', 'DELIMITER', 'DESC',
|
||||
'DESCENDING', 'DESC', 'DESCE', 'DESCEN', 'DESCEND', 'DESCENDI', 'DESCENDIN',
|
||||
'DESELECT-FOCUSED-ROW', 'DESELECTION', 'DESELECT-ROWS',
|
||||
'DESELECT-SELECTED-ROW', 'DESTRUCTOR', 'DIALOG-BOX', 'DICTIONARY', 'DICT',
|
||||
'DICTI', 'DICTIO', 'DICTION', 'DICTIONA', 'DICTIONAR', 'DIR', 'DISABLE',
|
||||
'DISABLE-AUTO-ZAP', 'DISABLED', 'DISABLE-DUMP-TRIGGERS',
|
||||
'DISABLE-LOAD-TRIGGERS', 'DISCONNECT', 'DISCON', 'DISCONN', 'DISCONNE',
|
||||
'DISCONNEC', 'DISP', 'DISPLAY', 'DISP', 'DISPL', 'DISPLA',
|
||||
'DISPLAY-MESSAGE', 'DISPLAY-TYPE', 'DISPLAY-T', 'DISPLAY-TY', 'DISPLAY-TYP',
|
||||
'DISTINCT', 'DO', 'DOMAIN-DESCRIPTION', 'DOMAIN-NAME', 'DOMAIN-TYPE', 'DOS',
|
||||
'DOUBLE', 'DOWN', 'DRAG-ENABLED', 'DROP', 'DROP-DOWN', 'DROP-DOWN-LIST',
|
||||
'DROP-FILE-NOTIFY', 'DROP-TARGET', 'DUMP', 'DYNAMIC', 'DYNAMIC-FUNCTION',
|
||||
'EACH', 'ECHO', 'EDGE-CHARS', 'EDGE', 'EDGE-', 'EDGE-C', 'EDGE-CH',
|
||||
'EDGE-CHA', 'EDGE-CHAR', 'EDGE-PIXELS', 'EDGE-P', 'EDGE-PI', 'EDGE-PIX',
|
||||
'EDGE-PIXE', 'EDGE-PIXEL', 'EDIT-CAN-PASTE', 'EDIT-CAN-UNDO', 'EDIT-CLEAR',
|
||||
'EDIT-COPY', 'EDIT-CUT', 'EDITING', 'EDITOR', 'EDIT-PASTE', 'EDIT-UNDO',
|
||||
'ELSE', 'EMPTY', 'EMPTY-TEMP-TABLE', 'ENABLE', 'ENABLED-FIELDS', 'ENCODE',
|
||||
'ENCRYPT', 'ENCRYPT-AUDIT-MAC-KEY', 'ENCRYPTION-SALT', 'END',
|
||||
'END-DOCUMENT', 'END-ELEMENT', 'END-EVENT-GROUP', 'END-FILE-DROP', 'ENDKEY',
|
||||
'END-KEY', 'END-MOVE', 'END-RESIZE', 'END-ROW-RESIZE', 'END-USER-PROMPT',
|
||||
'ENTERED', 'ENTRY', 'EQ', 'ERROR', 'ERROR-COLUMN', 'ERROR-COL',
|
||||
'ERROR-COLU', 'ERROR-COLUM', 'ERROR-ROW', 'ERROR-STACK-TRACE',
|
||||
'ERROR-STATUS', 'ERROR-STAT', 'ERROR-STATU', 'ESCAPE', 'ETIME',
|
||||
'EVENT-GROUP-ID', 'EVENT-PROCEDURE', 'EVENT-PROCEDURE-CONTEXT', 'EVENTS',
|
||||
'EVENT', 'EVENT-TYPE', 'EVENT-T', 'EVENT-TY', 'EVENT-TYP', 'EXCEPT',
|
||||
'EXCLUSIVE-ID', 'EXCLUSIVE-LOCK', 'EXCLUSIVE', 'EXCLUSIVE-', 'EXCLUSIVE-L',
|
||||
'EXCLUSIVE-LO', 'EXCLUSIVE-LOC', 'EXCLUSIVE-WEB-USER', 'EXECUTE', 'EXISTS',
|
||||
'EXP', 'EXPAND', 'EXPANDABLE', 'EXPLICIT', 'EXPORT', 'EXPORT-PRINCIPAL',
|
||||
'EXTENDED', 'EXTENT', 'EXTERNAL', 'FALSE', 'FETCH', 'FETCH-SELECTED-ROW',
|
||||
'FGCOLOR', 'FGC', 'FGCO', 'FGCOL', 'FGCOLO', 'FIELD', 'FIELDS', 'FIELD',
|
||||
'FILE', 'FILE-CREATE-DATE', 'FILE-CREATE-TIME', 'FILE-INFORMATION',
|
||||
'FILE-INFO', 'FILE-INFOR', 'FILE-INFORM', 'FILE-INFORMA', 'FILE-INFORMAT',
|
||||
'FILE-INFORMATI', 'FILE-INFORMATIO', 'FILE-MOD-DATE', 'FILE-MOD-TIME',
|
||||
'FILENAME', 'FILE-NAME', 'FILE-OFFSET', 'FILE-OFF', 'FILE-OFFS',
|
||||
'FILE-OFFSE', 'FILE-SIZE', 'FILE-TYPE', 'FILL', 'FILLED', 'FILL-IN',
|
||||
'FILTERS', 'FINAL', 'FINALLY', 'FIND', 'FIND-BY-ROWID',
|
||||
'FIND-CASE-SENSITIVE', 'FIND-CURRENT', 'FINDER', 'FIND-FIRST',
|
||||
'FIND-GLOBAL', 'FIND-LAST', 'FIND-NEXT-OCCURRENCE', 'FIND-PREV-OCCURRENCE',
|
||||
'FIND-SELECT', 'FIND-UNIQUE', 'FIND-WRAP-AROUND', 'FIRST',
|
||||
'FIRST-ASYNCH-REQUEST', 'FIRST-CHILD', 'FIRST-COLUMN', 'FIRST-FORM',
|
||||
'FIRST-OBJECT', 'FIRST-OF', 'FIRST-PROCEDURE', 'FIRST-PROC', 'FIRST-PROCE',
|
||||
'FIRST-PROCED', 'FIRST-PROCEDU', 'FIRST-PROCEDUR', 'FIRST-SERVER',
|
||||
'FIRST-TAB-ITEM', 'FIRST-TAB-I', 'FIRST-TAB-IT', 'FIRST-TAB-ITE',
|
||||
'FIT-LAST-COLUMN', 'FIXED-ONLY', 'FLAT-BUTTON', 'FLOAT', 'FOCUS',
|
||||
'FOCUSED-ROW', 'FOCUSED-ROW-SELECTED', 'FONT', 'FONT-TABLE', 'FOR',
|
||||
'FORCE-FILE', 'FOREGROUND', 'FORE', 'FOREG', 'FOREGR', 'FOREGRO',
|
||||
'FOREGROU', 'FOREGROUN', 'FORM', 'FORMAT', 'FORM', 'FORMA', 'FORMATTED',
|
||||
'FORMATTE', 'FORM-LONG-INPUT', 'FORWARD', 'FORWARDS', 'FORWARD', 'FRAGMENT',
|
||||
'FRAGMEN', 'FRAME', 'FRAM', 'FRAME-COL', 'FRAME-DB', 'FRAME-DOWN',
|
||||
'FRAME-FIELD', 'FRAME-FILE', 'FRAME-INDEX', 'FRAME-INDE', 'FRAME-LINE',
|
||||
'FRAME-NAME', 'FRAME-ROW', 'FRAME-SPACING', 'FRAME-SPA', 'FRAME-SPAC',
|
||||
'FRAME-SPACI', 'FRAME-SPACIN', 'FRAME-VALUE', 'FRAME-VAL', 'FRAME-VALU',
|
||||
'FRAME-X', 'FRAME-Y', 'FREQUENCY', 'FROM', 'FROM-CHARS', 'FROM-C',
|
||||
'FROM-CH', 'FROM-CHA', 'FROM-CHAR', 'FROM-CURRENT', 'FROM-CUR', 'FROM-CURR',
|
||||
'FROM-CURRE', 'FROM-CURREN', 'FROM-PIXELS', 'FROM-P', 'FROM-PI', 'FROM-PIX',
|
||||
'FROM-PIXE', 'FROM-PIXEL', 'FULL-HEIGHT-CHARS', 'FULL-HEIGHT',
|
||||
'FULL-HEIGHT-', 'FULL-HEIGHT-C', 'FULL-HEIGHT-CH', 'FULL-HEIGHT-CHA',
|
||||
'FULL-HEIGHT-CHAR', 'FULL-HEIGHT-PIXELS', 'FULL-HEIGHT-P', 'FULL-HEIGHT-PI',
|
||||
'FULL-HEIGHT-PIX', 'FULL-HEIGHT-PIXE', 'FULL-HEIGHT-PIXEL', 'FULL-PATHNAME',
|
||||
'FULL-PATHN', 'FULL-PATHNA', 'FULL-PATHNAM', 'FULL-WIDTH-CHARS',
|
||||
'FULL-WIDTH', 'FULL-WIDTH-', 'FULL-WIDTH-C', 'FULL-WIDTH-CH',
|
||||
'FULL-WIDTH-CHA', 'FULL-WIDTH-CHAR', 'FULL-WIDTH-PIXELS', 'FULL-WIDTH-P',
|
||||
'FULL-WIDTH-PI', 'FULL-WIDTH-PIX', 'FULL-WIDTH-PIXE', 'FULL-WIDTH-PIXEL',
|
||||
'FUNCTION', 'FUNCTION-CALL-TYPE', 'GATEWAYS', 'GATEWAY', 'GE',
|
||||
'GENERATE-MD5', 'GENERATE-PBE-KEY', 'GENERATE-PBE-SALT',
|
||||
'GENERATE-RANDOM-KEY', 'GENERATE-UUID', 'GET', 'GET-ATTR-CALL-TYPE',
|
||||
'GET-ATTRIBUTE-NODE', 'GET-BINARY-DATA', 'GET-BLUE-VALUE', 'GET-BLUE',
|
||||
'GET-BLUE-', 'GET-BLUE-V', 'GET-BLUE-VA', 'GET-BLUE-VAL', 'GET-BLUE-VALU',
|
||||
'GET-BROWSE-COLUMN', 'GET-BUFFER-HANDLEGETBYTE', 'GET-BYTE',
|
||||
'GET-CALLBACK-PROC-CONTEXT', 'GET-CALLBACK-PROC-NAME', 'GET-CGI-LIST',
|
||||
'GET-CGI-LONG-VALUE', 'GET-CGI-VALUE', 'GET-CODEPAGES', 'GET-COLLATIONS',
|
||||
'GET-CONFIG-VALUE', 'GET-CURRENT', 'GET-DOUBLE', 'GET-DROPPED-FILE',
|
||||
'GET-DYNAMIC', 'GET-ERROR-COLUMN', 'GET-ERROR-ROW', 'GET-FILE',
|
||||
'GET-FILE-NAME', 'GET-FILE-OFFSET', 'GET-FILE-OFFSE', 'GET-FIRST',
|
||||
'GET-FLOAT', 'GET-GREEN-VALUE', 'GET-GREEN', 'GET-GREEN-', 'GET-GREEN-V',
|
||||
'GET-GREEN-VA', 'GET-GREEN-VAL', 'GET-GREEN-VALU',
|
||||
'GET-INDEX-BY-NAMESPACE-NAME', 'GET-INDEX-BY-QNAME', 'GET-INT64',
|
||||
'GET-ITERATION', 'GET-KEY-VALUE', 'GET-KEY-VAL', 'GET-KEY-VALU', 'GET-LAST',
|
||||
'GET-LOCALNAME-BY-INDEX', 'GET-LONG', 'GET-MESSAGE', 'GET-NEXT',
|
||||
'GET-NUMBER', 'GET-POINTER-VALUE', 'GET-PREV', 'GET-PRINTERS',
|
||||
'GET-PROPERTY', 'GET-QNAME-BY-INDEX', 'GET-RED-VALUE', 'GET-RED',
|
||||
'GET-RED-', 'GET-RED-V', 'GET-RED-VA', 'GET-RED-VAL', 'GET-RED-VALU',
|
||||
'GET-REPOSITIONED-ROW', 'GET-RGB-VALUE', 'GET-SELECTED-WIDGET',
|
||||
'GET-SELECTED', 'GET-SELECTED-', 'GET-SELECTED-W', 'GET-SELECTED-WI',
|
||||
'GET-SELECTED-WID', 'GET-SELECTED-WIDG', 'GET-SELECTED-WIDGE', 'GET-SHORT',
|
||||
'GET-SIGNATURE', 'GET-SIZE', 'GET-STRING', 'GET-TAB-ITEM',
|
||||
'GET-TEXT-HEIGHT-CHARS', 'GET-TEXT-HEIGHT', 'GET-TEXT-HEIGHT-',
|
||||
'GET-TEXT-HEIGHT-C', 'GET-TEXT-HEIGHT-CH', 'GET-TEXT-HEIGHT-CHA',
|
||||
'GET-TEXT-HEIGHT-CHAR', 'GET-TEXT-HEIGHT-PIXELS', 'GET-TEXT-HEIGHT-P',
|
||||
'GET-TEXT-HEIGHT-PI', 'GET-TEXT-HEIGHT-PIX', 'GET-TEXT-HEIGHT-PIXE',
|
||||
'GET-TEXT-HEIGHT-PIXEL', 'GET-TEXT-WIDTH-CHARS', 'GET-TEXT-WIDTH',
|
||||
'GET-TEXT-WIDTH-', 'GET-TEXT-WIDTH-C', 'GET-TEXT-WIDTH-CH',
|
||||
'GET-TEXT-WIDTH-CHA', 'GET-TEXT-WIDTH-CHAR', 'GET-TEXT-WIDTH-PIXELS',
|
||||
'GET-TEXT-WIDTH-P', 'GET-TEXT-WIDTH-PI', 'GET-TEXT-WIDTH-PIX',
|
||||
'GET-TEXT-WIDTH-PIXE', 'GET-TEXT-WIDTH-PIXEL', 'GET-TYPE-BY-INDEX',
|
||||
'GET-TYPE-BY-NAMESPACE-NAME', 'GET-TYPE-BY-QNAME', 'GET-UNSIGNED-LONG',
|
||||
'GET-UNSIGNED-SHORT', 'GET-URI-BY-INDEX', 'GET-VALUE-BY-INDEX',
|
||||
'GET-VALUE-BY-NAMESPACE-NAME', 'GET-VALUE-BY-QNAME', 'GET-WAIT-STATE',
|
||||
'GLOBAL', 'GO-ON', 'GO-PENDING', 'GO-PEND', 'GO-PENDI', 'GO-PENDIN',
|
||||
'GRANT', 'GRAPHIC-EDGE', 'GRAPHIC-E', 'GRAPHIC-ED', 'GRAPHIC-EDG',
|
||||
'GRID-FACTOR-HORIZONTAL', 'GRID-FACTOR-H', 'GRID-FACTOR-HO',
|
||||
'GRID-FACTOR-HOR', 'GRID-FACTOR-HORI', 'GRID-FACTOR-HORIZ',
|
||||
'GRID-FACTOR-HORIZO', 'GRID-FACTOR-HORIZON', 'GRID-FACTOR-HORIZONT',
|
||||
'GRID-FACTOR-HORIZONTA', 'GRID-FACTOR-VERTICAL', 'GRID-FACTOR-V',
|
||||
'GRID-FACTOR-VE', 'GRID-FACTOR-VER', 'GRID-FACTOR-VERT', 'GRID-FACTOR-VERT',
|
||||
'GRID-FACTOR-VERTI', 'GRID-FACTOR-VERTIC', 'GRID-FACTOR-VERTICA',
|
||||
'GRID-SNAP', 'GRID-UNIT-HEIGHT-CHARS', 'GRID-UNIT-HEIGHT',
|
||||
'GRID-UNIT-HEIGHT-', 'GRID-UNIT-HEIGHT-C', 'GRID-UNIT-HEIGHT-CH',
|
||||
'GRID-UNIT-HEIGHT-CHA', 'GRID-UNIT-HEIGHT-PIXELS', 'GRID-UNIT-HEIGHT-P',
|
||||
'GRID-UNIT-HEIGHT-PI', 'GRID-UNIT-HEIGHT-PIX', 'GRID-UNIT-HEIGHT-PIXE',
|
||||
'GRID-UNIT-HEIGHT-PIXEL', 'GRID-UNIT-WIDTH-CHARS', 'GRID-UNIT-WIDTH',
|
||||
'GRID-UNIT-WIDTH-', 'GRID-UNIT-WIDTH-C', 'GRID-UNIT-WIDTH-CH',
|
||||
'GRID-UNIT-WIDTH-CHA', 'GRID-UNIT-WIDTH-CHAR', 'GRID-UNIT-WIDTH-PIXELS',
|
||||
'GRID-UNIT-WIDTH-P', 'GRID-UNIT-WIDTH-PI', 'GRID-UNIT-WIDTH-PIX',
|
||||
'GRID-UNIT-WIDTH-PIXE', 'GRID-UNIT-WIDTH-PIXEL', 'GRID-VISIBLE', 'GROUP',
|
||||
'GT', 'GUID', 'HANDLER', 'HAS-RECORDS', 'HAVING', 'HEADER', 'HEIGHT-CHARS',
|
||||
'HEIGHT', 'HEIGHT-', 'HEIGHT-C', 'HEIGHT-CH', 'HEIGHT-CHA', 'HEIGHT-CHAR',
|
||||
'HEIGHT-PIXELS', 'HEIGHT-P', 'HEIGHT-PI', 'HEIGHT-PIX', 'HEIGHT-PIXE',
|
||||
'HEIGHT-PIXEL', 'HELP', 'HEX-DECODE', 'HEX-ENCODE', 'HIDDEN', 'HIDE',
|
||||
'HORIZONTAL', 'HORI', 'HORIZ', 'HORIZO', 'HORIZON', 'HORIZONT', 'HORIZONTA',
|
||||
'HOST-BYTE-ORDER', 'HTML-CHARSET', 'HTML-END-OF-LINE', 'HTML-END-OF-PAGE',
|
||||
'HTML-FRAME-BEGIN', 'HTML-FRAME-END', 'HTML-HEADER-BEGIN',
|
||||
'HTML-HEADER-END', 'HTML-TITLE-BEGIN', 'HTML-TITLE-END', 'HWND', 'ICON',
|
||||
'IF', 'IMAGE', 'IMAGE-DOWN', 'IMAGE-INSENSITIVE', 'IMAGE-SIZE',
|
||||
'IMAGE-SIZE-CHARS', 'IMAGE-SIZE-C', 'IMAGE-SIZE-CH', 'IMAGE-SIZE-CHA',
|
||||
'IMAGE-SIZE-CHAR', 'IMAGE-SIZE-PIXELS', 'IMAGE-SIZE-P', 'IMAGE-SIZE-PI',
|
||||
'IMAGE-SIZE-PIX', 'IMAGE-SIZE-PIXE', 'IMAGE-SIZE-PIXEL', 'IMAGE-UP',
|
||||
'IMMEDIATE-DISPLAY', 'IMPLEMENTS', 'IMPORT', 'IMPORT-PRINCIPAL', 'IN',
|
||||
'INCREMENT-EXCLUSIVE-ID', 'INDEX', 'INDEXED-REPOSITION', 'INDEX-HINT',
|
||||
'INDEX-INFORMATION', 'INDICATOR', 'INFORMATION', 'INFO', 'INFOR', 'INFORM',
|
||||
'INFORMA', 'INFORMAT', 'INFORMATI', 'INFORMATIO', 'IN-HANDLE',
|
||||
'INHERIT-BGCOLOR', 'INHERIT-BGC', 'INHERIT-BGCO', 'INHERIT-BGCOL',
|
||||
'INHERIT-BGCOLO', 'INHERIT-FGCOLOR', 'INHERIT-FGC', 'INHERIT-FGCO',
|
||||
'INHERIT-FGCOL', 'INHERIT-FGCOLO', 'INHERITS', 'INITIAL', 'INIT', 'INITI',
|
||||
'INITIA', 'INITIAL-DIR', 'INITIAL-FILTER', 'INITIALIZE-DOCUMENT-TYPE',
|
||||
'INITIATE', 'INNER-CHARS', 'INNER-LINES', 'INPUT', 'INPUT-OUTPUT',
|
||||
'INPUT-O', 'INPUT-OU', 'INPUT-OUT', 'INPUT-OUTP', 'INPUT-OUTPU',
|
||||
'INPUT-VALUE', 'INSERT', 'INSERT-ATTRIBUTE', 'INSERT-BACKTAB', 'INSERT-B',
|
||||
'INSERT-BA', 'INSERT-BAC', 'INSERT-BACK', 'INSERT-BACKT', 'INSERT-BACKTA',
|
||||
'INSERT-FILE', 'INSERT-ROW', 'INSERT-STRING', 'INSERT-TAB', 'INSERT-T',
|
||||
'INSERT-TA', 'INTERFACE', 'INTERNAL-ENTRIES', 'INTO', 'INVOKE', 'IS',
|
||||
'IS-ATTR-SPACE', 'IS-ATTR', 'IS-ATTR-', 'IS-ATTR-S', 'IS-ATTR-SP',
|
||||
'IS-ATTR-SPA', 'IS-ATTR-SPAC', 'IS-CLASS', 'IS-CLAS', 'IS-LEAD-BYTE',
|
||||
'IS-ATTR', 'IS-OPEN', 'IS-PARAMETER-SET', 'IS-ROW-SELECTED', 'IS-SELECTED',
|
||||
'ITEM', 'ITEMS-PER-ROW', 'JOIN', 'JOIN-BY-SQLDB', 'KBLABEL',
|
||||
'KEEP-CONNECTION-OPEN', 'KEEP-FRAME-Z-ORDER', 'KEEP-FRAME-Z',
|
||||
'KEEP-FRAME-Z-', 'KEEP-FRAME-Z-O', 'KEEP-FRAME-Z-OR', 'KEEP-FRAME-Z-ORD',
|
||||
'KEEP-FRAME-Z-ORDE', 'KEEP-MESSAGES', 'KEEP-SECURITY-CACHE',
|
||||
'KEEP-TAB-ORDER', 'KEY', 'KEYCODE', 'KEY-CODE', 'KEYFUNCTION', 'KEYFUNC',
|
||||
'KEYFUNCT', 'KEYFUNCTI', 'KEYFUNCTIO', 'KEY-FUNCTION', 'KEY-FUNC',
|
||||
'KEY-FUNCT', 'KEY-FUNCTI', 'KEY-FUNCTIO', 'KEYLABEL', 'KEY-LABEL', 'KEYS',
|
||||
'KEYWORD', 'KEYWORD-ALL', 'LABEL', 'LABEL-BGCOLOR', 'LABEL-BGC',
|
||||
'LABEL-BGCO', 'LABEL-BGCOL', 'LABEL-BGCOLO', 'LABEL-DCOLOR', 'LABEL-DC',
|
||||
'LABEL-DCO', 'LABEL-DCOL', 'LABEL-DCOLO', 'LABEL-FGCOLOR', 'LABEL-FGC',
|
||||
'LABEL-FGCO', 'LABEL-FGCOL', 'LABEL-FGCOLO', 'LABEL-FONT', 'LABEL-PFCOLOR',
|
||||
'LABEL-PFC', 'LABEL-PFCO', 'LABEL-PFCOL', 'LABEL-PFCOLO', 'LABELS',
|
||||
'LANDSCAPE', 'LANGUAGES', 'LANGUAGE', 'LARGE', 'LARGE-TO-SMALL', 'LAST',
|
||||
'LAST-ASYNCH-REQUEST', 'LAST-BATCH', 'LAST-CHILD', 'LAST-EVENT',
|
||||
'LAST-EVEN', 'LAST-FORM', 'LASTKEY', 'LAST-KEY', 'LAST-OBJECT', 'LAST-OF',
|
||||
'LAST-PROCEDURE', 'LAST-PROCE', 'LAST-PROCED', 'LAST-PROCEDU',
|
||||
'LAST-PROCEDUR', 'LAST-SERVER', 'LAST-TAB-ITEM', 'LAST-TAB-I',
|
||||
'LAST-TAB-IT', 'LAST-TAB-ITE', 'LC', 'LDBNAME', 'LE', 'LEAVE',
|
||||
'LEFT-ALIGNED', 'LEFT-ALIGN', 'LEFT-ALIGNE', 'LEFT-TRIM', 'LENGTH',
|
||||
'LIBRARY', 'LIKE', 'LIKE-SEQUENTIAL', 'LINE', 'LINE-COUNTER', 'LINE-COUNT',
|
||||
'LINE-COUNTE', 'LIST-EVENTS', 'LISTING', 'LISTI', 'LISTIN',
|
||||
'LIST-ITEM-PAIRS', 'LIST-ITEMS', 'LIST-PROPERTY-NAMES', 'LIST-QUERY-ATTRS',
|
||||
'LIST-SET-ATTRS', 'LIST-WIDGETS', 'LITERAL-QUESTION', 'LITTLE-ENDIAN',
|
||||
'LOAD', 'LOAD-DOMAINS', 'LOAD-ICON', 'LOAD-IMAGE', 'LOAD-IMAGE-DOWN',
|
||||
'LOAD-IMAGE-INSENSITIVE', 'LOAD-IMAGE-UP', 'LOAD-MOUSE-POINTER',
|
||||
'LOAD-MOUSE-P', 'LOAD-MOUSE-PO', 'LOAD-MOUSE-POI', 'LOAD-MOUSE-POIN',
|
||||
'LOAD-MOUSE-POINT', 'LOAD-MOUSE-POINTE', 'LOAD-PICTURE', 'LOAD-SMALL-ICON',
|
||||
'LOCAL-NAME', 'LOCATOR-COLUMN-NUMBER', 'LOCATOR-LINE-NUMBER',
|
||||
'LOCATOR-PUBLIC-ID', 'LOCATOR-SYSTEM-ID', 'LOCATOR-TYPE', 'LOCKED',
|
||||
'LOCK-REGISTRATION', 'LOG', 'LOG-AUDIT-EVENT', 'LOGIN-EXPIRATION-TIMESTAMP',
|
||||
'LOGIN-HOST', 'LOGIN-STATE', 'LOG-MANAGER', 'LOGOUT', 'LOOKAHEAD', 'LOOKUP',
|
||||
'LT', 'MACHINE-CLASS', 'MANDATORY', 'MANUAL-HIGHLIGHT', 'MAP',
|
||||
'MARGIN-EXTRA', 'MARGIN-HEIGHT-CHARS', 'MARGIN-HEIGHT', 'MARGIN-HEIGHT-',
|
||||
'MARGIN-HEIGHT-C', 'MARGIN-HEIGHT-CH', 'MARGIN-HEIGHT-CHA',
|
||||
'MARGIN-HEIGHT-CHAR', 'MARGIN-HEIGHT-PIXELS', 'MARGIN-HEIGHT-P',
|
||||
'MARGIN-HEIGHT-PI', 'MARGIN-HEIGHT-PIX', 'MARGIN-HEIGHT-PIXE',
|
||||
'MARGIN-HEIGHT-PIXEL', 'MARGIN-WIDTH-CHARS', 'MARGIN-WIDTH',
|
||||
'MARGIN-WIDTH-', 'MARGIN-WIDTH-C', 'MARGIN-WIDTH-CH', 'MARGIN-WIDTH-CHA',
|
||||
'MARGIN-WIDTH-CHAR', 'MARGIN-WIDTH-PIXELS', 'MARGIN-WIDTH-P',
|
||||
'MARGIN-WIDTH-PI', 'MARGIN-WIDTH-PIX', 'MARGIN-WIDTH-PIXE',
|
||||
'MARGIN-WIDTH-PIXEL', 'MARK-NEW', 'MARK-ROW-STATE', 'MATCHES', 'MAX',
|
||||
'MAX-BUTTON', 'MAX-CHARS', 'MAX-DATA-GUESS', 'MAX-HEIGHT',
|
||||
'MAX-HEIGHT-CHARS', 'MAX-HEIGHT-C', 'MAX-HEIGHT-CH', 'MAX-HEIGHT-CHA',
|
||||
'MAX-HEIGHT-CHAR', 'MAX-HEIGHT-PIXELS', 'MAX-HEIGHT-P', 'MAX-HEIGHT-PI',
|
||||
'MAX-HEIGHT-PIX', 'MAX-HEIGHT-PIXE', 'MAX-HEIGHT-PIXEL', 'MAXIMIZE',
|
||||
'MAXIMUM', 'MAX', 'MAXI', 'MAXIM', 'MAXIMU', 'MAXIMUM-LEVEL', 'MAX-ROWS',
|
||||
'MAX-SIZE', 'MAX-VALUE', 'MAX-VAL', 'MAX-VALU', 'MAX-WIDTH',
|
||||
'MAX-WIDTH-CHARS', 'MAX-WIDTH', 'MAX-WIDTH-', 'MAX-WIDTH-C', 'MAX-WIDTH-CH',
|
||||
'MAX-WIDTH-CHA', 'MAX-WIDTH-CHAR', 'MAX-WIDTH-PIXELS', 'MAX-WIDTH-P',
|
||||
'MAX-WIDTH-PI', 'MAX-WIDTH-PIX', 'MAX-WIDTH-PIXE', 'MAX-WIDTH-PIXEL',
|
||||
'MD5-DIGEST', 'MEMBER', 'MEMPTR-TO-NODE-VALUE', 'MENU', 'MENUBAR',
|
||||
'MENU-BAR', 'MENU-ITEM', 'MENU-KEY', 'MENU-K', 'MENU-KE', 'MENU-MOUSE',
|
||||
'MENU-M', 'MENU-MO', 'MENU-MOU', 'MENU-MOUS', 'MERGE-BY-FIELD', 'MESSAGE',
|
||||
'MESSAGE-AREA', 'MESSAGE-AREA-FONT', 'MESSAGE-LINES', 'METHOD', 'MIN',
|
||||
'MIN-BUTTON', 'MIN-COLUMN-WIDTH-CHARS', 'MIN-COLUMN-WIDTH-C',
|
||||
'MIN-COLUMN-WIDTH-CH', 'MIN-COLUMN-WIDTH-CHA', 'MIN-COLUMN-WIDTH-CHAR',
|
||||
'MIN-COLUMN-WIDTH-PIXELS', 'MIN-COLUMN-WIDTH-P', 'MIN-COLUMN-WIDTH-PI',
|
||||
'MIN-COLUMN-WIDTH-PIX', 'MIN-COLUMN-WIDTH-PIXE', 'MIN-COLUMN-WIDTH-PIXEL',
|
||||
'MIN-HEIGHT-CHARS', 'MIN-HEIGHT', 'MIN-HEIGHT-', 'MIN-HEIGHT-C',
|
||||
'MIN-HEIGHT-CH', 'MIN-HEIGHT-CHA', 'MIN-HEIGHT-CHAR', 'MIN-HEIGHT-PIXELS',
|
||||
'MIN-HEIGHT-P', 'MIN-HEIGHT-PI', 'MIN-HEIGHT-PIX', 'MIN-HEIGHT-PIXE',
|
||||
'MIN-HEIGHT-PIXEL', 'MINIMUM', 'MIN', 'MINI', 'MINIM', 'MINIMU', 'MIN-SIZE',
|
||||
'MIN-VALUE', 'MIN-VAL', 'MIN-VALU', 'MIN-WIDTH-CHARS', 'MIN-WIDTH',
|
||||
'MIN-WIDTH-', 'MIN-WIDTH-C', 'MIN-WIDTH-CH', 'MIN-WIDTH-CHA',
|
||||
'MIN-WIDTH-CHAR', 'MIN-WIDTH-PIXELS', 'MIN-WIDTH-P', 'MIN-WIDTH-PI',
|
||||
'MIN-WIDTH-PIX', 'MIN-WIDTH-PIXE', 'MIN-WIDTH-PIXEL', 'MODIFIED', 'MODULO',
|
||||
'MOD', 'MODU', 'MODUL', 'MONTH', 'MOUSE', 'MOUSE-POINTER', 'MOUSE-P',
|
||||
'MOUSE-PO', 'MOUSE-POI', 'MOUSE-POIN', 'MOUSE-POINT', 'MOUSE-POINTE',
|
||||
'MOVABLE', 'MOVE-AFTER-TAB-ITEM', 'MOVE-AFTER', 'MOVE-AFTER-',
|
||||
'MOVE-AFTER-T', 'MOVE-AFTER-TA', 'MOVE-AFTER-TAB', 'MOVE-AFTER-TAB-',
|
||||
'MOVE-AFTER-TAB-I', 'MOVE-AFTER-TAB-IT', 'MOVE-AFTER-TAB-ITE',
|
||||
'MOVE-BEFORE-TAB-ITEM', 'MOVE-BEFOR', 'MOVE-BEFORE', 'MOVE-BEFORE-',
|
||||
'MOVE-BEFORE-T', 'MOVE-BEFORE-TA', 'MOVE-BEFORE-TAB', 'MOVE-BEFORE-TAB-',
|
||||
'MOVE-BEFORE-TAB-I', 'MOVE-BEFORE-TAB-IT', 'MOVE-BEFORE-TAB-ITE',
|
||||
'MOVE-COLUMN', 'MOVE-COL', 'MOVE-COLU', 'MOVE-COLUM', 'MOVE-TO-BOTTOM',
|
||||
'MOVE-TO-B', 'MOVE-TO-BO', 'MOVE-TO-BOT', 'MOVE-TO-BOTT', 'MOVE-TO-BOTTO',
|
||||
'MOVE-TO-EOF', 'MOVE-TO-TOP', 'MOVE-TO-T', 'MOVE-TO-TO', 'MPE',
|
||||
'MULTI-COMPILE', 'MULTIPLE', 'MULTIPLE-KEY', 'MULTITASKING-INTERVAL',
|
||||
'MUST-EXIST', 'NAME', 'NAMESPACE-PREFIX', 'NAMESPACE-URI', 'NATIVE', 'NE',
|
||||
'NEEDS-APPSERVER-PROMPT', 'NEEDS-PROMPT', 'NEW', 'NEW-INSTANCE', 'NEW-ROW',
|
||||
'NEXT', 'NEXT-COLUMN', 'NEXT-PROMPT', 'NEXT-ROWID', 'NEXT-SIBLING',
|
||||
'NEXT-TAB-ITEM', 'NEXT-TAB-I', 'NEXT-TAB-IT', 'NEXT-TAB-ITE', 'NEXT-VALUE',
|
||||
'NO', 'NO-APPLY', 'NO-ARRAY-MESSAGE', 'NO-ASSIGN', 'NO-ATTR-LIST',
|
||||
'NO-ATTR', 'NO-ATTR-', 'NO-ATTR-L', 'NO-ATTR-LI', 'NO-ATTR-LIS',
|
||||
'NO-ATTR-SPACE', 'NO-ATTR', 'NO-ATTR-', 'NO-ATTR-S', 'NO-ATTR-SP',
|
||||
'NO-ATTR-SPA', 'NO-ATTR-SPAC', 'NO-AUTO-VALIDATE', 'NO-BIND-WHERE',
|
||||
'NO-BOX', 'NO-CONSOLE', 'NO-CONVERT', 'NO-CONVERT-3D-COLORS',
|
||||
'NO-CURRENT-VALUE', 'NO-DEBUG', 'NODE-VALUE-TO-MEMPTR', 'NO-DRAG',
|
||||
'NO-ECHO', 'NO-EMPTY-SPACE', 'NO-ERROR', 'NO-FILL', 'NO-F', 'NO-FI',
|
||||
'NO-FIL', 'NO-FOCUS', 'NO-HELP', 'NO-HIDE', 'NO-INDEX-HINT',
|
||||
'NO-INHERIT-BGCOLOR', 'NO-INHERIT-BGC', 'NO-INHERIT-BGCO', 'LABEL-BGCOL',
|
||||
'LABEL-BGCOLO', 'NO-INHERIT-FGCOLOR', 'NO-INHERIT-FGC', 'NO-INHERIT-FGCO',
|
||||
'NO-INHERIT-FGCOL', 'NO-INHERIT-FGCOLO', 'NO-JOIN-BY-SQLDB', 'NO-LABELS',
|
||||
'NO-LABE', 'NO-LOBS', 'NO-LOCK', 'NO-LOOKAHEAD', 'NO-MAP', 'NO-MESSAGE',
|
||||
'NO-MES', 'NO-MESS', 'NO-MESSA', 'NO-MESSAG', 'NONAMESPACE-SCHEMA-LOCATION',
|
||||
'NONE', 'NO-PAUSE', 'NO-PREFETCH', 'NO-PREFE', 'NO-PREFET', 'NO-PREFETC',
|
||||
'NORMALIZE', 'NO-ROW-MARKERS', 'NO-SCROLLBAR-VERTICAL',
|
||||
'NO-SEPARATE-CONNECTION', 'NO-SEPARATORS', 'NOT', 'NO-TAB-STOP',
|
||||
'NOT-ACTIVE', 'NO-UNDERLINE', 'NO-UND', 'NO-UNDE', 'NO-UNDER', 'NO-UNDERL',
|
||||
'NO-UNDERLI', 'NO-UNDERLIN', 'NO-UNDO', 'NO-VALIDATE', 'NO-VAL', 'NO-VALI',
|
||||
'NO-VALID', 'NO-VALIDA', 'NO-VALIDAT', 'NOW', 'NO-WAIT', 'NO-WORD-WRAP',
|
||||
'NULL', 'NUM-ALIASES', 'NUM-ALI', 'NUM-ALIA', 'NUM-ALIAS', 'NUM-ALIASE',
|
||||
'NUM-BUFFERS', 'NUM-BUTTONS', 'NUM-BUT', 'NUM-BUTT', 'NUM-BUTTO',
|
||||
'NUM-BUTTON', 'NUM-COLUMNS', 'NUM-COL', 'NUM-COLU', 'NUM-COLUM',
|
||||
'NUM-COLUMN', 'NUM-COPIES', 'NUM-DBS', 'NUM-DROPPED-FILES', 'NUM-ENTRIES',
|
||||
'NUMERIC', 'NUMERIC-FORMAT', 'NUMERIC-F', 'NUMERIC-FO', 'NUMERIC-FOR',
|
||||
'NUMERIC-FORM', 'NUMERIC-FORMA', 'NUM-FIELDS', 'NUM-FORMATS', 'NUM-ITEMS',
|
||||
'NUM-ITERATIONS', 'NUM-LINES', 'NUM-LOCKED-COLUMNS', 'NUM-LOCKED-COL',
|
||||
'NUM-LOCKED-COLU', 'NUM-LOCKED-COLUM', 'NUM-LOCKED-COLUMN', 'NUM-MESSAGES',
|
||||
'NUM-PARAMETERS', 'NUM-REFERENCES', 'NUM-REPLACED', 'NUM-RESULTS',
|
||||
'NUM-SELECTED-ROWS', 'NUM-SELECTED-WIDGETS', 'NUM-SELECTED',
|
||||
'NUM-SELECTED-', 'NUM-SELECTED-W', 'NUM-SELECTED-WI', 'NUM-SELECTED-WID',
|
||||
'NUM-SELECTED-WIDG', 'NUM-SELECTED-WIDGE', 'NUM-SELECTED-WIDGET',
|
||||
'NUM-TABS', 'NUM-TO-RETAIN', 'NUM-VISIBLE-COLUMNS', 'OCTET-LENGTH', 'OF',
|
||||
'OFF', 'OK', 'OK-CANCEL', 'OLD', 'ON', 'ON-FRAME-BORDER', 'ON-FRAME',
|
||||
'ON-FRAME-', 'ON-FRAME-B', 'ON-FRAME-BO', 'ON-FRAME-BOR', 'ON-FRAME-BORD',
|
||||
'ON-FRAME-BORDE', 'OPEN', 'OPSYS', 'OPTION', 'OR', 'ORDERED-JOIN',
|
||||
'ORDINAL', 'OS-APPEND', 'OS-COMMAND', 'OS-COPY', 'OS-CREATE-DIR',
|
||||
'OS-DELETE', 'OS-DIR', 'OS-DRIVES', 'OS-DRIVE', 'OS-ERROR', 'OS-GETENV',
|
||||
'OS-RENAME', 'OTHERWISE', 'OUTPUT', 'OVERLAY', 'OVERRIDE', 'OWNER', 'PAGE',
|
||||
'PAGE-BOTTOM', 'PAGE-BOT', 'PAGE-BOTT', 'PAGE-BOTTO', 'PAGED',
|
||||
'PAGE-NUMBER', 'PAGE-NUM', 'PAGE-NUMB', 'PAGE-NUMBE', 'PAGE-SIZE',
|
||||
'PAGE-TOP', 'PAGE-WIDTH', 'PAGE-WID', 'PAGE-WIDT', 'PARAMETER', 'PARAM',
|
||||
'PARAME', 'PARAMET', 'PARAMETE', 'PARENT', 'PARSE-STATUS', 'PARTIAL-KEY',
|
||||
'PASCAL', 'PASSWORD-FIELD', 'PATHNAME', 'PAUSE', 'PBE-HASH-ALGORITHM',
|
||||
'PBE-HASH-ALG', 'PBE-HASH-ALGO', 'PBE-HASH-ALGOR', 'PBE-HASH-ALGORI',
|
||||
'PBE-HASH-ALGORIT', 'PBE-HASH-ALGORITH', 'PBE-KEY-ROUNDS', 'PDBNAME',
|
||||
'PERSISTENT', 'PERSIST', 'PERSISTE', 'PERSISTEN',
|
||||
'PERSISTENT-CACHE-DISABLED', 'PFCOLOR', 'PFC', 'PFCO', 'PFCOL', 'PFCOLO',
|
||||
'PIXELS', 'PIXELS-PER-COLUMN', 'PIXELS-PER-COL', 'PIXELS-PER-COLU',
|
||||
'PIXELS-PER-COLUM', 'PIXELS-PER-ROW', 'POPUP-MENU', 'POPUP-M', 'POPUP-ME',
|
||||
'POPUP-MEN', 'POPUP-ONLY', 'POPUP-O', 'POPUP-ON', 'POPUP-ONL', 'PORTRAIT',
|
||||
'POSITION', 'PRECISION', 'PREFER-DATASET', 'PREPARED', 'PREPARE-STRING',
|
||||
'PREPROCESS', 'PREPROC', 'PREPROCE', 'PREPROCES', 'PRESELECT', 'PRESEL',
|
||||
'PRESELE', 'PRESELEC', 'PREV', 'PREV-COLUMN', 'PREV-SIBLING',
|
||||
'PREV-TAB-ITEM', 'PREV-TAB-I', 'PREV-TAB-IT', 'PREV-TAB-ITE', 'PRIMARY',
|
||||
'PRINTER', 'PRINTER-CONTROL-HANDLE', 'PRINTER-HDC', 'PRINTER-NAME',
|
||||
'PRINTER-PORT', 'PRINTER-SETUP', 'PRIVATE', 'PRIVATE-DATA', 'PRIVATE-D',
|
||||
'PRIVATE-DA', 'PRIVATE-DAT', 'PRIVILEGES', 'PROCEDURE', 'PROCE', 'PROCED',
|
||||
'PROCEDU', 'PROCEDUR', 'PROCEDURE-CALL-TYPE', 'PROCESS', 'PROC-HANDLE',
|
||||
'PROC-HA', 'PROC-HAN', 'PROC-HAND', 'PROC-HANDL', 'PROC-STATUS', 'PROC-ST',
|
||||
'PROC-STA', 'PROC-STAT', 'PROC-STATU', 'proc-text', 'proc-text-buffe',
|
||||
'PROFILER', 'PROGRAM-NAME', 'PROGRESS', 'PROGRESS-SOURCE', 'PROGRESS-S',
|
||||
'PROGRESS-SO', 'PROGRESS-SOU', 'PROGRESS-SOUR', 'PROGRESS-SOURC', 'PROMPT',
|
||||
'PROMPT-FOR', 'PROMPT-F', 'PROMPT-FO', 'PROMSGS', 'PROPATH', 'PROPERTY',
|
||||
'PROTECTED', 'PROVERSION', 'PROVERS', 'PROVERSI', 'PROVERSIO', 'PROXY',
|
||||
'PROXY-PASSWORD', 'PROXY-USERID', 'PUBLIC', 'PUBLIC-ID', 'PUBLISH',
|
||||
'PUBLISHED-EVENTS', 'PUT', 'PUTBYTE', 'PUT-BYTE', 'PUT-DOUBLE', 'PUT-FLOAT',
|
||||
'PUT-INT64', 'PUT-KEY-VALUE', 'PUT-KEY-VAL', 'PUT-KEY-VALU', 'PUT-LONG',
|
||||
'PUT-SHORT', 'PUT-STRING', 'PUT-UNSIGNED-LONG', 'QUERY', 'QUERY-CLOSE',
|
||||
'QUERY-OFF-END', 'QUERY-OPEN', 'QUERY-PREPARE', 'QUERY-TUNING', 'QUESTION',
|
||||
'QUIT', 'QUOTER', 'RADIO-BUTTONS', 'RADIO-SET', 'RANDOM', 'RAW-TRANSFER',
|
||||
'RCODE-INFORMATION', 'RCODE-INFO', 'RCODE-INFOR', 'RCODE-INFORM',
|
||||
'RCODE-INFORMA', 'RCODE-INFORMAT', 'RCODE-INFORMATI', 'RCODE-INFORMATIO',
|
||||
'READ-AVAILABLE', 'READ-EXACT-NUM', 'READ-FILE', 'READKEY', 'READ-ONLY',
|
||||
'READ-XML', 'READ-XMLSCHEMA', 'REAL', 'RECORD-LENGTH', 'RECTANGLE', 'RECT',
|
||||
'RECTA', 'RECTAN', 'RECTANG', 'RECTANGL', 'RECURSIVE', 'REFERENCE-ONLY',
|
||||
'REFRESH', 'REFRESHABLE', 'REFRESH-AUDIT-POLICY', 'REGISTER-DOMAIN',
|
||||
'RELEASE', 'REMOTE', 'REMOVE-EVENTS-PROCEDURE', 'REMOVE-SUPER-PROCEDURE',
|
||||
'REPEAT', 'REPLACE', 'REPLACE-SELECTION-TEXT', 'REPOSITION',
|
||||
'REPOSITION-BACKWARD', 'REPOSITION-FORWARD', 'REPOSITION-MODE',
|
||||
'REPOSITION-TO-ROW', 'REPOSITION-TO-ROWID', 'REQUEST', 'RESET', 'RESIZABLE',
|
||||
'RESIZA', 'RESIZAB', 'RESIZABL', 'RESIZE', 'RESTART-ROW', 'RESTART-ROWID',
|
||||
'RETAIN', 'RETAIN-SHAPE', 'RETRY', 'RETRY-CANCEL', 'RETURN',
|
||||
'RETURN-INSERTED', 'RETURN-INS', 'RETURN-INSE', 'RETURN-INSER',
|
||||
'RETURN-INSERT', 'RETURN-INSERTE', 'RETURNS', 'RETURN-TO-START-DIR',
|
||||
'RETURN-TO-START-DI', 'RETURN-VALUE', 'RETURN-VAL', 'RETURN-VALU',
|
||||
'RETURN-VALUE-DATA-TYPE', 'REVERSE-FROM', 'REVERT', 'REVOKE', 'RGB-VALUE',
|
||||
'RIGHT-ALIGNED', 'RETURN-ALIGN', 'RETURN-ALIGNE', 'RIGHT-TRIM', 'R-INDEX',
|
||||
'ROLES', 'ROUND', 'ROUTINE-LEVEL', 'ROW', 'ROW-HEIGHT-CHARS', 'HEIGHT',
|
||||
'ROW-HEIGHT-PIXELS', 'HEIGHT-P', 'ROW-MARKERS', 'ROW-OF', 'ROW-RESIZABLE',
|
||||
'RULE', 'RUN', 'RUN-PROCEDURE', 'SAVE', 'SAVE-AS', 'SAVE-FILE',
|
||||
'SAX-COMPLETE', 'SAX-COMPLE', 'SAX-COMPLET', 'SAX-PARSE', 'SAX-PARSE-FIRST',
|
||||
'SAX-PARSE-NEXT', 'SAX-PARSER-ERROR', 'SAX-RUNNING', 'SAX-UNINITIALIZED',
|
||||
'SAX-WRITE-BEGIN', 'SAX-WRITE-COMPLETE', 'SAX-WRITE-CONTENT',
|
||||
'SAX-WRITE-ELEMENT', 'SAX-WRITE-ERROR', 'SAX-WRITE-IDLE', 'SAX-WRITER',
|
||||
'SAX-WRITE-TAG', 'SCHEMA', 'SCHEMA-LOCATION', 'SCHEMA-MARSHAL',
|
||||
'SCHEMA-PATH', 'SCREEN', 'SCREEN-IO', 'SCREEN-LINES', 'SCREEN-VALUE',
|
||||
'SCREEN-VAL', 'SCREEN-VALU', 'SCROLL', 'SCROLLABLE', 'SCROLLBAR-HORIZONTAL',
|
||||
'SCROLLBAR-H', 'SCROLLBAR-HO', 'SCROLLBAR-HOR', 'SCROLLBAR-HORI',
|
||||
'SCROLLBAR-HORIZ', 'SCROLLBAR-HORIZO', 'SCROLLBAR-HORIZON',
|
||||
'SCROLLBAR-HORIZONT', 'SCROLLBAR-HORIZONTA', 'SCROLL-BARS',
|
||||
'SCROLLBAR-VERTICAL', 'SCROLLBAR-V', 'SCROLLBAR-VE', 'SCROLLBAR-VER',
|
||||
'SCROLLBAR-VERT', 'SCROLLBAR-VERTI', 'SCROLLBAR-VERTIC',
|
||||
'SCROLLBAR-VERTICA', 'SCROLL-DELTA', 'SCROLLED-ROW-POSITION',
|
||||
'SCROLLED-ROW-POS', 'SCROLLED-ROW-POSI', 'SCROLLED-ROW-POSIT',
|
||||
'SCROLLED-ROW-POSITI', 'SCROLLED-ROW-POSITIO', 'SCROLLING', 'SCROLL-OFFSET',
|
||||
'SCROLL-TO-CURRENT-ROW', 'SCROLL-TO-ITEM', 'SCROLL-TO-I', 'SCROLL-TO-IT',
|
||||
'SCROLL-TO-ITE', 'SCROLL-TO-SELECTED-ROW', 'SDBNAME', 'SEAL',
|
||||
'SEAL-TIMESTAMP', 'SEARCH', 'SEARCH-SELF', 'SEARCH-TARGET', 'SECTION',
|
||||
'SECURITY-POLICY', 'SEEK', 'SELECT', 'SELECTABLE', 'SELECT-ALL', 'SELECTED',
|
||||
'SELECT-FOCUSED-ROW', 'SELECTION', 'SELECTION-END', 'SELECTION-LIST',
|
||||
'SELECTION-START', 'SELECTION-TEXT', 'SELECT-NEXT-ROW', 'SELECT-PREV-ROW',
|
||||
'SELECT-ROW', 'SELF', 'SEND', 'send-sql-statement', 'send-sql', 'SENSITIVE',
|
||||
'SEPARATE-CONNECTION', 'SEPARATOR-FGCOLOR', 'SEPARATORS', 'SERVER',
|
||||
'SERVER-CONNECTION-BOUND', 'SERVER-CONNECTION-BOUND-REQUEST',
|
||||
'SERVER-CONNECTION-CONTEXT', 'SERVER-CONNECTION-ID',
|
||||
'SERVER-OPERATING-MODE', 'SESSION', 'SESSION-ID', 'SET', 'SET-APPL-CONTEXT',
|
||||
'SET-ATTR-CALL-TYPE', 'SET-ATTRIBUTE-NODE', 'SET-BLUE-VALUE', 'SET-BLUE',
|
||||
'SET-BLUE-', 'SET-BLUE-V', 'SET-BLUE-VA', 'SET-BLUE-VAL', 'SET-BLUE-VALU',
|
||||
'SET-BREAK', 'SET-BUFFERS', 'SET-CALLBACK', 'SET-CLIENT', 'SET-COMMIT',
|
||||
'SET-CONTENTS', 'SET-CURRENT-VALUE', 'SET-DB-CLIENT', 'SET-DYNAMIC',
|
||||
'SET-EVENT-MANAGER-OPTION', 'SET-GREEN-VALUE', 'SET-GREEN', 'SET-GREEN-',
|
||||
'SET-GREEN-V', 'SET-GREEN-VA', 'SET-GREEN-VAL', 'SET-GREEN-VALU',
|
||||
'SET-INPUT-SOURCE', 'SET-OPTION', 'SET-OUTPUT-DESTINATION', 'SET-PARAMETER',
|
||||
'SET-POINTER-VALUE', 'SET-PROPERTY', 'SET-RED-VALUE', 'SET-RED', 'SET-RED-',
|
||||
'SET-RED-V', 'SET-RED-VA', 'SET-RED-VAL', 'SET-RED-VALU',
|
||||
'SET-REPOSITIONED-ROW', 'SET-RGB-VALUE', 'SET-ROLLBACK', 'SET-SELECTION',
|
||||
'SET-SIZE', 'SET-SORT-ARROW', 'SETUSERID', 'SETUSER', 'SETUSERI',
|
||||
'SET-WAIT-STATE', 'SHA1-DIGEST', 'SHARED', 'SHARE-LOCK', 'SHARE', 'SHARE-',
|
||||
'SHARE-L', 'SHARE-LO', 'SHARE-LOC', 'SHOW-IN-TASKBAR', 'SHOW-STATS',
|
||||
'SHOW-STAT', 'SIDE-LABEL-HANDLE', 'SIDE-LABEL-H', 'SIDE-LABEL-HA',
|
||||
'SIDE-LABEL-HAN', 'SIDE-LABEL-HAND', 'SIDE-LABEL-HANDL', 'SIDE-LABELS',
|
||||
'SIDE-LAB', 'SIDE-LABE', 'SIDE-LABEL', 'SILENT', 'SIMPLE', 'SINGLE', 'SIZE',
|
||||
'SIZE-CHARS', 'SIZE-C', 'SIZE-CH', 'SIZE-CHA', 'SIZE-CHAR', 'SIZE-PIXELS',
|
||||
'SIZE-P', 'SIZE-PI', 'SIZE-PIX', 'SIZE-PIXE', 'SIZE-PIXEL', 'SKIP',
|
||||
'SKIP-DELETED-RECORD', 'SLIDER', 'SMALL-ICON', 'SMALLINT', 'SMALL-TITLE',
|
||||
'SOME', 'SORT', 'SORT-ASCENDING', 'SORT-NUMBER', 'SOURCE',
|
||||
'SOURCE-PROCEDURE', 'SPACE', 'SQL', 'SQRT', 'SSL-SERVER-NAME', 'STANDALONE',
|
||||
'START', 'START-DOCUMENT', 'START-ELEMENT', 'START-MOVE', 'START-RESIZE',
|
||||
'START-ROW-RESIZE', 'STATE-DETAIL', 'STATIC', 'STATUS', 'STATUS-AREA',
|
||||
'STATUS-AREA-FONT', 'STDCALL', 'STOP', 'STOP-PARSING', 'STOPPED', 'STOPPE',
|
||||
'STORED-PROCEDURE', 'STORED-PROC', 'STORED-PROCE', 'STORED-PROCED',
|
||||
'STORED-PROCEDU', 'STORED-PROCEDUR', 'STREAM', 'STREAM-HANDLE', 'STREAM-IO',
|
||||
'STRETCH-TO-FIT', 'STRICT', 'STRING', 'STRING-VALUE', 'STRING-XREF',
|
||||
'SUB-AVERAGE', 'SUB-AVE', 'SUB-AVER', 'SUB-AVERA', 'SUB-AVERAG',
|
||||
'SUB-COUNT', 'SUB-MAXIMUM', 'SUM-MAX', 'SUM-MAXI', 'SUM-MAXIM',
|
||||
'SUM-MAXIMU', 'SUB-MENU', 'SUBSUB-', 'MINIMUM', 'SUB-MIN', 'SUBSCRIBE',
|
||||
'SUBSTITUTE', 'SUBST', 'SUBSTI', 'SUBSTIT', 'SUBSTITU', 'SUBSTITUT',
|
||||
'SUBSTRING', 'SUBSTR', 'SUBSTRI', 'SUBSTRIN', 'SUB-TOTAL', 'SUBTYPE', 'SUM',
|
||||
'SUPER', 'SUPER-PROCEDURES', 'SUPPRESS-NAMESPACE-PROCESSING',
|
||||
'SUPPRESS-WARNINGS', 'SUPPRESS-W', 'SUPPRESS-WA', 'SUPPRESS-WAR',
|
||||
'SUPPRESS-WARN', 'SUPPRESS-WARNI', 'SUPPRESS-WARNIN', 'SUPPRESS-WARNING',
|
||||
'SYMMETRIC-ENCRYPTION-ALGORITHM', 'SYMMETRIC-ENCRYPTION-IV',
|
||||
'SYMMETRIC-ENCRYPTION-KEY', 'SYMMETRIC-SUPPORT', 'SYSTEM-ALERT-BOXES',
|
||||
'SYSTEM-ALERT', 'SYSTEM-ALERT-', 'SYSTEM-ALERT-B', 'SYSTEM-ALERT-BO',
|
||||
'SYSTEM-ALERT-BOX', 'SYSTEM-ALERT-BOXE', 'SYSTEM-DIALOG', 'SYSTEM-HELP',
|
||||
'SYSTEM-ID', 'TABLE', 'TABLE-HANDLE', 'TABLE-NUMBER', 'TAB-POSITION',
|
||||
'TAB-STOP', 'TARGET', 'TARGET-PROCEDURE', 'TEMP-DIRECTORY', 'TEMP-DIR',
|
||||
'TEMP-DIRE', 'TEMP-DIREC', 'TEMP-DIRECT', 'TEMP-DIRECTO', 'TEMP-DIRECTOR',
|
||||
'TEMP-TABLE', 'TEMP-TABLE-PREPARE', 'TERM', 'TERMINAL', 'TERM', 'TERMI',
|
||||
'TERMIN', 'TERMINA', 'TERMINATE', 'TEXT', 'TEXT-CURSOR', 'TEXT-SEG-GROW',
|
||||
'TEXT-SELECTED', 'THEN', 'THIS-OBJECT', 'THIS-PROCEDURE', 'THREE-D',
|
||||
'THROW', 'THROUGH', 'THRU', 'TIC-MARKS', 'TIME', 'TIME-SOURCE', 'TITLE',
|
||||
'TITLE-BGCOLOR', 'TITLE-BGC', 'TITLE-BGCO', 'TITLE-BGCOL', 'TITLE-BGCOLO',
|
||||
'TITLE-DCOLOR', 'TITLE-DC', 'TITLE-DCO', 'TITLE-DCOL', 'TITLE-DCOLO',
|
||||
'TITLE-FGCOLOR', 'TITLE-FGC', 'TITLE-FGCO', 'TITLE-FGCOL', 'TITLE-FGCOLO',
|
||||
'TITLE-FONT', 'TITLE-FO', 'TITLE-FON', 'TO', 'TODAY', 'TOGGLE-BOX',
|
||||
'TOOLTIP', 'TOOLTIPS', 'TOPIC', 'TOP-NAV-QUERY', 'TOP-ONLY', 'TO-ROWID',
|
||||
'TOTAL', 'TRAILING', 'TRANS', 'TRANSACTION', 'TRANSACTION-MODE',
|
||||
'TRANS-INIT-PROCEDURE', 'TRANSPARENT', 'TRIGGER', 'TRIGGERS', 'TRIM',
|
||||
'TRUE', 'TRUNCATE', 'TRUNC', 'TRUNCA', 'TRUNCAT', 'TYPE', 'TYPE-OF',
|
||||
'UNBOX', 'UNBUFFERED', 'UNBUFF', 'UNBUFFE', 'UNBUFFER', 'UNBUFFERE',
|
||||
'UNDERLINE', 'UNDERL', 'UNDERLI', 'UNDERLIN', 'UNDO', 'UNFORMATTED',
|
||||
'UNFORM', 'UNFORMA', 'UNFORMAT', 'UNFORMATT', 'UNFORMATTE', 'UNION',
|
||||
'UNIQUE', 'UNIQUE-ID', 'UNIQUE-MATCH', 'UNIX', 'UNLESS-HIDDEN', 'UNLOAD',
|
||||
'UNSIGNED-LONG', 'UNSUBSCRIBE', 'UP', 'UPDATE', 'UPDATE-ATTRIBUTE', 'URL',
|
||||
'URL-DECODE', 'URL-ENCODE', 'URL-PASSWORD', 'URL-USERID', 'USE',
|
||||
'USE-DICT-EXPS', 'USE-FILENAME', 'USE-INDEX', 'USER', 'USE-REVVIDEO',
|
||||
'USERID', 'USER-ID', 'USE-TEXT', 'USE-UNDERLINE', 'USE-WIDGET-POOL',
|
||||
'USING', 'V6DISPLAY', 'V6FRAME', 'VALIDATE', 'VALIDATE-EXPRESSION',
|
||||
'VALIDATE-MESSAGE', 'VALIDATE-SEAL', 'VALIDATION-ENABLED', 'VALID-EVENT',
|
||||
'VALID-HANDLE', 'VALID-OBJECT', 'VALUE', 'VALUE-CHANGED', 'VALUES',
|
||||
'VARIABLE', 'VAR', 'VARI', 'VARIA', 'VARIAB', 'VARIABL', 'VERBOSE',
|
||||
'VERSION', 'VERTICAL', 'VERT', 'VERTI', 'VERTIC', 'VERTICA', 'VIEW',
|
||||
'VIEW-AS', 'VIEW-FIRST-COLUMN-ON-REOPEN', 'VIRTUAL-HEIGHT-CHARS',
|
||||
'VIRTUAL-HEIGHT', 'VIRTUAL-HEIGHT-', 'VIRTUAL-HEIGHT-C',
|
||||
'VIRTUAL-HEIGHT-CH', 'VIRTUAL-HEIGHT-CHA', 'VIRTUAL-HEIGHT-CHAR',
|
||||
'VIRTUAL-HEIGHT-PIXELS', 'VIRTUAL-HEIGHT-P', 'VIRTUAL-HEIGHT-PI',
|
||||
'VIRTUAL-HEIGHT-PIX', 'VIRTUAL-HEIGHT-PIXE', 'VIRTUAL-HEIGHT-PIXEL',
|
||||
'VIRTUAL-WIDTH-CHARS', 'VIRTUAL-WIDTH', 'VIRTUAL-WIDTH-', 'VIRTUAL-WIDTH-C',
|
||||
'VIRTUAL-WIDTH-CH', 'VIRTUAL-WIDTH-CHA', 'VIRTUAL-WIDTH-CHAR',
|
||||
'VIRTUAL-WIDTH-PIXELS', 'VIRTUAL-WIDTH-P', 'VIRTUAL-WIDTH-PI',
|
||||
'VIRTUAL-WIDTH-PIX', 'VIRTUAL-WIDTH-PIXE', 'VIRTUAL-WIDTH-PIXEL', 'VISIBLE',
|
||||
'VOID', 'WAIT', 'WAIT-FOR', 'WARNING', 'WEB-CONTEXT', 'WEEKDAY', 'WHEN',
|
||||
'WHERE', 'WHILE', 'WIDGET', 'WIDGET-ENTER', 'WIDGET-E', 'WIDGET-EN',
|
||||
'WIDGET-ENT', 'WIDGET-ENTE', 'WIDGET-ID', 'WIDGET-LEAVE', 'WIDGET-L',
|
||||
'WIDGET-LE', 'WIDGET-LEA', 'WIDGET-LEAV', 'WIDGET-POOL', 'WIDTH',
|
||||
'WIDTH-CHARS', 'WIDTH', 'WIDTH-', 'WIDTH-C', 'WIDTH-CH', 'WIDTH-CHA',
|
||||
'WIDTH-CHAR', 'WIDTH-PIXELS', 'WIDTH-P', 'WIDTH-PI', 'WIDTH-PIX',
|
||||
'WIDTH-PIXE', 'WIDTH-PIXEL', 'WINDOW', 'WINDOW-MAXIMIZED', 'WINDOW-MAXIM',
|
||||
'WINDOW-MAXIMI', 'WINDOW-MAXIMIZ', 'WINDOW-MAXIMIZE', 'WINDOW-MINIMIZED',
|
||||
'WINDOW-MINIM', 'WINDOW-MINIMI', 'WINDOW-MINIMIZ', 'WINDOW-MINIMIZE',
|
||||
'WINDOW-NAME', 'WINDOW-NORMAL', 'WINDOW-STATE', 'WINDOW-STA', 'WINDOW-STAT',
|
||||
'WINDOW-SYSTEM', 'WITH', 'WORD-INDEX', 'WORD-WRAP',
|
||||
'WORK-AREA-HEIGHT-PIXELS', 'WORK-AREA-WIDTH-PIXELS', 'WORK-AREA-X',
|
||||
'WORK-AREA-Y', 'WORKFILE', 'WORK-TABLE', 'WORK-TAB', 'WORK-TABL', 'WRITE',
|
||||
'WRITE-CDATA', 'WRITE-CHARACTERS', 'WRITE-COMMENT', 'WRITE-DATA-ELEMENT',
|
||||
'WRITE-EMPTY-ELEMENT', 'WRITE-ENTITY-REF', 'WRITE-EXTERNAL-DTD',
|
||||
'WRITE-FRAGMENT', 'WRITE-MESSAGE', 'WRITE-PROCESSING-INSTRUCTION',
|
||||
'WRITE-STATUS', 'WRITE-XML', 'WRITE-XMLSCHEMA', 'X', 'XCODE',
|
||||
'XML-DATA-TYPE', 'XML-NODE-TYPE', 'XML-SCHEMA-PATH',
|
||||
'XML-SUPPRESS-NAMESPACE-PROCESSING', 'X-OF', 'XREF', 'XREF-XML', 'Y',
|
||||
'YEAR', 'YEAR-OFFSET', 'YES', 'YES-NO', 'YES-NO-CANCEL', 'Y-OF'
|
||||
]
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,233 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._postgres_builtins
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Self-updating data files for PostgreSQL lexer.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
import urllib
|
||||
|
||||
# One man's constant is another man's variable.
|
||||
SOURCE_URL = 'https://github.com/postgres/postgres/raw/master'
|
||||
KEYWORDS_URL = SOURCE_URL + '/doc/src/sgml/keywords.sgml'
|
||||
DATATYPES_URL = SOURCE_URL + '/doc/src/sgml/datatype.sgml'
|
||||
|
||||
def update_myself():
|
||||
data_file = list(fetch(DATATYPES_URL))
|
||||
datatypes = parse_datatypes(data_file)
|
||||
pseudos = parse_pseudos(data_file)
|
||||
|
||||
keywords = parse_keywords(fetch(KEYWORDS_URL))
|
||||
update_consts(__file__, 'DATATYPES', datatypes)
|
||||
update_consts(__file__, 'PSEUDO_TYPES', pseudos)
|
||||
update_consts(__file__, 'KEYWORDS', keywords)
|
||||
|
||||
def parse_keywords(f):
|
||||
kw = []
|
||||
for m in re.finditer(
|
||||
r'\s*<entry><token>([^<]+)</token></entry>\s*'
|
||||
r'<entry>([^<]+)</entry>', f.read()):
|
||||
kw.append(m.group(1))
|
||||
|
||||
if not kw:
|
||||
raise ValueError('no keyword found')
|
||||
|
||||
kw.sort()
|
||||
return kw
|
||||
|
||||
def parse_datatypes(f):
|
||||
dt = set()
|
||||
for line in f:
|
||||
if '<sect1' in line:
|
||||
break
|
||||
if '<entry><type>' not in line:
|
||||
continue
|
||||
|
||||
# Parse a string such as
|
||||
# time [ (<replaceable>p</replaceable>) ] [ without time zone ]
|
||||
# into types "time" and "without time zone"
|
||||
|
||||
# remove all the tags
|
||||
line = re.sub("<replaceable>[^<]+</replaceable>", "", line)
|
||||
line = re.sub("<[^>]+>", "", line)
|
||||
|
||||
# Drop the parts containing braces
|
||||
for tmp in [t for tmp in line.split('[')
|
||||
for t in tmp.split(']') if "(" not in t]:
|
||||
for t in tmp.split(','):
|
||||
t = t.strip()
|
||||
if not t: continue
|
||||
dt.add(" ".join(t.split()))
|
||||
|
||||
dt = list(dt)
|
||||
dt.sort()
|
||||
return dt
|
||||
|
||||
def parse_pseudos(f):
|
||||
dt = []
|
||||
re_start = re.compile(r'\s*<table id="datatype-pseudotypes-table">')
|
||||
re_entry = re.compile(r'\s*<entry><type>([^<]+)</></entry>')
|
||||
re_end = re.compile(r'\s*</table>')
|
||||
|
||||
f = iter(f)
|
||||
for line in f:
|
||||
if re_start.match(line) is not None:
|
||||
break
|
||||
else:
|
||||
raise ValueError('pseudo datatypes table not found')
|
||||
|
||||
for line in f:
|
||||
m = re_entry.match(line)
|
||||
if m is not None:
|
||||
dt.append(m.group(1))
|
||||
|
||||
if re_end.match(line) is not None:
|
||||
break
|
||||
else:
|
||||
raise ValueError('end of pseudo datatypes table not found')
|
||||
|
||||
if not dt:
|
||||
raise ValueError('pseudo datatypes not found')
|
||||
|
||||
return dt
|
||||
|
||||
def fetch(url):
|
||||
return urllib.urlopen(url)
|
||||
|
||||
def update_consts(filename, constname, content):
|
||||
f = open(filename)
|
||||
lines = f.readlines()
|
||||
f.close()
|
||||
|
||||
# Line to start/end inserting
|
||||
re_start = re.compile(r'^%s\s*=\s*\[\s*$' % constname)
|
||||
re_end = re.compile(r'^\s*\]\s*$')
|
||||
start = [ n for n, l in enumerate(lines) if re_start.match(l) ]
|
||||
if not start:
|
||||
raise ValueError("couldn't find line containing '%s = ['" % constname)
|
||||
if len(start) > 1:
|
||||
raise ValueError("too many lines containing '%s = ['" % constname)
|
||||
start = start[0] + 1
|
||||
|
||||
end = [ n for n, l in enumerate(lines) if n >= start and re_end.match(l) ]
|
||||
if not end:
|
||||
raise ValueError("couldn't find line containing ']' after %s " % constname)
|
||||
end = end[0]
|
||||
|
||||
# Pack the new content in lines not too long
|
||||
content = [repr(item) for item in content ]
|
||||
new_lines = [[]]
|
||||
for item in content:
|
||||
if sum(map(len, new_lines[-1])) + 2 * len(new_lines[-1]) + len(item) + 4 > 75:
|
||||
new_lines.append([])
|
||||
new_lines[-1].append(item)
|
||||
|
||||
lines[start:end] = [ " %s,\n" % ", ".join(items) for items in new_lines ]
|
||||
|
||||
f = open(filename, 'w')
|
||||
f.write(''.join(lines))
|
||||
f.close()
|
||||
|
||||
|
||||
# Autogenerated: please edit them if you like wasting your time.
|
||||
|
||||
KEYWORDS = [
|
||||
'ABORT', 'ABSOLUTE', 'ACCESS', 'ACTION', 'ADD', 'ADMIN', 'AFTER',
|
||||
'AGGREGATE', 'ALL', 'ALSO', 'ALTER', 'ALWAYS', 'ANALYSE', 'ANALYZE',
|
||||
'AND', 'ANY', 'ARRAY', 'AS', 'ASC', 'ASSERTION', 'ASSIGNMENT',
|
||||
'ASYMMETRIC', 'AT', 'ATTRIBUTE', 'AUTHORIZATION', 'BACKWARD', 'BEFORE',
|
||||
'BEGIN', 'BETWEEN', 'BIGINT', 'BINARY', 'BIT', 'BOOLEAN', 'BOTH', 'BY',
|
||||
'CACHE', 'CALLED', 'CASCADE', 'CASCADED', 'CASE', 'CAST', 'CATALOG',
|
||||
'CHAIN', 'CHAR', 'CHARACTER', 'CHARACTERISTICS', 'CHECK', 'CHECKPOINT',
|
||||
'CLASS', 'CLOSE', 'CLUSTER', 'COALESCE', 'COLLATE', 'COLLATION',
|
||||
'COLUMN', 'COMMENT', 'COMMENTS', 'COMMIT', 'COMMITTED', 'CONCURRENTLY',
|
||||
'CONFIGURATION', 'CONNECTION', 'CONSTRAINT', 'CONSTRAINTS', 'CONTENT',
|
||||
'CONTINUE', 'CONVERSION', 'COPY', 'COST', 'CREATE', 'CROSS', 'CSV',
|
||||
'CURRENT', 'CURRENT_CATALOG', 'CURRENT_DATE', 'CURRENT_ROLE',
|
||||
'CURRENT_SCHEMA', 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'CURRENT_USER',
|
||||
'CURSOR', 'CYCLE', 'DATA', 'DATABASE', 'DAY', 'DEALLOCATE', 'DEC',
|
||||
'DECIMAL', 'DECLARE', 'DEFAULT', 'DEFAULTS', 'DEFERRABLE', 'DEFERRED',
|
||||
'DEFINER', 'DELETE', 'DELIMITER', 'DELIMITERS', 'DESC', 'DICTIONARY',
|
||||
'DISABLE', 'DISCARD', 'DISTINCT', 'DO', 'DOCUMENT', 'DOMAIN', 'DOUBLE',
|
||||
'DROP', 'EACH', 'ELSE', 'ENABLE', 'ENCODING', 'ENCRYPTED', 'END',
|
||||
'ENUM', 'ESCAPE', 'EXCEPT', 'EXCLUDE', 'EXCLUDING', 'EXCLUSIVE',
|
||||
'EXECUTE', 'EXISTS', 'EXPLAIN', 'EXTENSION', 'EXTERNAL', 'EXTRACT',
|
||||
'FALSE', 'FAMILY', 'FETCH', 'FIRST', 'FLOAT', 'FOLLOWING', 'FOR',
|
||||
'FORCE', 'FOREIGN', 'FORWARD', 'FREEZE', 'FROM', 'FULL', 'FUNCTION',
|
||||
'FUNCTIONS', 'GLOBAL', 'GRANT', 'GRANTED', 'GREATEST', 'GROUP',
|
||||
'HANDLER', 'HAVING', 'HEADER', 'HOLD', 'HOUR', 'IDENTITY', 'IF',
|
||||
'ILIKE', 'IMMEDIATE', 'IMMUTABLE', 'IMPLICIT', 'IN', 'INCLUDING',
|
||||
'INCREMENT', 'INDEX', 'INDEXES', 'INHERIT', 'INHERITS', 'INITIALLY',
|
||||
'INLINE', 'INNER', 'INOUT', 'INPUT', 'INSENSITIVE', 'INSERT', 'INSTEAD',
|
||||
'INT', 'INTEGER', 'INTERSECT', 'INTERVAL', 'INTO', 'INVOKER', 'IS',
|
||||
'ISNULL', 'ISOLATION', 'JOIN', 'KEY', 'LABEL', 'LANGUAGE', 'LARGE',
|
||||
'LAST', 'LC_COLLATE', 'LC_CTYPE', 'LEADING', 'LEAST', 'LEFT', 'LEVEL',
|
||||
'LIKE', 'LIMIT', 'LISTEN', 'LOAD', 'LOCAL', 'LOCALTIME',
|
||||
'LOCALTIMESTAMP', 'LOCATION', 'LOCK', 'MAPPING', 'MATCH', 'MAXVALUE',
|
||||
'MINUTE', 'MINVALUE', 'MODE', 'MONTH', 'MOVE', 'NAME', 'NAMES',
|
||||
'NATIONAL', 'NATURAL', 'NCHAR', 'NEXT', 'NO', 'NONE', 'NOT', 'NOTHING',
|
||||
'NOTIFY', 'NOTNULL', 'NOWAIT', 'NULL', 'NULLIF', 'NULLS', 'NUMERIC',
|
||||
'OBJECT', 'OF', 'OFF', 'OFFSET', 'OIDS', 'ON', 'ONLY', 'OPERATOR',
|
||||
'OPTION', 'OPTIONS', 'OR', 'ORDER', 'OUT', 'OUTER', 'OVER', 'OVERLAPS',
|
||||
'OVERLAY', 'OWNED', 'OWNER', 'PARSER', 'PARTIAL', 'PARTITION',
|
||||
'PASSING', 'PASSWORD', 'PLACING', 'PLANS', 'POSITION', 'PRECEDING',
|
||||
'PRECISION', 'PREPARE', 'PREPARED', 'PRESERVE', 'PRIMARY', 'PRIOR',
|
||||
'PRIVILEGES', 'PROCEDURAL', 'PROCEDURE', 'QUOTE', 'RANGE', 'READ',
|
||||
'REAL', 'REASSIGN', 'RECHECK', 'RECURSIVE', 'REF', 'REFERENCES',
|
||||
'REINDEX', 'RELATIVE', 'RELEASE', 'RENAME', 'REPEATABLE', 'REPLACE',
|
||||
'REPLICA', 'RESET', 'RESTART', 'RESTRICT', 'RETURNING', 'RETURNS',
|
||||
'REVOKE', 'RIGHT', 'ROLE', 'ROLLBACK', 'ROW', 'ROWS', 'RULE',
|
||||
'SAVEPOINT', 'SCHEMA', 'SCROLL', 'SEARCH', 'SECOND', 'SECURITY',
|
||||
'SELECT', 'SEQUENCE', 'SEQUENCES', 'SERIALIZABLE', 'SERVER', 'SESSION',
|
||||
'SESSION_USER', 'SET', 'SETOF', 'SHARE', 'SHOW', 'SIMILAR', 'SIMPLE',
|
||||
'SMALLINT', 'SOME', 'STABLE', 'STANDALONE', 'START', 'STATEMENT',
|
||||
'STATISTICS', 'STDIN', 'STDOUT', 'STORAGE', 'STRICT', 'STRIP',
|
||||
'SUBSTRING', 'SYMMETRIC', 'SYSID', 'SYSTEM', 'TABLE', 'TABLES',
|
||||
'TABLESPACE', 'TEMP', 'TEMPLATE', 'TEMPORARY', 'TEXT', 'THEN', 'TIME',
|
||||
'TIMESTAMP', 'TO', 'TRAILING', 'TRANSACTION', 'TREAT', 'TRIGGER',
|
||||
'TRIM', 'TRUE', 'TRUNCATE', 'TRUSTED', 'TYPE', 'UNBOUNDED',
|
||||
'UNCOMMITTED', 'UNENCRYPTED', 'UNION', 'UNIQUE', 'UNKNOWN', 'UNLISTEN',
|
||||
'UNLOGGED', 'UNTIL', 'UPDATE', 'USER', 'USING', 'VACUUM', 'VALID',
|
||||
'VALIDATE', 'VALIDATOR', 'VALUE', 'VALUES', 'VARCHAR', 'VARIADIC',
|
||||
'VARYING', 'VERBOSE', 'VERSION', 'VIEW', 'VOLATILE', 'WHEN', 'WHERE',
|
||||
'WHITESPACE', 'WINDOW', 'WITH', 'WITHOUT', 'WORK', 'WRAPPER', 'WRITE',
|
||||
'XML', 'XMLATTRIBUTES', 'XMLCONCAT', 'XMLELEMENT', 'XMLEXISTS',
|
||||
'XMLFOREST', 'XMLPARSE', 'XMLPI', 'XMLROOT', 'XMLSERIALIZE', 'YEAR',
|
||||
'YES', 'ZONE',
|
||||
]
|
||||
|
||||
DATATYPES = [
|
||||
'bigint', 'bigserial', 'bit', 'bit varying', 'bool', 'boolean', 'box',
|
||||
'bytea', 'char', 'character', 'character varying', 'cidr', 'circle',
|
||||
'date', 'decimal', 'double precision', 'float4', 'float8', 'inet',
|
||||
'int', 'int2', 'int4', 'int8', 'integer', 'interval', 'json', 'line',
|
||||
'lseg', 'macaddr', 'money', 'numeric', 'path', 'point', 'polygon',
|
||||
'real', 'serial', 'serial2', 'serial4', 'serial8', 'smallint',
|
||||
'smallserial', 'text', 'time', 'timestamp', 'timestamptz', 'timetz',
|
||||
'tsquery', 'tsvector', 'txid_snapshot', 'uuid', 'varbit', 'varchar',
|
||||
'with time zone', 'without time zone', 'xml',
|
||||
]
|
||||
|
||||
PSEUDO_TYPES = [
|
||||
'any', 'anyelement', 'anyarray', 'anynonarray', 'anyenum', 'anyrange',
|
||||
'cstring', 'internal', 'language_handler', 'fdw_handler', 'record',
|
||||
'trigger', 'void', 'opaque',
|
||||
]
|
||||
|
||||
# Remove 'trigger' from types
|
||||
PSEUDO_TYPES = sorted(set(PSEUDO_TYPES) - set(map(str.lower, KEYWORDS)))
|
||||
|
||||
PLPGSQL_KEYWORDS = [
|
||||
'ALIAS', 'CONSTANT', 'DIAGNOSTICS', 'ELSIF', 'EXCEPTION', 'EXIT',
|
||||
'FOREACH', 'GET', 'LOOP', 'NOTICE', 'OPEN', 'PERFORM', 'QUERY', 'RAISE',
|
||||
'RETURN', 'REVERSE', 'SQLSTATE', 'WHILE',
|
||||
]
|
||||
|
||||
if __name__ == '__main__':
|
||||
update_myself()
|
||||
|
|
@ -0,0 +1,557 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._robotframeworklexer
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexer for Robot Framework.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
# Copyright 2012 Nokia Siemens Networks Oyj
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import Lexer
|
||||
from pygments.token import Token
|
||||
|
||||
|
||||
HEADING = Token.Generic.Heading
|
||||
SETTING = Token.Keyword.Namespace
|
||||
IMPORT = Token.Name.Namespace
|
||||
TC_KW_NAME = Token.Generic.Subheading
|
||||
KEYWORD = Token.Name.Function
|
||||
ARGUMENT = Token.String
|
||||
VARIABLE = Token.Name.Variable
|
||||
COMMENT = Token.Comment
|
||||
SEPARATOR = Token.Punctuation
|
||||
SYNTAX = Token.Punctuation
|
||||
GHERKIN = Token.Generic.Emph
|
||||
ERROR = Token.Error
|
||||
|
||||
|
||||
def normalize(string, remove=''):
|
||||
string = string.lower()
|
||||
for char in remove + ' ':
|
||||
if char in string:
|
||||
string = string.replace(char, '')
|
||||
return string
|
||||
|
||||
|
||||
class RobotFrameworkLexer(Lexer):
|
||||
"""
|
||||
For `Robot Framework <http://robotframework.org>`_ test data.
|
||||
|
||||
Supports both space and pipe separated plain text formats.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
name = 'RobotFramework'
|
||||
aliases = ['RobotFramework', 'robotframework']
|
||||
filenames = ['*.txt', '*.robot']
|
||||
mimetypes = ['text/x-robotframework']
|
||||
|
||||
def __init__(self, **options):
|
||||
options['tabsize'] = 2
|
||||
options['encoding'] = 'UTF-8'
|
||||
Lexer.__init__(self, **options)
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
row_tokenizer = RowTokenizer()
|
||||
var_tokenizer = VariableTokenizer()
|
||||
index = 0
|
||||
for row in text.splitlines():
|
||||
for value, token in row_tokenizer.tokenize(row):
|
||||
for value, token in var_tokenizer.tokenize(value, token):
|
||||
if value:
|
||||
yield index, token, unicode(value)
|
||||
index += len(value)
|
||||
|
||||
|
||||
class VariableTokenizer(object):
|
||||
|
||||
def tokenize(self, string, token):
|
||||
var = VariableSplitter(string, identifiers='$@%')
|
||||
if var.start < 0 or token in (COMMENT, ERROR):
|
||||
yield string, token
|
||||
return
|
||||
for value, token in self._tokenize(var, string, token):
|
||||
if value:
|
||||
yield value, token
|
||||
|
||||
def _tokenize(self, var, string, orig_token):
|
||||
before = string[:var.start]
|
||||
yield before, orig_token
|
||||
yield var.identifier + '{', SYNTAX
|
||||
for value, token in self.tokenize(var.base, VARIABLE):
|
||||
yield value, token
|
||||
yield '}', SYNTAX
|
||||
if var.index:
|
||||
yield '[', SYNTAX
|
||||
for value, token in self.tokenize(var.index, VARIABLE):
|
||||
yield value, token
|
||||
yield ']', SYNTAX
|
||||
for value, token in self.tokenize(string[var.end:], orig_token):
|
||||
yield value, token
|
||||
|
||||
|
||||
class RowTokenizer(object):
|
||||
|
||||
def __init__(self):
|
||||
self._table = UnknownTable()
|
||||
self._splitter = RowSplitter()
|
||||
testcases = TestCaseTable()
|
||||
settings = SettingTable(testcases.set_default_template)
|
||||
variables = VariableTable()
|
||||
keywords = KeywordTable()
|
||||
self._tables = {'settings': settings, 'setting': settings,
|
||||
'metadata': settings,
|
||||
'variables': variables, 'variable': variables,
|
||||
'testcases': testcases, 'testcase': testcases,
|
||||
'keywords': keywords, 'keyword': keywords,
|
||||
'userkeywords': keywords, 'userkeyword': keywords}
|
||||
|
||||
def tokenize(self, row):
|
||||
commented = False
|
||||
heading = False
|
||||
for index, value in enumerate(self._splitter.split(row)):
|
||||
# First value, and every second after that, is a separator.
|
||||
index, separator = divmod(index-1, 2)
|
||||
if value.startswith('#'):
|
||||
commented = True
|
||||
elif index == 0 and value.startswith('*'):
|
||||
self._table = self._start_table(value)
|
||||
heading = True
|
||||
for value, token in self._tokenize(value, index, commented,
|
||||
separator, heading):
|
||||
yield value, token
|
||||
self._table.end_row()
|
||||
|
||||
def _start_table(self, header):
|
||||
name = normalize(header, remove='*')
|
||||
return self._tables.get(name, UnknownTable())
|
||||
|
||||
def _tokenize(self, value, index, commented, separator, heading):
|
||||
if commented:
|
||||
yield value, COMMENT
|
||||
elif separator:
|
||||
yield value, SEPARATOR
|
||||
elif heading:
|
||||
yield value, HEADING
|
||||
else:
|
||||
for value, token in self._table.tokenize(value, index):
|
||||
yield value, token
|
||||
|
||||
|
||||
class RowSplitter(object):
|
||||
_space_splitter = re.compile('( {2,})')
|
||||
_pipe_splitter = re.compile('((?:^| +)\|(?: +|$))')
|
||||
|
||||
def split(self, row):
|
||||
splitter = (row.startswith('| ') and self._split_from_pipes
|
||||
or self._split_from_spaces)
|
||||
for value in splitter(row):
|
||||
yield value
|
||||
yield '\n'
|
||||
|
||||
def _split_from_spaces(self, row):
|
||||
yield '' # Start with (pseudo)separator similarly as with pipes
|
||||
for value in self._space_splitter.split(row):
|
||||
yield value
|
||||
|
||||
def _split_from_pipes(self, row):
|
||||
_, separator, rest = self._pipe_splitter.split(row, 1)
|
||||
yield separator
|
||||
while self._pipe_splitter.search(rest):
|
||||
cell, separator, rest = self._pipe_splitter.split(rest, 1)
|
||||
yield cell
|
||||
yield separator
|
||||
yield rest
|
||||
|
||||
|
||||
class Tokenizer(object):
|
||||
_tokens = None
|
||||
|
||||
def __init__(self):
|
||||
self._index = 0
|
||||
|
||||
def tokenize(self, value):
|
||||
values_and_tokens = self._tokenize(value, self._index)
|
||||
self._index += 1
|
||||
if isinstance(values_and_tokens, type(Token)):
|
||||
values_and_tokens = [(value, values_and_tokens)]
|
||||
return values_and_tokens
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
index = min(index, len(self._tokens) - 1)
|
||||
return self._tokens[index]
|
||||
|
||||
def _is_assign(self, value):
|
||||
if value.endswith('='):
|
||||
value = value[:-1].strip()
|
||||
var = VariableSplitter(value, identifiers='$@')
|
||||
return var.start == 0 and var.end == len(value)
|
||||
|
||||
|
||||
class Comment(Tokenizer):
|
||||
_tokens = (COMMENT,)
|
||||
|
||||
|
||||
class Setting(Tokenizer):
|
||||
_tokens = (SETTING, ARGUMENT)
|
||||
_keyword_settings = ('suitesetup', 'suiteprecondition', 'suiteteardown',
|
||||
'suitepostcondition', 'testsetup', 'testprecondition',
|
||||
'testteardown', 'testpostcondition', 'testtemplate')
|
||||
_import_settings = ('library', 'resource', 'variables')
|
||||
_other_settings = ('documentation', 'metadata', 'forcetags', 'defaulttags',
|
||||
'testtimeout')
|
||||
_custom_tokenizer = None
|
||||
|
||||
def __init__(self, template_setter=None):
|
||||
Tokenizer.__init__(self)
|
||||
self._template_setter = template_setter
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if index == 1 and self._template_setter:
|
||||
self._template_setter(value)
|
||||
if index == 0:
|
||||
normalized = normalize(value)
|
||||
if normalized in self._keyword_settings:
|
||||
self._custom_tokenizer = KeywordCall(support_assign=False)
|
||||
elif normalized in self._import_settings:
|
||||
self._custom_tokenizer = ImportSetting()
|
||||
elif normalized not in self._other_settings:
|
||||
return ERROR
|
||||
elif self._custom_tokenizer:
|
||||
return self._custom_tokenizer.tokenize(value)
|
||||
return Tokenizer._tokenize(self, value, index)
|
||||
|
||||
|
||||
class ImportSetting(Tokenizer):
|
||||
_tokens = (IMPORT, ARGUMENT)
|
||||
|
||||
|
||||
class TestCaseSetting(Setting):
|
||||
_keyword_settings = ('setup', 'precondition', 'teardown', 'postcondition',
|
||||
'template')
|
||||
_import_settings = ()
|
||||
_other_settings = ('documentation', 'tags', 'timeout')
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if index == 0:
|
||||
type = Setting._tokenize(self, value[1:-1], index)
|
||||
return [('[', SYNTAX), (value[1:-1], type), (']', SYNTAX)]
|
||||
return Setting._tokenize(self, value, index)
|
||||
|
||||
|
||||
class KeywordSetting(TestCaseSetting):
|
||||
_keyword_settings = ('teardown',)
|
||||
_other_settings = ('documentation', 'arguments', 'return', 'timeout')
|
||||
|
||||
|
||||
class Variable(Tokenizer):
|
||||
_tokens = (SYNTAX, ARGUMENT)
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if index == 0 and not self._is_assign(value):
|
||||
return ERROR
|
||||
return Tokenizer._tokenize(self, value, index)
|
||||
|
||||
|
||||
class KeywordCall(Tokenizer):
|
||||
_tokens = (KEYWORD, ARGUMENT)
|
||||
|
||||
def __init__(self, support_assign=True):
|
||||
Tokenizer.__init__(self)
|
||||
self._keyword_found = not support_assign
|
||||
self._assigns = 0
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if not self._keyword_found and self._is_assign(value):
|
||||
self._assigns += 1
|
||||
return SYNTAX # VariableTokenizer tokenizes this later.
|
||||
if self._keyword_found:
|
||||
return Tokenizer._tokenize(self, value, index - self._assigns)
|
||||
self._keyword_found = True
|
||||
return GherkinTokenizer().tokenize(value, KEYWORD)
|
||||
|
||||
|
||||
class GherkinTokenizer(object):
|
||||
_gherkin_prefix = re.compile('^(Given|When|Then|And) ', re.IGNORECASE)
|
||||
|
||||
def tokenize(self, value, token):
|
||||
match = self._gherkin_prefix.match(value)
|
||||
if not match:
|
||||
return [(value, token)]
|
||||
end = match.end()
|
||||
return [(value[:end], GHERKIN), (value[end:], token)]
|
||||
|
||||
|
||||
class TemplatedKeywordCall(Tokenizer):
|
||||
_tokens = (ARGUMENT,)
|
||||
|
||||
|
||||
class ForLoop(Tokenizer):
|
||||
|
||||
def __init__(self):
|
||||
Tokenizer.__init__(self)
|
||||
self._in_arguments = False
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
token = self._in_arguments and ARGUMENT or SYNTAX
|
||||
if value.upper() in ('IN', 'IN RANGE'):
|
||||
self._in_arguments = True
|
||||
return token
|
||||
|
||||
|
||||
class _Table(object):
|
||||
_tokenizer_class = None
|
||||
|
||||
def __init__(self, prev_tokenizer=None):
|
||||
self._tokenizer = self._tokenizer_class()
|
||||
self._prev_tokenizer = prev_tokenizer
|
||||
self._prev_values_on_row = []
|
||||
|
||||
def tokenize(self, value, index):
|
||||
if self._continues(value, index):
|
||||
self._tokenizer = self._prev_tokenizer
|
||||
yield value, SYNTAX
|
||||
else:
|
||||
for value_and_token in self._tokenize(value, index):
|
||||
yield value_and_token
|
||||
self._prev_values_on_row.append(value)
|
||||
|
||||
def _continues(self, value, index):
|
||||
return value == '...' and all(self._is_empty(t)
|
||||
for t in self._prev_values_on_row)
|
||||
|
||||
def _is_empty(self, value):
|
||||
return value in ('', '\\')
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
return self._tokenizer.tokenize(value)
|
||||
|
||||
def end_row(self):
|
||||
self.__init__(prev_tokenizer=self._tokenizer)
|
||||
|
||||
|
||||
class UnknownTable(_Table):
|
||||
_tokenizer_class = Comment
|
||||
|
||||
def _continues(self, value, index):
|
||||
return False
|
||||
|
||||
|
||||
class VariableTable(_Table):
|
||||
_tokenizer_class = Variable
|
||||
|
||||
|
||||
class SettingTable(_Table):
|
||||
_tokenizer_class = Setting
|
||||
|
||||
def __init__(self, template_setter, prev_tokenizer=None):
|
||||
_Table.__init__(self, prev_tokenizer)
|
||||
self._template_setter = template_setter
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if index == 0 and normalize(value) == 'testtemplate':
|
||||
self._tokenizer = Setting(self._template_setter)
|
||||
return _Table._tokenize(self, value, index)
|
||||
|
||||
def end_row(self):
|
||||
self.__init__(self._template_setter, prev_tokenizer=self._tokenizer)
|
||||
|
||||
|
||||
class TestCaseTable(_Table):
|
||||
_setting_class = TestCaseSetting
|
||||
_test_template = None
|
||||
_default_template = None
|
||||
|
||||
@property
|
||||
def _tokenizer_class(self):
|
||||
if self._test_template or (self._default_template and
|
||||
self._test_template is not False):
|
||||
return TemplatedKeywordCall
|
||||
return KeywordCall
|
||||
|
||||
def _continues(self, value, index):
|
||||
return index > 0 and _Table._continues(self, value, index)
|
||||
|
||||
def _tokenize(self, value, index):
|
||||
if index == 0:
|
||||
if value:
|
||||
self._test_template = None
|
||||
return GherkinTokenizer().tokenize(value, TC_KW_NAME)
|
||||
if index == 1 and self._is_setting(value):
|
||||
if self._is_template(value):
|
||||
self._test_template = False
|
||||
self._tokenizer = self._setting_class(self.set_test_template)
|
||||
else:
|
||||
self._tokenizer = self._setting_class()
|
||||
if index == 1 and self._is_for_loop(value):
|
||||
self._tokenizer = ForLoop()
|
||||
if index == 1 and self._is_empty(value):
|
||||
return [(value, SYNTAX)]
|
||||
return _Table._tokenize(self, value, index)
|
||||
|
||||
def _is_setting(self, value):
|
||||
return value.startswith('[') and value.endswith(']')
|
||||
|
||||
def _is_template(self, value):
|
||||
return normalize(value) == '[template]'
|
||||
|
||||
def _is_for_loop(self, value):
|
||||
return value.startswith(':') and normalize(value, remove=':') == 'for'
|
||||
|
||||
def set_test_template(self, template):
|
||||
self._test_template = self._is_template_set(template)
|
||||
|
||||
def set_default_template(self, template):
|
||||
self._default_template = self._is_template_set(template)
|
||||
|
||||
def _is_template_set(self, template):
|
||||
return normalize(template) not in ('', '\\', 'none', '${empty}')
|
||||
|
||||
|
||||
class KeywordTable(TestCaseTable):
|
||||
_tokenizer_class = KeywordCall
|
||||
_setting_class = KeywordSetting
|
||||
|
||||
def _is_template(self, value):
|
||||
return False
|
||||
|
||||
|
||||
# Following code copied directly from Robot Framework 2.7.5.
|
||||
|
||||
class VariableSplitter:
|
||||
|
||||
def __init__(self, string, identifiers):
|
||||
self.identifier = None
|
||||
self.base = None
|
||||
self.index = None
|
||||
self.start = -1
|
||||
self.end = -1
|
||||
self._identifiers = identifiers
|
||||
self._may_have_internal_variables = False
|
||||
try:
|
||||
self._split(string)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self._finalize()
|
||||
|
||||
def get_replaced_base(self, variables):
|
||||
if self._may_have_internal_variables:
|
||||
return variables.replace_string(self.base)
|
||||
return self.base
|
||||
|
||||
def _finalize(self):
|
||||
self.identifier = self._variable_chars[0]
|
||||
self.base = ''.join(self._variable_chars[2:-1])
|
||||
self.end = self.start + len(self._variable_chars)
|
||||
if self._has_list_variable_index():
|
||||
self.index = ''.join(self._list_variable_index_chars[1:-1])
|
||||
self.end += len(self._list_variable_index_chars)
|
||||
|
||||
def _has_list_variable_index(self):
|
||||
return self._list_variable_index_chars\
|
||||
and self._list_variable_index_chars[-1] == ']'
|
||||
|
||||
def _split(self, string):
|
||||
start_index, max_index = self._find_variable(string)
|
||||
self.start = start_index
|
||||
self._open_curly = 1
|
||||
self._state = self._variable_state
|
||||
self._variable_chars = [string[start_index], '{']
|
||||
self._list_variable_index_chars = []
|
||||
self._string = string
|
||||
start_index += 2
|
||||
for index, char in enumerate(string[start_index:]):
|
||||
index += start_index # Giving start to enumerate only in Py 2.6+
|
||||
try:
|
||||
self._state(char, index)
|
||||
except StopIteration:
|
||||
return
|
||||
if index == max_index and not self._scanning_list_variable_index():
|
||||
return
|
||||
|
||||
def _scanning_list_variable_index(self):
|
||||
return self._state in [self._waiting_list_variable_index_state,
|
||||
self._list_variable_index_state]
|
||||
|
||||
def _find_variable(self, string):
|
||||
max_end_index = string.rfind('}')
|
||||
if max_end_index == -1:
|
||||
raise ValueError('No variable end found')
|
||||
if self._is_escaped(string, max_end_index):
|
||||
return self._find_variable(string[:max_end_index])
|
||||
start_index = self._find_start_index(string, 1, max_end_index)
|
||||
if start_index == -1:
|
||||
raise ValueError('No variable start found')
|
||||
return start_index, max_end_index
|
||||
|
||||
def _find_start_index(self, string, start, end):
|
||||
index = string.find('{', start, end) - 1
|
||||
if index < 0:
|
||||
return -1
|
||||
if self._start_index_is_ok(string, index):
|
||||
return index
|
||||
return self._find_start_index(string, index+2, end)
|
||||
|
||||
def _start_index_is_ok(self, string, index):
|
||||
return string[index] in self._identifiers\
|
||||
and not self._is_escaped(string, index)
|
||||
|
||||
def _is_escaped(self, string, index):
|
||||
escaped = False
|
||||
while index > 0 and string[index-1] == '\\':
|
||||
index -= 1
|
||||
escaped = not escaped
|
||||
return escaped
|
||||
|
||||
def _variable_state(self, char, index):
|
||||
self._variable_chars.append(char)
|
||||
if char == '}' and not self._is_escaped(self._string, index):
|
||||
self._open_curly -= 1
|
||||
if self._open_curly == 0:
|
||||
if not self._is_list_variable():
|
||||
raise StopIteration
|
||||
self._state = self._waiting_list_variable_index_state
|
||||
elif char in self._identifiers:
|
||||
self._state = self._internal_variable_start_state
|
||||
|
||||
def _is_list_variable(self):
|
||||
return self._variable_chars[0] == '@'
|
||||
|
||||
def _internal_variable_start_state(self, char, index):
|
||||
self._state = self._variable_state
|
||||
if char == '{':
|
||||
self._variable_chars.append(char)
|
||||
self._open_curly += 1
|
||||
self._may_have_internal_variables = True
|
||||
else:
|
||||
self._variable_state(char, index)
|
||||
|
||||
def _waiting_list_variable_index_state(self, char, index):
|
||||
if char != '[':
|
||||
raise StopIteration
|
||||
self._list_variable_index_chars.append(char)
|
||||
self._state = self._list_variable_index_state
|
||||
|
||||
def _list_variable_index_state(self, char, index):
|
||||
self._list_variable_index_chars.append(char)
|
||||
if char == ']':
|
||||
raise StopIteration
|
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,360 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers._stan_builtins
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
This file contains the names of functions for Stan used by
|
||||
``pygments.lexers.math.StanLexer.
|
||||
|
||||
:copyright: Copyright 2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
KEYWORDS = ['else', 'for', 'if', 'in', 'lower', 'lp__', 'print', 'upper', 'while']
|
||||
|
||||
TYPES = [ 'corr_matrix',
|
||||
'cov_matrix',
|
||||
'int',
|
||||
'matrix',
|
||||
'ordered',
|
||||
'positive_ordered',
|
||||
'real',
|
||||
'row_vector',
|
||||
'simplex',
|
||||
'unit_vector',
|
||||
'vector']
|
||||
|
||||
FUNCTIONS = [ 'Phi',
|
||||
'Phi_approx',
|
||||
'abs',
|
||||
'acos',
|
||||
'acosh',
|
||||
'asin',
|
||||
'asinh',
|
||||
'atan',
|
||||
'atan2',
|
||||
'atanh',
|
||||
'bernoulli_cdf',
|
||||
'bernoulli_log',
|
||||
'bernoulli_logit_log',
|
||||
'bernoulli_rng',
|
||||
'beta_binomial_cdf',
|
||||
'beta_binomial_log',
|
||||
'beta_binomial_rng',
|
||||
'beta_cdf',
|
||||
'beta_log',
|
||||
'beta_rng',
|
||||
'binary_log_loss',
|
||||
'binomial_cdf',
|
||||
'binomial_coefficient_log',
|
||||
'binomial_log',
|
||||
'binomial_logit_log',
|
||||
'binomial_rng',
|
||||
'block',
|
||||
'categorical_log',
|
||||
'categorical_rng',
|
||||
'cauchy_cdf',
|
||||
'cauchy_log',
|
||||
'cauchy_rng',
|
||||
'cbrt',
|
||||
'ceil',
|
||||
'chi_square_log',
|
||||
'chi_square_rng',
|
||||
'cholesky_decompose',
|
||||
'col',
|
||||
'cols',
|
||||
'cos',
|
||||
'cosh',
|
||||
'crossprod',
|
||||
'cumulative_sum',
|
||||
'determinant',
|
||||
'diag_matrix',
|
||||
'diag_post_multiply',
|
||||
'diag_pre_multiply',
|
||||
'diagonal',
|
||||
'dims',
|
||||
'dirichlet_log',
|
||||
'dirichlet_rng',
|
||||
'dot_product',
|
||||
'dot_self',
|
||||
'double_exponential_log',
|
||||
'double_exponential_rng',
|
||||
'e',
|
||||
'eigenvalues_sym',
|
||||
'eigenvectors_sym',
|
||||
'epsilon',
|
||||
'erf',
|
||||
'erfc',
|
||||
'exp',
|
||||
'exp2',
|
||||
'exp_mod_normal_cdf',
|
||||
'exp_mod_normal_log',
|
||||
'exp_mod_normal_rng',
|
||||
'expm1',
|
||||
'exponential_cdf',
|
||||
'exponential_log',
|
||||
'exponential_rng',
|
||||
'fabs',
|
||||
'fdim',
|
||||
'floor',
|
||||
'fma',
|
||||
'fmax',
|
||||
'fmin',
|
||||
'fmod',
|
||||
'gamma_log',
|
||||
'gamma_rng',
|
||||
'gumbel_cdf',
|
||||
'gumbel_log',
|
||||
'gumbel_rng',
|
||||
'hypergeometric_log',
|
||||
'hypergeometric_rng',
|
||||
'hypot',
|
||||
'if_else',
|
||||
'int_step',
|
||||
'inv_chi_square_cdf',
|
||||
'inv_chi_square_log',
|
||||
'inv_chi_square_rng',
|
||||
'inv_cloglog',
|
||||
'inv_gamma_cdf',
|
||||
'inv_gamma_log',
|
||||
'inv_gamma_rng',
|
||||
'inv_logit',
|
||||
'inv_wishart_log',
|
||||
'inv_wishart_rng',
|
||||
'inverse',
|
||||
'lbeta',
|
||||
'lgamma',
|
||||
'lkj_corr_cholesky_log',
|
||||
'lkj_corr_cholesky_rng',
|
||||
'lkj_corr_log',
|
||||
'lkj_corr_rng',
|
||||
'lkj_cov_log',
|
||||
'lmgamma',
|
||||
'log',
|
||||
'log10',
|
||||
'log1m',
|
||||
'log1m_inv_logit',
|
||||
'log1p',
|
||||
'log1p_exp',
|
||||
'log2',
|
||||
'log_determinant',
|
||||
'log_inv_logit',
|
||||
'log_sum_exp',
|
||||
'logistic_cdf',
|
||||
'logistic_log',
|
||||
'logistic_rng',
|
||||
'logit',
|
||||
'lognormal_cdf',
|
||||
'lognormal_log',
|
||||
'lognormal_rng',
|
||||
'max',
|
||||
'mdivide_left_tri_low',
|
||||
'mdivide_right_tri_low',
|
||||
'mean',
|
||||
'min',
|
||||
'multi_normal_cholesky_log',
|
||||
'multi_normal_log',
|
||||
'multi_normal_prec_log',
|
||||
'multi_normal_rng',
|
||||
'multi_student_t_log',
|
||||
'multi_student_t_rng',
|
||||
'multinomial_cdf',
|
||||
'multinomial_log',
|
||||
'multinomial_rng',
|
||||
'multiply_log',
|
||||
'multiply_lower_tri_self_transpose',
|
||||
'neg_binomial_cdf',
|
||||
'neg_binomial_log',
|
||||
'neg_binomial_rng',
|
||||
'negative_epsilon',
|
||||
'negative_infinity',
|
||||
'normal_cdf',
|
||||
'normal_log',
|
||||
'normal_rng',
|
||||
'not_a_number',
|
||||
'ordered_logistic_log',
|
||||
'ordered_logistic_rng',
|
||||
'owens_t',
|
||||
'pareto_cdf',
|
||||
'pareto_log',
|
||||
'pareto_rng',
|
||||
'pi',
|
||||
'poisson_cdf',
|
||||
'poisson_log',
|
||||
'poisson_log_log',
|
||||
'poisson_rng',
|
||||
'positive_infinity',
|
||||
'pow',
|
||||
'prod',
|
||||
'rep_array',
|
||||
'rep_matrix',
|
||||
'rep_row_vector',
|
||||
'rep_vector',
|
||||
'round',
|
||||
'row',
|
||||
'rows',
|
||||
'scaled_inv_chi_square_cdf',
|
||||
'scaled_inv_chi_square_log',
|
||||
'scaled_inv_chi_square_rng',
|
||||
'sd',
|
||||
'sin',
|
||||
'singular_values',
|
||||
'sinh',
|
||||
'size',
|
||||
'skew_normal_cdf',
|
||||
'skew_normal_log',
|
||||
'skew_normal_rng',
|
||||
'softmax',
|
||||
'sqrt',
|
||||
'sqrt2',
|
||||
'square',
|
||||
'step',
|
||||
'student_t_cdf',
|
||||
'student_t_log',
|
||||
'student_t_rng',
|
||||
'sum',
|
||||
'tan',
|
||||
'tanh',
|
||||
'tcrossprod',
|
||||
'tgamma',
|
||||
'trace',
|
||||
'trunc',
|
||||
'uniform_log',
|
||||
'uniform_rng',
|
||||
'variance',
|
||||
'weibull_cdf',
|
||||
'weibull_log',
|
||||
'weibull_rng',
|
||||
'wishart_log',
|
||||
'wishart_rng']
|
||||
|
||||
DISTRIBUTIONS = [ 'bernoulli',
|
||||
'bernoulli_logit',
|
||||
'beta',
|
||||
'beta_binomial',
|
||||
'binomial',
|
||||
'binomial_coefficient',
|
||||
'binomial_logit',
|
||||
'categorical',
|
||||
'cauchy',
|
||||
'chi_square',
|
||||
'dirichlet',
|
||||
'double_exponential',
|
||||
'exp_mod_normal',
|
||||
'exponential',
|
||||
'gamma',
|
||||
'gumbel',
|
||||
'hypergeometric',
|
||||
'inv_chi_square',
|
||||
'inv_gamma',
|
||||
'inv_wishart',
|
||||
'lkj_corr',
|
||||
'lkj_corr_cholesky',
|
||||
'lkj_cov',
|
||||
'logistic',
|
||||
'lognormal',
|
||||
'multi_normal',
|
||||
'multi_normal_cholesky',
|
||||
'multi_normal_prec',
|
||||
'multi_student_t',
|
||||
'multinomial',
|
||||
'multiply',
|
||||
'neg_binomial',
|
||||
'normal',
|
||||
'ordered_logistic',
|
||||
'pareto',
|
||||
'poisson',
|
||||
'poisson_log',
|
||||
'scaled_inv_chi_square',
|
||||
'skew_normal',
|
||||
'student_t',
|
||||
'uniform',
|
||||
'weibull',
|
||||
'wishart']
|
||||
|
||||
RESERVED = [ 'alignas',
|
||||
'alignof',
|
||||
'and',
|
||||
'and_eq',
|
||||
'asm',
|
||||
'auto',
|
||||
'bitand',
|
||||
'bitor',
|
||||
'bool',
|
||||
'break',
|
||||
'case',
|
||||
'catch',
|
||||
'char',
|
||||
'char16_t',
|
||||
'char32_t',
|
||||
'class',
|
||||
'compl',
|
||||
'const',
|
||||
'const_cast',
|
||||
'constexpr',
|
||||
'continue',
|
||||
'decltype',
|
||||
'default',
|
||||
'delete',
|
||||
'do',
|
||||
'double',
|
||||
'dynamic_cast',
|
||||
'enum',
|
||||
'explicit',
|
||||
'export',
|
||||
'extern',
|
||||
'false',
|
||||
'false',
|
||||
'float',
|
||||
'friend',
|
||||
'goto',
|
||||
'inline',
|
||||
'int',
|
||||
'long',
|
||||
'mutable',
|
||||
'namespace',
|
||||
'new',
|
||||
'noexcept',
|
||||
'not',
|
||||
'not_eq',
|
||||
'nullptr',
|
||||
'operator',
|
||||
'or',
|
||||
'or_eq',
|
||||
'private',
|
||||
'protected',
|
||||
'public',
|
||||
'register',
|
||||
'reinterpret_cast',
|
||||
'repeat',
|
||||
'return',
|
||||
'short',
|
||||
'signed',
|
||||
'sizeof',
|
||||
'static',
|
||||
'static_assert',
|
||||
'static_cast',
|
||||
'struct',
|
||||
'switch',
|
||||
'template',
|
||||
'then',
|
||||
'this',
|
||||
'thread_local',
|
||||
'throw',
|
||||
'true',
|
||||
'true',
|
||||
'try',
|
||||
'typedef',
|
||||
'typeid',
|
||||
'typename',
|
||||
'union',
|
||||
'unsigned',
|
||||
'until',
|
||||
'using',
|
||||
'virtual',
|
||||
'void',
|
||||
'volatile',
|
||||
'wchar_t',
|
||||
'xor',
|
||||
'xor_eq']
|
||||
|
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,398 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.asm
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for assembly languages.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import RegexLexer, include, bygroups, using, DelegatingLexer
|
||||
from pygments.lexers.compiled import DLexer, CppLexer, CLexer
|
||||
from pygments.token import Text, Name, Number, String, Comment, Punctuation, \
|
||||
Other, Keyword, Operator
|
||||
|
||||
__all__ = ['GasLexer', 'ObjdumpLexer','DObjdumpLexer', 'CppObjdumpLexer',
|
||||
'CObjdumpLexer', 'LlvmLexer', 'NasmLexer', 'Ca65Lexer']
|
||||
|
||||
|
||||
class GasLexer(RegexLexer):
|
||||
"""
|
||||
For Gas (AT&T) assembly code.
|
||||
"""
|
||||
name = 'GAS'
|
||||
aliases = ['gas', 'asm']
|
||||
filenames = ['*.s', '*.S']
|
||||
mimetypes = ['text/x-gas']
|
||||
|
||||
#: optional Comment or Whitespace
|
||||
string = r'"(\\"|[^"])*"'
|
||||
char = r'[a-zA-Z$._0-9@-]'
|
||||
identifier = r'(?:[a-zA-Z$_]' + char + '*|\.' + char + '+)'
|
||||
number = r'(?:0[xX][a-zA-Z0-9]+|\d+)'
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('whitespace'),
|
||||
(identifier + ':', Name.Label),
|
||||
(r'\.' + identifier, Name.Attribute, 'directive-args'),
|
||||
(r'lock|rep(n?z)?|data\d+', Name.Attribute),
|
||||
(identifier, Name.Function, 'instruction-args'),
|
||||
(r'[\r\n]+', Text)
|
||||
],
|
||||
'directive-args': [
|
||||
(identifier, Name.Constant),
|
||||
(string, String),
|
||||
('@' + identifier, Name.Attribute),
|
||||
(number, Number.Integer),
|
||||
(r'[\r\n]+', Text, '#pop'),
|
||||
|
||||
(r'#.*?$', Comment, '#pop'),
|
||||
|
||||
include('punctuation'),
|
||||
include('whitespace')
|
||||
],
|
||||
'instruction-args': [
|
||||
# For objdump-disassembled code, shouldn't occur in
|
||||
# actual assembler input
|
||||
('([a-z0-9]+)( )(<)('+identifier+')(>)',
|
||||
bygroups(Number.Hex, Text, Punctuation, Name.Constant,
|
||||
Punctuation)),
|
||||
('([a-z0-9]+)( )(<)('+identifier+')([-+])('+number+')(>)',
|
||||
bygroups(Number.Hex, Text, Punctuation, Name.Constant,
|
||||
Punctuation, Number.Integer, Punctuation)),
|
||||
|
||||
# Address constants
|
||||
(identifier, Name.Constant),
|
||||
(number, Number.Integer),
|
||||
# Registers
|
||||
('%' + identifier, Name.Variable),
|
||||
# Numeric constants
|
||||
('$'+number, Number.Integer),
|
||||
(r"$'(.|\\')'", String.Char),
|
||||
(r'[\r\n]+', Text, '#pop'),
|
||||
(r'#.*?$', Comment, '#pop'),
|
||||
include('punctuation'),
|
||||
include('whitespace')
|
||||
],
|
||||
'whitespace': [
|
||||
(r'\n', Text),
|
||||
(r'\s+', Text),
|
||||
(r'#.*?\n', Comment)
|
||||
],
|
||||
'punctuation': [
|
||||
(r'[-*,.():]+', Punctuation)
|
||||
]
|
||||
}
|
||||
|
||||
def analyse_text(text):
|
||||
if re.match(r'^\.(text|data|section)', text, re.M):
|
||||
return True
|
||||
elif re.match(r'^\.\w+', text, re.M):
|
||||
return 0.1
|
||||
|
||||
|
||||
class ObjdumpLexer(RegexLexer):
|
||||
"""
|
||||
For the output of 'objdump -dr'
|
||||
"""
|
||||
name = 'objdump'
|
||||
aliases = ['objdump']
|
||||
filenames = ['*.objdump']
|
||||
mimetypes = ['text/x-objdump']
|
||||
|
||||
hex = r'[0-9A-Za-z]'
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
# File name & format:
|
||||
('(.*?)(:)( +file format )(.*?)$',
|
||||
bygroups(Name.Label, Punctuation, Text, String)),
|
||||
# Section header
|
||||
('(Disassembly of section )(.*?)(:)$',
|
||||
bygroups(Text, Name.Label, Punctuation)),
|
||||
# Function labels
|
||||
# (With offset)
|
||||
('('+hex+'+)( )(<)(.*?)([-+])(0[xX][A-Za-z0-9]+)(>:)$',
|
||||
bygroups(Number.Hex, Text, Punctuation, Name.Function,
|
||||
Punctuation, Number.Hex, Punctuation)),
|
||||
# (Without offset)
|
||||
('('+hex+'+)( )(<)(.*?)(>:)$',
|
||||
bygroups(Number.Hex, Text, Punctuation, Name.Function,
|
||||
Punctuation)),
|
||||
# Code line with disassembled instructions
|
||||
('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)( *\t)([a-zA-Z].*?)$',
|
||||
bygroups(Text, Name.Label, Text, Number.Hex, Text,
|
||||
using(GasLexer))),
|
||||
# Code line with ascii
|
||||
('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)( *)(.*?)$',
|
||||
bygroups(Text, Name.Label, Text, Number.Hex, Text, String)),
|
||||
# Continued code line, only raw opcodes without disassembled
|
||||
# instruction
|
||||
('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)$',
|
||||
bygroups(Text, Name.Label, Text, Number.Hex)),
|
||||
# Skipped a few bytes
|
||||
(r'\t\.\.\.$', Text),
|
||||
# Relocation line
|
||||
# (With offset)
|
||||
(r'(\t\t\t)('+hex+r'+:)( )([^\t]+)(\t)(.*?)([-+])(0x' + hex + '+)$',
|
||||
bygroups(Text, Name.Label, Text, Name.Property, Text,
|
||||
Name.Constant, Punctuation, Number.Hex)),
|
||||
# (Without offset)
|
||||
(r'(\t\t\t)('+hex+r'+:)( )([^\t]+)(\t)(.*?)$',
|
||||
bygroups(Text, Name.Label, Text, Name.Property, Text,
|
||||
Name.Constant)),
|
||||
(r'[^\n]+\n', Other)
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class DObjdumpLexer(DelegatingLexer):
|
||||
"""
|
||||
For the output of 'objdump -Sr on compiled D files'
|
||||
"""
|
||||
name = 'd-objdump'
|
||||
aliases = ['d-objdump']
|
||||
filenames = ['*.d-objdump']
|
||||
mimetypes = ['text/x-d-objdump']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(DObjdumpLexer, self).__init__(DLexer, ObjdumpLexer, **options)
|
||||
|
||||
|
||||
class CppObjdumpLexer(DelegatingLexer):
|
||||
"""
|
||||
For the output of 'objdump -Sr on compiled C++ files'
|
||||
"""
|
||||
name = 'cpp-objdump'
|
||||
aliases = ['cpp-objdump', 'c++-objdumb', 'cxx-objdump']
|
||||
filenames = ['*.cpp-objdump', '*.c++-objdump', '*.cxx-objdump']
|
||||
mimetypes = ['text/x-cpp-objdump']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(CppObjdumpLexer, self).__init__(CppLexer, ObjdumpLexer, **options)
|
||||
|
||||
|
||||
class CObjdumpLexer(DelegatingLexer):
|
||||
"""
|
||||
For the output of 'objdump -Sr on compiled C files'
|
||||
"""
|
||||
name = 'c-objdump'
|
||||
aliases = ['c-objdump']
|
||||
filenames = ['*.c-objdump']
|
||||
mimetypes = ['text/x-c-objdump']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(CObjdumpLexer, self).__init__(CLexer, ObjdumpLexer, **options)
|
||||
|
||||
|
||||
class LlvmLexer(RegexLexer):
|
||||
"""
|
||||
For LLVM assembly code.
|
||||
"""
|
||||
name = 'LLVM'
|
||||
aliases = ['llvm']
|
||||
filenames = ['*.ll']
|
||||
mimetypes = ['text/x-llvm']
|
||||
|
||||
#: optional Comment or Whitespace
|
||||
string = r'"[^"]*?"'
|
||||
identifier = r'([-a-zA-Z$._][-a-zA-Z$._0-9]*|' + string + ')'
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('whitespace'),
|
||||
|
||||
# Before keywords, because keywords are valid label names :(...
|
||||
(identifier + '\s*:', Name.Label),
|
||||
|
||||
include('keyword'),
|
||||
|
||||
(r'%' + identifier, Name.Variable),#Name.Identifier.Local),
|
||||
(r'@' + identifier, Name.Variable.Global),#Name.Identifier.Global),
|
||||
(r'%\d+', Name.Variable.Anonymous),#Name.Identifier.Anonymous),
|
||||
(r'@\d+', Name.Variable.Global),#Name.Identifier.Anonymous),
|
||||
(r'!' + identifier, Name.Variable),
|
||||
(r'!\d+', Name.Variable.Anonymous),
|
||||
(r'c?' + string, String),
|
||||
|
||||
(r'0[xX][a-fA-F0-9]+', Number),
|
||||
(r'-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?', Number),
|
||||
|
||||
(r'[=<>{}\[\]()*.,!]|x\b', Punctuation)
|
||||
],
|
||||
'whitespace': [
|
||||
(r'(\n|\s)+', Text),
|
||||
(r';.*?\n', Comment)
|
||||
],
|
||||
'keyword': [
|
||||
# Regular keywords
|
||||
(r'(begin|end'
|
||||
r'|true|false'
|
||||
r'|declare|define'
|
||||
r'|global|constant'
|
||||
|
||||
r'|private|linker_private|internal|available_externally|linkonce'
|
||||
r'|linkonce_odr|weak|weak_odr|appending|dllimport|dllexport'
|
||||
r'|common|default|hidden|protected|extern_weak|external'
|
||||
r'|thread_local|zeroinitializer|undef|null|to|tail|target|triple'
|
||||
r'|datalayout|volatile|nuw|nsw|nnan|ninf|nsz|arcp|fast|exact|inbounds'
|
||||
r'|align|addrspace|section|alias|module|asm|sideeffect|gc|dbg'
|
||||
|
||||
r'|ccc|fastcc|coldcc|x86_stdcallcc|x86_fastcallcc|arm_apcscc'
|
||||
r'|arm_aapcscc|arm_aapcs_vfpcc|ptx_device|ptx_kernel'
|
||||
|
||||
r'|cc|c'
|
||||
|
||||
r'|signext|zeroext|inreg|sret|nounwind|noreturn|noalias|nocapture'
|
||||
r'|byval|nest|readnone|readonly'
|
||||
|
||||
r'|inlinehint|noinline|alwaysinline|optsize|ssp|sspreq|noredzone'
|
||||
r'|noimplicitfloat|naked'
|
||||
|
||||
r'|type|opaque'
|
||||
|
||||
r'|eq|ne|slt|sgt|sle'
|
||||
r'|sge|ult|ugt|ule|uge'
|
||||
r'|oeq|one|olt|ogt|ole'
|
||||
r'|oge|ord|uno|ueq|une'
|
||||
r'|x'
|
||||
|
||||
# instructions
|
||||
r'|add|fadd|sub|fsub|mul|fmul|udiv|sdiv|fdiv|urem|srem|frem|shl'
|
||||
r'|lshr|ashr|and|or|xor|icmp|fcmp'
|
||||
|
||||
r'|phi|call|trunc|zext|sext|fptrunc|fpext|uitofp|sitofp|fptoui'
|
||||
r'fptosi|inttoptr|ptrtoint|bitcast|select|va_arg|ret|br|switch'
|
||||
r'|invoke|unwind|unreachable'
|
||||
|
||||
r'|malloc|alloca|free|load|store|getelementptr'
|
||||
|
||||
r'|extractelement|insertelement|shufflevector|getresult'
|
||||
r'|extractvalue|insertvalue'
|
||||
|
||||
r')\b', Keyword),
|
||||
|
||||
# Types
|
||||
(r'void|float|double|x86_fp80|fp128|ppc_fp128|label|metadata',
|
||||
Keyword.Type),
|
||||
|
||||
# Integer types
|
||||
(r'i[1-9]\d*', Keyword)
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class NasmLexer(RegexLexer):
|
||||
"""
|
||||
For Nasm (Intel) assembly code.
|
||||
"""
|
||||
name = 'NASM'
|
||||
aliases = ['nasm']
|
||||
filenames = ['*.asm', '*.ASM']
|
||||
mimetypes = ['text/x-nasm']
|
||||
|
||||
identifier = r'[a-zA-Z$._?][a-zA-Z0-9$._?#@~]*'
|
||||
hexn = r'(?:0[xX][0-9a-fA-F]+|$0[0-9a-fA-F]*|[0-9]+[0-9a-fA-F]*h)'
|
||||
octn = r'[0-7]+q'
|
||||
binn = r'[01]+b'
|
||||
decn = r'[0-9]+'
|
||||
floatn = decn + r'\.e?' + decn
|
||||
string = r'"(\\"|[^"\n])*"|' + r"'(\\'|[^'\n])*'|" + r"`(\\`|[^`\n])*`"
|
||||
declkw = r'(?:res|d)[bwdqt]|times'
|
||||
register = (r'r[0-9][0-5]?[bwd]|'
|
||||
r'[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|'
|
||||
r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]')
|
||||
wordop = r'seg|wrt|strict'
|
||||
type = r'byte|[dq]?word'
|
||||
directives = (r'BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|'
|
||||
r'ORG|ALIGN|STRUC|ENDSTRUC|COMMON|CPU|GROUP|UPPERCASE|IMPORT|'
|
||||
r'EXPORT|LIBRARY|MODULE')
|
||||
|
||||
flags = re.IGNORECASE | re.MULTILINE
|
||||
tokens = {
|
||||
'root': [
|
||||
include('whitespace'),
|
||||
(r'^\s*%', Comment.Preproc, 'preproc'),
|
||||
(identifier + ':', Name.Label),
|
||||
(r'(%s)(\s+)(equ)' % identifier,
|
||||
bygroups(Name.Constant, Keyword.Declaration, Keyword.Declaration),
|
||||
'instruction-args'),
|
||||
(directives, Keyword, 'instruction-args'),
|
||||
(declkw, Keyword.Declaration, 'instruction-args'),
|
||||
(identifier, Name.Function, 'instruction-args'),
|
||||
(r'[\r\n]+', Text)
|
||||
],
|
||||
'instruction-args': [
|
||||
(string, String),
|
||||
(hexn, Number.Hex),
|
||||
(octn, Number.Oct),
|
||||
(binn, Number),
|
||||
(floatn, Number.Float),
|
||||
(decn, Number.Integer),
|
||||
include('punctuation'),
|
||||
(register, Name.Builtin),
|
||||
(identifier, Name.Variable),
|
||||
(r'[\r\n]+', Text, '#pop'),
|
||||
include('whitespace')
|
||||
],
|
||||
'preproc': [
|
||||
(r'[^;\n]+', Comment.Preproc),
|
||||
(r';.*?\n', Comment.Single, '#pop'),
|
||||
(r'\n', Comment.Preproc, '#pop'),
|
||||
],
|
||||
'whitespace': [
|
||||
(r'\n', Text),
|
||||
(r'[ \t]+', Text),
|
||||
(r';.*', Comment.Single)
|
||||
],
|
||||
'punctuation': [
|
||||
(r'[,():\[\]]+', Punctuation),
|
||||
(r'[&|^<>+*/%~-]+', Operator),
|
||||
(r'[$]+', Keyword.Constant),
|
||||
(wordop, Operator.Word),
|
||||
(type, Keyword.Type)
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class Ca65Lexer(RegexLexer):
|
||||
"""
|
||||
For ca65 assembler sources.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
name = 'ca65'
|
||||
aliases = ['ca65']
|
||||
filenames = ['*.s']
|
||||
|
||||
flags = re.IGNORECASE
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r';.*', Comment.Single),
|
||||
(r'\s+', Text),
|
||||
(r'[a-z_.@$][\w.@$]*:', Name.Label),
|
||||
(r'((ld|st)[axy]|(in|de)[cxy]|asl|lsr|ro[lr]|adc|sbc|cmp|cp[xy]'
|
||||
r'|cl[cvdi]|se[cdi]|jmp|jsr|bne|beq|bpl|bmi|bvc|bvs|bcc|bcs'
|
||||
r'|p[lh][ap]|rt[is]|brk|nop|ta[xy]|t[xy]a|txs|tsx|and|ora|eor'
|
||||
r'|bit)\b', Keyword),
|
||||
(r'\.[a-z0-9_]+', Keyword.Pseudo),
|
||||
(r'[-+~*/^&|!<>=]', Operator),
|
||||
(r'"[^"\n]*.', String),
|
||||
(r"'[^'\n]*.", String.Char),
|
||||
(r'\$[0-9a-f]+|[0-9a-f]+h\b', Number.Hex),
|
||||
(r'\d+|%[01]+', Number.Integer),
|
||||
(r'[#,.:()=]', Punctuation),
|
||||
(r'[a-z_.@$][\w.@$]*', Name),
|
||||
]
|
||||
}
|
||||
|
||||
def analyse_text(self, text):
|
||||
# comments in GAS start with "#"
|
||||
if re.match(r'^\s*;', text, re.MULTILINE):
|
||||
return 0.9
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,104 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.dalvik
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Pygments lexers for Dalvik VM-related languages.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.lexer import RegexLexer, include, bygroups
|
||||
from pygments.token import Keyword, Text, Comment, Name, String, Number, \
|
||||
Punctuation
|
||||
|
||||
__all__ = ['SmaliLexer']
|
||||
|
||||
|
||||
class SmaliLexer(RegexLexer):
|
||||
"""
|
||||
For `Smali <http://code.google.com/p/smali/>`_ (Android/Dalvik) assembly
|
||||
code.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
name = 'Smali'
|
||||
aliases = ['smali']
|
||||
filenames = ['*.smali']
|
||||
mimetypes = ['text/smali']
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('comment'),
|
||||
include('label'),
|
||||
include('field'),
|
||||
include('method'),
|
||||
include('class'),
|
||||
include('directive'),
|
||||
include('access-modifier'),
|
||||
include('instruction'),
|
||||
include('literal'),
|
||||
include('punctuation'),
|
||||
include('type'),
|
||||
include('whitespace')
|
||||
],
|
||||
'directive': [
|
||||
(r'^[ \t]*\.(class|super|implements|field|subannotation|annotation|'
|
||||
r'enum|method|registers|locals|array-data|packed-switch|'
|
||||
r'sparse-switch|catchall|catch|line|parameter|local|prologue|'
|
||||
r'epilogue|source)', Keyword),
|
||||
(r'^[ \t]*\.end (field|subannotation|annotation|method|array-data|'
|
||||
'packed-switch|sparse-switch|parameter|local)', Keyword),
|
||||
(r'^[ \t]*\.restart local', Keyword),
|
||||
],
|
||||
'access-modifier': [
|
||||
(r'(public|private|protected|static|final|synchronized|bridge|'
|
||||
r'varargs|native|abstract|strictfp|synthetic|constructor|'
|
||||
r'declared-synchronized|interface|enum|annotation|volatile|'
|
||||
r'transient)', Keyword),
|
||||
],
|
||||
'whitespace': [
|
||||
(r'\n', Text),
|
||||
(r'\s+', Text),
|
||||
],
|
||||
'instruction': [
|
||||
(r'\b[vp]\d+\b', Name.Builtin), # registers
|
||||
(r'\b[a-z][A-Za-z0-9/-]+\s+', Text), # instructions
|
||||
],
|
||||
'literal': [
|
||||
(r'".*"', String),
|
||||
(r'0x[0-9A-Fa-f]+t?', Number.Hex),
|
||||
(r'[0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
|
||||
(r'[0-9]+L?', Number.Integer),
|
||||
],
|
||||
'field': [
|
||||
(r'(\$?\b)([A-Za-z0-9_$]*)(:)',
|
||||
bygroups(Punctuation, Name.Variable, Punctuation)),
|
||||
],
|
||||
'method': [
|
||||
(r'<(?:cl)?init>', Name.Function), # constructor
|
||||
(r'(\$?\b)([A-Za-z0-9_$]*)(\()',
|
||||
bygroups(Punctuation, Name.Function, Punctuation)),
|
||||
],
|
||||
'label': [
|
||||
(r':[A-Za-z0-9_]+', Name.Label),
|
||||
],
|
||||
'class': [
|
||||
# class names in the form Lcom/namespace/ClassName;
|
||||
# I only want to color the ClassName part, so the namespace part is
|
||||
# treated as 'Text'
|
||||
(r'(L)((?:[A-Za-z0-9_$]+/)*)([A-Za-z0-9_$]+)(;)',
|
||||
bygroups(Keyword.Type, Text, Name.Class, Text)),
|
||||
],
|
||||
'punctuation': [
|
||||
(r'->', Punctuation),
|
||||
(r'[{},\(\):=\.-]', Punctuation),
|
||||
],
|
||||
'type': [
|
||||
(r'[ZBSCIJFDV\[]+', Keyword.Type),
|
||||
],
|
||||
'comment': [
|
||||
(r'#.*?\n', Comment),
|
||||
],
|
||||
}
|
|
@ -0,0 +1,671 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.dotnet
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for .net languages.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
import re
|
||||
|
||||
from pygments.lexer import RegexLexer, DelegatingLexer, bygroups, include, \
|
||||
using, this
|
||||
from pygments.token import Punctuation, \
|
||||
Text, Comment, Operator, Keyword, Name, String, Number, Literal, Other
|
||||
from pygments.util import get_choice_opt
|
||||
from pygments import unistring as uni
|
||||
|
||||
from pygments.lexers.web import XmlLexer
|
||||
|
||||
__all__ = ['CSharpLexer', 'NemerleLexer', 'BooLexer', 'VbNetLexer',
|
||||
'CSharpAspxLexer', 'VbNetAspxLexer', 'FSharpLexer']
|
||||
|
||||
|
||||
class CSharpLexer(RegexLexer):
|
||||
"""
|
||||
For `C# <http://msdn2.microsoft.com/en-us/vcsharp/default.aspx>`_
|
||||
source code.
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`unicodelevel`
|
||||
Determines which Unicode characters this lexer allows for identifiers.
|
||||
The possible values are:
|
||||
|
||||
* ``none`` -- only the ASCII letters and numbers are allowed. This
|
||||
is the fastest selection.
|
||||
* ``basic`` -- all Unicode characters from the specification except
|
||||
category ``Lo`` are allowed.
|
||||
* ``full`` -- all Unicode characters as specified in the C# specs
|
||||
are allowed. Note that this means a considerable slowdown since the
|
||||
``Lo`` category has more than 40,000 characters in it!
|
||||
|
||||
The default value is ``basic``.
|
||||
|
||||
*New in Pygments 0.8.*
|
||||
"""
|
||||
|
||||
name = 'C#'
|
||||
aliases = ['csharp', 'c#']
|
||||
filenames = ['*.cs']
|
||||
mimetypes = ['text/x-csharp'] # inferred
|
||||
|
||||
flags = re.MULTILINE | re.DOTALL | re.UNICODE
|
||||
|
||||
# for the range of allowed unicode characters in identifiers,
|
||||
# see http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
|
||||
|
||||
levels = {
|
||||
'none': '@?[_a-zA-Z][a-zA-Z0-9_]*',
|
||||
'basic': ('@?[_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl + ']' +
|
||||
'[' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl +
|
||||
uni.Nd + uni.Pc + uni.Cf + uni.Mn + uni.Mc + ']*'),
|
||||
'full': ('@?(?:_|[^' +
|
||||
uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') + '])'
|
||||
+ '[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
|
||||
'Nd', 'Pc', 'Cf', 'Mn', 'Mc') + ']*'),
|
||||
}
|
||||
|
||||
tokens = {}
|
||||
token_variants = True
|
||||
|
||||
for levelname, cs_ident in levels.items():
|
||||
tokens[levelname] = {
|
||||
'root': [
|
||||
# method names
|
||||
(r'^([ \t]*(?:' + cs_ident + r'(?:\[\])?\s+)+?)' # return type
|
||||
r'(' + cs_ident + ')' # method name
|
||||
r'(\s*)(\()', # signature start
|
||||
bygroups(using(this), Name.Function, Text, Punctuation)),
|
||||
(r'^\s*\[.*?\]', Name.Attribute),
|
||||
(r'[^\S\n]+', Text),
|
||||
(r'\\\n', Text), # line continuation
|
||||
(r'//.*?\n', Comment.Single),
|
||||
(r'/[*].*?[*]/', Comment.Multiline),
|
||||
(r'\n', Text),
|
||||
(r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
|
||||
(r'[{}]', Punctuation),
|
||||
(r'@"(""|[^"])*"', String),
|
||||
(r'"(\\\\|\\"|[^"\n])*["\n]', String),
|
||||
(r"'\\.'|'[^\\]'", String.Char),
|
||||
(r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?"
|
||||
r"[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?", Number),
|
||||
(r'#[ \t]*(if|endif|else|elif|define|undef|'
|
||||
r'line|error|warning|region|endregion|pragma)\b.*?\n',
|
||||
Comment.Preproc),
|
||||
(r'\b(extern)(\s+)(alias)\b', bygroups(Keyword, Text,
|
||||
Keyword)),
|
||||
(r'(abstract|as|async|await|base|break|case|catch|'
|
||||
r'checked|const|continue|default|delegate|'
|
||||
r'do|else|enum|event|explicit|extern|false|finally|'
|
||||
r'fixed|for|foreach|goto|if|implicit|in|interface|'
|
||||
r'internal|is|lock|new|null|operator|'
|
||||
r'out|override|params|private|protected|public|readonly|'
|
||||
r'ref|return|sealed|sizeof|stackalloc|static|'
|
||||
r'switch|this|throw|true|try|typeof|'
|
||||
r'unchecked|unsafe|virtual|void|while|'
|
||||
r'get|set|new|partial|yield|add|remove|value|alias|ascending|'
|
||||
r'descending|from|group|into|orderby|select|where|'
|
||||
r'join|equals)\b', Keyword),
|
||||
(r'(global)(::)', bygroups(Keyword, Punctuation)),
|
||||
(r'(bool|byte|char|decimal|double|dynamic|float|int|long|object|'
|
||||
r'sbyte|short|string|uint|ulong|ushort|var)\b\??', Keyword.Type),
|
||||
(r'(class|struct)(\s+)', bygroups(Keyword, Text), 'class'),
|
||||
(r'(namespace|using)(\s+)', bygroups(Keyword, Text), 'namespace'),
|
||||
(cs_ident, Name),
|
||||
],
|
||||
'class': [
|
||||
(cs_ident, Name.Class, '#pop')
|
||||
],
|
||||
'namespace': [
|
||||
(r'(?=\()', Text, '#pop'), # using (resource)
|
||||
('(' + cs_ident + r'|\.)+', Name.Namespace, '#pop')
|
||||
]
|
||||
}
|
||||
|
||||
def __init__(self, **options):
|
||||
level = get_choice_opt(options, 'unicodelevel', self.tokens.keys(), 'basic')
|
||||
if level not in self._all_tokens:
|
||||
# compile the regexes now
|
||||
self._tokens = self.__class__.process_tokendef(level)
|
||||
else:
|
||||
self._tokens = self._all_tokens[level]
|
||||
|
||||
RegexLexer.__init__(self, **options)
|
||||
|
||||
|
||||
class NemerleLexer(RegexLexer):
|
||||
"""
|
||||
For `Nemerle <http://nemerle.org>`_ source code.
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`unicodelevel`
|
||||
Determines which Unicode characters this lexer allows for identifiers.
|
||||
The possible values are:
|
||||
|
||||
* ``none`` -- only the ASCII letters and numbers are allowed. This
|
||||
is the fastest selection.
|
||||
* ``basic`` -- all Unicode characters from the specification except
|
||||
category ``Lo`` are allowed.
|
||||
* ``full`` -- all Unicode characters as specified in the C# specs
|
||||
are allowed. Note that this means a considerable slowdown since the
|
||||
``Lo`` category has more than 40,000 characters in it!
|
||||
|
||||
The default value is ``basic``.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
|
||||
name = 'Nemerle'
|
||||
aliases = ['nemerle']
|
||||
filenames = ['*.n']
|
||||
mimetypes = ['text/x-nemerle'] # inferred
|
||||
|
||||
flags = re.MULTILINE | re.DOTALL | re.UNICODE
|
||||
|
||||
# for the range of allowed unicode characters in identifiers, see
|
||||
# http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
|
||||
|
||||
levels = dict(
|
||||
none = '@?[_a-zA-Z][a-zA-Z0-9_]*',
|
||||
basic = ('@?[_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl + ']' +
|
||||
'[' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl +
|
||||
uni.Nd + uni.Pc + uni.Cf + uni.Mn + uni.Mc + ']*'),
|
||||
full = ('@?(?:_|[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo',
|
||||
'Nl') + '])'
|
||||
+ '[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
|
||||
'Nd', 'Pc', 'Cf', 'Mn', 'Mc') + ']*'),
|
||||
)
|
||||
|
||||
tokens = {}
|
||||
token_variants = True
|
||||
|
||||
for levelname, cs_ident in levels.items():
|
||||
tokens[levelname] = {
|
||||
'root': [
|
||||
# method names
|
||||
(r'^([ \t]*(?:' + cs_ident + r'(?:\[\])?\s+)+?)' # return type
|
||||
r'(' + cs_ident + ')' # method name
|
||||
r'(\s*)(\()', # signature start
|
||||
bygroups(using(this), Name.Function, Text, Punctuation)),
|
||||
(r'^\s*\[.*?\]', Name.Attribute),
|
||||
(r'[^\S\n]+', Text),
|
||||
(r'\\\n', Text), # line continuation
|
||||
(r'//.*?\n', Comment.Single),
|
||||
(r'/[*].*?[*]/', Comment.Multiline),
|
||||
(r'\n', Text),
|
||||
(r'\$\s*"', String, 'splice-string'),
|
||||
(r'\$\s*<#', String, 'splice-string2'),
|
||||
(r'<#', String, 'recursive-string'),
|
||||
|
||||
(r'(<\[)\s*(' + cs_ident + ':)?', Keyword),
|
||||
(r'\]\>', Keyword),
|
||||
|
||||
# quasiquotation only
|
||||
(r'\$' + cs_ident, Name),
|
||||
(r'(\$)(\()', bygroups(Name, Punctuation),
|
||||
'splice-string-content'),
|
||||
|
||||
(r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
|
||||
(r'[{}]', Punctuation),
|
||||
(r'@"(""|[^"])*"', String),
|
||||
(r'"(\\\\|\\"|[^"\n])*["\n]', String),
|
||||
(r"'\\.'|'[^\\]'", String.Char),
|
||||
(r"0[xX][0-9a-fA-F]+[Ll]?", Number),
|
||||
(r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?", Number),
|
||||
(r'#[ \t]*(if|endif|else|elif|define|undef|'
|
||||
r'line|error|warning|region|endregion|pragma)\b.*?\n',
|
||||
Comment.Preproc),
|
||||
(r'\b(extern)(\s+)(alias)\b', bygroups(Keyword, Text,
|
||||
Keyword)),
|
||||
(r'(abstract|and|as|base|catch|def|delegate|'
|
||||
r'enum|event|extern|false|finally|'
|
||||
r'fun|implements|interface|internal|'
|
||||
r'is|macro|match|matches|module|mutable|new|'
|
||||
r'null|out|override|params|partial|private|'
|
||||
r'protected|public|ref|sealed|static|'
|
||||
r'syntax|this|throw|true|try|type|typeof|'
|
||||
r'virtual|volatile|when|where|with|'
|
||||
r'assert|assert2|async|break|checked|continue|do|else|'
|
||||
r'ensures|for|foreach|if|late|lock|new|nolate|'
|
||||
r'otherwise|regexp|repeat|requires|return|surroundwith|'
|
||||
r'unchecked|unless|using|while|yield)\b', Keyword),
|
||||
(r'(global)(::)', bygroups(Keyword, Punctuation)),
|
||||
(r'(bool|byte|char|decimal|double|float|int|long|object|sbyte|'
|
||||
r'short|string|uint|ulong|ushort|void|array|list)\b\??',
|
||||
Keyword.Type),
|
||||
(r'(:>?)\s*(' + cs_ident + r'\??)',
|
||||
bygroups(Punctuation, Keyword.Type)),
|
||||
(r'(class|struct|variant|module)(\s+)',
|
||||
bygroups(Keyword, Text), 'class'),
|
||||
(r'(namespace|using)(\s+)', bygroups(Keyword, Text),
|
||||
'namespace'),
|
||||
(cs_ident, Name),
|
||||
],
|
||||
'class': [
|
||||
(cs_ident, Name.Class, '#pop')
|
||||
],
|
||||
'namespace': [
|
||||
(r'(?=\()', Text, '#pop'), # using (resource)
|
||||
('(' + cs_ident + r'|\.)+', Name.Namespace, '#pop')
|
||||
],
|
||||
'splice-string': [
|
||||
(r'[^"$]', String),
|
||||
(r'\$' + cs_ident, Name),
|
||||
(r'(\$)(\()', bygroups(Name, Punctuation),
|
||||
'splice-string-content'),
|
||||
(r'\\"', String),
|
||||
(r'"', String, '#pop')
|
||||
],
|
||||
'splice-string2': [
|
||||
(r'[^#<>$]', String),
|
||||
(r'\$' + cs_ident, Name),
|
||||
(r'(\$)(\()', bygroups(Name, Punctuation),
|
||||
'splice-string-content'),
|
||||
(r'<#', String, '#push'),
|
||||
(r'#>', String, '#pop')
|
||||
],
|
||||
'recursive-string': [
|
||||
(r'[^#<>]', String),
|
||||
(r'<#', String, '#push'),
|
||||
(r'#>', String, '#pop')
|
||||
],
|
||||
'splice-string-content': [
|
||||
(r'if|match', Keyword),
|
||||
(r'[~!%^&*+=|\[\]:;,.<>/?-\\"$ ]', Punctuation),
|
||||
(cs_ident, Name),
|
||||
(r'\d+', Number),
|
||||
(r'\(', Punctuation, '#push'),
|
||||
(r'\)', Punctuation, '#pop')
|
||||
]
|
||||
}
|
||||
|
||||
def __init__(self, **options):
|
||||
level = get_choice_opt(options, 'unicodelevel', self.tokens.keys(),
|
||||
'basic')
|
||||
if level not in self._all_tokens:
|
||||
# compile the regexes now
|
||||
self._tokens = self.__class__.process_tokendef(level)
|
||||
else:
|
||||
self._tokens = self._all_tokens[level]
|
||||
|
||||
RegexLexer.__init__(self, **options)
|
||||
|
||||
|
||||
class BooLexer(RegexLexer):
|
||||
"""
|
||||
For `Boo <http://boo.codehaus.org/>`_ source code.
|
||||
"""
|
||||
|
||||
name = 'Boo'
|
||||
aliases = ['boo']
|
||||
filenames = ['*.boo']
|
||||
mimetypes = ['text/x-boo']
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\s+', Text),
|
||||
(r'(#|//).*$', Comment.Single),
|
||||
(r'/[*]', Comment.Multiline, 'comment'),
|
||||
(r'[]{}:(),.;[]', Punctuation),
|
||||
(r'\\\n', Text),
|
||||
(r'\\', Text),
|
||||
(r'(in|is|and|or|not)\b', Operator.Word),
|
||||
(r'/(\\\\|\\/|[^/\s])/', String.Regex),
|
||||
(r'@/(\\\\|\\/|[^/])*/', String.Regex),
|
||||
(r'=~|!=|==|<<|>>|[-+/*%=<>&^|]', Operator),
|
||||
(r'(as|abstract|callable|constructor|destructor|do|import|'
|
||||
r'enum|event|final|get|interface|internal|of|override|'
|
||||
r'partial|private|protected|public|return|set|static|'
|
||||
r'struct|transient|virtual|yield|super|and|break|cast|'
|
||||
r'continue|elif|else|ensure|except|for|given|goto|if|in|'
|
||||
r'is|isa|not|or|otherwise|pass|raise|ref|try|unless|when|'
|
||||
r'while|from|as)\b', Keyword),
|
||||
(r'def(?=\s+\(.*?\))', Keyword),
|
||||
(r'(def)(\s+)', bygroups(Keyword, Text), 'funcname'),
|
||||
(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
|
||||
(r'(namespace)(\s+)', bygroups(Keyword, Text), 'namespace'),
|
||||
(r'(?<!\.)(true|false|null|self|__eval__|__switch__|array|'
|
||||
r'assert|checked|enumerate|filter|getter|len|lock|map|'
|
||||
r'matrix|max|min|normalArrayIndexing|print|property|range|'
|
||||
r'rawArrayIndexing|required|typeof|unchecked|using|'
|
||||
r'yieldAll|zip)\b', Name.Builtin),
|
||||
(r'"""(\\\\|\\"|.*?)"""', String.Double),
|
||||
(r'"(\\\\|\\"|[^"]*?)"', String.Double),
|
||||
(r"'(\\\\|\\'|[^']*?)'", String.Single),
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
(r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
|
||||
(r'[0-9][0-9\.]*(ms?|d|h|s)', Number),
|
||||
(r'0\d+', Number.Oct),
|
||||
(r'0x[a-fA-F0-9]+', Number.Hex),
|
||||
(r'\d+L', Number.Integer.Long),
|
||||
(r'\d+', Number.Integer),
|
||||
],
|
||||
'comment': [
|
||||
('/[*]', Comment.Multiline, '#push'),
|
||||
('[*]/', Comment.Multiline, '#pop'),
|
||||
('[^/*]', Comment.Multiline),
|
||||
('[*/]', Comment.Multiline)
|
||||
],
|
||||
'funcname': [
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*', Name.Function, '#pop')
|
||||
],
|
||||
'classname': [
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop')
|
||||
],
|
||||
'namespace': [
|
||||
('[a-zA-Z_][a-zA-Z0-9_.]*', Name.Namespace, '#pop')
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class VbNetLexer(RegexLexer):
|
||||
"""
|
||||
For
|
||||
`Visual Basic.NET <http://msdn2.microsoft.com/en-us/vbasic/default.aspx>`_
|
||||
source code.
|
||||
"""
|
||||
|
||||
name = 'VB.net'
|
||||
aliases = ['vb.net', 'vbnet']
|
||||
filenames = ['*.vb', '*.bas']
|
||||
mimetypes = ['text/x-vbnet', 'text/x-vba'] # (?)
|
||||
|
||||
flags = re.MULTILINE | re.IGNORECASE
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'^\s*<.*?>', Name.Attribute),
|
||||
(r'\s+', Text),
|
||||
(r'\n', Text),
|
||||
(r'rem\b.*?\n', Comment),
|
||||
(r"'.*?\n", Comment),
|
||||
(r'#If\s.*?\sThen|#ElseIf\s.*?\sThen|#End\s+If|#Const|'
|
||||
r'#ExternalSource.*?\n|#End\s+ExternalSource|'
|
||||
r'#Region.*?\n|#End\s+Region|#ExternalChecksum',
|
||||
Comment.Preproc),
|
||||
(r'[\(\){}!#,.:]', Punctuation),
|
||||
(r'Option\s+(Strict|Explicit|Compare)\s+'
|
||||
r'(On|Off|Binary|Text)', Keyword.Declaration),
|
||||
(r'(?<!\.)(AddHandler|Alias|'
|
||||
r'ByRef|ByVal|Call|Case|Catch|CBool|CByte|CChar|CDate|'
|
||||
r'CDec|CDbl|CInt|CLng|CObj|Continue|CSByte|CShort|'
|
||||
r'CSng|CStr|CType|CUInt|CULng|CUShort|Declare|'
|
||||
r'Default|Delegate|DirectCast|Do|Each|Else|ElseIf|'
|
||||
r'EndIf|Erase|Error|Event|Exit|False|Finally|For|'
|
||||
r'Friend|Get|Global|GoSub|GoTo|Handles|If|'
|
||||
r'Implements|Inherits|Interface|'
|
||||
r'Let|Lib|Loop|Me|MustInherit|'
|
||||
r'MustOverride|MyBase|MyClass|Narrowing|New|Next|'
|
||||
r'Not|Nothing|NotInheritable|NotOverridable|Of|On|'
|
||||
r'Operator|Option|Optional|Overloads|Overridable|'
|
||||
r'Overrides|ParamArray|Partial|Private|Protected|'
|
||||
r'Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|'
|
||||
r'Return|Select|Set|Shadows|Shared|Single|'
|
||||
r'Static|Step|Stop|SyncLock|Then|'
|
||||
r'Throw|To|True|Try|TryCast|Wend|'
|
||||
r'Using|When|While|Widening|With|WithEvents|'
|
||||
r'WriteOnly)\b', Keyword),
|
||||
(r'(?<!\.)End\b', Keyword, 'end'),
|
||||
(r'(?<!\.)(Dim|Const)\b', Keyword, 'dim'),
|
||||
(r'(?<!\.)(Function|Sub|Property)(\s+)',
|
||||
bygroups(Keyword, Text), 'funcname'),
|
||||
(r'(?<!\.)(Class|Structure|Enum)(\s+)',
|
||||
bygroups(Keyword, Text), 'classname'),
|
||||
(r'(?<!\.)(Module|Namespace|Imports)(\s+)',
|
||||
bygroups(Keyword, Text), 'namespace'),
|
||||
(r'(?<!\.)(Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|'
|
||||
r'Object|SByte|Short|Single|String|Variant|UInteger|ULong|'
|
||||
r'UShort)\b', Keyword.Type),
|
||||
(r'(?<!\.)(AddressOf|And|AndAlso|As|GetType|In|Is|IsNot|Like|Mod|'
|
||||
r'Or|OrElse|TypeOf|Xor)\b', Operator.Word),
|
||||
(r'&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|'
|
||||
r'<=|>=|<>|[-&*/\\^+=<>]',
|
||||
Operator),
|
||||
('"', String, 'string'),
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*[%&@!#$]?', Name),
|
||||
('#.*?#', Literal.Date),
|
||||
(r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
|
||||
(r'\d+([SILDFR]|US|UI|UL)?', Number.Integer),
|
||||
(r'&H[0-9a-f]+([SILDFR]|US|UI|UL)?', Number.Integer),
|
||||
(r'&O[0-7]+([SILDFR]|US|UI|UL)?', Number.Integer),
|
||||
(r'_\n', Text), # Line continuation
|
||||
],
|
||||
'string': [
|
||||
(r'""', String),
|
||||
(r'"C?', String, '#pop'),
|
||||
(r'[^"]+', String),
|
||||
],
|
||||
'dim': [
|
||||
(r'[a-z_][a-z0-9_]*', Name.Variable, '#pop'),
|
||||
(r'', Text, '#pop'), # any other syntax
|
||||
],
|
||||
'funcname': [
|
||||
(r'[a-z_][a-z0-9_]*', Name.Function, '#pop'),
|
||||
],
|
||||
'classname': [
|
||||
(r'[a-z_][a-z0-9_]*', Name.Class, '#pop'),
|
||||
],
|
||||
'namespace': [
|
||||
(r'[a-z_][a-z0-9_.]*', Name.Namespace, '#pop'),
|
||||
],
|
||||
'end': [
|
||||
(r'\s+', Text),
|
||||
(r'(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b',
|
||||
Keyword, '#pop'),
|
||||
(r'', Text, '#pop'),
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class GenericAspxLexer(RegexLexer):
|
||||
"""
|
||||
Lexer for ASP.NET pages.
|
||||
"""
|
||||
|
||||
name = 'aspx-gen'
|
||||
filenames = []
|
||||
mimetypes = []
|
||||
|
||||
flags = re.DOTALL
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'(<%[@=#]?)(.*?)(%>)', bygroups(Name.Tag, Other, Name.Tag)),
|
||||
(r'(<script.*?>)(.*?)(</script>)', bygroups(using(XmlLexer),
|
||||
Other,
|
||||
using(XmlLexer))),
|
||||
(r'(.+?)(?=<)', using(XmlLexer)),
|
||||
(r'.+', using(XmlLexer)),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
#TODO support multiple languages within the same source file
|
||||
class CSharpAspxLexer(DelegatingLexer):
|
||||
"""
|
||||
Lexer for highligting C# within ASP.NET pages.
|
||||
"""
|
||||
|
||||
name = 'aspx-cs'
|
||||
aliases = ['aspx-cs']
|
||||
filenames = ['*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd']
|
||||
mimetypes = []
|
||||
|
||||
def __init__(self, **options):
|
||||
super(CSharpAspxLexer, self).__init__(CSharpLexer,GenericAspxLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
if re.search(r'Page\s*Language="C#"', text, re.I) is not None:
|
||||
return 0.2
|
||||
elif re.search(r'script[^>]+language=["\']C#', text, re.I) is not None:
|
||||
return 0.15
|
||||
|
||||
|
||||
class VbNetAspxLexer(DelegatingLexer):
|
||||
"""
|
||||
Lexer for highligting Visual Basic.net within ASP.NET pages.
|
||||
"""
|
||||
|
||||
name = 'aspx-vb'
|
||||
aliases = ['aspx-vb']
|
||||
filenames = ['*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd']
|
||||
mimetypes = []
|
||||
|
||||
def __init__(self, **options):
|
||||
super(VbNetAspxLexer, self).__init__(VbNetLexer,GenericAspxLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
if re.search(r'Page\s*Language="Vb"', text, re.I) is not None:
|
||||
return 0.2
|
||||
elif re.search(r'script[^>]+language=["\']vb', text, re.I) is not None:
|
||||
return 0.15
|
||||
|
||||
|
||||
# Very close to functional.OcamlLexer
|
||||
class FSharpLexer(RegexLexer):
|
||||
"""
|
||||
For the F# language (version 3.0).
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
|
||||
name = 'FSharp'
|
||||
aliases = ['fsharp']
|
||||
filenames = ['*.fs', '*.fsi']
|
||||
mimetypes = ['text/x-fsharp']
|
||||
|
||||
keywords = [
|
||||
'abstract', 'as', 'assert', 'base', 'begin', 'class', 'default',
|
||||
'delegate', 'do!', 'do', 'done', 'downcast', 'downto', 'elif', 'else',
|
||||
'end', 'exception', 'extern', 'false', 'finally', 'for', 'function',
|
||||
'fun', 'global', 'if', 'inherit', 'inline', 'interface', 'internal',
|
||||
'in', 'lazy', 'let!', 'let', 'match', 'member', 'module', 'mutable',
|
||||
'namespace', 'new', 'null', 'of', 'open', 'override', 'private', 'public',
|
||||
'rec', 'return!', 'return', 'select', 'static', 'struct', 'then', 'to',
|
||||
'true', 'try', 'type', 'upcast', 'use!', 'use', 'val', 'void', 'when',
|
||||
'while', 'with', 'yield!', 'yield',
|
||||
]
|
||||
# Reserved words; cannot hurt to color them as keywords too.
|
||||
keywords += [
|
||||
'atomic', 'break', 'checked', 'component', 'const', 'constraint',
|
||||
'constructor', 'continue', 'eager', 'event', 'external', 'fixed',
|
||||
'functor', 'include', 'method', 'mixin', 'object', 'parallel',
|
||||
'process', 'protected', 'pure', 'sealed', 'tailcall', 'trait',
|
||||
'virtual', 'volatile',
|
||||
]
|
||||
keyopts = [
|
||||
'!=', '#', '&&', '&', '\(', '\)', '\*', '\+', ',', '-\.',
|
||||
'->', '-', '\.\.', '\.', '::', ':=', ':>', ':', ';;', ';', '<-',
|
||||
'<\]', '<', '>\]', '>', '\?\?', '\?', '\[<', '\[\|', '\[', '\]',
|
||||
'_', '`', '{', '\|\]', '\|', '}', '~', '<@@', '<@', '=', '@>', '@@>',
|
||||
]
|
||||
|
||||
operators = r'[!$%&*+\./:<=>?@^|~-]'
|
||||
word_operators = ['and', 'or', 'not']
|
||||
prefix_syms = r'[!?~]'
|
||||
infix_syms = r'[=<>@^|&+\*/$%-]'
|
||||
primitives = [
|
||||
'sbyte', 'byte', 'char', 'nativeint', 'unativeint', 'float32', 'single',
|
||||
'float', 'double', 'int8', 'uint8', 'int16', 'uint16', 'int32',
|
||||
'uint32', 'int64', 'uint64', 'decimal', 'unit', 'bool', 'string',
|
||||
'list', 'exn', 'obj', 'enum',
|
||||
]
|
||||
|
||||
# See http://msdn.microsoft.com/en-us/library/dd233181.aspx and/or
|
||||
# http://fsharp.org/about/files/spec.pdf for reference. Good luck.
|
||||
|
||||
tokens = {
|
||||
'escape-sequence': [
|
||||
(r'\\[\\\"\'ntbrafv]', String.Escape),
|
||||
(r'\\[0-9]{3}', String.Escape),
|
||||
(r'\\u[0-9a-fA-F]{4}', String.Escape),
|
||||
(r'\\U[0-9a-fA-F]{8}', String.Escape),
|
||||
],
|
||||
'root': [
|
||||
(r'\s+', Text),
|
||||
(r'\(\)|\[\]', Name.Builtin.Pseudo),
|
||||
(r'\b(?<!\.)([A-Z][A-Za-z0-9_\']*)(?=\s*\.)',
|
||||
Name.Namespace, 'dotted'),
|
||||
(r'\b([A-Z][A-Za-z0-9_\']*)', Name),
|
||||
(r'///.*?\n', String.Doc),
|
||||
(r'//.*?\n', Comment.Single),
|
||||
(r'\(\*(?!\))', Comment, 'comment'),
|
||||
|
||||
(r'@"', String, 'lstring'),
|
||||
(r'"""', String, 'tqs'),
|
||||
(r'"', String, 'string'),
|
||||
|
||||
(r'\b(open|module)(\s+)([a-zA-Z0-9_.]+)',
|
||||
bygroups(Keyword, Text, Name.Namespace)),
|
||||
(r'\b(let!?)(\s+)([a-zA-Z0-9_]+)',
|
||||
bygroups(Keyword, Text, Name.Variable)),
|
||||
(r'\b(type)(\s+)([a-zA-Z0-9_]+)',
|
||||
bygroups(Keyword, Text, Name.Class)),
|
||||
(r'\b(member|override)(\s+)([a-zA-Z0-9_]+)(\.)([a-zA-Z0-9_]+)',
|
||||
bygroups(Keyword, Text, Name, Punctuation, Name.Function)),
|
||||
(r'\b(%s)\b' % '|'.join(keywords), Keyword),
|
||||
(r'(%s)' % '|'.join(keyopts), Operator),
|
||||
(r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
|
||||
(r'\b(%s)\b' % '|'.join(word_operators), Operator.Word),
|
||||
(r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
|
||||
(r'#[ \t]*(if|endif|else|line|nowarn|light|\d+)\b.*?\n',
|
||||
Comment.Preproc),
|
||||
|
||||
(r"[^\W\d][\w']*", Name),
|
||||
|
||||
(r'\d[\d_]*[uU]?[yslLnQRZINGmM]?', Number.Integer),
|
||||
(r'0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?', Number.Hex),
|
||||
(r'0[oO][0-7][0-7_]*[uU]?[yslLn]?', Number.Oct),
|
||||
(r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Binary),
|
||||
(r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?',
|
||||
Number.Float),
|
||||
|
||||
(r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?",
|
||||
String.Char),
|
||||
(r"'.'", String.Char),
|
||||
(r"'", Keyword), # a stray quote is another syntax element
|
||||
|
||||
(r'[~?][a-z][\w\']*:', Name.Variable),
|
||||
],
|
||||
'dotted': [
|
||||
(r'\s+', Text),
|
||||
(r'\.', Punctuation),
|
||||
(r'[A-Z][A-Za-z0-9_\']*(?=\s*\.)', Name.Namespace),
|
||||
(r'[A-Z][A-Za-z0-9_\']*', Name, '#pop'),
|
||||
(r'[a-z_][A-Za-z0-9_\']*', Name, '#pop'),
|
||||
],
|
||||
'comment': [
|
||||
(r'[^(*)@"]+', Comment),
|
||||
(r'\(\*', Comment, '#push'),
|
||||
(r'\*\)', Comment, '#pop'),
|
||||
# comments cannot be closed within strings in comments
|
||||
(r'@"', String, 'lstring'),
|
||||
(r'"""', String, 'tqs'),
|
||||
(r'"', String, 'string'),
|
||||
(r'[(*)@]', Comment),
|
||||
],
|
||||
'string': [
|
||||
(r'[^\\"]+', String),
|
||||
include('escape-sequence'),
|
||||
(r'\\\n', String),
|
||||
(r'\n', String), # newlines are allowed in any string
|
||||
(r'"B?', String, '#pop'),
|
||||
],
|
||||
'lstring': [
|
||||
(r'[^"]+', String),
|
||||
(r'\n', String),
|
||||
(r'""', String),
|
||||
(r'"B?', String, '#pop'),
|
||||
],
|
||||
'tqs': [
|
||||
(r'[^"]+', String),
|
||||
(r'\n', String),
|
||||
(r'"""B?', String, '#pop'),
|
||||
(r'"', String),
|
||||
],
|
||||
}
|
|
@ -0,0 +1,428 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.foxpro
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Simple lexer for Microsoft Visual FoxPro source code.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import RegexLexer
|
||||
from pygments.token import Punctuation, Text, Comment, Operator, Keyword, \
|
||||
Name, String
|
||||
|
||||
__all__ = ['FoxProLexer']
|
||||
|
||||
|
||||
class FoxProLexer(RegexLexer):
|
||||
"""Lexer for Microsoft Visual FoxPro language.
|
||||
|
||||
FoxPro syntax allows to shorten all keywords and function names
|
||||
to 4 characters. Shortened forms are not recognized by this lexer.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
|
||||
name = 'FoxPro'
|
||||
aliases = ['Clipper', 'XBase']
|
||||
filenames = ['*.PRG', '*.prg']
|
||||
mimetype = []
|
||||
|
||||
flags = re.IGNORECASE | re.MULTILINE
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r';\s*\n', Punctuation), # consume newline
|
||||
(r'(^|\n)\s*', Text, 'newline'),
|
||||
|
||||
# Square brackets may be used for array indices
|
||||
# and for string literal. Look for arrays
|
||||
# before matching string literals.
|
||||
(r'(?<=\w)\[[0-9, ]+\]', Text),
|
||||
(r'\'[^\'\n]*\'|"[^"\n]*"|\[[^]*]\]', String),
|
||||
(r'(^\s*\*|&&|&&).*?\n', Comment.Single),
|
||||
|
||||
(r'(ABS|ACLASS|ACOPY|ACOS|ADATABASES|ADBOBJECTS|ADDBS|'
|
||||
r'ADDPROPERTY|ADEL|ADIR|ADLLS|ADOCKSTATE|AELEMENT|AERROR|'
|
||||
r'AEVENTS|AFIELDS|AFONT|AGETCLASS|AGETFILEVERSION|AINS|'
|
||||
r'AINSTANCE|ALANGUAGE|ALEN|ALIAS|ALINES|ALLTRIM|'
|
||||
r'AMEMBERS|AMOUSEOBJ|ANETRESOURCES|APRINTERS|APROCINFO|'
|
||||
r'ASC|ASCAN|ASELOBJ|ASESSIONS|ASIN|ASORT|ASQLHANDLES|'
|
||||
r'ASTACKINFO|ASUBSCRIPT|AT|AT_C|ATAGINFO|ATAN|ATC|ATCC|'
|
||||
r'ATCLINE|ATLINE|ATN2|AUSED|AVCXCLASSES|BAR|BARCOUNT|'
|
||||
r'BARPROMPT|BETWEEN|BINDEVENT|BINTOC|BITAND|BITCLEAR|'
|
||||
r'BITLSHIFT|BITNOT|BITOR|BITRSHIFT|BITSET|BITTEST|BITXOR|'
|
||||
r'BOF|CANDIDATE|CAPSLOCK|CAST|CDOW|CDX|CEILING|CHR|CHRSAW|'
|
||||
r'CHRTRAN|CHRTRANC|CLEARRESULTSET|CMONTH|CNTBAR|CNTPAD|COL|'
|
||||
r'COM|Functions|COMARRAY|COMCLASSINFO|COMPOBJ|COMPROP|'
|
||||
r'COMRETURNERROR|COS|CPCONVERT|CPCURRENT|CPDBF|CREATEBINARY|'
|
||||
r'CREATEOBJECT|CREATEOBJECTEX|CREATEOFFLINE|CTOBIN|CTOD|'
|
||||
r'CTOT|CURDIR|CURSORGETPROP|CURSORSETPROP|CURSORTOXML|'
|
||||
r'CURVAL|DATE|DATETIME|DAY|DBC|DBF|DBGETPROP|DBSETPROP|'
|
||||
r'DBUSED|DDEAbortTrans|DDEAdvise|DDEEnabled|DDEExecute|'
|
||||
r'DDEInitiate|DDELastError|DDEPoke|DDERequest|DDESetOption|'
|
||||
r'DDESetService|DDESetTopic|DDETerminate|DEFAULTEXT|'
|
||||
r'DELETED|DESCENDING|DIFFERENCE|DIRECTORY|DISKSPACE|'
|
||||
r'DisplayPath|DMY|DODEFAULT|DOW|DRIVETYPE|DROPOFFLINE|'
|
||||
r'DTOC|DTOR|DTOS|DTOT|EDITSOURCE|EMPTY|EOF|ERROR|EVAL(UATE)?|'
|
||||
r'EVENTHANDLER|EVL|EXECSCRIPT|EXP|FCHSIZE|FCLOSE|FCOUNT|'
|
||||
r'FCREATE|FDATE|FEOF|FERROR|FFLUSH|FGETS|FIELD|FILE|'
|
||||
r'FILETOSTR|FILTER|FKLABEL|FKMAX|FLDLIST|FLOCK|FLOOR|'
|
||||
r'FONTMETRIC|FOPEN|FOR|FORCEEXT|FORCEPATH|FOUND|FPUTS|'
|
||||
r'FREAD|FSEEK|FSIZE|FTIME|FULLPATH|FV|FWRITE|'
|
||||
r'GETAUTOINCVALUE|GETBAR|GETCOLOR|GETCP|GETDIR|GETENV|'
|
||||
r'GETFILE|GETFLDSTATE|GETFONT|GETINTERFACE|'
|
||||
r'GETNEXTMODIFIED|GETOBJECT|GETPAD|GETPEM|GETPICT|'
|
||||
r'GETPRINTER|GETRESULTSET|GETWORDCOUNT|GETWORDNUM|'
|
||||
r'GETCURSORADAPTER|GOMONTH|HEADER|HOME|HOUR|ICASE|'
|
||||
r'IDXCOLLATE|IIF|IMESTATUS|INDBC|INDEXSEEK|INKEY|INLIST|'
|
||||
r'INPUTBOX|INSMODE|INT|ISALPHA|ISBLANK|ISCOLOR|ISDIGIT|'
|
||||
r'ISEXCLUSIVE|ISFLOCKED|ISLEADBYTE|ISLOWER|ISMEMOFETCHED|'
|
||||
r'ISMOUSE|ISNULL|ISPEN|ISREADONLY|ISRLOCKED|'
|
||||
r'ISTRANSACTABLE|ISUPPER|JUSTDRIVE|JUSTEXT|JUSTFNAME|'
|
||||
r'JUSTPATH|JUSTSTEM|KEY|KEYMATCH|LASTKEY|LEFT|LEFTC|LEN|'
|
||||
r'LENC|LIKE|LIKEC|LINENO|LOADPICTURE|LOCFILE|LOCK|LOG|'
|
||||
r'LOG10|LOOKUP|LOWER|LTRIM|LUPDATE|MAKETRANSACTABLE|MAX|'
|
||||
r'MCOL|MDOWN|MDX|MDY|MEMLINES|MEMORY|MENU|MESSAGE|'
|
||||
r'MESSAGEBOX|MIN|MINUTE|MLINE|MOD|MONTH|MRKBAR|MRKPAD|'
|
||||
r'MROW|MTON|MWINDOW|NDX|NEWOBJECT|NORMALIZE|NTOM|NUMLOCK|'
|
||||
r'NVL|OBJNUM|OBJTOCLIENT|OBJVAR|OCCURS|OEMTOANSI|OLDVAL|'
|
||||
r'ON|ORDER|OS|PAD|PADL|PARAMETERS|PAYMENT|PCOL|PCOUNT|'
|
||||
r'PEMSTATUS|PI|POPUP|PRIMARY|PRINTSTATUS|PRMBAR|PRMPAD|'
|
||||
r'PROGRAM|PROMPT|PROPER|PROW|PRTINFO|PUTFILE|PV|QUARTER|'
|
||||
r'RAISEEVENT|RAND|RAT|RATC|RATLINE|RDLEVEL|READKEY|RECCOUNT|'
|
||||
r'RECNO|RECSIZE|REFRESH|RELATION|REPLICATE|REQUERY|RGB|'
|
||||
r'RGBSCHEME|RIGHT|RIGHTC|RLOCK|ROUND|ROW|RTOD|RTRIM|'
|
||||
r'SAVEPICTURE|SCHEME|SCOLS|SEC|SECONDS|SEEK|SELECT|SET|'
|
||||
r'SETFLDSTATE|SETRESULTSET|SIGN|SIN|SKPBAR|SKPPAD|SOUNDEX|'
|
||||
r'SPACE|SQLCANCEL|SQLCOLUMNS|SQLCOMMIT|SQLCONNECT|'
|
||||
r'SQLDISCONNECT|SQLEXEC|SQLGETPROP|SQLIDLEDISCONNECT|'
|
||||
r'SQLMORERESULTS|SQLPREPARE|SQLROLLBACK|SQLSETPROP|'
|
||||
r'SQLSTRINGCONNECT|SQLTABLES|SQRT|SROWS|STR|STRCONV|'
|
||||
r'STREXTRACT|STRTOFILE|STRTRAN|STUFF|STUFFC|SUBSTR|'
|
||||
r'SUBSTRC|SYS|SYSMETRIC|TABLEREVERT|TABLEUPDATE|TAG|'
|
||||
r'TAGCOUNT|TAGNO|TAN|TARGET|TEXTMERGE|TIME|TRANSFORM|'
|
||||
r'TRIM|TTOC|TTOD|TXNLEVEL|TXTWIDTH|TYPE|UNBINDEVENTS|'
|
||||
r'UNIQUE|UPDATED|UPPER|USED|VAL|VARREAD|VARTYPE|VERSION|'
|
||||
r'WBORDER|WCHILD|WCOLS|WDOCKABLE|WEEK|WEXIST|WFONT|WLAST|'
|
||||
r'WLCOL|WLROW|WMAXIMUM|WMINIMUM|WONTOP|WOUTPUT|WPARENT|'
|
||||
r'WREAD|WROWS|WTITLE|WVISIBLE|XMLTOCURSOR|XMLUPDATEGRAM|'
|
||||
r'YEAR)(?=\s*\()', Name.Function),
|
||||
|
||||
(r'_ALIGNMENT|_ASCIICOLS|_ASCIIROWS|_ASSIST|_BEAUTIFY|_BOX|'
|
||||
r'_BROWSER|_BUILDER|_CALCMEM|_CALCVALUE|_CLIPTEXT|_CONVERTER|'
|
||||
r'_COVERAGE|_CUROBJ|_DBLCLICK|_DIARYDATE|_DOS|_FOXDOC|_FOXREF|'
|
||||
r'_GALLERY|_GENGRAPH|_GENHTML|_GENMENU|_GENPD|_GENSCRN|'
|
||||
r'_GENXTAB|_GETEXPR|_INCLUDE|_INCSEEK|_INDENT|_LMARGIN|_MAC|'
|
||||
r'_MENUDESIGNER|_MLINE|_PADVANCE|_PAGENO|_PAGETOTAL|_PBPAGE|'
|
||||
r'_PCOLNO|_PCOPIES|_PDRIVER|_PDSETUP|_PECODE|_PEJECT|_PEPAGE|'
|
||||
r'_PLENGTH|_PLINENO|_PLOFFSET|_PPITCH|_PQUALITY|_PRETEXT|'
|
||||
r'_PSCODE|_PSPACING|_PWAIT|_RMARGIN|_REPORTBUILDER|'
|
||||
r'_REPORTOUTPUT|_REPORTPREVIEW|_SAMPLES|_SCCTEXT|_SCREEN|'
|
||||
r'_SHELL|_SPELLCHK|_STARTUP|_TABS|_TALLY|_TASKPANE|_TEXT|'
|
||||
r'_THROTTLE|_TOOLBOX|_TOOLTIPTIMEOUT|_TRANSPORT|_TRIGGERLEVEL|'
|
||||
r'_UNIX|_VFP|_WINDOWS|_WIZARD|_WRAP', Keyword.Pseudo),
|
||||
|
||||
(r'THISFORMSET|THISFORM|THIS', Name.Builtin),
|
||||
|
||||
(r'Application|CheckBox|Collection|Column|ComboBox|'
|
||||
r'CommandButton|CommandGroup|Container|Control|CursorAdapter|'
|
||||
r'Cursor|Custom|DataEnvironment|DataObject|EditBox|'
|
||||
r'Empty|Exception|Fields|Files|File|FormSet|Form|FoxCode|'
|
||||
r'Grid|Header|Hyperlink|Image|Label|Line|ListBox|Objects|'
|
||||
r'OptionButton|OptionGroup|PageFrame|Page|ProjectHook|Projects|'
|
||||
r'Project|Relation|ReportListener|Separator|Servers|Server|'
|
||||
r'Session|Shape|Spinner|Tables|TextBox|Timer|ToolBar|'
|
||||
r'XMLAdapter|XMLField|XMLTable', Name.Class),
|
||||
|
||||
(r'm\.[a-z_]\w*', Name.Variable),
|
||||
(r'\.(F|T|AND|OR|NOT|NULL)\.|\b(AND|OR|NOT|NULL)\b', Operator.Word),
|
||||
|
||||
(r'\.(ActiveColumn|ActiveControl|ActiveForm|ActivePage|'
|
||||
r'ActiveProject|ActiveRow|AddLineFeeds|ADOCodePage|Alias|'
|
||||
r'Alignment|Align|AllowAddNew|AllowAutoColumnFit|'
|
||||
r'AllowCellSelection|AllowDelete|AllowHeaderSizing|'
|
||||
r'AllowInsert|AllowModalMessages|AllowOutput|AllowRowSizing|'
|
||||
r'AllowSimultaneousFetch|AllowTabs|AllowUpdate|'
|
||||
r'AlwaysOnBottom|AlwaysOnTop|Anchor|Application|'
|
||||
r'AutoActivate|AutoCenter|AutoCloseTables|AutoComplete|'
|
||||
r'AutoCompSource|AutoCompTable|AutoHideScrollBar|'
|
||||
r'AutoIncrement|AutoOpenTables|AutoRelease|AutoSize|'
|
||||
r'AutoVerbMenu|AutoYield|BackColor|ForeColor|BackStyle|'
|
||||
r'BaseClass|BatchUpdateCount|BindControls|BorderColor|'
|
||||
r'BorderStyle|BorderWidth|BoundColumn|BoundTo|Bound|'
|
||||
r'BreakOnError|BufferModeOverride|BufferMode|'
|
||||
r'BuildDateTime|ButtonCount|Buttons|Cancel|Caption|'
|
||||
r'Centered|Century|ChildAlias|ChildOrder|ChildTable|'
|
||||
r'ClassLibrary|Class|ClipControls|Closable|CLSID|CodePage|'
|
||||
r'ColorScheme|ColorSource|ColumnCount|ColumnLines|'
|
||||
r'ColumnOrder|Columns|ColumnWidths|CommandClauses|'
|
||||
r'Comment|CompareMemo|ConflictCheckCmd|ConflictCheckType|'
|
||||
r'ContinuousScroll|ControlBox|ControlCount|Controls|'
|
||||
r'ControlSource|ConversionFunc|Count|CurrentControl|'
|
||||
r'CurrentDataSession|CurrentPass|CurrentX|CurrentY|'
|
||||
r'CursorSchema|CursorSource|CursorStatus|Curvature|'
|
||||
r'Database|DataSessionID|DataSession|DataSourceType|'
|
||||
r'DataSource|DataType|DateFormat|DateMark|Debug|'
|
||||
r'DeclareXMLPrefix|DEClassLibrary|DEClass|DefaultFilePath|'
|
||||
r'Default|DefOLELCID|DeleteCmdDataSourceType|DeleteCmdDataSource|'
|
||||
r'DeleteCmd|DeleteMark|Description|Desktop|'
|
||||
r'Details|DisabledBackColor|DisabledForeColor|'
|
||||
r'DisabledItemBackColor|DisabledItemForeColor|'
|
||||
r'DisabledPicture|DisableEncode|DisplayCount|'
|
||||
r'DisplayValue|Dockable|Docked|DockPosition|'
|
||||
r'DocumentFile|DownPicture|DragIcon|DragMode|DrawMode|'
|
||||
r'DrawStyle|DrawWidth|DynamicAlignment|DynamicBackColor|'
|
||||
r'DynamicForeColor|DynamicCurrentControl|DynamicFontBold|'
|
||||
r'DynamicFontItalic|DynamicFontStrikethru|'
|
||||
r'DynamicFontUnderline|DynamicFontName|DynamicFontOutline|'
|
||||
r'DynamicFontShadow|DynamicFontSize|DynamicInputMask|'
|
||||
r'DynamicLineHeight|EditorOptions|Enabled|'
|
||||
r'EnableHyperlinks|Encrypted|ErrorNo|Exclude|Exclusive|'
|
||||
r'FetchAsNeeded|FetchMemoCmdList|FetchMemoDataSourceType|'
|
||||
r'FetchMemoDataSource|FetchMemo|FetchSize|'
|
||||
r'FileClassLibrary|FileClass|FillColor|FillStyle|Filter|'
|
||||
r'FirstElement|FirstNestedTable|Flags|FontBold|FontItalic|'
|
||||
r'FontStrikethru|FontUnderline|FontCharSet|FontCondense|'
|
||||
r'FontExtend|FontName|FontOutline|FontShadow|FontSize|'
|
||||
r'ForceCloseTag|Format|FormCount|FormattedOutput|Forms|'
|
||||
r'FractionDigits|FRXDataSession|FullName|GDIPlusGraphics|'
|
||||
r'GridLineColor|GridLines|GridLineWidth|HalfHeightCaption|'
|
||||
r'HeaderClassLibrary|HeaderClass|HeaderHeight|Height|'
|
||||
r'HelpContextID|HideSelection|HighlightBackColor|'
|
||||
r'HighlightForeColor|HighlightStyle|HighlightRowLineWidth|'
|
||||
r'HighlightRow|Highlight|HomeDir|Hours|HostName|'
|
||||
r'HScrollSmallChange|hWnd|Icon|IncrementalSearch|Increment|'
|
||||
r'InitialSelectedAlias|InputMask|InsertCmdDataSourceType|'
|
||||
r'InsertCmdDataSource|InsertCmdRefreshCmd|'
|
||||
r'InsertCmdRefreshFieldList|InsertCmdRefreshKeyFieldList|'
|
||||
r'InsertCmd|Instancing|IntegralHeight|'
|
||||
r'Interval|IMEMode|IsAttribute|IsBase64|IsBinary|IsNull|'
|
||||
r'IsDiffGram|IsLoaded|ItemBackColor,|ItemData|ItemIDData|'
|
||||
r'ItemTips|IXMLDOMElement|KeyboardHighValue|KeyboardLowValue|'
|
||||
r'Keyfield|KeyFieldList|KeyPreview|KeySort|LanguageOptions|'
|
||||
r'LeftColumn|Left|LineContents|LineNo|LineSlant|LinkMaster|'
|
||||
r'ListCount|ListenerType|ListIndex|ListItemID|ListItem|'
|
||||
r'List|LockColumnsLeft|LockColumns|LockScreen|MacDesktop|'
|
||||
r'MainFile|MapN19_4ToCurrency|MapBinary|MapVarchar|Margin|'
|
||||
r'MaxButton|MaxHeight|MaxLeft|MaxLength|MaxRecords|MaxTop|'
|
||||
r'MaxWidth|MDIForm|MemberClassLibrary|MemberClass|'
|
||||
r'MemoWindow|Message|MinButton|MinHeight|MinWidth|'
|
||||
r'MouseIcon|MousePointer|Movable|MoverBars|MultiSelect|'
|
||||
r'Name|NestedInto|NewIndex|NewItemID|NextSiblingTable|'
|
||||
r'NoCpTrans|NoDataOnLoad|NoData|NullDisplay|'
|
||||
r'NumberOfElements|Object|OLEClass|OLEDragMode|'
|
||||
r'OLEDragPicture|OLEDropEffects|OLEDropHasData|'
|
||||
r'OLEDropMode|OLEDropTextInsertion|OLELCID|'
|
||||
r'OLERequestPendingTimeout|OLEServerBusyRaiseError|'
|
||||
r'OLEServerBusyTimeout|OLETypeAllowed|OneToMany|'
|
||||
r'OpenViews|OpenWindow|Optimize|OrderDirection|Order|'
|
||||
r'OutputPageCount|OutputType|PageCount|PageHeight|'
|
||||
r'PageNo|PageOrder|Pages|PageTotal|PageWidth|'
|
||||
r'PanelLink|Panel|ParentAlias|ParentClass|ParentTable|'
|
||||
r'Parent|Partition|PasswordChar|PictureMargin|'
|
||||
r'PicturePosition|PictureSpacing|PictureSelectionDisplay|'
|
||||
r'PictureVal|Picture|Prepared|'
|
||||
r'PolyPoints|PreserveWhiteSpace|PreviewContainer|'
|
||||
r'PrintJobName|Procedure|PROCESSID|ProgID|ProjectHookClass|'
|
||||
r'ProjectHookLibrary|ProjectHook|QuietMode|'
|
||||
r'ReadCycle|ReadLock|ReadMouse|ReadObject|ReadOnly|'
|
||||
r'ReadSave|ReadTimeout|RecordMark|RecordSourceType|'
|
||||
r'RecordSource|RefreshAlias|'
|
||||
r'RefreshCmdDataSourceType|RefreshCmdDataSource|RefreshCmd|'
|
||||
r'RefreshIgnoreFieldList|RefreshTimeStamp|RelationalExpr|'
|
||||
r'RelativeColumn|RelativeRow|ReleaseType|Resizable|'
|
||||
r'RespectCursorCP|RespectNesting|RightToLeft|RotateFlip|'
|
||||
r'Rotation|RowColChange|RowHeight|RowSourceType|'
|
||||
r'RowSource|ScaleMode|SCCProvider|SCCStatus|ScrollBars|'
|
||||
r'Seconds|SelectCmd|SelectedID|'
|
||||
r'SelectedItemBackColor|SelectedItemForeColor|Selected|'
|
||||
r'SelectionNamespaces|SelectOnEntry|SelLength|SelStart|'
|
||||
r'SelText|SendGDIPlusImage|SendUpdates|ServerClassLibrary|'
|
||||
r'ServerClass|ServerHelpFile|ServerName|'
|
||||
r'ServerProject|ShowTips|ShowInTaskbar|ShowWindow|'
|
||||
r'Sizable|SizeBox|SOM|Sorted|Sparse|SpecialEffect|'
|
||||
r'SpinnerHighValue|SpinnerLowValue|SplitBar|StackLevel|'
|
||||
r'StartMode|StatusBarText|StatusBar|Stretch|StrictDateEntry|'
|
||||
r'Style|TabIndex|Tables|TabOrientation|Tabs|TabStop|'
|
||||
r'TabStretch|TabStyle|Tag|TerminateRead|Text|Themes|'
|
||||
r'ThreadID|TimestampFieldList|TitleBar|ToolTipText|'
|
||||
r'TopIndex|TopItemID|Top|TwoPassProcess|TypeLibCLSID|'
|
||||
r'TypeLibDesc|TypeLibName|Type|Unicode|UpdatableFieldList|'
|
||||
r'UpdateCmdDataSourceType|UpdateCmdDataSource|'
|
||||
r'UpdateCmdRefreshCmd|UpdateCmdRefreshFieldList|'
|
||||
r'UpdateCmdRefreshKeyFieldList|UpdateCmd|'
|
||||
r'UpdateGramSchemaLocation|UpdateGram|UpdateNameList|UpdateType|'
|
||||
r'UseCodePage|UseCursorSchema|UseDeDataSource|UseMemoSize|'
|
||||
r'UserValue|UseTransactions|UTF8Encoded|Value|VersionComments|'
|
||||
r'VersionCompany|VersionCopyright|VersionDescription|'
|
||||
r'VersionNumber|VersionProduct|VersionTrademarks|Version|'
|
||||
r'VFPXMLProgID|ViewPortHeight|ViewPortLeft|'
|
||||
r'ViewPortTop|ViewPortWidth|VScrollSmallChange|View|Visible|'
|
||||
r'VisualEffect|WhatsThisButton|WhatsThisHelpID|WhatsThisHelp|'
|
||||
r'WhereType|Width|WindowList|WindowState|WindowType|WordWrap|'
|
||||
r'WrapCharInCDATA|WrapInCDATA|WrapMemoInCDATA|XMLAdapter|'
|
||||
r'XMLConstraints|XMLNameIsXPath|XMLNamespace|XMLName|'
|
||||
r'XMLPrefix|XMLSchemaLocation|XMLTable|XMLType|'
|
||||
r'XSDfractionDigits|XSDmaxLength|XSDtotalDigits|'
|
||||
r'XSDtype|ZoomBox)', Name.Attribute),
|
||||
|
||||
(r'\.(ActivateCell|AddColumn|AddItem|AddListItem|AddObject|'
|
||||
r'AddProperty|AddTableSchema|AddToSCC|Add|'
|
||||
r'ApplyDiffgram|Attach|AutoFit|AutoOpen|Box|Build|'
|
||||
r'CancelReport|ChangesToCursor|CheckIn|CheckOut|Circle|'
|
||||
r'CleanUp|ClearData|ClearStatus|Clear|CloneObject|CloseTables|'
|
||||
r'Close|Cls|CursorAttach|CursorDetach|CursorFill|'
|
||||
r'CursorRefresh|DataToClip|DelayedMemoFetch|DeleteColumn|'
|
||||
r'Dock|DoMessage|DoScroll|DoStatus|DoVerb|Drag|Draw|Eval|'
|
||||
r'GetData|GetDockState|GetFormat|GetKey|GetLatestVersion|'
|
||||
r'GetPageHeight|GetPageWidth|Help|Hide|IncludePageInOutput|'
|
||||
r'IndexToItemID|ItemIDToIndex|Item|LoadXML|Line|Modify|'
|
||||
r'MoveItem|Move|Nest|OLEDrag|OnPreviewClose|OutputPage|'
|
||||
r'Point|Print|PSet|Quit|ReadExpression|ReadMethod|'
|
||||
r'RecordRefresh|Refresh|ReleaseXML|Release|RemoveFromSCC|'
|
||||
r'RemoveItem|RemoveListItem|RemoveObject|Remove|'
|
||||
r'Render|Requery|RequestData|ResetToDefault|Reset|Run|'
|
||||
r'SaveAsClass|SaveAs|SetAll|SetData|SetFocus|SetFormat|'
|
||||
r'SetMain|SetVar|SetViewPort|ShowWhatsThis|Show|'
|
||||
r'SupportsListenerType|TextHeight|TextWidth|ToCursor|'
|
||||
r'ToXML|UndoCheckOut|Unnest|UpdateStatus|WhatsThisMode|'
|
||||
r'WriteExpression|WriteMethod|ZOrder)', Name.Function),
|
||||
|
||||
(r'\.(Activate|AdjustObjectSize|AfterBand|AfterBuild|'
|
||||
r'AfterCloseTables|AfterCursorAttach|AfterCursorClose|'
|
||||
r'AfterCursorDetach|AfterCursorFill|AfterCursorRefresh|'
|
||||
r'AfterCursorUpdate|AfterDelete|AfterInsert|'
|
||||
r'AfterRecordRefresh|AfterUpdate|AfterDock|AfterReport|'
|
||||
r'AfterRowColChange|BeforeBand|BeforeCursorAttach|'
|
||||
r'BeforeCursorClose|BeforeCursorDetach|BeforeCursorFill|'
|
||||
r'BeforeCursorRefresh|BeforeCursorUpdate|BeforeDelete|'
|
||||
r'BeforeInsert|BeforeDock|BeforeOpenTables|'
|
||||
r'BeforeRecordRefresh|BeforeReport|BeforeRowColChange|'
|
||||
r'BeforeUpdate|Click|dbc_Activate|dbc_AfterAddTable|'
|
||||
r'dbc_AfterAppendProc|dbc_AfterCloseTable|dbc_AfterCopyProc|'
|
||||
r'dbc_AfterCreateConnection|dbc_AfterCreateOffline|'
|
||||
r'dbc_AfterCreateTable|dbc_AfterCreateView|dbc_AfterDBGetProp|'
|
||||
r'dbc_AfterDBSetProp|dbc_AfterDeleteConnection|'
|
||||
r'dbc_AfterDropOffline|dbc_AfterDropTable|'
|
||||
r'dbc_AfterModifyConnection|dbc_AfterModifyProc|'
|
||||
r'dbc_AfterModifyTable|dbc_AfterModifyView|dbc_AfterOpenTable|'
|
||||
r'dbc_AfterRemoveTable|dbc_AfterRenameConnection|'
|
||||
r'dbc_AfterRenameTable|dbc_AfterRenameView|'
|
||||
r'dbc_AfterValidateData|dbc_BeforeAddTable|'
|
||||
r'dbc_BeforeAppendProc|dbc_BeforeCloseTable|'
|
||||
r'dbc_BeforeCopyProc|dbc_BeforeCreateConnection|'
|
||||
r'dbc_BeforeCreateOffline|dbc_BeforeCreateTable|'
|
||||
r'dbc_BeforeCreateView|dbc_BeforeDBGetProp|'
|
||||
r'dbc_BeforeDBSetProp|dbc_BeforeDeleteConnection|'
|
||||
r'dbc_BeforeDropOffline|dbc_BeforeDropTable|'
|
||||
r'dbc_BeforeModifyConnection|dbc_BeforeModifyProc|'
|
||||
r'dbc_BeforeModifyTable|dbc_BeforeModifyView|'
|
||||
r'dbc_BeforeOpenTable|dbc_BeforeRemoveTable|'
|
||||
r'dbc_BeforeRenameConnection|dbc_BeforeRenameTable|'
|
||||
r'dbc_BeforeRenameView|dbc_BeforeValidateData|'
|
||||
r'dbc_CloseData|dbc_Deactivate|dbc_ModifyData|dbc_OpenData|'
|
||||
r'dbc_PackData|DblClick|Deactivate|Deleted|Destroy|DoCmd|'
|
||||
r'DownClick|DragDrop|DragOver|DropDown|ErrorMessage|Error|'
|
||||
r'EvaluateContents|GotFocus|Init|InteractiveChange|KeyPress|'
|
||||
r'LoadReport|Load|LostFocus|Message|MiddleClick|MouseDown|'
|
||||
r'MouseEnter|MouseLeave|MouseMove|MouseUp|MouseWheel|Moved|'
|
||||
r'OLECompleteDrag|OLEDragOver|OLEGiveFeedback|OLESetData|'
|
||||
r'OLEStartDrag|OnMoveItem|Paint|ProgrammaticChange|'
|
||||
r'QueryAddFile|QueryModifyFile|QueryNewFile|QueryRemoveFile|'
|
||||
r'QueryRunFile|QueryUnload|RangeHigh|RangeLow|ReadActivate|'
|
||||
r'ReadDeactivate|ReadShow|ReadValid|ReadWhen|Resize|'
|
||||
r'RightClick|SCCInit|SCCDestroy|Scrolled|Timer|UIEnable|'
|
||||
r'UnDock|UnloadReport|Unload|UpClick|Valid|When)', Name.Function),
|
||||
|
||||
(r'\s+', Text),
|
||||
# everything else is not colored
|
||||
(r'.', Text),
|
||||
],
|
||||
'newline': [
|
||||
(r'\*.*?$', Comment.Single, '#pop'),
|
||||
(r'(ACCEPT|ACTIVATE\s*MENU|ACTIVATE\s*POPUP|ACTIVATE\s*SCREEN|'
|
||||
r'ACTIVATE\s*WINDOW|APPEND|APPEND\s*FROM|APPEND\s*FROM\s*ARRAY|'
|
||||
r'APPEND\s*GENERAL|APPEND\s*MEMO|ASSIST|AVERAGE|BLANK|BROWSE|'
|
||||
r'BUILD\s*APP|BUILD\s*EXE|BUILD\s*PROJECT|CALCULATE|CALL|'
|
||||
r'CANCEL|CHANGE|CLEAR|CLOSE|CLOSE\s*MEMO|COMPILE|CONTINUE|'
|
||||
r'COPY\s*FILE|COPY\s*INDEXES|COPY\s*MEMO|COPY\s*STRUCTURE|'
|
||||
r'COPY\s*STRUCTURE\s*EXTENDED|COPY\s*TAG|COPY\s*TO|'
|
||||
r'COPY\s*TO\s*ARRAY|COUNT|CREATE|CREATE\s*COLOR\s*SET|'
|
||||
r'CREATE\s*CURSOR|CREATE\s*FROM|CREATE\s*LABEL|CREATE\s*MENU|'
|
||||
r'CREATE\s*PROJECT|CREATE\s*QUERY|CREATE\s*REPORT|'
|
||||
r'CREATE\s*SCREEN|CREATE\s*TABLE|CREATE\s*VIEW|DDE|'
|
||||
r'DEACTIVATE\s*MENU|DEACTIVATE\s*POPUP|DEACTIVATE\s*WINDOW|'
|
||||
r'DECLARE|DEFINE\s*BAR|DEFINE\s*BOX|DEFINE\s*MENU|'
|
||||
r'DEFINE\s*PAD|DEFINE\s*POPUP|DEFINE\s*WINDOW|DELETE|'
|
||||
r'DELETE\s*FILE|DELETE\s*TAG|DIMENSION|DIRECTORY|DISPLAY|'
|
||||
r'DISPLAY\s*FILES|DISPLAY\s*MEMORY|DISPLAY\s*STATUS|'
|
||||
r'DISPLAY\s*STRUCTURE|DO|EDIT|EJECT|EJECT\s*PAGE|ERASE|'
|
||||
r'EXIT|EXPORT|EXTERNAL|FILER|FIND|FLUSH|FUNCTION|GATHER|'
|
||||
r'GETEXPR|GO|GOTO|HELP|HIDE\s*MENU|HIDE\s*POPUP|'
|
||||
r'HIDE\s*WINDOW|IMPORT|INDEX|INPUT|INSERT|JOIN|KEYBOARD|'
|
||||
r'LABEL|LIST|LOAD|LOCATE|LOOP|MENU|MENU\s*TO|MODIFY\s*COMMAND|'
|
||||
r'MODIFY\s*FILE|MODIFY\s*GENERAL|MODIFY\s*LABEL|MODIFY\s*MEMO|'
|
||||
r'MODIFY\s*MENU|MODIFY\s*PROJECT|MODIFY\s*QUERY|'
|
||||
r'MODIFY\s*REPORT|MODIFY\s*SCREEN|MODIFY\s*STRUCTURE|'
|
||||
r'MODIFY\s*WINDOW|MOVE\s*POPUP|MOVE\s*WINDOW|NOTE|'
|
||||
r'ON\s*APLABOUT|ON\s*BAR|ON\s*ERROR|ON\s*ESCAPE|'
|
||||
r'ON\s*EXIT\s*BAR|ON\s*EXIT\s*MENU|ON\s*EXIT\s*PAD|'
|
||||
r'ON\s*EXIT\s*POPUP|ON\s*KEY|ON\s*KEY\s*=|ON\s*KEY\s*LABEL|'
|
||||
r'ON\s*MACHELP|ON\s*PAD|ON\s*PAGE|ON\s*READERROR|'
|
||||
r'ON\s*SELECTION\s*BAR|ON\s*SELECTION\s*MENU|'
|
||||
r'ON\s*SELECTION\s*PAD|ON\s*SELECTION\s*POPUP|ON\s*SHUTDOWN|'
|
||||
r'PACK|PARAMETERS|PLAY\s*MACRO|POP\s*KEY|POP\s*MENU|'
|
||||
r'POP\s*POPUP|PRIVATE|PROCEDURE|PUBLIC|PUSH\s*KEY|'
|
||||
r'PUSH\s*MENU|PUSH\s*POPUP|QUIT|READ|READ\s*MENU|RECALL|'
|
||||
r'REINDEX|RELEASE|RELEASE\s*MODULE|RENAME|REPLACE|'
|
||||
r'REPLACE\s*FROM\s*ARRAY|REPORT|RESTORE\s*FROM|'
|
||||
r'RESTORE\s*MACROS|RESTORE\s*SCREEN|RESTORE\s*WINDOW|'
|
||||
r'RESUME|RETRY|RETURN|RUN|RUN\s*\/N"|RUNSCRIPT|'
|
||||
r'SAVE\s*MACROS|SAVE\s*SCREEN|SAVE\s*TO|SAVE\s*WINDOWS|'
|
||||
r'SCATTER|SCROLL|SEEK|SELECT|SET|SET\s*ALTERNATE|'
|
||||
r'SET\s*ANSI|SET\s*APLABOUT|SET\s*AUTOSAVE|SET\s*BELL|'
|
||||
r'SET\s*BLINK|SET\s*BLOCKSIZE|SET\s*BORDER|SET\s*BRSTATUS|'
|
||||
r'SET\s*CARRY|SET\s*CENTURY|SET\s*CLEAR|SET\s*CLOCK|'
|
||||
r'SET\s*COLLATE|SET\s*COLOR\s*OF|SET\s*COLOR\s*OF\s*SCHEME|'
|
||||
r'SET\s*COLOR\s*SET|SET\s*COLOR\s*TO|SET\s*COMPATIBLE|'
|
||||
r'SET\s*CONFIRM|SET\s*CONSOLE|SET\s*CURRENCY|SET\s*CURSOR|'
|
||||
r'SET\s*DATE|SET\s*DEBUG|SET\s*DECIMALS|SET\s*DEFAULT|'
|
||||
r'SET\s*DELETED|SET\s*DELIMITERS|SET\s*DEVELOPMENT|'
|
||||
r'SET\s*DEVICE|SET\s*DISPLAY|SET\s*DOHISTORY|SET\s*ECHO|'
|
||||
r'SET\s*ESCAPE|SET\s*EXACT|SET\s*EXCLUSIVE|SET\s*FIELDS|'
|
||||
r'SET\s*FILTER|SET\s*FIXED|SET\s*FORMAT|SET\s*FULLPATH|'
|
||||
r'SET\s*FUNCTION|SET\s*HEADINGS|SET\s*HELP|SET\s*HELPFILTER|'
|
||||
r'SET\s*HOURS|SET\s*INDEX|SET\s*INTENSITY|SET\s*KEY|'
|
||||
r'SET\s*KEYCOMP|SET\s*LIBRARY|SET\s*LOCK|SET\s*LOGERRORS|'
|
||||
r'SET\s*MACDESKTOP|SET\s*MACHELP|SET\s*MACKEY|SET\s*MARGIN|'
|
||||
r'SET\s*MARK\s*OF|SET\s*MARK\s*TO|SET\s*MEMOWIDTH|'
|
||||
r'SET\s*MESSAGE|SET\s*MOUSE|SET\s*MULTILOCKS|SET\s*NEAR|'
|
||||
r'SET\s*NOCPTRANS|SET\s*NOTIFY|SET\s*ODOMETER|SET\s*OPTIMIZE|'
|
||||
r'SET\s*ORDER|SET\s*PALETTE|SET\s*PATH|SET\s*PDSETUP|'
|
||||
r'SET\s*POINT|SET\s*PRINTER|SET\s*PROCEDURE|SET\s*READBORDER|'
|
||||
r'SET\s*REFRESH|SET\s*RELATION|SET\s*RELATION\s*OFF|'
|
||||
r'SET\s*REPROCESS|SET\s*RESOURCE|SET\s*SAFETY|SET\s*SCOREBOARD|'
|
||||
r'SET\s*SEPARATOR|SET\s*SHADOWS|SET\s*SKIP|SET\s*SKIP\s*OF|'
|
||||
r'SET\s*SPACE|SET\s*STATUS|SET\s*STATUS\s*BAR|SET\s*STEP|'
|
||||
r'SET\s*STICKY|SET\s*SYSMENU|SET\s*TALK|SET\s*TEXTMERGE|'
|
||||
r'SET\s*TEXTMERGE\s*DELIMITERS|SET\s*TOPIC|SET\s*TRBETWEEN|'
|
||||
r'SET\s*TYPEAHEAD|SET\s*UDFPARMS|SET\s*UNIQUE|SET\s*VIEW|'
|
||||
r'SET\s*VOLUME|SET\s*WINDOW\s*OF\s*MEMO|SET\s*XCMDFILE|'
|
||||
r'SHOW\s*GET|SHOW\s*GETS|SHOW\s*MENU|SHOW\s*OBJECT|'
|
||||
r'SHOW\s*POPUP|SHOW\s*WINDOW|SIZE\s*POPUP|SKIP|SORT|'
|
||||
r'STORE|SUM|SUSPEND|TOTAL|TYPE|UNLOCK|UPDATE|USE|WAIT|'
|
||||
r'ZAP|ZOOM\s*WINDOW|DO\s*CASE|CASE|OTHERWISE|ENDCASE|'
|
||||
r'DO\s*WHILE|ENDDO|FOR|ENDFOR|NEXT|IF|ELSE|ENDIF|PRINTJOB|'
|
||||
r'ENDPRINTJOB|SCAN|ENDSCAN|TEXT|ENDTEXT|=)',
|
||||
Keyword.Reserved, '#pop'),
|
||||
(r'#\s*(IF|ELIF|ELSE|ENDIF|DEFINE|IFDEF|IFNDEF|INCLUDE)',
|
||||
Comment.Preproc, '#pop'),
|
||||
(r'(m\.)?[a-z_]\w*', Name.Variable, '#pop'),
|
||||
(r'.', Text, '#pop'),
|
||||
],
|
||||
}
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,356 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.hdl
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for hardware descriptor languages.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
from pygments.lexer import RegexLexer, bygroups, include, using, this
|
||||
from pygments.token import \
|
||||
Text, Comment, Operator, Keyword, Name, String, Number, Punctuation, \
|
||||
Error
|
||||
|
||||
__all__ = ['VerilogLexer', 'SystemVerilogLexer', 'VhdlLexer']
|
||||
|
||||
|
||||
class VerilogLexer(RegexLexer):
|
||||
"""
|
||||
For verilog source code with preprocessor directives.
|
||||
|
||||
*New in Pygments 1.4.*
|
||||
"""
|
||||
name = 'verilog'
|
||||
aliases = ['verilog', 'v']
|
||||
filenames = ['*.v']
|
||||
mimetypes = ['text/x-verilog']
|
||||
|
||||
#: optional Comment or Whitespace
|
||||
_ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'^\s*`define', Comment.Preproc, 'macro'),
|
||||
(r'\n', Text),
|
||||
(r'\s+', Text),
|
||||
(r'\\\n', Text), # line continuation
|
||||
(r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
|
||||
(r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
|
||||
(r'[{}#@]', Punctuation),
|
||||
(r'L?"', String, 'string'),
|
||||
(r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
|
||||
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
|
||||
(r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
|
||||
(r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
|
||||
(r'([0-9]+)|(\'b)[0-1]+', Number.Hex), # should be binary
|
||||
(r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
|
||||
(r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
|
||||
(r'\'[01xz]', Number),
|
||||
(r'\d+[Ll]?', Number.Integer),
|
||||
(r'\*/', Error),
|
||||
(r'[~!%^&*+=|?:<>/-]', Operator),
|
||||
(r'[()\[\],.;\']', Punctuation),
|
||||
(r'`[a-zA-Z_][a-zA-Z0-9_]*', Name.Constant),
|
||||
|
||||
(r'^(\s*)(package)(\s+)', bygroups(Text, Keyword.Namespace, Text)),
|
||||
(r'^(\s*)(import)(\s+)', bygroups(Text, Keyword.Namespace, Text),
|
||||
'import'),
|
||||
|
||||
(r'(always|always_comb|always_ff|always_latch|and|assign|automatic|'
|
||||
r'begin|break|buf|bufif0|bufif1|case|casex|casez|cmos|const|'
|
||||
r'continue|deassign|default|defparam|disable|do|edge|else|end|endcase|'
|
||||
r'endfunction|endgenerate|endmodule|endpackage|endprimitive|endspecify|'
|
||||
r'endtable|endtask|enum|event|final|for|force|forever|fork|function|'
|
||||
r'generate|genvar|highz0|highz1|if|initial|inout|input|'
|
||||
r'integer|join|large|localparam|macromodule|medium|module|'
|
||||
r'nand|negedge|nmos|nor|not|notif0|notif1|or|output|packed|'
|
||||
r'parameter|pmos|posedge|primitive|pull0|pull1|pulldown|pullup|rcmos|'
|
||||
r'ref|release|repeat|return|rnmos|rpmos|rtran|rtranif0|'
|
||||
r'rtranif1|scalared|signed|small|specify|specparam|strength|'
|
||||
r'string|strong0|strong1|struct|table|task|'
|
||||
r'tran|tranif0|tranif1|type|typedef|'
|
||||
r'unsigned|var|vectored|void|wait|weak0|weak1|while|'
|
||||
r'xnor|xor)\b', Keyword),
|
||||
|
||||
(r'`(accelerate|autoexpand_vectornets|celldefine|default_nettype|'
|
||||
r'else|elsif|endcelldefine|endif|endprotect|endprotected|'
|
||||
r'expand_vectornets|ifdef|ifndef|include|noaccelerate|noexpand_vectornets|'
|
||||
r'noremove_gatenames|noremove_netnames|nounconnected_drive|'
|
||||
r'protect|protected|remove_gatenames|remove_netnames|resetall|'
|
||||
r'timescale|unconnected_drive|undef)\b', Comment.Preproc),
|
||||
|
||||
(r'\$(bits|bitstoreal|bitstoshortreal|countdrivers|display|fclose|'
|
||||
r'fdisplay|finish|floor|fmonitor|fopen|fstrobe|fwrite|'
|
||||
r'getpattern|history|incsave|input|itor|key|list|log|'
|
||||
r'monitor|monitoroff|monitoron|nokey|nolog|printtimescale|'
|
||||
r'random|readmemb|readmemh|realtime|realtobits|reset|reset_count|'
|
||||
r'reset_value|restart|rtoi|save|scale|scope|shortrealtobits|'
|
||||
r'showscopes|showvariables|showvars|sreadmemb|sreadmemh|'
|
||||
r'stime|stop|strobe|time|timeformat|write)\b', Name.Builtin),
|
||||
|
||||
(r'(byte|shortint|int|longint|integer|time|'
|
||||
r'bit|logic|reg|'
|
||||
r'supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|wor'
|
||||
r'shortreal|real|realtime)\b', Keyword.Type),
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
],
|
||||
'string': [
|
||||
(r'"', String, '#pop'),
|
||||
(r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
|
||||
(r'[^\\"\n]+', String), # all other characters
|
||||
(r'\\\n', String), # line continuation
|
||||
(r'\\', String), # stray backslash
|
||||
],
|
||||
'macro': [
|
||||
(r'[^/\n]+', Comment.Preproc),
|
||||
(r'/[*](.|\n)*?[*]/', Comment.Multiline),
|
||||
(r'//.*?\n', Comment.Single, '#pop'),
|
||||
(r'/', Comment.Preproc),
|
||||
(r'(?<=\\)\n', Comment.Preproc),
|
||||
(r'\n', Comment.Preproc, '#pop'),
|
||||
],
|
||||
'import': [
|
||||
(r'[a-zA-Z0-9_:]+\*?', Name.Namespace, '#pop')
|
||||
]
|
||||
}
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
for index, token, value in \
|
||||
RegexLexer.get_tokens_unprocessed(self, text):
|
||||
# Convention: mark all upper case names as constants
|
||||
if token is Name:
|
||||
if value.isupper():
|
||||
token = Name.Constant
|
||||
yield index, token, value
|
||||
|
||||
|
||||
class SystemVerilogLexer(RegexLexer):
|
||||
"""
|
||||
Extends verilog lexer to recognise all SystemVerilog keywords from IEEE
|
||||
1800-2009 standard.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
name = 'systemverilog'
|
||||
aliases = ['systemverilog', 'sv']
|
||||
filenames = ['*.sv', '*.svh']
|
||||
mimetypes = ['text/x-systemverilog']
|
||||
|
||||
#: optional Comment or Whitespace
|
||||
_ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'^\s*`define', Comment.Preproc, 'macro'),
|
||||
(r'^(\s*)(package)(\s+)', bygroups(Text, Keyword.Namespace, Text)),
|
||||
(r'^(\s*)(import)(\s+)', bygroups(Text, Keyword.Namespace, Text), 'import'),
|
||||
|
||||
(r'\n', Text),
|
||||
(r'\s+', Text),
|
||||
(r'\\\n', Text), # line continuation
|
||||
(r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
|
||||
(r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
|
||||
(r'[{}#@]', Punctuation),
|
||||
(r'L?"', String, 'string'),
|
||||
(r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
|
||||
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
|
||||
(r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
|
||||
(r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
|
||||
(r'([0-9]+)|(\'b)[0-1]+', Number.Hex), # should be binary
|
||||
(r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
|
||||
(r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
|
||||
(r'\'[01xz]', Number),
|
||||
(r'\d+[Ll]?', Number.Integer),
|
||||
(r'\*/', Error),
|
||||
(r'[~!%^&*+=|?:<>/-]', Operator),
|
||||
(r'[()\[\],.;\']', Punctuation),
|
||||
(r'`[a-zA-Z_][a-zA-Z0-9_]*', Name.Constant),
|
||||
|
||||
(r'(accept_on|alias|always|always_comb|always_ff|always_latch|'
|
||||
r'and|assert|assign|assume|automatic|before|begin|bind|bins|'
|
||||
r'binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|'
|
||||
r'cell|chandle|checker|class|clocking|cmos|config|const|constraint|'
|
||||
r'context|continue|cover|covergroup|coverpoint|cross|deassign|'
|
||||
r'default|defparam|design|disable|dist|do|edge|else|end|endcase|'
|
||||
r'endchecker|endclass|endclocking|endconfig|endfunction|endgenerate|'
|
||||
r'endgroup|endinterface|endmodule|endpackage|endprimitive|'
|
||||
r'endprogram|endproperty|endsequence|endspecify|endtable|'
|
||||
r'endtask|enum|event|eventually|expect|export|extends|extern|'
|
||||
r'final|first_match|for|force|foreach|forever|fork|forkjoin|'
|
||||
r'function|generate|genvar|global|highz0|highz1|if|iff|ifnone|'
|
||||
r'ignore_bins|illegal_bins|implies|import|incdir|include|'
|
||||
r'initial|inout|input|inside|instance|int|integer|interface|'
|
||||
r'intersect|join|join_any|join_none|large|let|liblist|library|'
|
||||
r'local|localparam|logic|longint|macromodule|matches|medium|'
|
||||
r'modport|module|nand|negedge|new|nexttime|nmos|nor|noshowcancelled|'
|
||||
r'not|notif0|notif1|null|or|output|package|packed|parameter|'
|
||||
r'pmos|posedge|primitive|priority|program|property|protected|'
|
||||
r'pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|'
|
||||
r'pure|rand|randc|randcase|randsequence|rcmos|real|realtime|'
|
||||
r'ref|reg|reject_on|release|repeat|restrict|return|rnmos|'
|
||||
r'rpmos|rtran|rtranif0|rtranif1|s_always|s_eventually|s_nexttime|'
|
||||
r's_until|s_until_with|scalared|sequence|shortint|shortreal|'
|
||||
r'showcancelled|signed|small|solve|specify|specparam|static|'
|
||||
r'string|strong|strong0|strong1|struct|super|supply0|supply1|'
|
||||
r'sync_accept_on|sync_reject_on|table|tagged|task|this|throughout|'
|
||||
r'time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|'
|
||||
r'tri1|triand|trior|trireg|type|typedef|union|unique|unique0|'
|
||||
r'unsigned|until|until_with|untyped|use|uwire|var|vectored|'
|
||||
r'virtual|void|wait|wait_order|wand|weak|weak0|weak1|while|'
|
||||
r'wildcard|wire|with|within|wor|xnor|xor)\b', Keyword ),
|
||||
|
||||
(r'(`__FILE__|`__LINE__|`begin_keywords|`celldefine|`default_nettype|'
|
||||
r'`define|`else|`elsif|`end_keywords|`endcelldefine|`endif|'
|
||||
r'`ifdef|`ifndef|`include|`line|`nounconnected_drive|`pragma|'
|
||||
r'`resetall|`timescale|`unconnected_drive|`undef|`undefineall)\b',
|
||||
Comment.Preproc ),
|
||||
|
||||
(r'(\$display|\$displayb|\$displayh|\$displayo|\$dumpall|\$dumpfile|'
|
||||
r'\$dumpflush|\$dumplimit|\$dumpoff|\$dumpon|\$dumpports|'
|
||||
r'\$dumpportsall|\$dumpportsflush|\$dumpportslimit|\$dumpportsoff|'
|
||||
r'\$dumpportson|\$dumpvars|\$fclose|\$fdisplay|\$fdisplayb|'
|
||||
r'\$fdisplayh|\$fdisplayo|\$feof|\$ferror|\$fflush|\$fgetc|'
|
||||
r'\$fgets|\$fmonitor|\$fmonitorb|\$fmonitorh|\$fmonitoro|'
|
||||
r'\$fopen|\$fread|\$fscanf|\$fseek|\$fstrobe|\$fstrobeb|\$fstrobeh|'
|
||||
r'\$fstrobeo|\$ftell|\$fwrite|\$fwriteb|\$fwriteh|\$fwriteo|'
|
||||
r'\$monitor|\$monitorb|\$monitorh|\$monitoro|\$monitoroff|'
|
||||
r'\$monitoron|\$plusargs|\$readmemb|\$readmemh|\$rewind|\$sformat|'
|
||||
r'\$sformatf|\$sscanf|\$strobe|\$strobeb|\$strobeh|\$strobeo|'
|
||||
r'\$swrite|\$swriteb|\$swriteh|\$swriteo|\$test|\$ungetc|'
|
||||
r'\$value\$plusargs|\$write|\$writeb|\$writeh|\$writememb|'
|
||||
r'\$writememh|\$writeo)\b' , Name.Builtin ),
|
||||
|
||||
(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
|
||||
(r'(byte|shortint|int|longint|integer|time|'
|
||||
r'bit|logic|reg|'
|
||||
r'supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|wor'
|
||||
r'shortreal|real|realtime)\b', Keyword.Type),
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
|
||||
('[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
],
|
||||
'classname': [
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop'),
|
||||
],
|
||||
'string': [
|
||||
(r'"', String, '#pop'),
|
||||
(r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
|
||||
(r'[^\\"\n]+', String), # all other characters
|
||||
(r'\\\n', String), # line continuation
|
||||
(r'\\', String), # stray backslash
|
||||
],
|
||||
'macro': [
|
||||
(r'[^/\n]+', Comment.Preproc),
|
||||
(r'/[*](.|\n)*?[*]/', Comment.Multiline),
|
||||
(r'//.*?\n', Comment.Single, '#pop'),
|
||||
(r'/', Comment.Preproc),
|
||||
(r'(?<=\\)\n', Comment.Preproc),
|
||||
(r'\n', Comment.Preproc, '#pop'),
|
||||
],
|
||||
'import': [
|
||||
(r'[a-zA-Z0-9_:]+\*?', Name.Namespace, '#pop')
|
||||
]
|
||||
}
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
for index, token, value in \
|
||||
RegexLexer.get_tokens_unprocessed(self, text):
|
||||
# Convention: mark all upper case names as constants
|
||||
if token is Name:
|
||||
if value.isupper():
|
||||
token = Name.Constant
|
||||
yield index, token, value
|
||||
|
||||
def analyse_text(text):
|
||||
if text.startswith('//') or text.startswith('/*'):
|
||||
return 0.5
|
||||
|
||||
|
||||
class VhdlLexer(RegexLexer):
|
||||
"""
|
||||
For VHDL source code.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
name = 'vhdl'
|
||||
aliases = ['vhdl']
|
||||
filenames = ['*.vhdl', '*.vhd']
|
||||
mimetypes = ['text/x-vhdl']
|
||||
flags = re.MULTILINE | re.IGNORECASE
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\n', Text),
|
||||
(r'\s+', Text),
|
||||
(r'\\\n', Text), # line continuation
|
||||
(r'--(?![!#$%&*+./<=>?@\^|_~]).*?$', Comment.Single),
|
||||
(r"'(U|X|0|1|Z|W|L|H|-)'", String.Char),
|
||||
(r'[~!%^&*+=|?:<>/-]', Operator),
|
||||
(r"'[a-zA-Z_][a-zA-Z0-9_]*", Name.Attribute),
|
||||
(r'[()\[\],.;\']', Punctuation),
|
||||
(r'"[^\n\\]*"', String),
|
||||
|
||||
(r'(library)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)',
|
||||
bygroups(Keyword, Text, Name.Namespace)),
|
||||
(r'(use)(\s+)(entity)', bygroups(Keyword, Text, Keyword)),
|
||||
(r'(use)(\s+)([a-zA-Z_][\.a-zA-Z0-9_]*)',
|
||||
bygroups(Keyword, Text, Name.Namespace)),
|
||||
(r'(entity|component)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)',
|
||||
bygroups(Keyword, Text, Name.Class)),
|
||||
(r'(architecture|configuration)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s+)'
|
||||
r'(of)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s+)(is)',
|
||||
bygroups(Keyword, Text, Name.Class, Text, Keyword, Text,
|
||||
Name.Class, Text, Keyword)),
|
||||
|
||||
(r'(end)(\s+)', bygroups(using(this), Text), 'endblock'),
|
||||
|
||||
include('types'),
|
||||
include('keywords'),
|
||||
include('numbers'),
|
||||
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
],
|
||||
'endblock': [
|
||||
include('keywords'),
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class),
|
||||
(r'(\s+)', Text),
|
||||
(r';', Punctuation, '#pop'),
|
||||
],
|
||||
'types': [
|
||||
(r'(boolean|bit|character|severity_level|integer|time|delay_length|'
|
||||
r'natural|positive|string|bit_vector|file_open_kind|'
|
||||
r'file_open_status|std_ulogic|std_ulogic_vector|std_logic|'
|
||||
r'std_logic_vector)\b', Keyword.Type),
|
||||
],
|
||||
'keywords': [
|
||||
(r'(abs|access|after|alias|all|and|'
|
||||
r'architecture|array|assert|attribute|begin|block|'
|
||||
r'body|buffer|bus|case|component|configuration|'
|
||||
r'constant|disconnect|downto|else|elsif|end|'
|
||||
r'entity|exit|file|for|function|generate|'
|
||||
r'generic|group|guarded|if|impure|in|'
|
||||
r'inertial|inout|is|label|library|linkage|'
|
||||
r'literal|loop|map|mod|nand|new|'
|
||||
r'next|nor|not|null|of|on|'
|
||||
r'open|or|others|out|package|port|'
|
||||
r'postponed|procedure|process|pure|range|record|'
|
||||
r'register|reject|return|rol|ror|select|'
|
||||
r'severity|signal|shared|sla|sli|sra|'
|
||||
r'srl|subtype|then|to|transport|type|'
|
||||
r'units|until|use|variable|wait|when|'
|
||||
r'while|with|xnor|xor)\b', Keyword),
|
||||
],
|
||||
'numbers': [
|
||||
(r'\d{1,2}#[0-9a-fA-F_]+#?', Number.Integer),
|
||||
(r'[0-1_]+(\.[0-1_])', Number.Integer),
|
||||
(r'\d+', Number.Integer),
|
||||
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
|
||||
(r'H"[0-9a-fA-F_]+"', Number.Oct),
|
||||
(r'O"[0-7_]+"', Number.Oct),
|
||||
(r'B"[0-1_]+"', Number.Oct),
|
||||
],
|
||||
}
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,778 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.parsers
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for parser generators.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import RegexLexer, DelegatingLexer, \
|
||||
include, bygroups, using
|
||||
from pygments.token import Punctuation, Other, Text, Comment, Operator, \
|
||||
Keyword, Name, String, Number, Whitespace
|
||||
from pygments.lexers.compiled import JavaLexer, CLexer, CppLexer, \
|
||||
ObjectiveCLexer, DLexer
|
||||
from pygments.lexers.dotnet import CSharpLexer
|
||||
from pygments.lexers.agile import RubyLexer, PythonLexer, PerlLexer
|
||||
from pygments.lexers.web import ActionScriptLexer
|
||||
|
||||
|
||||
__all__ = ['RagelLexer', 'RagelEmbeddedLexer', 'RagelCLexer', 'RagelDLexer',
|
||||
'RagelCppLexer', 'RagelObjectiveCLexer', 'RagelRubyLexer',
|
||||
'RagelJavaLexer', 'AntlrLexer', 'AntlrPythonLexer',
|
||||
'AntlrPerlLexer', 'AntlrRubyLexer', 'AntlrCppLexer',
|
||||
#'AntlrCLexer',
|
||||
'AntlrCSharpLexer', 'AntlrObjectiveCLexer',
|
||||
'AntlrJavaLexer', "AntlrActionScriptLexer",
|
||||
'TreetopLexer']
|
||||
|
||||
|
||||
class RagelLexer(RegexLexer):
|
||||
"""
|
||||
A pure `Ragel <http://www.complang.org/ragel/>`_ lexer. Use this for
|
||||
fragments of Ragel. For ``.rl`` files, use RagelEmbeddedLexer instead
|
||||
(or one of the language-specific subclasses).
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel'
|
||||
aliases = ['ragel']
|
||||
filenames = []
|
||||
|
||||
tokens = {
|
||||
'whitespace': [
|
||||
(r'\s+', Whitespace)
|
||||
],
|
||||
'comments': [
|
||||
(r'\#.*$', Comment),
|
||||
],
|
||||
'keywords': [
|
||||
(r'(access|action|alphtype)\b', Keyword),
|
||||
(r'(getkey|write|machine|include)\b', Keyword),
|
||||
(r'(any|ascii|extend|alpha|digit|alnum|lower|upper)\b', Keyword),
|
||||
(r'(xdigit|cntrl|graph|print|punct|space|zlen|empty)\b', Keyword)
|
||||
],
|
||||
'numbers': [
|
||||
(r'0x[0-9A-Fa-f]+', Number.Hex),
|
||||
(r'[+-]?[0-9]+', Number.Integer),
|
||||
],
|
||||
'literals': [
|
||||
(r'"(\\\\|\\"|[^"])*"', String), # double quote string
|
||||
(r"'(\\\\|\\'|[^'])*'", String), # single quote string
|
||||
(r'\[(\\\\|\\\]|[^\]])*\]', String), # square bracket literals
|
||||
(r'/(?!\*)(\\\\|\\/|[^/])*/', String.Regex), # regular expressions
|
||||
],
|
||||
'identifiers': [
|
||||
(r'[a-zA-Z_][a-zA-Z_0-9]*', Name.Variable),
|
||||
],
|
||||
'operators': [
|
||||
(r',', Operator), # Join
|
||||
(r'\||&|--?', Operator), # Union, Intersection and Subtraction
|
||||
(r'\.|<:|:>>?', Operator), # Concatention
|
||||
(r':', Operator), # Label
|
||||
(r'->', Operator), # Epsilon Transition
|
||||
(r'(>|\$|%|<|@|<>)(/|eof\b)', Operator), # EOF Actions
|
||||
(r'(>|\$|%|<|@|<>)(!|err\b)', Operator), # Global Error Actions
|
||||
(r'(>|\$|%|<|@|<>)(\^|lerr\b)', Operator), # Local Error Actions
|
||||
(r'(>|\$|%|<|@|<>)(~|to\b)', Operator), # To-State Actions
|
||||
(r'(>|\$|%|<|@|<>)(\*|from\b)', Operator), # From-State Actions
|
||||
(r'>|@|\$|%', Operator), # Transition Actions and Priorities
|
||||
(r'\*|\?|\+|{[0-9]*,[0-9]*}', Operator), # Repetition
|
||||
(r'!|\^', Operator), # Negation
|
||||
(r'\(|\)', Operator), # Grouping
|
||||
],
|
||||
'root': [
|
||||
include('literals'),
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
include('keywords'),
|
||||
include('numbers'),
|
||||
include('identifiers'),
|
||||
include('operators'),
|
||||
(r'{', Punctuation, 'host'),
|
||||
(r'=', Operator),
|
||||
(r';', Punctuation),
|
||||
],
|
||||
'host': [
|
||||
(r'(' + r'|'.join(( # keep host code in largest possible chunks
|
||||
r'[^{}\'"/#]+', # exclude unsafe characters
|
||||
r'[^\\][\\][{}]', # allow escaped { or }
|
||||
|
||||
# strings and comments may safely contain unsafe characters
|
||||
r'"(\\\\|\\"|[^"])*"', # double quote string
|
||||
r"'(\\\\|\\'|[^'])*'", # single quote string
|
||||
r'//.*$\n?', # single line comment
|
||||
r'/\*(.|\n)*?\*/', # multi-line javadoc-style comment
|
||||
r'\#.*$\n?', # ruby comment
|
||||
|
||||
# regular expression: There's no reason for it to start
|
||||
# with a * and this stops confusion with comments.
|
||||
r'/(?!\*)(\\\\|\\/|[^/])*/',
|
||||
|
||||
# / is safe now that we've handled regex and javadoc comments
|
||||
r'/',
|
||||
)) + r')+', Other),
|
||||
|
||||
(r'{', Punctuation, '#push'),
|
||||
(r'}', Punctuation, '#pop'),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class RagelEmbeddedLexer(RegexLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ embedded in a host language file.
|
||||
|
||||
This will only highlight Ragel statements. If you want host language
|
||||
highlighting then call the language-specific Ragel lexer.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Embedded Ragel'
|
||||
aliases = ['ragel-em']
|
||||
filenames = ['*.rl']
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'(' + r'|'.join(( # keep host code in largest possible chunks
|
||||
r'[^%\'"/#]+', # exclude unsafe characters
|
||||
r'%(?=[^%]|$)', # a single % sign is okay, just not 2 of them
|
||||
|
||||
# strings and comments may safely contain unsafe characters
|
||||
r'"(\\\\|\\"|[^"])*"', # double quote string
|
||||
r"'(\\\\|\\'|[^'])*'", # single quote string
|
||||
r'/\*(.|\n)*?\*/', # multi-line javadoc-style comment
|
||||
r'//.*$\n?', # single line comment
|
||||
r'\#.*$\n?', # ruby/ragel comment
|
||||
r'/(?!\*)(\\\\|\\/|[^/])*/', # regular expression
|
||||
|
||||
# / is safe now that we've handled regex and javadoc comments
|
||||
r'/',
|
||||
)) + r')+', Other),
|
||||
|
||||
# Single Line FSM.
|
||||
# Please don't put a quoted newline in a single line FSM.
|
||||
# That's just mean. It will break this.
|
||||
(r'(%%)(?![{%])(.*)($|;)(\n?)', bygroups(Punctuation,
|
||||
using(RagelLexer),
|
||||
Punctuation, Text)),
|
||||
|
||||
# Multi Line FSM.
|
||||
(r'(%%%%|%%){', Punctuation, 'multi-line-fsm'),
|
||||
],
|
||||
'multi-line-fsm': [
|
||||
(r'(' + r'|'.join(( # keep ragel code in largest possible chunks.
|
||||
r'(' + r'|'.join((
|
||||
r'[^}\'"\[/#]', # exclude unsafe characters
|
||||
r'}(?=[^%]|$)', # } is okay as long as it's not followed by %
|
||||
r'}%(?=[^%]|$)', # ...well, one %'s okay, just not two...
|
||||
r'[^\\][\\][{}]', # ...and } is okay if it's escaped
|
||||
|
||||
# allow / if it's preceded with one of these symbols
|
||||
# (ragel EOF actions)
|
||||
r'(>|\$|%|<|@|<>)/',
|
||||
|
||||
# specifically allow regex followed immediately by *
|
||||
# so it doesn't get mistaken for a comment
|
||||
r'/(?!\*)(\\\\|\\/|[^/])*/\*',
|
||||
|
||||
# allow / as long as it's not followed by another / or by a *
|
||||
r'/(?=[^/\*]|$)',
|
||||
|
||||
# We want to match as many of these as we can in one block.
|
||||
# Not sure if we need the + sign here,
|
||||
# does it help performance?
|
||||
)) + r')+',
|
||||
|
||||
# strings and comments may safely contain unsafe characters
|
||||
r'"(\\\\|\\"|[^"])*"', # double quote string
|
||||
r"'(\\\\|\\'|[^'])*'", # single quote string
|
||||
r"\[(\\\\|\\\]|[^\]])*\]", # square bracket literal
|
||||
r'/\*(.|\n)*?\*/', # multi-line javadoc-style comment
|
||||
r'//.*$\n?', # single line comment
|
||||
r'\#.*$\n?', # ruby/ragel comment
|
||||
)) + r')+', using(RagelLexer)),
|
||||
|
||||
(r'}%%', Punctuation, '#pop'),
|
||||
]
|
||||
}
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: indep' in text or 0.1
|
||||
|
||||
|
||||
class RagelRubyLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in a Ruby host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in Ruby Host'
|
||||
aliases = ['ragel-ruby', 'ragel-rb']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelRubyLexer, self).__init__(RubyLexer, RagelEmbeddedLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: ruby' in text
|
||||
|
||||
|
||||
class RagelCLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in a C host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in C Host'
|
||||
aliases = ['ragel-c']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelCLexer, self).__init__(CLexer, RagelEmbeddedLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: c' in text
|
||||
|
||||
|
||||
class RagelDLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in a D host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in D Host'
|
||||
aliases = ['ragel-d']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelDLexer, self).__init__(DLexer, RagelEmbeddedLexer, **options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: d' in text
|
||||
|
||||
|
||||
class RagelCppLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in a CPP host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in CPP Host'
|
||||
aliases = ['ragel-cpp']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelCppLexer, self).__init__(CppLexer, RagelEmbeddedLexer, **options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: c++' in text
|
||||
|
||||
|
||||
class RagelObjectiveCLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in an Objective C host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in Objective C Host'
|
||||
aliases = ['ragel-objc']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelObjectiveCLexer, self).__init__(ObjectiveCLexer,
|
||||
RagelEmbeddedLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: objc' in text
|
||||
|
||||
|
||||
class RagelJavaLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Ragel`_ in a Java host file.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Ragel in Java Host'
|
||||
aliases = ['ragel-java']
|
||||
filenames = ['*.rl']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(RagelJavaLexer, self).__init__(JavaLexer, RagelEmbeddedLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return '@LANG: java' in text
|
||||
|
||||
|
||||
class AntlrLexer(RegexLexer):
|
||||
"""
|
||||
Generic `ANTLR`_ Lexer.
|
||||
Should not be called directly, instead
|
||||
use DelegatingLexer for your target language.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
|
||||
.. _ANTLR: http://www.antlr.org/
|
||||
"""
|
||||
|
||||
name = 'ANTLR'
|
||||
aliases = ['antlr']
|
||||
filenames = []
|
||||
|
||||
_id = r'[A-Za-z][A-Za-z_0-9]*'
|
||||
_TOKEN_REF = r'[A-Z][A-Za-z_0-9]*'
|
||||
_RULE_REF = r'[a-z][A-Za-z_0-9]*'
|
||||
_STRING_LITERAL = r'\'(?:\\\\|\\\'|[^\']*)\''
|
||||
_INT = r'[0-9]+'
|
||||
|
||||
tokens = {
|
||||
'whitespace': [
|
||||
(r'\s+', Whitespace),
|
||||
],
|
||||
'comments': [
|
||||
(r'//.*$', Comment),
|
||||
(r'/\*(.|\n)*?\*/', Comment),
|
||||
],
|
||||
'root': [
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
|
||||
(r'(lexer|parser|tree)?(\s*)(grammar\b)(\s*)(' + _id + ')(;)',
|
||||
bygroups(Keyword, Whitespace, Keyword, Whitespace, Name.Class,
|
||||
Punctuation)),
|
||||
# optionsSpec
|
||||
(r'options\b', Keyword, 'options'),
|
||||
# tokensSpec
|
||||
(r'tokens\b', Keyword, 'tokens'),
|
||||
# attrScope
|
||||
(r'(scope)(\s*)(' + _id + ')(\s*)({)',
|
||||
bygroups(Keyword, Whitespace, Name.Variable, Whitespace,
|
||||
Punctuation), 'action'),
|
||||
# exception
|
||||
(r'(catch|finally)\b', Keyword, 'exception'),
|
||||
# action
|
||||
(r'(@' + _id + ')(\s*)(::)?(\s*)(' + _id + ')(\s*)({)',
|
||||
bygroups(Name.Label, Whitespace, Punctuation, Whitespace,
|
||||
Name.Label, Whitespace, Punctuation), 'action'),
|
||||
# rule
|
||||
(r'((?:protected|private|public|fragment)\b)?(\s*)(' + _id + ')(!)?', \
|
||||
bygroups(Keyword, Whitespace, Name.Label, Punctuation),
|
||||
('rule-alts', 'rule-prelims')),
|
||||
],
|
||||
'exception': [
|
||||
(r'\n', Whitespace, '#pop'),
|
||||
(r'\s', Whitespace),
|
||||
include('comments'),
|
||||
|
||||
(r'\[', Punctuation, 'nested-arg-action'),
|
||||
(r'\{', Punctuation, 'action'),
|
||||
],
|
||||
'rule-prelims': [
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
|
||||
(r'returns\b', Keyword),
|
||||
(r'\[', Punctuation, 'nested-arg-action'),
|
||||
(r'\{', Punctuation, 'action'),
|
||||
# throwsSpec
|
||||
(r'(throws)(\s+)(' + _id + ')',
|
||||
bygroups(Keyword, Whitespace, Name.Label)),
|
||||
(r'(,)(\s*)(' + _id + ')',
|
||||
bygroups(Punctuation, Whitespace, Name.Label)), # Additional throws
|
||||
# optionsSpec
|
||||
(r'options\b', Keyword, 'options'),
|
||||
# ruleScopeSpec - scope followed by target language code or name of action
|
||||
# TODO finish implementing other possibilities for scope
|
||||
# L173 ANTLRv3.g from ANTLR book
|
||||
(r'(scope)(\s+)({)', bygroups(Keyword, Whitespace, Punctuation),
|
||||
'action'),
|
||||
(r'(scope)(\s+)(' + _id + ')(\s*)(;)',
|
||||
bygroups(Keyword, Whitespace, Name.Label, Whitespace, Punctuation)),
|
||||
# ruleAction
|
||||
(r'(@' + _id + ')(\s*)({)',
|
||||
bygroups(Name.Label, Whitespace, Punctuation), 'action'),
|
||||
# finished prelims, go to rule alts!
|
||||
(r':', Punctuation, '#pop')
|
||||
],
|
||||
'rule-alts': [
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
|
||||
# These might need to go in a separate 'block' state triggered by (
|
||||
(r'options\b', Keyword, 'options'),
|
||||
(r':', Punctuation),
|
||||
|
||||
# literals
|
||||
(r"'(\\\\|\\'|[^'])*'", String),
|
||||
(r'"(\\\\|\\"|[^"])*"', String),
|
||||
(r'<<([^>]|>[^>])>>', String),
|
||||
# identifiers
|
||||
# Tokens start with capital letter.
|
||||
(r'\$?[A-Z_][A-Za-z_0-9]*', Name.Constant),
|
||||
# Rules start with small letter.
|
||||
(r'\$?[a-z_][A-Za-z_0-9]*', Name.Variable),
|
||||
# operators
|
||||
(r'(\+|\||->|=>|=|\(|\)|\.\.|\.|\?|\*|\^|!|\#|~)', Operator),
|
||||
(r',', Punctuation),
|
||||
(r'\[', Punctuation, 'nested-arg-action'),
|
||||
(r'\{', Punctuation, 'action'),
|
||||
(r';', Punctuation, '#pop')
|
||||
],
|
||||
'tokens': [
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
(r'{', Punctuation),
|
||||
(r'(' + _TOKEN_REF + r')(\s*)(=)?(\s*)(' + _STRING_LITERAL
|
||||
+ ')?(\s*)(;)',
|
||||
bygroups(Name.Label, Whitespace, Punctuation, Whitespace,
|
||||
String, Whitespace, Punctuation)),
|
||||
(r'}', Punctuation, '#pop'),
|
||||
],
|
||||
'options': [
|
||||
include('whitespace'),
|
||||
include('comments'),
|
||||
(r'{', Punctuation),
|
||||
(r'(' + _id + r')(\s*)(=)(\s*)(' +
|
||||
'|'.join((_id, _STRING_LITERAL, _INT, '\*'))+ ')(\s*)(;)',
|
||||
bygroups(Name.Variable, Whitespace, Punctuation, Whitespace,
|
||||
Text, Whitespace, Punctuation)),
|
||||
(r'}', Punctuation, '#pop'),
|
||||
],
|
||||
'action': [
|
||||
(r'(' + r'|'.join(( # keep host code in largest possible chunks
|
||||
r'[^\${}\'"/\\]+', # exclude unsafe characters
|
||||
|
||||
# strings and comments may safely contain unsafe characters
|
||||
r'"(\\\\|\\"|[^"])*"', # double quote string
|
||||
r"'(\\\\|\\'|[^'])*'", # single quote string
|
||||
r'//.*$\n?', # single line comment
|
||||
r'/\*(.|\n)*?\*/', # multi-line javadoc-style comment
|
||||
|
||||
# regular expression: There's no reason for it to start
|
||||
# with a * and this stops confusion with comments.
|
||||
r'/(?!\*)(\\\\|\\/|[^/])*/',
|
||||
|
||||
# backslashes are okay, as long as we are not backslashing a %
|
||||
r'\\(?!%)',
|
||||
|
||||
# Now that we've handled regex and javadoc comments
|
||||
# it's safe to let / through.
|
||||
r'/',
|
||||
)) + r')+', Other),
|
||||
(r'(\\)(%)', bygroups(Punctuation, Other)),
|
||||
(r'(\$[a-zA-Z]+)(\.?)(text|value)?',
|
||||
bygroups(Name.Variable, Punctuation, Name.Property)),
|
||||
(r'{', Punctuation, '#push'),
|
||||
(r'}', Punctuation, '#pop'),
|
||||
],
|
||||
'nested-arg-action': [
|
||||
(r'(' + r'|'.join(( # keep host code in largest possible chunks.
|
||||
r'[^\$\[\]\'"/]+', # exclude unsafe characters
|
||||
|
||||
# strings and comments may safely contain unsafe characters
|
||||
r'"(\\\\|\\"|[^"])*"', # double quote string
|
||||
r"'(\\\\|\\'|[^'])*'", # single quote string
|
||||
r'//.*$\n?', # single line comment
|
||||
r'/\*(.|\n)*?\*/', # multi-line javadoc-style comment
|
||||
|
||||
# regular expression: There's no reason for it to start
|
||||
# with a * and this stops confusion with comments.
|
||||
r'/(?!\*)(\\\\|\\/|[^/])*/',
|
||||
|
||||
# Now that we've handled regex and javadoc comments
|
||||
# it's safe to let / through.
|
||||
r'/',
|
||||
)) + r')+', Other),
|
||||
|
||||
|
||||
(r'\[', Punctuation, '#push'),
|
||||
(r'\]', Punctuation, '#pop'),
|
||||
(r'(\$[a-zA-Z]+)(\.?)(text|value)?',
|
||||
bygroups(Name.Variable, Punctuation, Name.Property)),
|
||||
(r'(\\\\|\\\]|\\\[|[^\[\]])+', Other),
|
||||
]
|
||||
}
|
||||
|
||||
def analyse_text(text):
|
||||
return re.search(r'^\s*grammar\s+[a-zA-Z0-9]+\s*;', text, re.M)
|
||||
|
||||
# http://www.antlr.org/wiki/display/ANTLR3/Code+Generation+Targets
|
||||
|
||||
# TH: I'm not aware of any language features of C++ that will cause
|
||||
# incorrect lexing of C files. Antlr doesn't appear to make a distinction,
|
||||
# so just assume they're C++. No idea how to make Objective C work in the
|
||||
# future.
|
||||
|
||||
#class AntlrCLexer(DelegatingLexer):
|
||||
# """
|
||||
# ANTLR with C Target
|
||||
#
|
||||
# *New in Pygments 1.1*
|
||||
# """
|
||||
#
|
||||
# name = 'ANTLR With C Target'
|
||||
# aliases = ['antlr-c']
|
||||
# filenames = ['*.G', '*.g']
|
||||
#
|
||||
# def __init__(self, **options):
|
||||
# super(AntlrCLexer, self).__init__(CLexer, AntlrLexer, **options)
|
||||
#
|
||||
# def analyse_text(text):
|
||||
# return re.match(r'^\s*language\s*=\s*C\s*;', text)
|
||||
|
||||
class AntlrCppLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with CPP Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With CPP Target'
|
||||
aliases = ['antlr-cpp']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrCppLexer, self).__init__(CppLexer, AntlrLexer, **options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*C\s*;', text, re.M)
|
||||
|
||||
|
||||
class AntlrObjectiveCLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with Objective-C Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With ObjectiveC Target'
|
||||
aliases = ['antlr-objc']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrObjectiveCLexer, self).__init__(ObjectiveCLexer,
|
||||
AntlrLexer, **options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*ObjC\s*;', text)
|
||||
|
||||
|
||||
class AntlrCSharpLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with C# Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With C# Target'
|
||||
aliases = ['antlr-csharp', 'antlr-c#']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrCSharpLexer, self).__init__(CSharpLexer, AntlrLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*CSharp2\s*;', text, re.M)
|
||||
|
||||
|
||||
class AntlrPythonLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with Python Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With Python Target'
|
||||
aliases = ['antlr-python']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrPythonLexer, self).__init__(PythonLexer, AntlrLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*Python\s*;', text, re.M)
|
||||
|
||||
|
||||
class AntlrJavaLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with Java Target
|
||||
|
||||
*New in Pygments 1.1*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With Java Target'
|
||||
aliases = ['antlr-java']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrJavaLexer, self).__init__(JavaLexer, AntlrLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
# Antlr language is Java by default
|
||||
return AntlrLexer.analyse_text(text) and 0.9
|
||||
|
||||
|
||||
class AntlrRubyLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with Ruby Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With Ruby Target'
|
||||
aliases = ['antlr-ruby', 'antlr-rb']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrRubyLexer, self).__init__(RubyLexer, AntlrLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*Ruby\s*;', text, re.M)
|
||||
|
||||
|
||||
class AntlrPerlLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with Perl Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With Perl Target'
|
||||
aliases = ['antlr-perl']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrPerlLexer, self).__init__(PerlLexer, AntlrLexer,
|
||||
**options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*Perl5\s*;', text, re.M)
|
||||
|
||||
|
||||
class AntlrActionScriptLexer(DelegatingLexer):
|
||||
"""
|
||||
`ANTLR`_ with ActionScript Target
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'ANTLR With ActionScript Target'
|
||||
aliases = ['antlr-as', 'antlr-actionscript']
|
||||
filenames = ['*.G', '*.g']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(AntlrActionScriptLexer, self).__init__(ActionScriptLexer,
|
||||
AntlrLexer, **options)
|
||||
|
||||
def analyse_text(text):
|
||||
return AntlrLexer.analyse_text(text) and \
|
||||
re.search(r'^\s*language\s*=\s*ActionScript\s*;', text, re.M)
|
||||
|
||||
class TreetopBaseLexer(RegexLexer):
|
||||
"""
|
||||
A base lexer for `Treetop <http://treetop.rubyforge.org/>`_ grammars.
|
||||
Not for direct use; use TreetopLexer instead.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('space'),
|
||||
(r'require[ \t]+[^\n\r]+[\n\r]', Other),
|
||||
(r'module\b', Keyword.Namespace, 'module'),
|
||||
(r'grammar\b', Keyword, 'grammar'),
|
||||
],
|
||||
'module': [
|
||||
include('space'),
|
||||
include('end'),
|
||||
(r'module\b', Keyword, '#push'),
|
||||
(r'grammar\b', Keyword, 'grammar'),
|
||||
(r'[A-Z][A-Za-z_0-9]*(?:::[A-Z][A-Za-z_0-9]*)*', Name.Namespace),
|
||||
],
|
||||
'grammar': [
|
||||
include('space'),
|
||||
include('end'),
|
||||
(r'rule\b', Keyword, 'rule'),
|
||||
(r'include\b', Keyword, 'include'),
|
||||
(r'[A-Z][A-Za-z_0-9]*', Name),
|
||||
],
|
||||
'include': [
|
||||
include('space'),
|
||||
(r'[A-Z][A-Za-z_0-9]*(?:::[A-Z][A-Za-z_0-9]*)*', Name.Class, '#pop'),
|
||||
],
|
||||
'rule': [
|
||||
include('space'),
|
||||
include('end'),
|
||||
(r'"(\\\\|\\"|[^"])*"', String.Double),
|
||||
(r"'(\\\\|\\'|[^'])*'", String.Single),
|
||||
(r'([A-Za-z_][A-Za-z_0-9]*)(:)', bygroups(Name.Label, Punctuation)),
|
||||
(r'[A-Za-z_][A-Za-z_0-9]*', Name),
|
||||
(r'[()]', Punctuation),
|
||||
(r'[?+*/&!~]', Operator),
|
||||
(r'\[(?:\\.|\[:\^?[a-z]+:\]|[^\\\]])+\]', String.Regex),
|
||||
(r'([0-9]*)(\.\.)([0-9]*)',
|
||||
bygroups(Number.Integer, Operator, Number.Integer)),
|
||||
(r'(<)([^>]+)(>)', bygroups(Punctuation, Name.Class, Punctuation)),
|
||||
(r'{', Punctuation, 'inline_module'),
|
||||
(r'\.', String.Regex),
|
||||
],
|
||||
'inline_module': [
|
||||
(r'{', Other, 'ruby'),
|
||||
(r'}', Punctuation, '#pop'),
|
||||
(r'[^{}]+', Other),
|
||||
],
|
||||
'ruby': [
|
||||
(r'{', Other, '#push'),
|
||||
(r'}', Other, '#pop'),
|
||||
(r'[^{}]+', Other),
|
||||
],
|
||||
'space': [
|
||||
(r'[ \t\n\r]+', Whitespace),
|
||||
(r'#[^\n]*', Comment.Single),
|
||||
],
|
||||
'end': [
|
||||
(r'end\b', Keyword, '#pop'),
|
||||
],
|
||||
}
|
||||
|
||||
class TreetopLexer(DelegatingLexer):
|
||||
"""
|
||||
A lexer for `Treetop <http://treetop.rubyforge.org/>`_ grammars.
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
|
||||
name = 'Treetop'
|
||||
aliases = ['treetop']
|
||||
filenames = ['*.treetop', '*.tt']
|
||||
|
||||
def __init__(self, **options):
|
||||
super(TreetopLexer, self).__init__(RubyLexer, TreetopBaseLexer, **options)
|
|
@ -0,0 +1,424 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.shell
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for various shells.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups, include
|
||||
from pygments.token import Punctuation, \
|
||||
Text, Comment, Operator, Keyword, Name, String, Number, Generic
|
||||
from pygments.util import shebang_matches
|
||||
|
||||
|
||||
__all__ = ['BashLexer', 'BashSessionLexer', 'TcshLexer', 'BatchLexer',
|
||||
'PowerShellLexer', 'ShellSessionLexer']
|
||||
|
||||
line_re = re.compile('.*?\n')
|
||||
|
||||
|
||||
class BashLexer(RegexLexer):
|
||||
"""
|
||||
Lexer for (ba|k|)sh shell scripts.
|
||||
|
||||
*New in Pygments 0.6.*
|
||||
"""
|
||||
|
||||
name = 'Bash'
|
||||
aliases = ['bash', 'sh', 'ksh']
|
||||
filenames = ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass',
|
||||
'.bashrc', 'bashrc', '.bash_*', 'bash_*']
|
||||
mimetypes = ['application/x-sh', 'application/x-shellscript']
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('basic'),
|
||||
(r'\$\(\(', Keyword, 'math'),
|
||||
(r'\$\(', Keyword, 'paren'),
|
||||
(r'\${#?', Keyword, 'curly'),
|
||||
(r'`', String.Backtick, 'backticks'),
|
||||
include('data'),
|
||||
],
|
||||
'basic': [
|
||||
(r'\b(if|fi|else|while|do|done|for|then|return|function|case|'
|
||||
r'select|continue|until|esac|elif)\s*\b',
|
||||
Keyword),
|
||||
(r'\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|'
|
||||
r'complete|declare|dirs|disown|echo|enable|eval|exec|exit|'
|
||||
r'export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|'
|
||||
r'local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|'
|
||||
r'shopt|source|suspend|test|time|times|trap|true|type|typeset|'
|
||||
r'ulimit|umask|unalias|unset|wait)\s*\b(?!\.)',
|
||||
Name.Builtin),
|
||||
(r'#.*\n', Comment),
|
||||
(r'\\[\w\W]', String.Escape),
|
||||
(r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
|
||||
(r'[\[\]{}()=]', Operator),
|
||||
(r'<<<', Operator), # here-string
|
||||
(r'<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
|
||||
(r'&&|\|\|', Operator),
|
||||
],
|
||||
'data': [
|
||||
(r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
|
||||
(r"(?s)\$?'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
|
||||
(r';', Punctuation),
|
||||
(r'&', Punctuation),
|
||||
(r'\|', Punctuation),
|
||||
(r'\s+', Text),
|
||||
(r'[^=\s\[\]{}()$"\'`\\<&|;]+', Text),
|
||||
(r'\d+(?= |\Z)', Number),
|
||||
(r'\$#?(\w+|.)', Name.Variable),
|
||||
(r'<', Text),
|
||||
],
|
||||
'curly': [
|
||||
(r'}', Keyword, '#pop'),
|
||||
(r':-', Keyword),
|
||||
(r'[a-zA-Z0-9_]+', Name.Variable),
|
||||
(r'[^}:"\'`$]+', Punctuation),
|
||||
(r':', Punctuation),
|
||||
include('root'),
|
||||
],
|
||||
'paren': [
|
||||
(r'\)', Keyword, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
'math': [
|
||||
(r'\)\)', Keyword, '#pop'),
|
||||
(r'[-+*/%^|&]|\*\*|\|\|', Operator),
|
||||
(r'\d+', Number),
|
||||
include('root'),
|
||||
],
|
||||
'backticks': [
|
||||
(r'`', String.Backtick, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
}
|
||||
|
||||
def analyse_text(text):
|
||||
if shebang_matches(text, r'(ba|z|)sh'):
|
||||
return 1
|
||||
if text.startswith('$ '):
|
||||
return 0.2
|
||||
|
||||
|
||||
class BashSessionLexer(Lexer):
|
||||
"""
|
||||
Lexer for simplistic shell sessions.
|
||||
|
||||
*New in Pygments 1.1.*
|
||||
"""
|
||||
|
||||
name = 'Bash Session'
|
||||
aliases = ['console']
|
||||
filenames = ['*.sh-session']
|
||||
mimetypes = ['application/x-shell-session']
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
bashlexer = BashLexer(**self.options)
|
||||
|
||||
pos = 0
|
||||
curcode = ''
|
||||
insertions = []
|
||||
|
||||
for match in line_re.finditer(text):
|
||||
line = match.group()
|
||||
m = re.match(r'^((?:\(\S+\))?(?:|sh\S*?|\w+\S+[@:]\S+(?:\s+\S+)'
|
||||
r'?|\[\S+[@:][^\n]+\].+)[$#%])(.*\n?)' , line)
|
||||
if m:
|
||||
# To support output lexers (say diff output), the output
|
||||
# needs to be broken by prompts whenever the output lexer
|
||||
# changes.
|
||||
if not insertions:
|
||||
pos = match.start()
|
||||
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, m.group(1))]))
|
||||
curcode += m.group(2)
|
||||
elif line.startswith('>'):
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, line[:1])]))
|
||||
curcode += line[1:]
|
||||
else:
|
||||
if insertions:
|
||||
toks = bashlexer.get_tokens_unprocessed(curcode)
|
||||
for i, t, v in do_insertions(insertions, toks):
|
||||
yield pos+i, t, v
|
||||
yield match.start(), Generic.Output, line
|
||||
insertions = []
|
||||
curcode = ''
|
||||
if insertions:
|
||||
for i, t, v in do_insertions(insertions,
|
||||
bashlexer.get_tokens_unprocessed(curcode)):
|
||||
yield pos+i, t, v
|
||||
|
||||
|
||||
class ShellSessionLexer(Lexer):
|
||||
"""
|
||||
Lexer for shell sessions that works with different command prompts
|
||||
|
||||
*New in Pygments 1.6.*
|
||||
"""
|
||||
|
||||
name = 'Shell Session'
|
||||
aliases = ['shell-session']
|
||||
filenames = ['*.shell-session']
|
||||
mimetypes = ['application/x-sh-session']
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
bashlexer = BashLexer(**self.options)
|
||||
|
||||
pos = 0
|
||||
curcode = ''
|
||||
insertions = []
|
||||
|
||||
for match in line_re.finditer(text):
|
||||
line = match.group()
|
||||
m = re.match(r'^((?:\[?\S+@[^$#%]+)[$#%])(.*\n?)', line)
|
||||
if m:
|
||||
# To support output lexers (say diff output), the output
|
||||
# needs to be broken by prompts whenever the output lexer
|
||||
# changes.
|
||||
if not insertions:
|
||||
pos = match.start()
|
||||
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, m.group(1))]))
|
||||
curcode += m.group(2)
|
||||
else:
|
||||
if insertions:
|
||||
toks = bashlexer.get_tokens_unprocessed(curcode)
|
||||
for i, t, v in do_insertions(insertions, toks):
|
||||
yield pos+i, t, v
|
||||
yield match.start(), Generic.Output, line
|
||||
insertions = []
|
||||
curcode = ''
|
||||
if insertions:
|
||||
for i, t, v in do_insertions(insertions,
|
||||
bashlexer.get_tokens_unprocessed(curcode)):
|
||||
yield pos+i, t, v
|
||||
|
||||
|
||||
class BatchLexer(RegexLexer):
|
||||
"""
|
||||
Lexer for the DOS/Windows Batch file format.
|
||||
|
||||
*New in Pygments 0.7.*
|
||||
"""
|
||||
name = 'Batchfile'
|
||||
aliases = ['bat', 'dosbatch', 'winbatch']
|
||||
filenames = ['*.bat', '*.cmd']
|
||||
mimetypes = ['application/x-dos-batch']
|
||||
|
||||
flags = re.MULTILINE | re.IGNORECASE
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
# Lines can start with @ to prevent echo
|
||||
(r'^\s*@', Punctuation),
|
||||
(r'^(\s*)(rem\s.*)$', bygroups(Text, Comment)),
|
||||
(r'".*?"', String.Double),
|
||||
(r"'.*?'", String.Single),
|
||||
# If made more specific, make sure you still allow expansions
|
||||
# like %~$VAR:zlt
|
||||
(r'%%?[~$:\w]+%?', Name.Variable),
|
||||
(r'::.*', Comment), # Technically :: only works at BOL
|
||||
(r'(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)),
|
||||
(r'(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)),
|
||||
(r'(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)),
|
||||
(r'\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|'
|
||||
r'setlocal|shift|errorlevel|exist|defined|cmdextversion|'
|
||||
r'errorlevel|else|cd|md|del|deltree|cls|choice)\b', Keyword),
|
||||
(r'\b(equ|neq|lss|leq|gtr|geq)\b', Operator),
|
||||
include('basic'),
|
||||
(r'.', Text),
|
||||
],
|
||||
'echo': [
|
||||
# Escapes only valid within echo args?
|
||||
(r'\^\^|\^<|\^>|\^\|', String.Escape),
|
||||
(r'\n', Text, '#pop'),
|
||||
include('basic'),
|
||||
(r'[^\'"^]+', Text),
|
||||
],
|
||||
'basic': [
|
||||
(r'".*?"', String.Double),
|
||||
(r"'.*?'", String.Single),
|
||||
(r'`.*?`', String.Backtick),
|
||||
(r'-?\d+', Number),
|
||||
(r',', Punctuation),
|
||||
(r'=', Operator),
|
||||
(r'/\S+', Name),
|
||||
(r':\w+', Name.Label),
|
||||
(r'\w:\w+', Text),
|
||||
(r'([<>|])(\s*)(\w+)', bygroups(Punctuation, Text, Name)),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class TcshLexer(RegexLexer):
|
||||
"""
|
||||
Lexer for tcsh scripts.
|
||||
|
||||
*New in Pygments 0.10.*
|
||||
"""
|
||||
|
||||
name = 'Tcsh'
|
||||
aliases = ['tcsh', 'csh']
|
||||
filenames = ['*.tcsh', '*.csh']
|
||||
mimetypes = ['application/x-csh']
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
include('basic'),
|
||||
(r'\$\(', Keyword, 'paren'),
|
||||
(r'\${#?', Keyword, 'curly'),
|
||||
(r'`', String.Backtick, 'backticks'),
|
||||
include('data'),
|
||||
],
|
||||
'basic': [
|
||||
(r'\b(if|endif|else|while|then|foreach|case|default|'
|
||||
r'continue|goto|breaksw|end|switch|endsw)\s*\b',
|
||||
Keyword),
|
||||
(r'\b(alias|alloc|bg|bindkey|break|builtins|bye|caller|cd|chdir|'
|
||||
r'complete|dirs|echo|echotc|eval|exec|exit|fg|filetest|getxvers|'
|
||||
r'glob|getspath|hashstat|history|hup|inlib|jobs|kill|'
|
||||
r'limit|log|login|logout|ls-F|migrate|newgrp|nice|nohup|notify|'
|
||||
r'onintr|popd|printenv|pushd|rehash|repeat|rootnode|popd|pushd|'
|
||||
r'set|shift|sched|setenv|setpath|settc|setty|setxvers|shift|'
|
||||
r'source|stop|suspend|source|suspend|telltc|time|'
|
||||
r'umask|unalias|uncomplete|unhash|universe|unlimit|unset|unsetenv|'
|
||||
r'ver|wait|warp|watchlog|where|which)\s*\b',
|
||||
Name.Builtin),
|
||||
(r'#.*\n', Comment),
|
||||
(r'\\[\w\W]', String.Escape),
|
||||
(r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
|
||||
(r'[\[\]{}()=]+', Operator),
|
||||
(r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
|
||||
],
|
||||
'data': [
|
||||
(r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
|
||||
(r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
|
||||
(r'\s+', Text),
|
||||
(r'[^=\s\[\]{}()$"\'`\\]+', Text),
|
||||
(r'\d+(?= |\Z)', Number),
|
||||
(r'\$#?(\w+|.)', Name.Variable),
|
||||
],
|
||||
'curly': [
|
||||
(r'}', Keyword, '#pop'),
|
||||
(r':-', Keyword),
|
||||
(r'[a-zA-Z0-9_]+', Name.Variable),
|
||||
(r'[^}:"\'`$]+', Punctuation),
|
||||
(r':', Punctuation),
|
||||
include('root'),
|
||||
],
|
||||
'paren': [
|
||||
(r'\)', Keyword, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
'backticks': [
|
||||
(r'`', String.Backtick, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class PowerShellLexer(RegexLexer):
|
||||
"""
|
||||
For Windows PowerShell code.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
name = 'PowerShell'
|
||||
aliases = ['powershell', 'posh', 'ps1', 'psm1']
|
||||
filenames = ['*.ps1','*.psm1']
|
||||
mimetypes = ['text/x-powershell']
|
||||
|
||||
flags = re.DOTALL | re.IGNORECASE | re.MULTILINE
|
||||
|
||||
keywords = (
|
||||
'while validateset validaterange validatepattern validatelength '
|
||||
'validatecount until trap switch return ref process param parameter in '
|
||||
'if global: function foreach for finally filter end elseif else '
|
||||
'dynamicparam do default continue cmdletbinding break begin alias \\? '
|
||||
'% #script #private #local #global mandatory parametersetname position '
|
||||
'valuefrompipeline valuefrompipelinebypropertyname '
|
||||
'valuefromremainingarguments helpmessage try catch throw').split()
|
||||
|
||||
operators = (
|
||||
'and as band bnot bor bxor casesensitive ccontains ceq cge cgt cle '
|
||||
'clike clt cmatch cne cnotcontains cnotlike cnotmatch contains '
|
||||
'creplace eq exact f file ge gt icontains ieq ige igt ile ilike ilt '
|
||||
'imatch ine inotcontains inotlike inotmatch ireplace is isnot le like '
|
||||
'lt match ne not notcontains notlike notmatch or regex replace '
|
||||
'wildcard').split()
|
||||
|
||||
verbs = (
|
||||
'write where wait use update unregister undo trace test tee take '
|
||||
'suspend stop start split sort skip show set send select scroll resume '
|
||||
'restore restart resolve resize reset rename remove register receive '
|
||||
'read push pop ping out new move measure limit join invoke import '
|
||||
'group get format foreach export expand exit enter enable disconnect '
|
||||
'disable debug cxnew copy convertto convertfrom convert connect '
|
||||
'complete compare clear checkpoint aggregate add').split()
|
||||
|
||||
commenthelp = (
|
||||
'component description example externalhelp forwardhelpcategory '
|
||||
'forwardhelptargetname functionality inputs link '
|
||||
'notes outputs parameter remotehelprunspace role synopsis').split()
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
# we need to count pairs of parentheses for correct highlight
|
||||
# of '$(...)' blocks in strings
|
||||
(r'\(', Punctuation, 'child'),
|
||||
(r'\s+', Text),
|
||||
(r'^(\s*#[#\s]*)(\.(?:%s))([^\n]*$)' % '|'.join(commenthelp),
|
||||
bygroups(Comment, String.Doc, Comment)),
|
||||
(r'#[^\n]*?$', Comment),
|
||||
(r'(<|<)#', Comment.Multiline, 'multline'),
|
||||
(r'@"\n', String.Heredoc, 'heredoc-double'),
|
||||
(r"@'\n.*?\n'@", String.Heredoc),
|
||||
# escaped syntax
|
||||
(r'`[\'"$@-]', Punctuation),
|
||||
(r'"', String.Double, 'string'),
|
||||
(r"'([^']|'')*'", String.Single),
|
||||
(r'(\$|@@|@)((global|script|private|env):)?[a-z0-9_]+',
|
||||
Name.Variable),
|
||||
(r'(%s)\b' % '|'.join(keywords), Keyword),
|
||||
(r'-(%s)\b' % '|'.join(operators), Operator),
|
||||
(r'(%s)-[a-z_][a-z0-9_]*\b' % '|'.join(verbs), Name.Builtin),
|
||||
(r'\[[a-z_\[][a-z0-9_. `,\[\]]*\]', Name.Constant), # .net [type]s
|
||||
(r'-[a-z_][a-z0-9_]*', Name),
|
||||
(r'\w+', Name),
|
||||
(r'[.,;@{}\[\]$()=+*/\\&%!~?^`|<>-]|::', Punctuation),
|
||||
],
|
||||
'child': [
|
||||
(r'\)', Punctuation, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
'multline': [
|
||||
(r'[^#&.]+', Comment.Multiline),
|
||||
(r'#(>|>)', Comment.Multiline, '#pop'),
|
||||
(r'\.(%s)' % '|'.join(commenthelp), String.Doc),
|
||||
(r'[#&.]', Comment.Multiline),
|
||||
],
|
||||
'string': [
|
||||
(r"`[0abfnrtv'\"\$]", String.Escape),
|
||||
(r'[^$`"]+', String.Double),
|
||||
(r'\$\(', Punctuation, 'child'),
|
||||
(r'""', String.Double),
|
||||
(r'[`$]', String.Double),
|
||||
(r'"', String.Double, '#pop'),
|
||||
],
|
||||
'heredoc-double': [
|
||||
(r'\n"@', String.Heredoc, '#pop'),
|
||||
(r'\$\(', Punctuation, 'child'),
|
||||
(r'[^@\n]+"]', String.Heredoc),
|
||||
(r".", String.Heredoc),
|
||||
]
|
||||
}
|
|
@ -0,0 +1,100 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.special
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Special lexers.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
import cStringIO
|
||||
|
||||
from pygments.lexer import Lexer
|
||||
from pygments.token import Token, Error, Text
|
||||
from pygments.util import get_choice_opt, b
|
||||
|
||||
|
||||
__all__ = ['TextLexer', 'RawTokenLexer']
|
||||
|
||||
|
||||
class TextLexer(Lexer):
|
||||
"""
|
||||
"Null" lexer, doesn't highlight anything.
|
||||
"""
|
||||
name = 'Text only'
|
||||
aliases = ['text']
|
||||
filenames = ['*.txt']
|
||||
mimetypes = ['text/plain']
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
yield 0, Text, text
|
||||
|
||||
|
||||
_ttype_cache = {}
|
||||
|
||||
line_re = re.compile(b('.*?\n'))
|
||||
|
||||
class RawTokenLexer(Lexer):
|
||||
"""
|
||||
Recreate a token stream formatted with the `RawTokenFormatter`. This
|
||||
lexer raises exceptions during parsing if the token stream in the
|
||||
file is malformed.
|
||||
|
||||
Additional options accepted:
|
||||
|
||||
`compress`
|
||||
If set to ``"gz"`` or ``"bz2"``, decompress the token stream with
|
||||
the given compression algorithm before lexing (default: ``""``).
|
||||
"""
|
||||
name = 'Raw token data'
|
||||
aliases = ['raw']
|
||||
filenames = []
|
||||
mimetypes = ['application/x-pygments-tokens']
|
||||
|
||||
def __init__(self, **options):
|
||||
self.compress = get_choice_opt(options, 'compress',
|
||||
['', 'none', 'gz', 'bz2'], '')
|
||||
Lexer.__init__(self, **options)
|
||||
|
||||
def get_tokens(self, text):
|
||||
if isinstance(text, unicode):
|
||||
# raw token stream never has any non-ASCII characters
|
||||
text = text.encode('ascii')
|
||||
if self.compress == 'gz':
|
||||
import gzip
|
||||
gzipfile = gzip.GzipFile('', 'rb', 9, cStringIO.StringIO(text))
|
||||
text = gzipfile.read()
|
||||
elif self.compress == 'bz2':
|
||||
import bz2
|
||||
text = bz2.decompress(text)
|
||||
|
||||
# do not call Lexer.get_tokens() because we do not want Unicode
|
||||
# decoding to occur, and stripping is not optional.
|
||||
text = text.strip(b('\n')) + b('\n')
|
||||
for i, t, v in self.get_tokens_unprocessed(text):
|
||||
yield t, v
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
length = 0
|
||||
for match in line_re.finditer(text):
|
||||
try:
|
||||
ttypestr, val = match.group().split(b('\t'), 1)
|
||||
except ValueError:
|
||||
val = match.group().decode(self.encoding)
|
||||
ttype = Error
|
||||
else:
|
||||
ttype = _ttype_cache.get(ttypestr)
|
||||
if not ttype:
|
||||
ttype = Token
|
||||
ttypes = ttypestr.split('.')[1:]
|
||||
for ttype_ in ttypes:
|
||||
if not ttype_ or not ttype_[0].isupper():
|
||||
raise ValueError('malformed token name')
|
||||
ttype = getattr(ttype, ttype_)
|
||||
_ttype_cache[ttypestr] = ttype
|
||||
val = val[2:-2].decode('unicode-escape')
|
||||
yield length, ttype, val
|
||||
length += len(val)
|
|
@ -0,0 +1,559 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.lexers.sql
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for various SQL dialects and related interactive sessions.
|
||||
|
||||
Postgres specific lexers:
|
||||
|
||||
`PostgresLexer`
|
||||
A SQL lexer for the PostgreSQL dialect. Differences w.r.t. the SQL
|
||||
lexer are:
|
||||
|
||||
- keywords and data types list parsed from the PG docs (run the
|
||||
`_postgres_builtins` module to update them);
|
||||
- Content of $-strings parsed using a specific lexer, e.g. the content
|
||||
of a PL/Python function is parsed using the Python lexer;
|
||||
- parse PG specific constructs: E-strings, $-strings, U&-strings,
|
||||
different operators and punctuation.
|
||||
|
||||
`PlPgsqlLexer`
|
||||
A lexer for the PL/pgSQL language. Adds a few specific construct on
|
||||
top of the PG SQL lexer (such as <<label>>).
|
||||
|
||||
`PostgresConsoleLexer`
|
||||
A lexer to highlight an interactive psql session:
|
||||
|
||||
- identifies the prompt and does its best to detect the end of command
|
||||
in multiline statement where not all the lines are prefixed by a
|
||||
prompt, telling them apart from the output;
|
||||
- highlights errors in the output and notification levels;
|
||||
- handles psql backslash commands.
|
||||
|
||||
The ``tests/examplefiles`` contains a few test files with data to be
|
||||
parsed by these lexers.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups
|
||||
from pygments.token import Punctuation, \
|
||||
Text, Comment, Operator, Keyword, Name, String, Number, Generic
|
||||
from pygments.lexers import get_lexer_by_name, ClassNotFound
|
||||
|
||||
from pygments.lexers._postgres_builtins import KEYWORDS, DATATYPES, \
|
||||
PSEUDO_TYPES, PLPGSQL_KEYWORDS
|
||||
|
||||
|
||||
__all__ = ['PostgresLexer', 'PlPgsqlLexer', 'PostgresConsoleLexer',
|
||||
'SqlLexer', 'MySqlLexer', 'SqliteConsoleLexer']
|
||||
|
||||
line_re = re.compile('.*?\n')
|
||||
|
||||
language_re = re.compile(r"\s+LANGUAGE\s+'?(\w+)'?", re.IGNORECASE)
|
||||
|
||||
def language_callback(lexer, match):
|
||||
"""Parse the content of a $-string using a lexer
|
||||
|
||||
The lexer is chosen looking for a nearby LANGUAGE.
|
||||
"""
|
||||
l = None
|
||||
m = language_re.match(lexer.text[match.end():match.end()+100])
|
||||
if m is not None:
|
||||
l = lexer._get_lexer(m.group(1))
|
||||
else:
|
||||
m = list(language_re.finditer(
|
||||
lexer.text[max(0, match.start()-100):match.start()]))
|
||||
if m:
|
||||
l = lexer._get_lexer(m[-1].group(1))
|
||||
|
||||
if l:
|
||||
yield (match.start(1), String, match.group(1))
|
||||
for x in l.get_tokens_unprocessed(match.group(2)):
|
||||
yield x
|
||||
yield (match.start(3), String, match.group(3))
|
||||
|
||||
else:
|
||||
yield (match.start(), String, match.group())
|
||||
|
||||
|
||||
class PostgresBase(object):
|
||||
"""Base class for Postgres-related lexers.
|
||||
|
||||
This is implemented as a mixin to avoid the Lexer metaclass kicking in.
|
||||
this way the different lexer don't have a common Lexer ancestor. If they
|
||||
had, _tokens could be created on this ancestor and not updated for the
|
||||
other classes, resulting e.g. in PL/pgSQL parsed as SQL. This shortcoming
|
||||
seem to suggest that regexp lexers are not really subclassable.
|
||||
"""
|
||||
def get_tokens_unprocessed(self, text, *args):
|
||||
# Have a copy of the entire text to be used by `language_callback`.
|
||||
self.text = text
|
||||
for x in super(PostgresBase, self).get_tokens_unprocessed(
|
||||
text, *args):
|
||||
yield x
|
||||
|
||||
def _get_lexer(self, lang):
|
||||
if lang.lower() == 'sql':
|
||||
return get_lexer_by_name('postgresql', **self.options)
|
||||
|
||||
tries = [ lang ]
|
||||
if lang.startswith('pl'):
|
||||
tries.append(lang[2:])
|
||||
if lang.endswith('u'):
|
||||
tries.append(lang[:-1])
|
||||
if lang.startswith('pl') and lang.endswith('u'):
|
||||
tries.append(lang[2:-1])
|
||||
|
||||
for l in tries:
|
||||
try:
|
||||
return get_lexer_by_name(l, **self.options)
|
||||
except ClassNotFound:
|
||||
pass
|
||||
else:
|
||||
# TODO: better logging
|
||||
# print >>sys.stderr, "language not found:", lang
|
||||
return None
|
||||
|
||||
|
||||
class PostgresLexer(PostgresBase, RegexLexer):
|
||||
"""
|
||||
Lexer for the PostgreSQL dialect of SQL.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
|
||||
name = 'PostgreSQL SQL dialect'
|
||||
aliases = ['postgresql', 'postgres']
|
||||
mimetypes = ['text/x-postgresql']
|
||||
|
||||
flags = re.IGNORECASE
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\s+', Text),
|
||||
(r'--.*?\n', Comment.Single),
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'(' + '|'.join([s.replace(" ", "\s+")
|
||||
for s in DATATYPES + PSEUDO_TYPES])
|
||||
+ r')\b', Name.Builtin),
|
||||
(r'(' + '|'.join(KEYWORDS) + r')\b', Keyword),
|
||||
(r'[+*/<>=~!@#%^&|`?-]+', Operator),
|
||||
(r'::', Operator), # cast
|
||||
(r'\$\d+', Name.Variable),
|
||||
(r'([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?', Number.Float),
|
||||
(r'[0-9]+', Number.Integer),
|
||||
(r"(E|U&)?'(''|[^'])*'", String.Single),
|
||||
(r'(U&)?"(""|[^"])*"', String.Name), # quoted identifier
|
||||
(r'(?s)(\$[^\$]*\$)(.*?)(\1)', language_callback),
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
|
||||
# psql variable in SQL
|
||||
(r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
|
||||
|
||||
(r'[;:()\[\]\{\},\.]', Punctuation),
|
||||
],
|
||||
'multiline-comments': [
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'\*/', Comment.Multiline, '#pop'),
|
||||
(r'[^/\*]+', Comment.Multiline),
|
||||
(r'[/*]', Comment.Multiline)
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class PlPgsqlLexer(PostgresBase, RegexLexer):
|
||||
"""
|
||||
Handle the extra syntax in Pl/pgSQL language.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
name = 'PL/pgSQL'
|
||||
aliases = ['plpgsql']
|
||||
mimetypes = ['text/x-plpgsql']
|
||||
|
||||
flags = re.IGNORECASE
|
||||
tokens = dict((k, l[:]) for (k, l) in PostgresLexer.tokens.iteritems())
|
||||
|
||||
# extend the keywords list
|
||||
for i, pattern in enumerate(tokens['root']):
|
||||
if pattern[1] == Keyword:
|
||||
tokens['root'][i] = (
|
||||
r'(' + '|'.join(KEYWORDS + PLPGSQL_KEYWORDS) + r')\b',
|
||||
Keyword)
|
||||
del i
|
||||
break
|
||||
else:
|
||||
assert 0, "SQL keywords not found"
|
||||
|
||||
# Add specific PL/pgSQL rules (before the SQL ones)
|
||||
tokens['root'][:0] = [
|
||||
(r'\%[a-z][a-z0-9_]*\b', Name.Builtin), # actually, a datatype
|
||||
(r':=', Operator),
|
||||
(r'\<\<[a-z][a-z0-9_]*\>\>', Name.Label),
|
||||
(r'\#[a-z][a-z0-9_]*\b', Keyword.Pseudo), # #variable_conflict
|
||||
]
|
||||
|
||||
|
||||
class PsqlRegexLexer(PostgresBase, RegexLexer):
|
||||
"""
|
||||
Extend the PostgresLexer adding support specific for psql commands.
|
||||
|
||||
This is not a complete psql lexer yet as it lacks prompt support
|
||||
and output rendering.
|
||||
"""
|
||||
|
||||
name = 'PostgreSQL console - regexp based lexer'
|
||||
aliases = [] # not public
|
||||
|
||||
flags = re.IGNORECASE
|
||||
tokens = dict((k, l[:]) for (k, l) in PostgresLexer.tokens.iteritems())
|
||||
|
||||
tokens['root'].append(
|
||||
(r'\\[^\s]+', Keyword.Pseudo, 'psql-command'))
|
||||
tokens['psql-command'] = [
|
||||
(r'\n', Text, 'root'),
|
||||
(r'\s+', Text),
|
||||
(r'\\[^\s]+', Keyword.Pseudo),
|
||||
(r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
|
||||
(r"'(''|[^'])*'", String.Single),
|
||||
(r"`([^`])*`", String.Backtick),
|
||||
(r"[^\s]+", String.Symbol),
|
||||
]
|
||||
|
||||
re_prompt = re.compile(r'^(\S.*?)??[=\-\(\$\'\"][#>]')
|
||||
re_psql_command = re.compile(r'\s*\\')
|
||||
re_end_command = re.compile(r';\s*(--.*?)?$')
|
||||
re_psql_command = re.compile(r'(\s*)(\\.+?)(\s+)$')
|
||||
re_error = re.compile(r'(ERROR|FATAL):')
|
||||
re_message = re.compile(
|
||||
r'((?:DEBUG|INFO|NOTICE|WARNING|ERROR|'
|
||||
r'FATAL|HINT|DETAIL|CONTEXT|LINE [0-9]+):)(.*?\n)')
|
||||
|
||||
|
||||
class lookahead(object):
|
||||
"""Wrap an iterator and allow pushing back an item."""
|
||||
def __init__(self, x):
|
||||
self.iter = iter(x)
|
||||
self._nextitem = None
|
||||
def __iter__(self):
|
||||
return self
|
||||
def send(self, i):
|
||||
self._nextitem = i
|
||||
return i
|
||||
def next(self):
|
||||
if self._nextitem is not None:
|
||||
ni = self._nextitem
|
||||
self._nextitem = None
|
||||
return ni
|
||||
return self.iter.next()
|
||||
|
||||
|
||||
class PostgresConsoleLexer(Lexer):
|
||||
"""
|
||||
Lexer for psql sessions.
|
||||
|
||||
*New in Pygments 1.5.*
|
||||
"""
|
||||
|
||||
name = 'PostgreSQL console (psql)'
|
||||
aliases = ['psql', 'postgresql-console', 'postgres-console']
|
||||
mimetypes = ['text/x-postgresql-psql']
|
||||
|
||||
def get_tokens_unprocessed(self, data):
|
||||
sql = PsqlRegexLexer(**self.options)
|
||||
|
||||
lines = lookahead(line_re.findall(data))
|
||||
|
||||
# prompt-output cycle
|
||||
while 1:
|
||||
|
||||
# consume the lines of the command: start with an optional prompt
|
||||
# and continue until the end of command is detected
|
||||
curcode = ''
|
||||
insertions = []
|
||||
while 1:
|
||||
try:
|
||||
line = lines.next()
|
||||
except StopIteration:
|
||||
# allow the emission of partially collected items
|
||||
# the repl loop will be broken below
|
||||
break
|
||||
|
||||
# Identify a shell prompt in case of psql commandline example
|
||||
if line.startswith('$') and not curcode:
|
||||
lexer = get_lexer_by_name('console', **self.options)
|
||||
for x in lexer.get_tokens_unprocessed(line):
|
||||
yield x
|
||||
break
|
||||
|
||||
# Identify a psql prompt
|
||||
mprompt = re_prompt.match(line)
|
||||
if mprompt is not None:
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, mprompt.group())]))
|
||||
curcode += line[len(mprompt.group()):]
|
||||
else:
|
||||
curcode += line
|
||||
|
||||
# Check if this is the end of the command
|
||||
# TODO: better handle multiline comments at the end with
|
||||
# a lexer with an external state?
|
||||
if re_psql_command.match(curcode) \
|
||||
or re_end_command.search(curcode):
|
||||
break
|
||||
|
||||
# Emit the combined stream of command and prompt(s)
|
||||
for item in do_insertions(insertions,
|
||||
sql.get_tokens_unprocessed(curcode)):
|
||||
yield item
|
||||
|
||||
# Emit the output lines
|
||||
out_token = Generic.Output
|
||||
while 1:
|
||||
line = lines.next()
|
||||
mprompt = re_prompt.match(line)
|
||||
if mprompt is not None:
|
||||
# push the line back to have it processed by the prompt
|
||||
lines.send(line)
|
||||
break
|
||||
|
||||
mmsg = re_message.match(line)
|
||||
if mmsg is not None:
|
||||
if mmsg.group(1).startswith("ERROR") \
|
||||
or mmsg.group(1).startswith("FATAL"):
|
||||
out_token = Generic.Error
|
||||
yield (mmsg.start(1), Generic.Strong, mmsg.group(1))
|
||||
yield (mmsg.start(2), out_token, mmsg.group(2))
|
||||
else:
|
||||
yield (0, out_token, line)
|
||||
|
||||
|
||||
class SqlLexer(RegexLexer):
|
||||
"""
|
||||
Lexer for Structured Query Language. Currently, this lexer does
|
||||
not recognize any special syntax except ANSI SQL.
|
||||
"""
|
||||
|
||||
name = 'SQL'
|
||||
aliases = ['sql']
|
||||
filenames = ['*.sql']
|
||||
mimetypes = ['text/x-sql']
|
||||
|
||||
flags = re.IGNORECASE
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\s+', Text),
|
||||
(r'--.*?\n', Comment.Single),
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'(ABORT|ABS|ABSOLUTE|ACCESS|ADA|ADD|ADMIN|AFTER|AGGREGATE|'
|
||||
r'ALIAS|ALL|ALLOCATE|ALTER|ANALYSE|ANALYZE|AND|ANY|ARE|AS|'
|
||||
r'ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|'
|
||||
r'AUTHORIZATION|AVG|BACKWARD|BEFORE|BEGIN|BETWEEN|BITVAR|'
|
||||
r'BIT_LENGTH|BOTH|BREADTH|BY|C|CACHE|CALL|CALLED|CARDINALITY|'
|
||||
r'CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CHAIN|'
|
||||
r'CHARACTERISTICS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|'
|
||||
r'CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|'
|
||||
r'CHECKED|CHECKPOINT|CLASS|CLASS_ORIGIN|CLOB|CLOSE|CLUSTER|'
|
||||
r'COALSECE|COBOL|COLLATE|COLLATION|COLLATION_CATALOG|'
|
||||
r'COLLATION_NAME|COLLATION_SCHEMA|COLUMN|COLUMN_NAME|'
|
||||
r'COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMENT|COMMIT|'
|
||||
r'COMMITTED|COMPLETION|CONDITION_NUMBER|CONNECT|CONNECTION|'
|
||||
r'CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|'
|
||||
r'CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTOR|CONTAINS|'
|
||||
r'CONTINUE|CONVERSION|CONVERT|COPY|CORRESPONTING|COUNT|'
|
||||
r'CREATE|CREATEDB|CREATEUSER|CROSS|CUBE|CURRENT|CURRENT_DATE|'
|
||||
r'CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|'
|
||||
r'CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATABASE|'
|
||||
r'DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|'
|
||||
r'DEALLOCATE|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|'
|
||||
r'DEFINED|DEFINER|DELETE|DELIMITER|DELIMITERS|DEREF|DESC|'
|
||||
r'DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DETERMINISTIC|'
|
||||
r'DIAGNOSTICS|DICTIONARY|DISCONNECT|DISPATCH|DISTINCT|DO|'
|
||||
r'DOMAIN|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|'
|
||||
r'EACH|ELSE|ENCODING|ENCRYPTED|END|END-EXEC|EQUALS|ESCAPE|EVERY|'
|
||||
r'EXCEPTION|EXCEPT|EXCLUDING|EXCLUSIVE|EXEC|EXECUTE|EXISTING|'
|
||||
r'EXISTS|EXPLAIN|EXTERNAL|EXTRACT|FALSE|FETCH|FINAL|FIRST|FOR|'
|
||||
r'FORCE|FOREIGN|FORTRAN|FORWARD|FOUND|FREE|FREEZE|FROM|FULL|'
|
||||
r'FUNCTION|G|GENERAL|GENERATED|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|'
|
||||
r'GROUP|GROUPING|HANDLER|HAVING|HIERARCHY|HOLD|HOST|IDENTITY|'
|
||||
r'IGNORE|ILIKE|IMMEDIATE|IMMUTABLE|IMPLEMENTATION|IMPLICIT|IN|'
|
||||
r'INCLUDING|INCREMENT|INDEX|INDITCATOR|INFIX|INHERITS|INITIALIZE|'
|
||||
r'INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANTIABLE|'
|
||||
r'INSTEAD|INTERSECT|INTO|INVOKER|IS|ISNULL|ISOLATION|ITERATE|JOIN|'
|
||||
r'KEY|KEY_MEMBER|KEY_TYPE|LANCOMPILER|LANGUAGE|LARGE|LAST|'
|
||||
r'LATERAL|LEADING|LEFT|LENGTH|LESS|LEVEL|LIKE|LIMIT|LISTEN|LOAD|'
|
||||
r'LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCATOR|LOCK|LOWER|'
|
||||
r'MAP|MATCH|MAX|MAXVALUE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|'
|
||||
r'MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODE|MODIFIES|'
|
||||
r'MODIFY|MONTH|MORE|MOVE|MUMPS|NAMES|NATIONAL|NATURAL|NCHAR|'
|
||||
r'NCLOB|NEW|NEXT|NO|NOCREATEDB|NOCREATEUSER|NONE|NOT|NOTHING|'
|
||||
r'NOTIFY|NOTNULL|NULL|NULLABLE|NULLIF|OBJECT|OCTET_LENGTH|OF|OFF|'
|
||||
r'OFFSET|OIDS|OLD|ON|ONLY|OPEN|OPERATION|OPERATOR|OPTION|OPTIONS|'
|
||||
r'OR|ORDER|ORDINALITY|OUT|OUTER|OUTPUT|OVERLAPS|OVERLAY|OVERRIDING|'
|
||||
r'OWNER|PAD|PARAMETER|PARAMETERS|PARAMETER_MODE|PARAMATER_NAME|'
|
||||
r'PARAMATER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|'
|
||||
r'PARAMETER_SPECIFIC_NAME|PARAMATER_SPECIFIC_SCHEMA|PARTIAL|'
|
||||
r'PASCAL|PENDANT|PLACING|PLI|POSITION|POSTFIX|PRECISION|PREFIX|'
|
||||
r'PREORDER|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|'
|
||||
r'PROCEDURE|PUBLIC|READ|READS|RECHECK|RECURSIVE|REF|REFERENCES|'
|
||||
r'REFERENCING|REINDEX|RELATIVE|RENAME|REPEATABLE|REPLACE|RESET|'
|
||||
r'RESTART|RESTRICT|RESULT|RETURN|RETURNED_LENGTH|'
|
||||
r'RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|'
|
||||
r'ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|'
|
||||
r'ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|RULE|SAVE_POINT|SCALE|SCHEMA|'
|
||||
r'SCHEMA_NAME|SCOPE|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SELF|'
|
||||
r'SENSITIVE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|'
|
||||
r'SETOF|SETS|SHARE|SHOW|SIMILAR|SIMPLE|SIZE|SOME|SOURCE|SPACE|'
|
||||
r'SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLCODE|SQLERROR|'
|
||||
r'SQLEXCEPTION|SQLSTATE|SQLWARNINIG|STABLE|START|STATE|STATEMENT|'
|
||||
r'STATIC|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRUCTURE|STYPE|'
|
||||
r'SUBCLASS_ORIGIN|SUBLIST|SUBSTRING|SUM|SYMMETRIC|SYSID|SYSTEM|'
|
||||
r'SYSTEM_USER|TABLE|TABLE_NAME| TEMP|TEMPLATE|TEMPORARY|TERMINATE|'
|
||||
r'THAN|THEN|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOAST|'
|
||||
r'TRAILING|TRANSATION|TRANSACTIONS_COMMITTED|'
|
||||
r'TRANSACTIONS_ROLLED_BACK|TRANSATION_ACTIVE|TRANSFORM|'
|
||||
r'TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|'
|
||||
r'TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|'
|
||||
r'UNCOMMITTED|UNDER|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|'
|
||||
r'UNNAMED|UNNEST|UNTIL|UPDATE|UPPER|USAGE|USER|'
|
||||
r'USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_NAME|'
|
||||
r'USER_DEFINED_TYPE_SCHEMA|USING|VACUUM|VALID|VALIDATOR|VALUES|'
|
||||
r'VARIABLE|VERBOSE|VERSION|VIEW|VOLATILE|WHEN|WHENEVER|WHERE|'
|
||||
r'WITH|WITHOUT|WORK|WRITE|YEAR|ZONE)\b', Keyword),
|
||||
(r'(ARRAY|BIGINT|BINARY|BIT|BLOB|BOOLEAN|CHAR|CHARACTER|DATE|'
|
||||
r'DEC|DECIMAL|FLOAT|INT|INTEGER|INTERVAL|NUMBER|NUMERIC|REAL|'
|
||||
r'SERIAL|SMALLINT|VARCHAR|VARYING|INT8|SERIAL8|TEXT)\b',
|
||||
Name.Builtin),
|
||||
(r'[+*/<>=~!@#%^&|`?-]', Operator),
|
||||
(r'[0-9]+', Number.Integer),
|
||||
# TODO: Backslash escapes?
|
||||
(r"'(''|[^'])*'", String.Single),
|
||||
(r'"(""|[^"])*"', String.Symbol), # not a real string literal in ANSI SQL
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
(r'[;:()\[\],\.]', Punctuation)
|
||||
],
|
||||
'multiline-comments': [
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'\*/', Comment.Multiline, '#pop'),
|
||||
(r'[^/\*]+', Comment.Multiline),
|
||||
(r'[/*]', Comment.Multiline)
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class MySqlLexer(RegexLexer):
|
||||
"""
|
||||
Special lexer for MySQL.
|
||||
"""
|
||||
|
||||
name = 'MySQL'
|
||||
aliases = ['mysql']
|
||||
mimetypes = ['text/x-mysql']
|
||||
|
||||
flags = re.IGNORECASE
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\s+', Text),
|
||||
(r'(#|--\s+).*?\n', Comment.Single),
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'[0-9]+', Number.Integer),
|
||||
(r'[0-9]*\.[0-9]+(e[+-][0-9]+)', Number.Float),
|
||||
# TODO: add backslash escapes
|
||||
(r"'(''|[^'])*'", String.Single),
|
||||
(r'"(""|[^"])*"', String.Double),
|
||||
(r"`(``|[^`])*`", String.Symbol),
|
||||
(r'[+*/<>=~!@#%^&|`?-]', Operator),
|
||||
(r'\b(tinyint|smallint|mediumint|int|integer|bigint|date|'
|
||||
r'datetime|time|bit|bool|tinytext|mediumtext|longtext|text|'
|
||||
r'tinyblob|mediumblob|longblob|blob|float|double|double\s+'
|
||||
r'precision|real|numeric|dec|decimal|timestamp|year|char|'
|
||||
r'varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?',
|
||||
bygroups(Keyword.Type, Text, Punctuation)),
|
||||
(r'\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|'
|
||||
r'bigint|binary|blob|both|by|call|cascade|case|change|char|'
|
||||
r'character|check|collate|column|condition|constraint|continue|'
|
||||
r'convert|create|cross|current_date|current_time|'
|
||||
r'current_timestamp|current_user|cursor|database|databases|'
|
||||
r'day_hour|day_microsecond|day_minute|day_second|dec|decimal|'
|
||||
r'declare|default|delayed|delete|desc|describe|deterministic|'
|
||||
r'distinct|distinctrow|div|double|drop|dual|each|else|elseif|'
|
||||
r'enclosed|escaped|exists|exit|explain|fetch|float|float4|float8'
|
||||
r'|for|force|foreign|from|fulltext|grant|group|having|'
|
||||
r'high_priority|hour_microsecond|hour_minute|hour_second|if|'
|
||||
r'ignore|in|index|infile|inner|inout|insensitive|insert|int|'
|
||||
r'int1|int2|int3|int4|int8|integer|interval|into|is|iterate|'
|
||||
r'join|key|keys|kill|leading|leave|left|like|limit|lines|load|'
|
||||
r'localtime|localtimestamp|lock|long|loop|low_priority|match|'
|
||||
r'minute_microsecond|minute_second|mod|modifies|natural|'
|
||||
r'no_write_to_binlog|not|numeric|on|optimize|option|optionally|'
|
||||
r'or|order|out|outer|outfile|precision|primary|procedure|purge|'
|
||||
r'raid0|read|reads|real|references|regexp|release|rename|repeat|'
|
||||
r'replace|require|restrict|return|revoke|right|rlike|schema|'
|
||||
r'schemas|second_microsecond|select|sensitive|separator|set|'
|
||||
r'show|smallint|soname|spatial|specific|sql|sql_big_result|'
|
||||
r'sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|'
|
||||
r'sqlwarning|ssl|starting|straight_join|table|terminated|then|'
|
||||
r'to|trailing|trigger|undo|union|unique|unlock|unsigned|update|'
|
||||
r'usage|use|using|utc_date|utc_time|utc_timestamp|values|'
|
||||
r'varying|when|where|while|with|write|x509|xor|year_month|'
|
||||
r'zerofill)\b', Keyword),
|
||||
# TODO: this list is not complete
|
||||
(r'\b(auto_increment|engine|charset|tables)\b', Keyword.Pseudo),
|
||||
(r'(true|false|null)', Name.Constant),
|
||||
(r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()',
|
||||
bygroups(Name.Function, Text, Punctuation)),
|
||||
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
||||
(r'@[A-Za-z0-9]*[._]*[A-Za-z0-9]*', Name.Variable),
|
||||
(r'[;:()\[\],\.]', Punctuation)
|
||||
],
|
||||
'multiline-comments': [
|
||||
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
||||
(r'\*/', Comment.Multiline, '#pop'),
|
||||
(r'[^/\*]+', Comment.Multiline),
|
||||
(r'[/*]', Comment.Multiline)
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
class SqliteConsoleLexer(Lexer):
|
||||
"""
|
||||
Lexer for example sessions using sqlite3.
|
||||
|
||||
*New in Pygments 0.11.*
|
||||
"""
|
||||
|
||||
name = 'sqlite3con'
|
||||
aliases = ['sqlite3']
|
||||
filenames = ['*.sqlite3-console']
|
||||
mimetypes = ['text/x-sqlite3-console']
|
||||
|
||||
def get_tokens_unprocessed(self, data):
|
||||
sql = SqlLexer(**self.options)
|
||||
|
||||
curcode = ''
|
||||
insertions = []
|
||||
for match in line_re.finditer(data):
|
||||
line = match.group()
|
||||
if line.startswith('sqlite> ') or line.startswith(' ...> '):
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, line[:8])]))
|
||||
curcode += line[8:]
|
||||
else:
|
||||
if curcode:
|
||||
for item in do_insertions(insertions,
|
||||
sql.get_tokens_unprocessed(curcode)):
|
||||
yield item
|
||||
curcode = ''
|
||||
insertions = []
|
||||
if line.startswith('SQL error: '):
|
||||
yield (match.start(), Generic.Traceback, line)
|
||||
else:
|
||||
yield (match.start(), Generic.Output, line)
|
||||
if curcode:
|
||||
for item in do_insertions(insertions,
|
||||
sql.get_tokens_unprocessed(curcode)):
|
||||
yield item
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,40 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.modeline
|
||||
~~~~~~~~~~~~~~~~~
|
||||
|
||||
A simple modeline parser (based on pymodeline).
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
__all__ = ['get_filetype_from_buffer']
|
||||
|
||||
modeline_re = re.compile(r'''
|
||||
(?: vi | vim | ex ) (?: [<=>]? \d* )? :
|
||||
.* (?: ft | filetype | syn | syntax ) = ( [^:\s]+ )
|
||||
''', re.VERBOSE)
|
||||
|
||||
def get_filetype_from_line(l):
|
||||
m = modeline_re.search(l)
|
||||
if m:
|
||||
return m.group(1)
|
||||
|
||||
def get_filetype_from_buffer(buf, max_lines=5):
|
||||
"""
|
||||
Scan the buffer for modelines and return filetype if one is found.
|
||||
"""
|
||||
lines = buf.splitlines()
|
||||
for l in lines[-1:-max_lines-1:-1]:
|
||||
ret = get_filetype_from_line(l)
|
||||
if ret:
|
||||
return ret
|
||||
for l in lines[max_lines:0:-1]:
|
||||
ret = get_filetype_from_line(l)
|
||||
if ret:
|
||||
return ret
|
||||
|
||||
return None
|
|
@ -0,0 +1,74 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.plugin
|
||||
~~~~~~~~~~~~~~~
|
||||
|
||||
Pygments setuptools plugin interface. The methods defined
|
||||
here also work if setuptools isn't installed but they just
|
||||
return nothing.
|
||||
|
||||
lexer plugins::
|
||||
|
||||
[pygments.lexers]
|
||||
yourlexer = yourmodule:YourLexer
|
||||
|
||||
formatter plugins::
|
||||
|
||||
[pygments.formatters]
|
||||
yourformatter = yourformatter:YourFormatter
|
||||
/.ext = yourformatter:YourFormatter
|
||||
|
||||
As you can see, you can define extensions for the formatter
|
||||
with a leading slash.
|
||||
|
||||
syntax plugins::
|
||||
|
||||
[pygments.styles]
|
||||
yourstyle = yourstyle:YourStyle
|
||||
|
||||
filter plugin::
|
||||
|
||||
[pygments.filter]
|
||||
yourfilter = yourfilter:YourFilter
|
||||
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
try:
|
||||
import pkg_resources
|
||||
except ImportError:
|
||||
pkg_resources = None
|
||||
|
||||
LEXER_ENTRY_POINT = 'pygments.lexers'
|
||||
FORMATTER_ENTRY_POINT = 'pygments.formatters'
|
||||
STYLE_ENTRY_POINT = 'pygments.styles'
|
||||
FILTER_ENTRY_POINT = 'pygments.filters'
|
||||
|
||||
|
||||
def find_plugin_lexers():
|
||||
if pkg_resources is None:
|
||||
return
|
||||
for entrypoint in pkg_resources.iter_entry_points(LEXER_ENTRY_POINT):
|
||||
yield entrypoint.load()
|
||||
|
||||
|
||||
def find_plugin_formatters():
|
||||
if pkg_resources is None:
|
||||
return
|
||||
for entrypoint in pkg_resources.iter_entry_points(FORMATTER_ENTRY_POINT):
|
||||
yield entrypoint.name, entrypoint.load()
|
||||
|
||||
|
||||
def find_plugin_styles():
|
||||
if pkg_resources is None:
|
||||
return
|
||||
for entrypoint in pkg_resources.iter_entry_points(STYLE_ENTRY_POINT):
|
||||
yield entrypoint.name, entrypoint.load()
|
||||
|
||||
|
||||
def find_plugin_filters():
|
||||
if pkg_resources is None:
|
||||
return
|
||||
for entrypoint in pkg_resources.iter_entry_points(FILTER_ENTRY_POINT):
|
||||
yield entrypoint.name, entrypoint.load()
|
|
@ -0,0 +1,104 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.scanner
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
This library implements a regex based scanner. Some languages
|
||||
like Pascal are easy to parse but have some keywords that
|
||||
depend on the context. Because of this it's impossible to lex
|
||||
that just by using a regular expression lexer like the
|
||||
`RegexLexer`.
|
||||
|
||||
Have a look at the `DelphiLexer` to get an idea of how to use
|
||||
this scanner.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
import re
|
||||
|
||||
|
||||
class EndOfText(RuntimeError):
|
||||
"""
|
||||
Raise if end of text is reached and the user
|
||||
tried to call a match function.
|
||||
"""
|
||||
|
||||
|
||||
class Scanner(object):
|
||||
"""
|
||||
Simple scanner
|
||||
|
||||
All method patterns are regular expression strings (not
|
||||
compiled expressions!)
|
||||
"""
|
||||
|
||||
def __init__(self, text, flags=0):
|
||||
"""
|
||||
:param text: The text which should be scanned
|
||||
:param flags: default regular expression flags
|
||||
"""
|
||||
self.data = text
|
||||
self.data_length = len(text)
|
||||
self.start_pos = 0
|
||||
self.pos = 0
|
||||
self.flags = flags
|
||||
self.last = None
|
||||
self.match = None
|
||||
self._re_cache = {}
|
||||
|
||||
def eos(self):
|
||||
"""`True` if the scanner reached the end of text."""
|
||||
return self.pos >= self.data_length
|
||||
eos = property(eos, eos.__doc__)
|
||||
|
||||
def check(self, pattern):
|
||||
"""
|
||||
Apply `pattern` on the current position and return
|
||||
the match object. (Doesn't touch pos). Use this for
|
||||
lookahead.
|
||||
"""
|
||||
if self.eos:
|
||||
raise EndOfText()
|
||||
if pattern not in self._re_cache:
|
||||
self._re_cache[pattern] = re.compile(pattern, self.flags)
|
||||
return self._re_cache[pattern].match(self.data, self.pos)
|
||||
|
||||
def test(self, pattern):
|
||||
"""Apply a pattern on the current position and check
|
||||
if it patches. Doesn't touch pos."""
|
||||
return self.check(pattern) is not None
|
||||
|
||||
def scan(self, pattern):
|
||||
"""
|
||||
Scan the text for the given pattern and update pos/match
|
||||
and related fields. The return value is a boolen that
|
||||
indicates if the pattern matched. The matched value is
|
||||
stored on the instance as ``match``, the last value is
|
||||
stored as ``last``. ``start_pos`` is the position of the
|
||||
pointer before the pattern was matched, ``pos`` is the
|
||||
end position.
|
||||
"""
|
||||
if self.eos:
|
||||
raise EndOfText()
|
||||
if pattern not in self._re_cache:
|
||||
self._re_cache[pattern] = re.compile(pattern, self.flags)
|
||||
self.last = self.match
|
||||
m = self._re_cache[pattern].match(self.data, self.pos)
|
||||
if m is None:
|
||||
return False
|
||||
self.start_pos = m.start()
|
||||
self.pos = m.end()
|
||||
self.match = m.group()
|
||||
return True
|
||||
|
||||
def get_char(self):
|
||||
"""Scan exactly one char."""
|
||||
self.scan('.')
|
||||
|
||||
def __repr__(self):
|
||||
return '<%s %d/%d>' % (
|
||||
self.__class__.__name__,
|
||||
self.pos,
|
||||
self.data_length
|
||||
)
|
|
@ -0,0 +1,117 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.style
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
Basic style object.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.token import Token, STANDARD_TYPES
|
||||
|
||||
|
||||
class StyleMeta(type):
|
||||
|
||||
def __new__(mcs, name, bases, dct):
|
||||
obj = type.__new__(mcs, name, bases, dct)
|
||||
for token in STANDARD_TYPES:
|
||||
if token not in obj.styles:
|
||||
obj.styles[token] = ''
|
||||
|
||||
def colorformat(text):
|
||||
if text[0:1] == '#':
|
||||
col = text[1:]
|
||||
if len(col) == 6:
|
||||
return col
|
||||
elif len(col) == 3:
|
||||
return col[0]*2 + col[1]*2 + col[2]*2
|
||||
elif text == '':
|
||||
return ''
|
||||
assert False, "wrong color format %r" % text
|
||||
|
||||
_styles = obj._styles = {}
|
||||
|
||||
for ttype in obj.styles:
|
||||
for token in ttype.split():
|
||||
if token in _styles:
|
||||
continue
|
||||
ndef = _styles.get(token.parent, None)
|
||||
styledefs = obj.styles.get(token, '').split()
|
||||
if not ndef or token is None:
|
||||
ndef = ['', 0, 0, 0, '', '', 0, 0, 0]
|
||||
elif 'noinherit' in styledefs and token is not Token:
|
||||
ndef = _styles[Token][:]
|
||||
else:
|
||||
ndef = ndef[:]
|
||||
_styles[token] = ndef
|
||||
for styledef in obj.styles.get(token, '').split():
|
||||
if styledef == 'noinherit':
|
||||
pass
|
||||
elif styledef == 'bold':
|
||||
ndef[1] = 1
|
||||
elif styledef == 'nobold':
|
||||
ndef[1] = 0
|
||||
elif styledef == 'italic':
|
||||
ndef[2] = 1
|
||||
elif styledef == 'noitalic':
|
||||
ndef[2] = 0
|
||||
elif styledef == 'underline':
|
||||
ndef[3] = 1
|
||||
elif styledef == 'nounderline':
|
||||
ndef[3] = 0
|
||||
elif styledef[:3] == 'bg:':
|
||||
ndef[4] = colorformat(styledef[3:])
|
||||
elif styledef[:7] == 'border:':
|
||||
ndef[5] = colorformat(styledef[7:])
|
||||
elif styledef == 'roman':
|
||||
ndef[6] = 1
|
||||
elif styledef == 'sans':
|
||||
ndef[7] = 1
|
||||
elif styledef == 'mono':
|
||||
ndef[8] = 1
|
||||
else:
|
||||
ndef[0] = colorformat(styledef)
|
||||
|
||||
return obj
|
||||
|
||||
def style_for_token(cls, token):
|
||||
t = cls._styles[token]
|
||||
return {
|
||||
'color': t[0] or None,
|
||||
'bold': bool(t[1]),
|
||||
'italic': bool(t[2]),
|
||||
'underline': bool(t[3]),
|
||||
'bgcolor': t[4] or None,
|
||||
'border': t[5] or None,
|
||||
'roman': bool(t[6]) or None,
|
||||
'sans': bool(t[7]) or None,
|
||||
'mono': bool(t[8]) or None,
|
||||
}
|
||||
|
||||
def list_styles(cls):
|
||||
return list(cls)
|
||||
|
||||
def styles_token(cls, ttype):
|
||||
return ttype in cls._styles
|
||||
|
||||
def __iter__(cls):
|
||||
for token in cls._styles:
|
||||
yield token, cls.style_for_token(token)
|
||||
|
||||
def __len__(cls):
|
||||
return len(cls._styles)
|
||||
|
||||
|
||||
class Style(object):
|
||||
__metaclass__ = StyleMeta
|
||||
|
||||
#: overall background color (``None`` means transparent)
|
||||
background_color = '#ffffff'
|
||||
|
||||
#: highlight background color
|
||||
highlight_color = '#ffffcc'
|
||||
|
||||
#: Style definitions for individual token types.
|
||||
styles = {}
|
|
@ -0,0 +1,70 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles
|
||||
~~~~~~~~~~~~~~~
|
||||
|
||||
Contains built-in styles.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.plugin import find_plugin_styles
|
||||
from pygments.util import ClassNotFound
|
||||
|
||||
|
||||
#: Maps style names to 'submodule::classname'.
|
||||
STYLE_MAP = {
|
||||
'default': 'default::DefaultStyle',
|
||||
'emacs': 'emacs::EmacsStyle',
|
||||
'friendly': 'friendly::FriendlyStyle',
|
||||
'colorful': 'colorful::ColorfulStyle',
|
||||
'autumn': 'autumn::AutumnStyle',
|
||||
'murphy': 'murphy::MurphyStyle',
|
||||
'manni': 'manni::ManniStyle',
|
||||
'monokai': 'monokai::MonokaiStyle',
|
||||
'perldoc': 'perldoc::PerldocStyle',
|
||||
'pastie': 'pastie::PastieStyle',
|
||||
'borland': 'borland::BorlandStyle',
|
||||
'trac': 'trac::TracStyle',
|
||||
'native': 'native::NativeStyle',
|
||||
'fruity': 'fruity::FruityStyle',
|
||||
'bw': 'bw::BlackWhiteStyle',
|
||||
'vim': 'vim::VimStyle',
|
||||
'vs': 'vs::VisualStudioStyle',
|
||||
'tango': 'tango::TangoStyle',
|
||||
'rrt': 'rrt::RrtStyle',
|
||||
}
|
||||
|
||||
|
||||
def get_style_by_name(name):
|
||||
if name in STYLE_MAP:
|
||||
mod, cls = STYLE_MAP[name].split('::')
|
||||
builtin = "yes"
|
||||
else:
|
||||
for found_name, style in find_plugin_styles():
|
||||
if name == found_name:
|
||||
return style
|
||||
# perhaps it got dropped into our styles package
|
||||
builtin = ""
|
||||
mod = name
|
||||
cls = name.title() + "Style"
|
||||
|
||||
try:
|
||||
mod = __import__('pygments.styles.' + mod, None, None, [cls])
|
||||
except ImportError:
|
||||
raise ClassNotFound("Could not find style module %r" % mod +
|
||||
(builtin and ", though it should be builtin") + ".")
|
||||
try:
|
||||
return getattr(mod, cls)
|
||||
except AttributeError:
|
||||
raise ClassNotFound("Could not find style class %r in style module." % cls)
|
||||
|
||||
|
||||
def get_all_styles():
|
||||
"""Return an generator for all styles by name,
|
||||
both builtin and plugin."""
|
||||
for name in STYLE_MAP:
|
||||
yield name
|
||||
for name, _ in find_plugin_styles():
|
||||
yield name
|
|
@ -0,0 +1,65 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.autumn
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A colorful style, inspired by the terminal highlighting style.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class AutumnStyle(Style):
|
||||
"""
|
||||
A colorful style, inspired by the terminal highlighting style.
|
||||
"""
|
||||
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
|
||||
Comment: 'italic #aaaaaa',
|
||||
Comment.Preproc: 'noitalic #4c8317',
|
||||
Comment.Special: 'italic #0000aa',
|
||||
|
||||
Keyword: '#0000aa',
|
||||
Keyword.Type: '#00aaaa',
|
||||
|
||||
Operator.Word: '#0000aa',
|
||||
|
||||
Name.Builtin: '#00aaaa',
|
||||
Name.Function: '#00aa00',
|
||||
Name.Class: 'underline #00aa00',
|
||||
Name.Namespace: 'underline #00aaaa',
|
||||
Name.Variable: '#aa0000',
|
||||
Name.Constant: '#aa0000',
|
||||
Name.Entity: 'bold #800',
|
||||
Name.Attribute: '#1e90ff',
|
||||
Name.Tag: 'bold #1e90ff',
|
||||
Name.Decorator: '#888888',
|
||||
|
||||
String: '#aa5500',
|
||||
String.Symbol: '#0000aa',
|
||||
String.Regex: '#009999',
|
||||
|
||||
Number: '#009999',
|
||||
|
||||
Generic.Heading: 'bold #000080',
|
||||
Generic.Subheading: 'bold #800080',
|
||||
Generic.Deleted: '#aa0000',
|
||||
Generic.Inserted: '#00aa00',
|
||||
Generic.Error: '#aa0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#555555',
|
||||
Generic.Output: '#888888',
|
||||
Generic.Traceback: '#aa0000',
|
||||
|
||||
Error: '#F00 bg:#FAA'
|
||||
}
|
|
@ -0,0 +1,51 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.borland
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Style similar to the style used in the Borland IDEs.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class BorlandStyle(Style):
|
||||
"""
|
||||
Style similar to the style used in the borland IDEs.
|
||||
"""
|
||||
|
||||
default_style = ''
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
|
||||
Comment: 'italic #008800',
|
||||
Comment.Preproc: 'noitalic #008080',
|
||||
Comment.Special: 'noitalic bold',
|
||||
|
||||
String: '#0000FF',
|
||||
String.Char: '#800080',
|
||||
Number: '#0000FF',
|
||||
Keyword: 'bold #000080',
|
||||
Operator.Word: 'bold',
|
||||
Name.Tag: 'bold #000080',
|
||||
Name.Attribute: '#FF0000',
|
||||
|
||||
Generic.Heading: '#999999',
|
||||
Generic.Subheading: '#aaaaaa',
|
||||
Generic.Deleted: 'bg:#ffdddd #000000',
|
||||
Generic.Inserted: 'bg:#ddffdd #000000',
|
||||
Generic.Error: '#aa0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#555555',
|
||||
Generic.Output: '#888888',
|
||||
Generic.Traceback: '#aa0000',
|
||||
|
||||
Error: 'bg:#e3d2d2 #a61717'
|
||||
}
|
|
@ -0,0 +1,49 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.bw
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Simple black/white only style.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Operator, Generic
|
||||
|
||||
|
||||
class BlackWhiteStyle(Style):
|
||||
|
||||
background_color = "#ffffff"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Comment: "italic",
|
||||
Comment.Preproc: "noitalic",
|
||||
|
||||
Keyword: "bold",
|
||||
Keyword.Pseudo: "nobold",
|
||||
Keyword.Type: "nobold",
|
||||
|
||||
Operator.Word: "bold",
|
||||
|
||||
Name.Class: "bold",
|
||||
Name.Namespace: "bold",
|
||||
Name.Exception: "bold",
|
||||
Name.Entity: "bold",
|
||||
Name.Tag: "bold",
|
||||
|
||||
String: "italic",
|
||||
String.Interpol: "bold",
|
||||
String.Escape: "bold",
|
||||
|
||||
Generic.Heading: "bold",
|
||||
Generic.Subheading: "bold",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,81 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.colorful
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A colorful style, inspired by CodeRay.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class ColorfulStyle(Style):
|
||||
"""
|
||||
A colorful style, inspired by CodeRay.
|
||||
"""
|
||||
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: "#bbbbbb",
|
||||
|
||||
Comment: "#888",
|
||||
Comment.Preproc: "#579",
|
||||
Comment.Special: "bold #cc0000",
|
||||
|
||||
Keyword: "bold #080",
|
||||
Keyword.Pseudo: "#038",
|
||||
Keyword.Type: "#339",
|
||||
|
||||
Operator: "#333",
|
||||
Operator.Word: "bold #000",
|
||||
|
||||
Name.Builtin: "#007020",
|
||||
Name.Function: "bold #06B",
|
||||
Name.Class: "bold #B06",
|
||||
Name.Namespace: "bold #0e84b5",
|
||||
Name.Exception: "bold #F00",
|
||||
Name.Variable: "#963",
|
||||
Name.Variable.Instance: "#33B",
|
||||
Name.Variable.Class: "#369",
|
||||
Name.Variable.Global: "bold #d70",
|
||||
Name.Constant: "bold #036",
|
||||
Name.Label: "bold #970",
|
||||
Name.Entity: "bold #800",
|
||||
Name.Attribute: "#00C",
|
||||
Name.Tag: "#070",
|
||||
Name.Decorator: "bold #555",
|
||||
|
||||
String: "bg:#fff0f0",
|
||||
String.Char: "#04D bg:",
|
||||
String.Doc: "#D42 bg:",
|
||||
String.Interpol: "bg:#eee",
|
||||
String.Escape: "bold #666",
|
||||
String.Regex: "bg:#fff0ff #000",
|
||||
String.Symbol: "#A60 bg:",
|
||||
String.Other: "#D20",
|
||||
|
||||
Number: "bold #60E",
|
||||
Number.Integer: "bold #00D",
|
||||
Number.Float: "bold #60E",
|
||||
Number.Hex: "bold #058",
|
||||
Number.Oct: "bold #40E",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#A00000",
|
||||
Generic.Inserted: "#00A000",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #c65d09",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "#F00 bg:#FAA"
|
||||
}
|
|
@ -0,0 +1,73 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.default
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The default highlighting style.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class DefaultStyle(Style):
|
||||
"""
|
||||
The default style (inspired by Emacs 22).
|
||||
"""
|
||||
|
||||
background_color = "#f8f8f8"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: "#bbbbbb",
|
||||
Comment: "italic #408080",
|
||||
Comment.Preproc: "noitalic #BC7A00",
|
||||
|
||||
#Keyword: "bold #AA22FF",
|
||||
Keyword: "bold #008000",
|
||||
Keyword.Pseudo: "nobold",
|
||||
Keyword.Type: "nobold #B00040",
|
||||
|
||||
Operator: "#666666",
|
||||
Operator.Word: "bold #AA22FF",
|
||||
|
||||
Name.Builtin: "#008000",
|
||||
Name.Function: "#0000FF",
|
||||
Name.Class: "bold #0000FF",
|
||||
Name.Namespace: "bold #0000FF",
|
||||
Name.Exception: "bold #D2413A",
|
||||
Name.Variable: "#19177C",
|
||||
Name.Constant: "#880000",
|
||||
Name.Label: "#A0A000",
|
||||
Name.Entity: "bold #999999",
|
||||
Name.Attribute: "#7D9029",
|
||||
Name.Tag: "bold #008000",
|
||||
Name.Decorator: "#AA22FF",
|
||||
|
||||
String: "#BA2121",
|
||||
String.Doc: "italic",
|
||||
String.Interpol: "bold #BB6688",
|
||||
String.Escape: "bold #BB6622",
|
||||
String.Regex: "#BB6688",
|
||||
#String.Symbol: "#B8860B",
|
||||
String.Symbol: "#19177C",
|
||||
String.Other: "#008000",
|
||||
Number: "#666666",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#A00000",
|
||||
Generic.Inserted: "#00A000",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #000080",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,72 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.emacs
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A highlighting style for Pygments, inspired by Emacs.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class EmacsStyle(Style):
|
||||
"""
|
||||
The default style (inspired by Emacs 22).
|
||||
"""
|
||||
|
||||
background_color = "#f8f8f8"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: "#bbbbbb",
|
||||
Comment: "italic #008800",
|
||||
Comment.Preproc: "noitalic",
|
||||
Comment.Special: "noitalic bold",
|
||||
|
||||
Keyword: "bold #AA22FF",
|
||||
Keyword.Pseudo: "nobold",
|
||||
Keyword.Type: "bold #00BB00",
|
||||
|
||||
Operator: "#666666",
|
||||
Operator.Word: "bold #AA22FF",
|
||||
|
||||
Name.Builtin: "#AA22FF",
|
||||
Name.Function: "#00A000",
|
||||
Name.Class: "#0000FF",
|
||||
Name.Namespace: "bold #0000FF",
|
||||
Name.Exception: "bold #D2413A",
|
||||
Name.Variable: "#B8860B",
|
||||
Name.Constant: "#880000",
|
||||
Name.Label: "#A0A000",
|
||||
Name.Entity: "bold #999999",
|
||||
Name.Attribute: "#BB4444",
|
||||
Name.Tag: "bold #008000",
|
||||
Name.Decorator: "#AA22FF",
|
||||
|
||||
String: "#BB4444",
|
||||
String.Doc: "italic",
|
||||
String.Interpol: "bold #BB6688",
|
||||
String.Escape: "bold #BB6622",
|
||||
String.Regex: "#BB6688",
|
||||
String.Symbol: "#B8860B",
|
||||
String.Other: "#008000",
|
||||
Number: "#666666",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#A00000",
|
||||
Generic.Inserted: "#00A000",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #000080",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,72 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.friendly
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A modern style based on the VIM pyte theme.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class FriendlyStyle(Style):
|
||||
"""
|
||||
A modern style based on the VIM pyte theme.
|
||||
"""
|
||||
|
||||
background_color = "#f0f0f0"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: "#bbbbbb",
|
||||
Comment: "italic #60a0b0",
|
||||
Comment.Preproc: "noitalic #007020",
|
||||
Comment.Special: "noitalic bg:#fff0f0",
|
||||
|
||||
Keyword: "bold #007020",
|
||||
Keyword.Pseudo: "nobold",
|
||||
Keyword.Type: "nobold #902000",
|
||||
|
||||
Operator: "#666666",
|
||||
Operator.Word: "bold #007020",
|
||||
|
||||
Name.Builtin: "#007020",
|
||||
Name.Function: "#06287e",
|
||||
Name.Class: "bold #0e84b5",
|
||||
Name.Namespace: "bold #0e84b5",
|
||||
Name.Exception: "#007020",
|
||||
Name.Variable: "#bb60d5",
|
||||
Name.Constant: "#60add5",
|
||||
Name.Label: "bold #002070",
|
||||
Name.Entity: "bold #d55537",
|
||||
Name.Attribute: "#4070a0",
|
||||
Name.Tag: "bold #062873",
|
||||
Name.Decorator: "bold #555555",
|
||||
|
||||
String: "#4070a0",
|
||||
String.Doc: "italic",
|
||||
String.Interpol: "italic #70a0d0",
|
||||
String.Escape: "bold #4070a0",
|
||||
String.Regex: "#235388",
|
||||
String.Symbol: "#517918",
|
||||
String.Other: "#c65d09",
|
||||
Number: "#40a070",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#A00000",
|
||||
Generic.Inserted: "#00A000",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #c65d09",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,42 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.fruity
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
pygments version of my "fruity" vim theme.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Token, Comment, Name, Keyword, \
|
||||
Generic, Number, String, Whitespace
|
||||
|
||||
class FruityStyle(Style):
|
||||
"""
|
||||
Pygments version of the "native" vim theme.
|
||||
"""
|
||||
|
||||
background_color = '#111111'
|
||||
highlight_color = '#333333'
|
||||
|
||||
styles = {
|
||||
Whitespace: '#888888',
|
||||
Token: '#ffffff',
|
||||
Generic.Output: '#444444 bg:#222222',
|
||||
Keyword: '#fb660a bold',
|
||||
Keyword.Pseudo: 'nobold',
|
||||
Number: '#0086f7 bold',
|
||||
Name.Tag: '#fb660a bold',
|
||||
Name.Variable: '#fb660a',
|
||||
Comment: '#008800 bg:#0f140f italic',
|
||||
Name.Attribute: '#ff0086 bold',
|
||||
String: '#0086d2',
|
||||
Name.Function: '#ff0086 bold',
|
||||
Generic.Heading: '#ffffff bold',
|
||||
Keyword.Type: '#cdcaa9 bold',
|
||||
Generic.Subheading: '#ffffff bold',
|
||||
Name.Constant: '#0086d2',
|
||||
Comment.Preproc: '#ff0007 bold'
|
||||
}
|
|
@ -0,0 +1,75 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.manni
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A colorful style, inspired by the terminal highlighting style.
|
||||
|
||||
This is a port of the style used in the `php port`_ of pygments
|
||||
by Manni. The style is called 'default' there.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class ManniStyle(Style):
|
||||
"""
|
||||
A colorful style, inspired by the terminal highlighting style.
|
||||
"""
|
||||
|
||||
background_color = '#f0f3f3'
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
Comment: 'italic #0099FF',
|
||||
Comment.Preproc: 'noitalic #009999',
|
||||
Comment.Special: 'bold',
|
||||
|
||||
Keyword: 'bold #006699',
|
||||
Keyword.Pseudo: 'nobold',
|
||||
Keyword.Type: '#007788',
|
||||
|
||||
Operator: '#555555',
|
||||
Operator.Word: 'bold #000000',
|
||||
|
||||
Name.Builtin: '#336666',
|
||||
Name.Function: '#CC00FF',
|
||||
Name.Class: 'bold #00AA88',
|
||||
Name.Namespace: 'bold #00CCFF',
|
||||
Name.Exception: 'bold #CC0000',
|
||||
Name.Variable: '#003333',
|
||||
Name.Constant: '#336600',
|
||||
Name.Label: '#9999FF',
|
||||
Name.Entity: 'bold #999999',
|
||||
Name.Attribute: '#330099',
|
||||
Name.Tag: 'bold #330099',
|
||||
Name.Decorator: '#9999FF',
|
||||
|
||||
String: '#CC3300',
|
||||
String.Doc: 'italic',
|
||||
String.Interpol: '#AA0000',
|
||||
String.Escape: 'bold #CC3300',
|
||||
String.Regex: '#33AAAA',
|
||||
String.Symbol: '#FFCC33',
|
||||
String.Other: '#CC3300',
|
||||
|
||||
Number: '#FF6600',
|
||||
|
||||
Generic.Heading: 'bold #003300',
|
||||
Generic.Subheading: 'bold #003300',
|
||||
Generic.Deleted: 'border:#CC0000 bg:#FFCCCC',
|
||||
Generic.Inserted: 'border:#00CC00 bg:#CCFFCC',
|
||||
Generic.Error: '#FF0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: 'bold #000099',
|
||||
Generic.Output: '#AAAAAA',
|
||||
Generic.Traceback: '#99CC66',
|
||||
|
||||
Error: 'bg:#FFAAAA #AA0000'
|
||||
}
|
|
@ -0,0 +1,106 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.monokai
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Mimic the Monokai color scheme. Based on tango.py.
|
||||
|
||||
http://www.monokai.nl/blog/2006/07/15/textmate-color-theme/
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, Text, \
|
||||
Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
|
||||
|
||||
class MonokaiStyle(Style):
|
||||
"""
|
||||
This style mimics the Monokai color scheme.
|
||||
"""
|
||||
|
||||
background_color = "#272822"
|
||||
highlight_color = "#49483e"
|
||||
|
||||
styles = {
|
||||
# No corresponding class for the following:
|
||||
Text: "#f8f8f2", # class: ''
|
||||
Whitespace: "", # class: 'w'
|
||||
Error: "#960050 bg:#1e0010", # class: 'err'
|
||||
Other: "", # class 'x'
|
||||
|
||||
Comment: "#75715e", # class: 'c'
|
||||
Comment.Multiline: "", # class: 'cm'
|
||||
Comment.Preproc: "", # class: 'cp'
|
||||
Comment.Single: "", # class: 'c1'
|
||||
Comment.Special: "", # class: 'cs'
|
||||
|
||||
Keyword: "#66d9ef", # class: 'k'
|
||||
Keyword.Constant: "", # class: 'kc'
|
||||
Keyword.Declaration: "", # class: 'kd'
|
||||
Keyword.Namespace: "#f92672", # class: 'kn'
|
||||
Keyword.Pseudo: "", # class: 'kp'
|
||||
Keyword.Reserved: "", # class: 'kr'
|
||||
Keyword.Type: "", # class: 'kt'
|
||||
|
||||
Operator: "#f92672", # class: 'o'
|
||||
Operator.Word: "", # class: 'ow' - like keywords
|
||||
|
||||
Punctuation: "#f8f8f2", # class: 'p'
|
||||
|
||||
Name: "#f8f8f2", # class: 'n'
|
||||
Name.Attribute: "#a6e22e", # class: 'na' - to be revised
|
||||
Name.Builtin: "", # class: 'nb'
|
||||
Name.Builtin.Pseudo: "", # class: 'bp'
|
||||
Name.Class: "#a6e22e", # class: 'nc' - to be revised
|
||||
Name.Constant: "#66d9ef", # class: 'no' - to be revised
|
||||
Name.Decorator: "#a6e22e", # class: 'nd' - to be revised
|
||||
Name.Entity: "", # class: 'ni'
|
||||
Name.Exception: "#a6e22e", # class: 'ne'
|
||||
Name.Function: "#a6e22e", # class: 'nf'
|
||||
Name.Property: "", # class: 'py'
|
||||
Name.Label: "", # class: 'nl'
|
||||
Name.Namespace: "", # class: 'nn' - to be revised
|
||||
Name.Other: "#a6e22e", # class: 'nx'
|
||||
Name.Tag: "#f92672", # class: 'nt' - like a keyword
|
||||
Name.Variable: "", # class: 'nv' - to be revised
|
||||
Name.Variable.Class: "", # class: 'vc' - to be revised
|
||||
Name.Variable.Global: "", # class: 'vg' - to be revised
|
||||
Name.Variable.Instance: "", # class: 'vi' - to be revised
|
||||
|
||||
Number: "#ae81ff", # class: 'm'
|
||||
Number.Float: "", # class: 'mf'
|
||||
Number.Hex: "", # class: 'mh'
|
||||
Number.Integer: "", # class: 'mi'
|
||||
Number.Integer.Long: "", # class: 'il'
|
||||
Number.Oct: "", # class: 'mo'
|
||||
|
||||
Literal: "#ae81ff", # class: 'l'
|
||||
Literal.Date: "#e6db74", # class: 'ld'
|
||||
|
||||
String: "#e6db74", # class: 's'
|
||||
String.Backtick: "", # class: 'sb'
|
||||
String.Char: "", # class: 'sc'
|
||||
String.Doc: "", # class: 'sd' - like a comment
|
||||
String.Double: "", # class: 's2'
|
||||
String.Escape: "#ae81ff", # class: 'se'
|
||||
String.Heredoc: "", # class: 'sh'
|
||||
String.Interpol: "", # class: 'si'
|
||||
String.Other: "", # class: 'sx'
|
||||
String.Regex: "", # class: 'sr'
|
||||
String.Single: "", # class: 's1'
|
||||
String.Symbol: "", # class: 'ss'
|
||||
|
||||
Generic: "", # class: 'g'
|
||||
Generic.Deleted: "", # class: 'gd',
|
||||
Generic.Emph: "italic", # class: 'ge'
|
||||
Generic.Error: "", # class: 'gr'
|
||||
Generic.Heading: "", # class: 'gh'
|
||||
Generic.Inserted: "", # class: 'gi'
|
||||
Generic.Output: "", # class: 'go'
|
||||
Generic.Prompt: "", # class: 'gp'
|
||||
Generic.Strong: "bold", # class: 'gs'
|
||||
Generic.Subheading: "", # class: 'gu'
|
||||
Generic.Traceback: "", # class: 'gt'
|
||||
}
|
|
@ -0,0 +1,80 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.murphy
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Murphy's style from CodeRay.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class MurphyStyle(Style):
|
||||
"""
|
||||
Murphy's style from CodeRay.
|
||||
"""
|
||||
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Whitespace: "#bbbbbb",
|
||||
Comment: "#666 italic",
|
||||
Comment.Preproc: "#579 noitalic",
|
||||
Comment.Special: "#c00 bold",
|
||||
|
||||
Keyword: "bold #289",
|
||||
Keyword.Pseudo: "#08f",
|
||||
Keyword.Type: "#66f",
|
||||
|
||||
Operator: "#333",
|
||||
Operator.Word: "bold #000",
|
||||
|
||||
Name.Builtin: "#072",
|
||||
Name.Function: "bold #5ed",
|
||||
Name.Class: "bold #e9e",
|
||||
Name.Namespace: "bold #0e84b5",
|
||||
Name.Exception: "bold #F00",
|
||||
Name.Variable: "#036",
|
||||
Name.Variable.Instance: "#aaf",
|
||||
Name.Variable.Class: "#ccf",
|
||||
Name.Variable.Global: "#f84",
|
||||
Name.Constant: "bold #5ed",
|
||||
Name.Label: "bold #970",
|
||||
Name.Entity: "#800",
|
||||
Name.Attribute: "#007",
|
||||
Name.Tag: "#070",
|
||||
Name.Decorator: "bold #555",
|
||||
|
||||
String: "bg:#e0e0ff",
|
||||
String.Char: "#88F bg:",
|
||||
String.Doc: "#D42 bg:",
|
||||
String.Interpol: "bg:#eee",
|
||||
String.Escape: "bold #666",
|
||||
String.Regex: "bg:#e0e0ff #000",
|
||||
String.Symbol: "#fc8 bg:",
|
||||
String.Other: "#f88",
|
||||
|
||||
Number: "bold #60E",
|
||||
Number.Integer: "bold #66f",
|
||||
Number.Float: "bold #60E",
|
||||
Number.Hex: "bold #058",
|
||||
Number.Oct: "bold #40E",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#A00000",
|
||||
Generic.Inserted: "#00A000",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #c65d09",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "#F00 bg:#FAA"
|
||||
}
|
|
@ -0,0 +1,65 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.native
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
pygments version of my "native" vim theme.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Token, Whitespace
|
||||
|
||||
|
||||
class NativeStyle(Style):
|
||||
"""
|
||||
Pygments version of the "native" vim theme.
|
||||
"""
|
||||
|
||||
background_color = '#202020'
|
||||
highlight_color = '#404040'
|
||||
|
||||
styles = {
|
||||
Token: '#d0d0d0',
|
||||
Whitespace: '#666666',
|
||||
|
||||
Comment: 'italic #999999',
|
||||
Comment.Preproc: 'noitalic bold #cd2828',
|
||||
Comment.Special: 'noitalic bold #e50808 bg:#520000',
|
||||
|
||||
Keyword: 'bold #6ab825',
|
||||
Keyword.Pseudo: 'nobold',
|
||||
Operator.Word: 'bold #6ab825',
|
||||
|
||||
String: '#ed9d13',
|
||||
String.Other: '#ffa500',
|
||||
|
||||
Number: '#3677a9',
|
||||
|
||||
Name.Builtin: '#24909d',
|
||||
Name.Variable: '#40ffff',
|
||||
Name.Constant: '#40ffff',
|
||||
Name.Class: 'underline #447fcf',
|
||||
Name.Function: '#447fcf',
|
||||
Name.Namespace: 'underline #447fcf',
|
||||
Name.Exception: '#bbbbbb',
|
||||
Name.Tag: 'bold #6ab825',
|
||||
Name.Attribute: '#bbbbbb',
|
||||
Name.Decorator: '#ffa500',
|
||||
|
||||
Generic.Heading: 'bold #ffffff',
|
||||
Generic.Subheading: 'underline #ffffff',
|
||||
Generic.Deleted: '#d22323',
|
||||
Generic.Inserted: '#589819',
|
||||
Generic.Error: '#d22323',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#aaaaaa',
|
||||
Generic.Output: '#cccccc',
|
||||
Generic.Traceback: '#d22323',
|
||||
|
||||
Error: 'bg:#e3d2d2 #a61717'
|
||||
}
|
|
@ -0,0 +1,75 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.pastie
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Style similar to the `pastie`_ default style.
|
||||
|
||||
.. _pastie: http://pastie.caboo.se/
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class PastieStyle(Style):
|
||||
"""
|
||||
Style similar to the pastie default style.
|
||||
"""
|
||||
|
||||
default_style = ''
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
Comment: '#888888',
|
||||
Comment.Preproc: 'bold #cc0000',
|
||||
Comment.Special: 'bg:#fff0f0 bold #cc0000',
|
||||
|
||||
String: 'bg:#fff0f0 #dd2200',
|
||||
String.Regex: 'bg:#fff0ff #008800',
|
||||
String.Other: 'bg:#f0fff0 #22bb22',
|
||||
String.Symbol: '#aa6600',
|
||||
String.Interpol: '#3333bb',
|
||||
String.Escape: '#0044dd',
|
||||
|
||||
Operator.Word: '#008800',
|
||||
|
||||
Keyword: 'bold #008800',
|
||||
Keyword.Pseudo: 'nobold',
|
||||
Keyword.Type: '#888888',
|
||||
|
||||
Name.Class: 'bold #bb0066',
|
||||
Name.Exception: 'bold #bb0066',
|
||||
Name.Function: 'bold #0066bb',
|
||||
Name.Property: 'bold #336699',
|
||||
Name.Namespace: 'bold #bb0066',
|
||||
Name.Builtin: '#003388',
|
||||
Name.Variable: '#336699',
|
||||
Name.Variable.Class: '#336699',
|
||||
Name.Variable.Instance: '#3333bb',
|
||||
Name.Variable.Global: '#dd7700',
|
||||
Name.Constant: 'bold #003366',
|
||||
Name.Tag: 'bold #bb0066',
|
||||
Name.Attribute: '#336699',
|
||||
Name.Decorator: '#555555',
|
||||
Name.Label: 'italic #336699',
|
||||
|
||||
Number: 'bold #0000DD',
|
||||
|
||||
Generic.Heading: '#333',
|
||||
Generic.Subheading: '#666',
|
||||
Generic.Deleted: 'bg:#ffdddd #000000',
|
||||
Generic.Inserted: 'bg:#ddffdd #000000',
|
||||
Generic.Error: '#aa0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#555555',
|
||||
Generic.Output: '#888888',
|
||||
Generic.Traceback: '#aa0000',
|
||||
|
||||
Error: 'bg:#e3d2d2 #a61717'
|
||||
}
|
|
@ -0,0 +1,69 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.perldoc
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Style similar to the style used in the `perldoc`_ code blocks.
|
||||
|
||||
.. _perldoc: http://perldoc.perl.org/
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class PerldocStyle(Style):
|
||||
"""
|
||||
Style similar to the style used in the perldoc code blocks.
|
||||
"""
|
||||
|
||||
background_color = '#eeeedd'
|
||||
default_style = ''
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
Comment: '#228B22',
|
||||
Comment.Preproc: '#1e889b',
|
||||
Comment.Special: '#8B008B bold',
|
||||
|
||||
String: '#CD5555',
|
||||
String.Heredoc: '#1c7e71 italic',
|
||||
String.Regex: '#B452CD',
|
||||
String.Other: '#cb6c20',
|
||||
String.Regex: '#1c7e71',
|
||||
|
||||
Number: '#B452CD',
|
||||
|
||||
Operator.Word: '#8B008B',
|
||||
|
||||
Keyword: '#8B008B bold',
|
||||
Keyword.Type: '#a7a7a7',
|
||||
|
||||
Name.Class: '#008b45 bold',
|
||||
Name.Exception: '#008b45 bold',
|
||||
Name.Function: '#008b45',
|
||||
Name.Namespace: '#008b45 underline',
|
||||
Name.Variable: '#00688B',
|
||||
Name.Constant: '#00688B',
|
||||
Name.Decorator: '#707a7c',
|
||||
Name.Tag: '#8B008B bold',
|
||||
Name.Attribute: '#658b00',
|
||||
Name.Builtin: '#658b00',
|
||||
|
||||
Generic.Heading: 'bold #000080',
|
||||
Generic.Subheading: 'bold #800080',
|
||||
Generic.Deleted: '#aa0000',
|
||||
Generic.Inserted: '#00aa00',
|
||||
Generic.Error: '#aa0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#555555',
|
||||
Generic.Output: '#888888',
|
||||
Generic.Traceback: '#aa0000',
|
||||
|
||||
Error: 'bg:#e3d2d2 #a61717'
|
||||
}
|
|
@ -0,0 +1,33 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.rrt
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
pygments "rrt" theme, based on Zap and Emacs defaults.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Comment, Name, Keyword, String
|
||||
|
||||
|
||||
class RrtStyle(Style):
|
||||
"""
|
||||
Minimalistic "rrt" theme, based on Zap and Emacs defaults.
|
||||
"""
|
||||
|
||||
background_color = '#000000'
|
||||
highlight_color = '#0000ff'
|
||||
|
||||
styles = {
|
||||
Comment: '#00ff00',
|
||||
Name.Function: '#ffff00',
|
||||
Name.Variable: '#eedd82',
|
||||
Name.Constant: '#7fffd4',
|
||||
Keyword: '#ff0000',
|
||||
Comment.Preproc: '#e5e5e5',
|
||||
String: '#87ceeb',
|
||||
Keyword.Type: '#ee82ee',
|
||||
}
|
|
@ -0,0 +1,141 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.tango
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The Crunchy default Style inspired from the color palette from
|
||||
the Tango Icon Theme Guidelines.
|
||||
|
||||
http://tango.freedesktop.org/Tango_Icon_Theme_Guidelines
|
||||
|
||||
Butter: #fce94f #edd400 #c4a000
|
||||
Orange: #fcaf3e #f57900 #ce5c00
|
||||
Chocolate: #e9b96e #c17d11 #8f5902
|
||||
Chameleon: #8ae234 #73d216 #4e9a06
|
||||
Sky Blue: #729fcf #3465a4 #204a87
|
||||
Plum: #ad7fa8 #75507b #5c35cc
|
||||
Scarlet Red:#ef2929 #cc0000 #a40000
|
||||
Aluminium: #eeeeec #d3d7cf #babdb6
|
||||
#888a85 #555753 #2e3436
|
||||
|
||||
Not all of the above colors are used; other colors added:
|
||||
very light grey: #f8f8f8 (for background)
|
||||
|
||||
This style can be used as a template as it includes all the known
|
||||
Token types, unlike most (if not all) of the styles included in the
|
||||
Pygments distribution.
|
||||
|
||||
However, since Crunchy is intended to be used by beginners, we have strived
|
||||
to create a style that gloss over subtle distinctions between different
|
||||
categories.
|
||||
|
||||
Taking Python for example, comments (Comment.*) and docstrings (String.Doc)
|
||||
have been chosen to have the same style. Similarly, keywords (Keyword.*),
|
||||
and Operator.Word (and, or, in) have been assigned the same style.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
|
||||
|
||||
|
||||
class TangoStyle(Style):
|
||||
"""
|
||||
The Crunchy default Style inspired from the color palette from
|
||||
the Tango Icon Theme Guidelines.
|
||||
"""
|
||||
|
||||
# work in progress...
|
||||
|
||||
background_color = "#f8f8f8"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
# No corresponding class for the following:
|
||||
#Text: "", # class: ''
|
||||
Whitespace: "underline #f8f8f8", # class: 'w'
|
||||
Error: "#a40000 border:#ef2929", # class: 'err'
|
||||
Other: "#000000", # class 'x'
|
||||
|
||||
Comment: "italic #8f5902", # class: 'c'
|
||||
Comment.Multiline: "italic #8f5902", # class: 'cm'
|
||||
Comment.Preproc: "italic #8f5902", # class: 'cp'
|
||||
Comment.Single: "italic #8f5902", # class: 'c1'
|
||||
Comment.Special: "italic #8f5902", # class: 'cs'
|
||||
|
||||
Keyword: "bold #204a87", # class: 'k'
|
||||
Keyword.Constant: "bold #204a87", # class: 'kc'
|
||||
Keyword.Declaration: "bold #204a87", # class: 'kd'
|
||||
Keyword.Namespace: "bold #204a87", # class: 'kn'
|
||||
Keyword.Pseudo: "bold #204a87", # class: 'kp'
|
||||
Keyword.Reserved: "bold #204a87", # class: 'kr'
|
||||
Keyword.Type: "bold #204a87", # class: 'kt'
|
||||
|
||||
Operator: "bold #ce5c00", # class: 'o'
|
||||
Operator.Word: "bold #204a87", # class: 'ow' - like keywords
|
||||
|
||||
Punctuation: "bold #000000", # class: 'p'
|
||||
|
||||
# because special names such as Name.Class, Name.Function, etc.
|
||||
# are not recognized as such later in the parsing, we choose them
|
||||
# to look the same as ordinary variables.
|
||||
Name: "#000000", # class: 'n'
|
||||
Name.Attribute: "#c4a000", # class: 'na' - to be revised
|
||||
Name.Builtin: "#204a87", # class: 'nb'
|
||||
Name.Builtin.Pseudo: "#3465a4", # class: 'bp'
|
||||
Name.Class: "#000000", # class: 'nc' - to be revised
|
||||
Name.Constant: "#000000", # class: 'no' - to be revised
|
||||
Name.Decorator: "bold #5c35cc", # class: 'nd' - to be revised
|
||||
Name.Entity: "#ce5c00", # class: 'ni'
|
||||
Name.Exception: "bold #cc0000", # class: 'ne'
|
||||
Name.Function: "#000000", # class: 'nf'
|
||||
Name.Property: "#000000", # class: 'py'
|
||||
Name.Label: "#f57900", # class: 'nl'
|
||||
Name.Namespace: "#000000", # class: 'nn' - to be revised
|
||||
Name.Other: "#000000", # class: 'nx'
|
||||
Name.Tag: "bold #204a87", # class: 'nt' - like a keyword
|
||||
Name.Variable: "#000000", # class: 'nv' - to be revised
|
||||
Name.Variable.Class: "#000000", # class: 'vc' - to be revised
|
||||
Name.Variable.Global: "#000000", # class: 'vg' - to be revised
|
||||
Name.Variable.Instance: "#000000", # class: 'vi' - to be revised
|
||||
|
||||
# since the tango light blue does not show up well in text, we choose
|
||||
# a pure blue instead.
|
||||
Number: "bold #0000cf", # class: 'm'
|
||||
Number.Float: "bold #0000cf", # class: 'mf'
|
||||
Number.Hex: "bold #0000cf", # class: 'mh'
|
||||
Number.Integer: "bold #0000cf", # class: 'mi'
|
||||
Number.Integer.Long: "bold #0000cf", # class: 'il'
|
||||
Number.Oct: "bold #0000cf", # class: 'mo'
|
||||
|
||||
Literal: "#000000", # class: 'l'
|
||||
Literal.Date: "#000000", # class: 'ld'
|
||||
|
||||
String: "#4e9a06", # class: 's'
|
||||
String.Backtick: "#4e9a06", # class: 'sb'
|
||||
String.Char: "#4e9a06", # class: 'sc'
|
||||
String.Doc: "italic #8f5902", # class: 'sd' - like a comment
|
||||
String.Double: "#4e9a06", # class: 's2'
|
||||
String.Escape: "#4e9a06", # class: 'se'
|
||||
String.Heredoc: "#4e9a06", # class: 'sh'
|
||||
String.Interpol: "#4e9a06", # class: 'si'
|
||||
String.Other: "#4e9a06", # class: 'sx'
|
||||
String.Regex: "#4e9a06", # class: 'sr'
|
||||
String.Single: "#4e9a06", # class: 's1'
|
||||
String.Symbol: "#4e9a06", # class: 'ss'
|
||||
|
||||
Generic: "#000000", # class: 'g'
|
||||
Generic.Deleted: "#a40000", # class: 'gd'
|
||||
Generic.Emph: "italic #000000", # class: 'ge'
|
||||
Generic.Error: "#ef2929", # class: 'gr'
|
||||
Generic.Heading: "bold #000080", # class: 'gh'
|
||||
Generic.Inserted: "#00A000", # class: 'gi'
|
||||
Generic.Output: "italic #000000", # class: 'go'
|
||||
Generic.Prompt: "#8f5902", # class: 'gp'
|
||||
Generic.Strong: "bold #000000", # class: 'gs'
|
||||
Generic.Subheading: "bold #800080", # class: 'gu'
|
||||
Generic.Traceback: "bold #a40000", # class: 'gt'
|
||||
}
|
|
@ -0,0 +1,63 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.trac
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Port of the default trac highlighter design.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace
|
||||
|
||||
|
||||
class TracStyle(Style):
|
||||
"""
|
||||
Port of the default trac highlighter design.
|
||||
"""
|
||||
|
||||
default_style = ''
|
||||
|
||||
styles = {
|
||||
Whitespace: '#bbbbbb',
|
||||
Comment: 'italic #999988',
|
||||
Comment.Preproc: 'bold noitalic #999999',
|
||||
Comment.Special: 'bold #999999',
|
||||
|
||||
Operator: 'bold',
|
||||
|
||||
String: '#bb8844',
|
||||
String.Regex: '#808000',
|
||||
|
||||
Number: '#009999',
|
||||
|
||||
Keyword: 'bold',
|
||||
Keyword.Type: '#445588',
|
||||
|
||||
Name.Builtin: '#999999',
|
||||
Name.Function: 'bold #990000',
|
||||
Name.Class: 'bold #445588',
|
||||
Name.Exception: 'bold #990000',
|
||||
Name.Namespace: '#555555',
|
||||
Name.Variable: '#008080',
|
||||
Name.Constant: '#008080',
|
||||
Name.Tag: '#000080',
|
||||
Name.Attribute: '#008080',
|
||||
Name.Entity: '#800080',
|
||||
|
||||
Generic.Heading: '#999999',
|
||||
Generic.Subheading: '#aaaaaa',
|
||||
Generic.Deleted: 'bg:#ffdddd #000000',
|
||||
Generic.Inserted: 'bg:#ddffdd #000000',
|
||||
Generic.Error: '#aa0000',
|
||||
Generic.Emph: 'italic',
|
||||
Generic.Strong: 'bold',
|
||||
Generic.Prompt: '#555555',
|
||||
Generic.Output: '#888888',
|
||||
Generic.Traceback: '#aa0000',
|
||||
|
||||
Error: 'bg:#e3d2d2 #a61717'
|
||||
}
|
|
@ -0,0 +1,63 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.vim
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
A highlighting style for Pygments, inspired by vim.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Number, Operator, Generic, Whitespace, Token
|
||||
|
||||
|
||||
class VimStyle(Style):
|
||||
"""
|
||||
Styles somewhat like vim 7.0
|
||||
"""
|
||||
|
||||
background_color = "#000000"
|
||||
highlight_color = "#222222"
|
||||
default_style = "#cccccc"
|
||||
|
||||
styles = {
|
||||
Token: "#cccccc",
|
||||
Whitespace: "",
|
||||
Comment: "#000080",
|
||||
Comment.Preproc: "",
|
||||
Comment.Special: "bold #cd0000",
|
||||
|
||||
Keyword: "#cdcd00",
|
||||
Keyword.Declaration: "#00cd00",
|
||||
Keyword.Namespace: "#cd00cd",
|
||||
Keyword.Pseudo: "",
|
||||
Keyword.Type: "#00cd00",
|
||||
|
||||
Operator: "#3399cc",
|
||||
Operator.Word: "#cdcd00",
|
||||
|
||||
Name: "",
|
||||
Name.Class: "#00cdcd",
|
||||
Name.Builtin: "#cd00cd",
|
||||
Name.Exception: "bold #666699",
|
||||
Name.Variable: "#00cdcd",
|
||||
|
||||
String: "#cd0000",
|
||||
Number: "#cd00cd",
|
||||
|
||||
Generic.Heading: "bold #000080",
|
||||
Generic.Subheading: "bold #800080",
|
||||
Generic.Deleted: "#cd0000",
|
||||
Generic.Inserted: "#00cd00",
|
||||
Generic.Error: "#FF0000",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold #000080",
|
||||
Generic.Output: "#888",
|
||||
Generic.Traceback: "#04D",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,38 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.styles.vs
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Simple style with MS Visual Studio colors.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
from pygments.style import Style
|
||||
from pygments.token import Keyword, Name, Comment, String, Error, \
|
||||
Operator, Generic
|
||||
|
||||
|
||||
class VisualStudioStyle(Style):
|
||||
|
||||
background_color = "#ffffff"
|
||||
default_style = ""
|
||||
|
||||
styles = {
|
||||
Comment: "#008000",
|
||||
Comment.Preproc: "#0000ff",
|
||||
Keyword: "#0000ff",
|
||||
Operator.Word: "#0000ff",
|
||||
Keyword.Type: "#2b91af",
|
||||
Name.Class: "#2b91af",
|
||||
String: "#a31515",
|
||||
|
||||
Generic.Heading: "bold",
|
||||
Generic.Subheading: "bold",
|
||||
Generic.Emph: "italic",
|
||||
Generic.Strong: "bold",
|
||||
Generic.Prompt: "bold",
|
||||
|
||||
Error: "border:#FF0000"
|
||||
}
|
|
@ -0,0 +1,195 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.token
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
Basic token types and the standard tokens.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
class _TokenType(tuple):
|
||||
parent = None
|
||||
|
||||
def split(self):
|
||||
buf = []
|
||||
node = self
|
||||
while node is not None:
|
||||
buf.append(node)
|
||||
node = node.parent
|
||||
buf.reverse()
|
||||
return buf
|
||||
|
||||
def __init__(self, *args):
|
||||
# no need to call super.__init__
|
||||
self.subtypes = set()
|
||||
|
||||
def __contains__(self, val):
|
||||
return self is val or (
|
||||
type(val) is self.__class__ and
|
||||
val[:len(self)] == self
|
||||
)
|
||||
|
||||
def __getattr__(self, val):
|
||||
if not val or not val[0].isupper():
|
||||
return tuple.__getattribute__(self, val)
|
||||
new = _TokenType(self + (val,))
|
||||
setattr(self, val, new)
|
||||
self.subtypes.add(new)
|
||||
new.parent = self
|
||||
return new
|
||||
|
||||
def __repr__(self):
|
||||
return 'Token' + (self and '.' or '') + '.'.join(self)
|
||||
|
||||
|
||||
Token = _TokenType()
|
||||
|
||||
# Special token types
|
||||
Text = Token.Text
|
||||
Whitespace = Text.Whitespace
|
||||
Error = Token.Error
|
||||
# Text that doesn't belong to this lexer (e.g. HTML in PHP)
|
||||
Other = Token.Other
|
||||
|
||||
# Common token types for source code
|
||||
Keyword = Token.Keyword
|
||||
Name = Token.Name
|
||||
Literal = Token.Literal
|
||||
String = Literal.String
|
||||
Number = Literal.Number
|
||||
Punctuation = Token.Punctuation
|
||||
Operator = Token.Operator
|
||||
Comment = Token.Comment
|
||||
|
||||
# Generic types for non-source code
|
||||
Generic = Token.Generic
|
||||
|
||||
# String and some others are not direct childs of Token.
|
||||
# alias them:
|
||||
Token.Token = Token
|
||||
Token.String = String
|
||||
Token.Number = Number
|
||||
|
||||
|
||||
def is_token_subtype(ttype, other):
|
||||
"""
|
||||
Return True if ``ttype`` is a subtype of ``other``.
|
||||
|
||||
exists for backwards compatibility. use ``ttype in other`` now.
|
||||
"""
|
||||
return ttype in other
|
||||
|
||||
|
||||
def string_to_tokentype(s):
|
||||
"""
|
||||
Convert a string into a token type::
|
||||
|
||||
>>> string_to_token('String.Double')
|
||||
Token.Literal.String.Double
|
||||
>>> string_to_token('Token.Literal.Number')
|
||||
Token.Literal.Number
|
||||
>>> string_to_token('')
|
||||
Token
|
||||
|
||||
Tokens that are already tokens are returned unchanged:
|
||||
|
||||
>>> string_to_token(String)
|
||||
Token.Literal.String
|
||||
"""
|
||||
if isinstance(s, _TokenType):
|
||||
return s
|
||||
if not s:
|
||||
return Token
|
||||
node = Token
|
||||
for item in s.split('.'):
|
||||
node = getattr(node, item)
|
||||
return node
|
||||
|
||||
|
||||
# Map standard token types to short names, used in CSS class naming.
|
||||
# If you add a new item, please be sure to run this file to perform
|
||||
# a consistency check for duplicate values.
|
||||
STANDARD_TYPES = {
|
||||
Token: '',
|
||||
|
||||
Text: '',
|
||||
Whitespace: 'w',
|
||||
Error: 'err',
|
||||
Other: 'x',
|
||||
|
||||
Keyword: 'k',
|
||||
Keyword.Constant: 'kc',
|
||||
Keyword.Declaration: 'kd',
|
||||
Keyword.Namespace: 'kn',
|
||||
Keyword.Pseudo: 'kp',
|
||||
Keyword.Reserved: 'kr',
|
||||
Keyword.Type: 'kt',
|
||||
|
||||
Name: 'n',
|
||||
Name.Attribute: 'na',
|
||||
Name.Builtin: 'nb',
|
||||
Name.Builtin.Pseudo: 'bp',
|
||||
Name.Class: 'nc',
|
||||
Name.Constant: 'no',
|
||||
Name.Decorator: 'nd',
|
||||
Name.Entity: 'ni',
|
||||
Name.Exception: 'ne',
|
||||
Name.Function: 'nf',
|
||||
Name.Property: 'py',
|
||||
Name.Label: 'nl',
|
||||
Name.Namespace: 'nn',
|
||||
Name.Other: 'nx',
|
||||
Name.Tag: 'nt',
|
||||
Name.Variable: 'nv',
|
||||
Name.Variable.Class: 'vc',
|
||||
Name.Variable.Global: 'vg',
|
||||
Name.Variable.Instance: 'vi',
|
||||
|
||||
Literal: 'l',
|
||||
Literal.Date: 'ld',
|
||||
|
||||
String: 's',
|
||||
String.Backtick: 'sb',
|
||||
String.Char: 'sc',
|
||||
String.Doc: 'sd',
|
||||
String.Double: 's2',
|
||||
String.Escape: 'se',
|
||||
String.Heredoc: 'sh',
|
||||
String.Interpol: 'si',
|
||||
String.Other: 'sx',
|
||||
String.Regex: 'sr',
|
||||
String.Single: 's1',
|
||||
String.Symbol: 'ss',
|
||||
|
||||
Number: 'm',
|
||||
Number.Float: 'mf',
|
||||
Number.Hex: 'mh',
|
||||
Number.Integer: 'mi',
|
||||
Number.Integer.Long: 'il',
|
||||
Number.Oct: 'mo',
|
||||
|
||||
Operator: 'o',
|
||||
Operator.Word: 'ow',
|
||||
|
||||
Punctuation: 'p',
|
||||
|
||||
Comment: 'c',
|
||||
Comment.Multiline: 'cm',
|
||||
Comment.Preproc: 'cp',
|
||||
Comment.Single: 'c1',
|
||||
Comment.Special: 'cs',
|
||||
|
||||
Generic: 'g',
|
||||
Generic.Deleted: 'gd',
|
||||
Generic.Emph: 'ge',
|
||||
Generic.Error: 'gr',
|
||||
Generic.Heading: 'gh',
|
||||
Generic.Inserted: 'gi',
|
||||
Generic.Output: 'go',
|
||||
Generic.Prompt: 'gp',
|
||||
Generic.Strong: 'gs',
|
||||
Generic.Subheading: 'gu',
|
||||
Generic.Traceback: 'gt',
|
||||
}
|
File diff suppressed because one or more lines are too long
|
@ -0,0 +1,277 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
pygments.util
|
||||
~~~~~~~~~~~~~
|
||||
|
||||
Utility functions.
|
||||
|
||||
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
import sys
|
||||
import codecs
|
||||
|
||||
|
||||
split_path_re = re.compile(r'[/\\ ]')
|
||||
doctype_lookup_re = re.compile(r'''(?smx)
|
||||
(<\?.*?\?>)?\s*
|
||||
<!DOCTYPE\s+(
|
||||
[a-zA-Z_][a-zA-Z0-9]*\s+
|
||||
[a-zA-Z_][a-zA-Z0-9]*\s+
|
||||
"[^"]*")
|
||||
[^>]*>
|
||||
''')
|
||||
tag_re = re.compile(r'<(.+?)(\s.*?)?>.*?</.+?>(?uism)')
|
||||
|
||||
|
||||
class ClassNotFound(ValueError):
|
||||
"""
|
||||
If one of the get_*_by_* functions didn't find a matching class.
|
||||
"""
|
||||
|
||||
|
||||
class OptionError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def get_choice_opt(options, optname, allowed, default=None, normcase=False):
|
||||
string = options.get(optname, default)
|
||||
if normcase:
|
||||
string = string.lower()
|
||||
if string not in allowed:
|
||||
raise OptionError('Value for option %s must be one of %s' %
|
||||
(optname, ', '.join(map(str, allowed))))
|
||||
return string
|
||||
|
||||
|
||||
def get_bool_opt(options, optname, default=None):
|
||||
string = options.get(optname, default)
|
||||
if isinstance(string, bool):
|
||||
return string
|
||||
elif isinstance(string, int):
|
||||
return bool(string)
|
||||
elif not isinstance(string, basestring):
|
||||
raise OptionError('Invalid type %r for option %s; use '
|
||||
'1/0, yes/no, true/false, on/off' % (
|
||||
string, optname))
|
||||
elif string.lower() in ('1', 'yes', 'true', 'on'):
|
||||
return True
|
||||
elif string.lower() in ('0', 'no', 'false', 'off'):
|
||||
return False
|
||||
else:
|
||||
raise OptionError('Invalid value %r for option %s; use '
|
||||
'1/0, yes/no, true/false, on/off' % (
|
||||
string, optname))
|
||||
|
||||
|
||||
def get_int_opt(options, optname, default=None):
|
||||
string = options.get(optname, default)
|
||||
try:
|
||||
return int(string)
|
||||
except TypeError:
|
||||
raise OptionError('Invalid type %r for option %s; you '
|
||||
'must give an integer value' % (
|
||||
string, optname))
|
||||
except ValueError:
|
||||
raise OptionError('Invalid value %r for option %s; you '
|
||||
'must give an integer value' % (
|
||||
string, optname))
|
||||
|
||||
|
||||
def get_list_opt(options, optname, default=None):
|
||||
val = options.get(optname, default)
|
||||
if isinstance(val, basestring):
|
||||
return val.split()
|
||||
elif isinstance(val, (list, tuple)):
|
||||
return list(val)
|
||||
else:
|
||||
raise OptionError('Invalid type %r for option %s; you '
|
||||
'must give a list value' % (
|
||||
val, optname))
|
||||
|
||||
|
||||
def docstring_headline(obj):
|
||||
if not obj.__doc__:
|
||||
return ''
|
||||
res = []
|
||||
for line in obj.__doc__.strip().splitlines():
|
||||
if line.strip():
|
||||
res.append(" " + line.strip())
|
||||
else:
|
||||
break
|
||||
return ''.join(res).lstrip()
|
||||
|
||||
|
||||
def make_analysator(f):
|
||||
"""
|
||||
Return a static text analysation function that
|
||||
returns float values.
|
||||
"""
|
||||
def text_analyse(text):
|
||||
try:
|
||||
rv = f(text)
|
||||
except Exception:
|
||||
return 0.0
|
||||
if not rv:
|
||||
return 0.0
|
||||
try:
|
||||
return min(1.0, max(0.0, float(rv)))
|
||||
except (ValueError, TypeError):
|
||||
return 0.0
|
||||
text_analyse.__doc__ = f.__doc__
|
||||
return staticmethod(text_analyse)
|
||||
|
||||
|
||||
def shebang_matches(text, regex):
|
||||
"""
|
||||
Check if the given regular expression matches the last part of the
|
||||
shebang if one exists.
|
||||
|
||||
>>> from pygments.util import shebang_matches
|
||||
>>> shebang_matches('#!/usr/bin/env python', r'python(2\.\d)?')
|
||||
True
|
||||
>>> shebang_matches('#!/usr/bin/python2.4', r'python(2\.\d)?')
|
||||
True
|
||||
>>> shebang_matches('#!/usr/bin/python-ruby', r'python(2\.\d)?')
|
||||
False
|
||||
>>> shebang_matches('#!/usr/bin/python/ruby', r'python(2\.\d)?')
|
||||
False
|
||||
>>> shebang_matches('#!/usr/bin/startsomethingwith python',
|
||||
... r'python(2\.\d)?')
|
||||
True
|
||||
|
||||
It also checks for common windows executable file extensions::
|
||||
|
||||
>>> shebang_matches('#!C:\\Python2.4\\Python.exe', r'python(2\.\d)?')
|
||||
True
|
||||
|
||||
Parameters (``'-f'`` or ``'--foo'`` are ignored so ``'perl'`` does
|
||||
the same as ``'perl -e'``)
|
||||
|
||||
Note that this method automatically searches the whole string (eg:
|
||||
the regular expression is wrapped in ``'^$'``)
|
||||
"""
|
||||
index = text.find('\n')
|
||||
if index >= 0:
|
||||
first_line = text[:index].lower()
|
||||
else:
|
||||
first_line = text.lower()
|
||||
if first_line.startswith('#!'):
|
||||
try:
|
||||
found = [x for x in split_path_re.split(first_line[2:].strip())
|
||||
if x and not x.startswith('-')][-1]
|
||||
except IndexError:
|
||||
return False
|
||||
regex = re.compile('^%s(\.(exe|cmd|bat|bin))?$' % regex, re.IGNORECASE)
|
||||
if regex.search(found) is not None:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def doctype_matches(text, regex):
|
||||
"""
|
||||
Check if the doctype matches a regular expression (if present).
|
||||
Note that this method only checks the first part of a DOCTYPE.
|
||||
eg: 'html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"'
|
||||
"""
|
||||
m = doctype_lookup_re.match(text)
|
||||
if m is None:
|
||||
return False
|
||||
doctype = m.group(2)
|
||||
return re.compile(regex).match(doctype.strip()) is not None
|
||||
|
||||
|
||||
def html_doctype_matches(text):
|
||||
"""
|
||||
Check if the file looks like it has a html doctype.
|
||||
"""
|
||||
return doctype_matches(text, r'html\s+PUBLIC\s+"-//W3C//DTD X?HTML.*')
|
||||
|
||||
|
||||
_looks_like_xml_cache = {}
|
||||
def looks_like_xml(text):
|
||||
"""
|
||||
Check if a doctype exists or if we have some tags.
|
||||
"""
|
||||
key = hash(text)
|
||||
try:
|
||||
return _looks_like_xml_cache[key]
|
||||
except KeyError:
|
||||
m = doctype_lookup_re.match(text)
|
||||
if m is not None:
|
||||
return True
|
||||
rv = tag_re.search(text[:1000]) is not None
|
||||
_looks_like_xml_cache[key] = rv
|
||||
return rv
|
||||
|
||||
# Python narrow build compatibility
|
||||
|
||||
def _surrogatepair(c):
|
||||
return (0xd7c0 + (c >> 10), (0xdc00 + (c & 0x3ff)))
|
||||
|
||||
def unirange(a, b):
|
||||
"""
|
||||
Returns a regular expression string to match the given non-BMP range.
|
||||
"""
|
||||
if b < a:
|
||||
raise ValueError("Bad character range")
|
||||
if a < 0x10000 or b < 0x10000:
|
||||
raise ValueError("unirange is only defined for non-BMP ranges")
|
||||
|
||||
if sys.maxunicode > 0xffff:
|
||||
# wide build
|
||||
return u'[%s-%s]' % (unichr(a), unichr(b))
|
||||
else:
|
||||
# narrow build stores surrogates, and the 're' module handles them
|
||||
# (incorrectly) as characters. Since there is still ordering among
|
||||
# these characters, expand the range to one that it understands. Some
|
||||
# background in http://bugs.python.org/issue3665 and
|
||||
# http://bugs.python.org/issue12749
|
||||
#
|
||||
# Additionally, the lower constants are using unichr rather than
|
||||
# literals because jython [which uses the wide path] can't load this
|
||||
# file if they are literals.
|
||||
ah, al = _surrogatepair(a)
|
||||
bh, bl = _surrogatepair(b)
|
||||
if ah == bh:
|
||||
return u'(?:%s[%s-%s])' % (unichr(ah), unichr(al), unichr(bl))
|
||||
else:
|
||||
buf = []
|
||||
buf.append(u'%s[%s-%s]' %
|
||||
(unichr(ah), unichr(al),
|
||||
ah == bh and unichr(bl) or unichr(0xdfff)))
|
||||
if ah - bh > 1:
|
||||
buf.append(u'[%s-%s][%s-%s]' %
|
||||
unichr(ah+1), unichr(bh-1), unichr(0xdc00), unichr(0xdfff))
|
||||
if ah != bh:
|
||||
buf.append(u'%s[%s-%s]' %
|
||||
(unichr(bh), unichr(0xdc00), unichr(bl)))
|
||||
|
||||
return u'(?:' + u'|'.join(buf) + u')'
|
||||
|
||||
# Python 2/3 compatibility
|
||||
|
||||
if sys.version_info < (3,0):
|
||||
b = bytes = str
|
||||
u_prefix = 'u'
|
||||
import StringIO, cStringIO
|
||||
BytesIO = cStringIO.StringIO
|
||||
StringIO = StringIO.StringIO
|
||||
uni_open = codecs.open
|
||||
else:
|
||||
import builtins
|
||||
bytes = builtins.bytes
|
||||
u_prefix = ''
|
||||
def b(s):
|
||||
if isinstance(s, str):
|
||||
return bytes(map(ord, s))
|
||||
elif isinstance(s, bytes):
|
||||
return s
|
||||
else:
|
||||
raise TypeError("Invalid argument %r for b()" % (s,))
|
||||
import io
|
||||
BytesIO = io.BytesIO
|
||||
StringIO = io.StringIO
|
||||
uni_open = builtins.open
|
|
@ -0,0 +1,52 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
wakatime.stats
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
Stats about files such as total number of lines, source code language, etc.
|
||||
|
||||
:copyright: (c) 2013 Alan Hamlett.
|
||||
:license: BSD, see LICENSE for more details.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
from pygments.lexers import guess_lexer
|
||||
from pygments.util import ClassNotFound
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def guess_language(file_name):
|
||||
lexer = None
|
||||
try:
|
||||
with open(file_name) as f:
|
||||
lexer = guess_lexer(f.read(512000))
|
||||
except (ClassNotFound, IOError):
|
||||
pass
|
||||
if lexer:
|
||||
return str(lexer.name)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def number_lines_in_file(file_name):
|
||||
lines = 0
|
||||
try:
|
||||
with open(file_name) as f:
|
||||
for line in f:
|
||||
lines += 1
|
||||
except IOError:
|
||||
return None
|
||||
return lines
|
||||
|
||||
|
||||
def get_file_stats(file_name):
|
||||
stats = {
|
||||
'language': guess_language(file_name),
|
||||
'lines': number_lines_in_file(file_name),
|
||||
}
|
||||
return stats
|
Loading…
Reference in New Issue