class CAmkESLexer(RegexLexer):
"""
Basic lexer for the input language for the
`CAmkES <https://sel4.systems/CAmkES/>`_ component platform.
.. versionadded:: 2.1
"""
name = 'CAmkES'
aliases = ['camkes', 'idl4']
filenames = ['*.camkes', '*.idl4']
tokens = {
'root': [
# C pre-processor directive
(r'^\s*#.*\n', Comment.Preproc),
# Whitespace, comments
(r'\s+', Text),
(r'/\*(.|\n)*?\*/', Comment),
(r'//.*\n', Comment),
(r'[\[(){},.;\]]', Punctuation),
(r'[~!%^&*+=|?:<>/-]', Operator),
(words(('assembly', 'attribute', 'component', 'composition',
'configuration', 'connection', 'connector', 'consumes',
'control', 'dataport', 'Dataport', 'Dataports', 'emits',
'event', 'Event', 'Events', 'export', 'from', 'group',
'hardware', 'has', 'interface', 'Interface', 'maybe',
'procedure', 'Procedure', 'Procedures', 'provides',
'template', 'thread', 'threads', 'to', 'uses', 'with'),
suffix=r'\b'), Keyword),
(words(('bool', 'boolean', 'Buf', 'char', 'character', 'double',
'float', 'in', 'inout', 'int', 'int16_6', 'int32_t',
'int64_t', 'int8_t', 'integer', 'mutex', 'out', 'real',
'refin', 'semaphore', 'signed', 'string', 'struct',
'uint16_t', 'uint32_t', 'uint64_t', 'uint8_t', 'uintptr_t',
'unsigned', 'void'),
suffix=r'\b'), Keyword.Type),
# Recognised attributes
(r'[a-zA-Z_]\w*_(priority|domain|buffer)', Keyword.Reserved),
(words(('dma_pool', 'from_access', 'to_access'),
suffix=r'\b'), Keyword.Reserved),
# CAmkES-level include
(r'import\s+(<[^>]*>|"[^"]*");', Comment.Preproc),
# C-level include
(r'include\s+(<[^>]*>|"[^"]*");', Comment.Preproc),
# Literals
(r'0[xX][\da-fA-F]+', Number.Hex),
(r'-?[\d]+', Number),
(r'-?[\d]+\.[\d]+', Number.Float),
(r'"[^"]*"', String),
(r'[Tt]rue|[Ff]alse', Name.Builtin),
# Identifiers
(r'[a-zA-Z_]\w*', Name),
],
}
class CharmciLexer(CppLexer):
"""
For `Charm++ <https://charm.cs.illinois.edu>`_ interface files (.ci).
.. versionadded:: 2.4
"""
name = 'Charmci'
aliases = ['charmci']
filenames = ['*.ci']
mimetypes = []
tokens = {
'statements': [
(r'(module)(\s+)', bygroups(Keyword, Text), 'classname'),
(words(('mainmodule', 'mainchare', 'chare', 'array', 'group',
'nodegroup', 'message', 'conditional')), Keyword),
(words(('entry', 'aggregate', 'threaded', 'sync', 'exclusive',
'nokeep', 'notrace', 'immediate', 'expedited', 'inline',
'local', 'python', 'accel', 'readwrite', 'writeonly',
'accelblock', 'memcritical', 'packed', 'varsize',
'initproc', 'initnode', 'initcall', 'stacksize',
'createhere', 'createhome', 'reductiontarget', 'iget',
'nocopy', 'mutable', 'migratable', 'readonly')), Keyword),
inherit,
],
}
class NesCLexer(CLexer):
"""
For `nesC <https://github.com/tinyos/nesc>`_ source code with preprocessor
directives.
.. versionadded:: 2.0
"""
name = 'nesC'
aliases = ['nesc']
filenames = ['*.nc']
mimetypes = ['text/x-nescsrc']
tokens = {
'statements': [
(words((
'abstract', 'as', 'async', 'atomic', 'call', 'command', 'component',
'components', 'configuration', 'event', 'extends', 'generic',
'implementation', 'includes', 'interface', 'module', 'new', 'norace',
'post', 'provides', 'signal', 'task', 'uses'), suffix=r'\b'),
Keyword),
(words(('nx_struct', 'nx_union', 'nx_int8_t', 'nx_int16_t', 'nx_int32_t',
'nx_int64_t', 'nx_uint8_t', 'nx_uint16_t', 'nx_uint32_t',
'nx_uint64_t'), suffix=r'\b'),
Keyword.Type),
inherit,
],
}
class RoboconfGraphLexer(RegexLexer):
"""
Lexer for `Roboconf <http://roboconf.net/en/roboconf.html>`_ graph files.
.. versionadded:: 2.1
"""
name = 'Roboconf Graph'
aliases = ['roboconf-graph']
filenames = ['*.graph']
flags = re.IGNORECASE | re.MULTILINE
tokens = {
'root': [
# Skip white spaces
(r'\s+', Text),
# There is one operator
(r'=', Operator),
# Keywords
(words(('facet', 'import'), suffix=r'\s*\b',
prefix=r'\b'), Keyword),
(words(('installer', 'extends', 'exports', 'imports', 'facets',
'children'),
suffix=r'\s*:?',
prefix=r'\b'), Name),
# Comments
(r'#.*\n', Comment),
# Default
(r'[^#]', Text),
(r'.*\n', Text)
]
}
class ECLexer(CLexer):
"""
For eC source code with preprocessor directives.
.. versionadded:: 1.5
"""
name = 'eC'
aliases = ['ec']
filenames = ['*.ec', '*.eh']
mimetypes = ['text/x-echdr', 'text/x-ecsrc']
tokens = {
'statements': [
(words((
'virtual', 'class', 'private', 'public', 'property', 'import',
'delete', 'new', 'new0', 'renew', 'renew0', 'define', 'get',
'set', 'remote', 'dllexport', 'dllimport', 'stdcall', 'subclass',
'__on_register_module', 'namespace', 'using', 'typed_object',
'any_object', 'incref', 'register', 'watch', 'stopwatching', 'firewatchers',
'watchable', 'class_designer', 'class_fixed', 'class_no_expansion', 'isset',
'class_default_property', 'property_category', 'class_data',
'class_property', 'thisclass', 'dbtable', 'dbindex',
'database_open', 'dbfield'), suffix=r'\b'), Keyword),
(words(('uint', 'uint16', 'uint32', 'uint64', 'bool', 'byte',
'unichar', 'int64'), suffix=r'\b'),
Keyword.Type),
(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
(r'(null|value|this)\b', Name.Builtin),
inherit,
]
}
class RoboconfInstancesLexer(RegexLexer):
"""
Lexer for `Roboconf <http://roboconf.net/en/roboconf.html>`_ instances files.
.. versionadded:: 2.1
"""
name = 'Roboconf Instances'
aliases = ['roboconf-instances']
filenames = ['*.instances']
flags = re.IGNORECASE | re.MULTILINE
tokens = {
'root': [
# Skip white spaces
(r'\s+', Text),
# Keywords
(words(('instance of', 'import'), suffix=r'\s*\b',
prefix=r'\b'), Keyword),
(words(('name', 'count'), suffix=r's*:?', prefix=r'\b'), Name),
(r'\s*[\w.-]+\s*:', Name),
# Comments
(r'#.*\n', Comment),
# Default
(r'[^#]', Text),
(r'.*\n', Text)
]
}
class ProtoBufLexer(RegexLexer):
"""
Lexer for `Protocol Buffer <http://code.google.com/p/protobuf/>`_
definition files.
.. versionadded:: 1.4
"""
name = 'Protocol Buffer'
aliases = ['protobuf', 'proto']
filenames = ['*.proto']
tokens = {
'root': [
(r'[ \t]+', Text),
(r'[,;{}\[\]()<>]', Punctuation),
(r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
(r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment.Multiline),
(words((
'import', 'option', 'optional', 'required', 'repeated', 'default',
'packed', 'ctype', 'extensions', 'to', 'max', 'rpc', 'returns',
'oneof'), prefix=r'\b', suffix=r'\b'),
Keyword),
(words((
'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64',
'fixed32', 'fixed64', 'sfixed32', 'sfixed64',
'float', 'double', 'bool', 'string', 'bytes'), suffix=r'\b'),
Keyword.Type),
(r'(true|false)\b', Keyword.Constant),
(r'(package)(\s+)', bygroups(Keyword.Namespace, Text), 'package'),
(r'(message|extend)(\s+)',
bygroups(Keyword.Declaration, Text), 'message'),
(r'(enum|group|service)(\s+)',
bygroups(Keyword.Declaration, Text), 'type'),
(r'\".*?\"', String),
(r'\'.*?\'', String),
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
(r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
(r'(\-?(inf|nan))\b', Number.Float),
(r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
(r'0[0-7]+[LlUu]*', Number.Oct),
(r'\d+[LlUu]*', Number.Integer),
(r'[+-=]', Operator),
(r'([a-zA-Z_][\w.]*)([ \t]*)(=)',
bygroups(Name.Attribute, Text, Operator)),
(r'[a-zA-Z_][\w.]*', Name),
],
'package': [
(r'[a-zA-Z_]\w*', Name.Namespace, '#pop'),
default('#pop'),
],
'message': [
(r'[a-zA-Z_]\w*', Name.Class, '#pop'),
default('#pop'),
],
'type': [
(r'[a-zA-Z_]\w*', Name, '#pop'),
default('#pop'),
],
}
class MoselLexer(RegexLexer):
"""
For the Mosel optimization language.
.. versionadded:: 2.6
"""
name = 'Mosel'
aliases = ['mosel']
filenames = ['*.mos']
tokens = {
'root': [
(r'\n', Text),
(r'\s+', Text.Whitespace),
(r'!.*?\n', Comment.Single),
(r'\(!(.|\n)*?!\)', Comment.Multiline),
(words(('and', 'as', 'break', 'case', 'count', 'declarations',
'do', 'dynamic', 'elif', 'else', 'end-', 'end',
'evaluation', 'false', 'forall', 'forward', 'from',
'function', 'hashmap', 'if', 'imports', 'include',
'initialisations', 'initializations', 'inter', 'max',
'min', 'model', 'namespace', 'next', 'not', 'nsgroup',
'nssearch', 'of', 'options', 'or', 'package', 'parameters',
'procedure', 'public', 'prod', 'record', 'repeat',
'requirements', 'return', 'sum', 'then', 'to', 'true',
'union', 'until', 'uses', 'version', 'while', 'with'),
prefix=r'\b',
suffix=r'\b'), Keyword.Builtin),
(words(('range', 'array', 'set', 'list', 'mpvar', 'mpproblem',
'linctr', 'nlctr', 'integer', 'string', 'real', 'boolean',
'text', 'time', 'date', 'datetime', 'returned', 'Model',
'Mosel', 'counter', 'xmldoc', 'is_sos1', 'is_sos2',
'is_integer', 'is_binary', 'is_continuous', 'is_free',
'is_semcont', 'is_semint', 'is_partint'),
prefix=r'\b',
suffix=r'\b'), Keyword.Type),
(r'(\+|\-|\*|/|=|<=|>=|\||\^|<|>|<>|\.\.|\.|:=|::|:|in|mod|div)',
Operator),
(r'[()\[\]{},;]+', Punctuation),
(words(FUNCTIONS, prefix=r'\b', suffix=r'\b'), Name.Function),
(r'(\d+\.(?!\.)\d*|\.(?!.)\d+)([eE][+-]?\d+)?', Number.Float),
(r'\d+([eE][+-]?\d+)?', Number.Integer),
(r'[+-]?Infinity', Number.Integer),
(r'0[xX][0-9a-fA-F]+', Number),
(r'"', String.Double, 'double_quote'),
(r'\'', String.Single, 'single_quote'),
(r'(\w+|(\.(?!\.)))', Text),
],
'single_quote': [
(r'\'', String.Single, '#pop'),
(r'[^\']+', String.Single),
],
'double_quote': [
(r'(\\"|\\[0-7]{1,3}\D|\\[abfnrtv]|\\\\)', String.Escape),
(r'\"', String.Double, '#pop'),
(r'[^"\\]+', String.Double),
],
}
class CppLexer(CFamilyLexer):
"""
For C++ source code with preprocessor directives.
"""
name = 'C++'
aliases = ['cpp', 'c++']
filenames = [
'*.cpp', '*.hpp', '*.c++', '*.h++', '*.cc', '*.hh', '*.cxx', '*.hxx',
'*.C', '*.H', '*.cp', '*.CPP'
]
mimetypes = ['text/x-c++hdr', 'text/x-c++src']
priority = 0.1
tokens = {
'statements': [
(words(
('catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit',
'export', 'friend', 'mutable', 'namespace', 'new', 'operator',
'private', 'protected', 'public', 'reinterpret_cast',
'restrict', 'static_cast', 'template', 'this', 'throw',
'throws', 'try', 'typeid', 'typename', 'using', 'virtual',
'constexpr', 'nullptr', 'decltype', 'thread_local', 'alignas',
'alignof', 'static_assert', 'noexcept', 'override', 'final'),
suffix=r'\b'), Keyword),
(r'char(16_t|32_t)\b', Keyword.Type),
(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
# C++11 raw strings
(r'(R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
bygroups(String.Affix, String, String.Delimiter, String.Delimiter,
String, String.Delimiter, String)),
# C++11 UTF-8/16/32 strings
(r'(u8|u|U)(")', bygroups(String.Affix, String), 'string'),
inherit,
],
'root': [
inherit,
# C++ Microsoft-isms
(words(('virtual_inheritance', 'uuidof', 'super',
'single_inheritance', 'multiple_inheritance', 'interface',
'event'),
prefix=r'__',
suffix=r'\b'), Keyword.Reserved),
# Offload C++ extensions, http://offload.codeplay.com/
(r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo),
],
'classname': [
(r'[a-zA-Z_]\w*', Name.Class, '#pop'),
# template specification
(r'\s*(?=>)', Text, '#pop'),
],
}
def analyse_text(text):
if re.search('#include <[a-z_]+>', text):
return 0.2
if re.search('using namespace ', text):
return 0.4
class CapDLLexer(RegexLexer):
"""
Basic lexer for
`CapDL <https://ssrg.nicta.com.au/publications/nictaabstracts/Kuz_KLW_10.abstract.pml>`_.
The source of the primary tool that reads such specifications is available
at https://github.com/seL4/capdl/tree/master/capDL-tool. Note that this
lexer only supports a subset of the grammar. For example, identifiers can
shadow type names, but these instances are currently incorrectly
highlighted as types. Supporting this would need a stateful lexer that is
considered unnecessarily complex for now.
.. versionadded:: 2.2
"""
name = 'CapDL'
aliases = ['capdl']
filenames = ['*.cdl']
tokens = {
'root': [
# C pre-processor directive
(r'^\s*#.*\n', Comment.Preproc),
# Whitespace, comments
(r'\s+', Text),
(r'/\*(.|\n)*?\*/', Comment),
(r'(//|--).*\n', Comment),
(r'[<>\[(){},:;=\]]', Punctuation),
(r'\.\.', Punctuation),
(words(('arch', 'arm11', 'caps', 'child_of', 'ia32', 'irq', 'maps',
'objects'),
suffix=r'\b'), Keyword),
(words(('aep', 'asid_pool', 'cnode', 'ep', 'frame', 'io_device',
'io_ports', 'io_pt', 'notification', 'pd', 'pt', 'tcb',
'ut', 'vcpu'),
suffix=r'\b'), Keyword.Type),
# Properties
(words(('asid', 'addr', 'badge', 'cached', 'dom', 'domainID',
'elf', 'fault_ep', 'G', 'guard', 'guard_size', 'init',
'ip', 'prio', 'sp', 'R', 'RG', 'RX', 'RW', 'RWG', 'RWX',
'W', 'WG', 'WX', 'level', 'masked', 'master_reply',
'paddr', 'ports', 'reply', 'uncached'),
suffix=r'\b'), Keyword.Reserved),
# Literals
(r'0[xX][\da-fA-F]+', Number.Hex),
(r'\d+(\.\d+)?(k|M)?', Number),
(words(('bits', ), suffix=r'\b'), Number),
(words(('cspace', 'vspace', 'reply_slot', 'caller_slot',
'ipc_buffer_slot'),
suffix=r'\b'), Number),
# Identifiers
(r'[a-zA-Z_][-@\.\w]*', Name),
],
}
class PointlessLexer(RegexLexer):
"""
For `Pointless <https://ptls.dev>`_ source code.
.. versionadded:: 2.7
"""
name = 'Pointless'
aliases = ['pointless']
filenames = ['*.ptls']
ops = words([
"+", "-", "*", "/", "**", "%", "+=", "-=", "*=",
"/=", "**=", "%=", "|>", "=", "==", "!=", "<", ">",
"<=", ">=", "=>", "$", "++",
])
keywords = words([
"if", "then", "else", "where", "with", "cond",
"case", "and", "or", "not", "in", "as", "for",
"requires", "throw", "try", "catch", "when",
"yield", "upval",
], suffix=r'\b')
tokens = {
'root': [
(r'[ \n\r]+', Text),
(r'--.*$', Comment.Single),
(r'"""', String, 'multiString'),
(r'"', String, 'string'),
(r'[\[\](){}:;,.]', Punctuation),
(ops, Operator),
(keywords, Keyword),
(r'\d+|\d*\.\d+', Number),
(r'(true|false)\b', Name.Builtin),
(r'[A-Z][a-zA-Z0-9]*\b', String.Symbol),
(r'output\b', Name.Variable.Magic),
(r'(export|import)\b', Keyword.Namespace),
(r'[a-z][a-zA-Z0-9]*\b', Name.Variable)
],
'multiString': [
(r'\\.', String.Escape),
(r'"""', String, '#pop'),
(r'"', String),
(r'[^\\"]+', String),
],
'string': [
(r'\\.', String.Escape),
(r'"', String, '#pop'),
(r'\n', Error),
(r'[^\\"]+', String),
],
}
class PonyLexer(RegexLexer):
"""
For Pony source code.
.. versionadded:: 2.4
"""
name = 'Pony'
aliases = ['pony']
filenames = ['*.pony']
_caps = r'(iso|trn|ref|val|box|tag)'
tokens = {
'root':
[(r'\n', Text), (r'[^\S\n]+', Text), (r'//.*\n', Comment.Single),
(r'/\*', Comment.Multiline, 'nested_comment'),
(r'"""(?:.|\n)*?"""', String.Doc), (r'"', String, 'string'),
(r'\'.*\'', String.Char), (r'=>|[]{}:().~;,|&!^?[]', Punctuation),
(words(('addressof', 'and', 'as', 'consume', 'digestof', 'is', 'isnt',
'not', 'or'),
suffix=r'\b'), Operator.Word),
(r'!=|==|<<|>>|[-+/*%=<>]', Operator),
(words(('box', 'break', 'compile_error', 'compile_intrinsic',
'continue', 'do', 'else', 'elseif', 'embed', 'end', 'error',
'for', 'if', 'ifdef', 'in', 'iso', 'lambda', 'let', 'match',
'object', 'recover', 'ref', 'repeat', 'return', 'tag', 'then',
'this', 'trn', 'try', 'until', 'use', 'var', 'val', 'where',
'while', 'with', '#any', '#read', '#send', '#share'),
suffix=r'\b'), Keyword),
(r'(actor|class|struct|primitive|interface|trait|type)((?:\s)+)',
bygroups(Keyword, Text), 'typename'),
(r'(new|fun|be)((?:\s)+)', bygroups(Keyword, Text), 'methodname'),
(words(
('I8', 'U8', 'I16', 'U16', 'I32', 'U32', 'I64', 'U64', 'I128',
'U128', 'ILong', 'ULong', 'ISize', 'USize', 'F32', 'F64', 'Bool',
'Pointer', 'None', 'Any', 'Array', 'String', 'Iterator'),
suffix=r'\b'), Name.Builtin.Type), (r'_?[A-Z]\w*', Name.Type),
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
(r'0x[0-9a-fA-F]+', Number.Hex), (r'\d+', Number.Integer),
(r'(true|false)\b', Name.Builtin), (r'_\d*', Name),
(r'_?[a-z][\w\'_]*', Name)],
'typename': [(_caps + r'?((?:\s)*)(_?[A-Z]\w*)',
bygroups(Keyword, Text, Name.Class), '#pop')],
'methodname': [(_caps + r'?((?:\s)*)(_?[a-z]\w*)',
bygroups(Keyword, Text, Name.Function), '#pop')],
'nested_comment': [(r'[^*/]+', Comment.Multiline),
(r'/\*', Comment.Multiline, '#push'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline)],
'string': [(r'"', String, '#pop'), (r'\\"', String),
(r'[^\\"]+', String)]
}
class UcodeLexer(RegexLexer):
"""
Lexer for Icon ucode files.
.. versionadded:: 2.4
"""
name = 'ucode'
aliases = ['ucode']
filenames = ['*.u', '*.u1', '*.u2']
mimetypes = []
flags = re.MULTILINE
tokens = {
'root': [
(r'(#.*\n)', Comment),
(words(
('con', 'declend', 'end', 'global', 'impl', 'invocable', 'lab',
'link', 'local', 'record', 'uid', 'unions', 'version'),
prefix=r'\b',
suffix=r'\b'), Name.Function),
(words(('colm', 'filen', 'line', 'synt'),
prefix=r'\b',
suffix=r'\b'), Comment),
(words(
('asgn', 'bang', 'bscan', 'cat', 'ccase', 'chfail', 'coact',
'cofail', 'compl', 'coret', 'create', 'cset', 'diff', 'div',
'dup', 'efail', 'einit', 'end', 'eqv', 'eret', 'error',
'escan', 'esusp', 'field', 'goto', 'init', 'int', 'inter',
'invoke', 'keywd', 'lconcat', 'lexeq', 'lexge', 'lexgt',
'lexle', 'lexlt', 'lexne', 'limit', 'llist', 'lsusp', 'mark',
'mark0', 'minus', 'mod', 'mult', 'neg', 'neqv', 'nonnull',
'noop', 'null', 'number', 'numeq', 'numge', 'numgt', 'numle',
'numlt', 'numne', 'pfail', 'plus', 'pnull', 'pop', 'power',
'pret', 'proc', 'psusp', 'push1', 'pushn1', 'random', 'rasgn',
'rcv', 'rcvbk', 'real', 'refresh', 'rswap', 'sdup', 'sect',
'size', 'snd', 'sndbk', 'str', 'subsc', 'swap', 'tabmat',
'tally', 'toby', 'trace', 'unmark', 'value', 'var'),
prefix=r'\b',
suffix=r'\b'), Keyword.Declaration),
(words(('any', 'case', 'endcase', 'endevery', 'endif', 'endifelse',
'endrepeat', 'endsuspend', 'enduntil', 'endwhile', 'every',
'if', 'ifelse', 'repeat', 'suspend', 'until', 'while'),
prefix=r'\b',
suffix=r'\b'), Name.Constant),
(r'\d+(\s*|\.$|$)', Number.Integer),
(r'[+-]?\d*\.\d+(E[-+]?\d+)?', Number.Float),
(r'[+-]?\d+\.\d*(E[-+]?\d+)?', Number.Float),
(r"(<>|=>|[()|:;,.'`]|[{}]|[%^]|[&?])", Punctuation),
(r'\s+\b', Text),
(r'[\w-]+', Text),
],
}
class SilverLexer(RegexLexer):
"""
For `Silver <https://bitbucket.org/viperproject/silver>`_ source code.
.. versionadded:: 2.2
"""
name = 'Silver'
aliases = ['silver']
filenames = ['*.sil', '*.vpr']
tokens = {
'root': [
# Whitespace and Comments
(r'\n', Text),
(r'\s+', Text),
(r'\\\n', Text), # line continuation
(r'//[/!](.*?)\n', Comment.Doc),
(r'//(.*?)\n', Comment.Single),
(r'/\*', Comment.Multiline, 'comment'),
(words(('result', 'true', 'false', 'null', 'method', 'function',
'predicate', 'program', 'domain', 'axiom', 'var',
'returns', 'field', 'define', 'fold', 'unfold', 'inhale',
'exhale', 'new', 'assert', 'assume', 'goto', 'while', 'if',
'elseif', 'else', 'fresh', 'constraining', 'Seq', 'Set',
'Multiset', 'union', 'intersection', 'setminus', 'subset',
'unfolding', 'in', 'old', 'forall', 'exists', 'acc',
'wildcard', 'write', 'none', 'epsilon', 'perm', 'unique',
'apply', 'package', 'folding', 'label', 'forperm'),
suffix=r'\b'), Keyword),
(words(('requires', 'ensures', 'invariant'),
suffix=r'\b'), Name.Decorator),
(words(('Int', 'Perm', 'Bool', 'Ref', 'Rational'),
suffix=r'\b'), Keyword.Type),
include('numbers'),
(r'[!%&*+=|?:<>/\-\[\]]', Operator),
(r'\{.*?\}', Generic.Emph), #triggers
(r'([{}():;,.])', Punctuation),
# Identifier
(r'[\w$]\w*', Name),
],
'comment': [
(r'[^*/]+', Comment.Multiline),
(r'/\*', Comment.Multiline, '#push'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline),
],
'numbers': [
(r'[0-9]+', Number.Integer),
],
}
class BCLexer(RegexLexer):
"""
A `BC <https://www.gnu.org/software/bc/>`_ lexer.
.. versionadded:: 2.1
"""
name = 'BC'
aliases = ['bc']
filenames = ['*.bc']
tokens = {
'root': [
(r'/\*', Comment.Multiline, 'comment'),
(r'"(?:[^"\\]|\\.)*"', String),
(r'[{}();,]', Punctuation),
(words(('if', 'else', 'while', 'for', 'break', 'continue', 'halt',
'return', 'define', 'auto', 'print', 'read', 'length',
'scale', 'sqrt', 'limits', 'quit', 'warranty'),
suffix=r'\b'), Keyword),
(r'\+\+|--|\|\||&&|'
r'([-<>+*%\^/!=])=?', Operator),
# bc doesn't support exponential
(r'[0-9]+(\.[0-9]*)?', Number),
(r'\.[0-9]+', Number),
(r'.', Text)
],
'comment': [(r'[^*/]+', Comment.Multiline),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline)],
}
class PlPgsqlLexer(PostgresBase, RegexLexer):
"""
Handle the extra syntax in Pl/pgSQL language.
.. versionadded:: 1.5
"""
name = 'PL/pgSQL'
aliases = ['plpgsql']
mimetypes = ['text/x-plpgsql']
flags = re.IGNORECASE
tokens = dict((k, l[:]) for (k, l) in iteritems(PostgresLexer.tokens))
# extend the keywords list
for i, pattern in enumerate(tokens['root']):
if pattern[1] == Keyword:
tokens['root'][i] = (words(KEYWORDS + PLPGSQL_KEYWORDS,
suffix=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]\w*\b', Name.Builtin), # actually, a datatype
(r':=', Operator),
(r'\<\<[a-z]\w*\>\>', Name.Label),
(r'\#[a-z]\w*\b', Keyword.Pseudo), # #variable_conflict
]
class RslLexer(RegexLexer):
"""
`RSL <http://en.wikipedia.org/wiki/RAISE>`_ is the formal specification
language used in RAISE (Rigorous Approach to Industrial Software Engineering)
method.
.. versionadded:: 2.0
"""
name = 'RSL'
aliases = ['rsl']
filenames = ['*.rsl']
mimetypes = ['text/rsl']
flags = re.MULTILINE | re.DOTALL
tokens = {
'root': [
(words(
('Bool', 'Char', 'Int', 'Nat', 'Real', 'Text', 'Unit', 'abs',
'all', 'always', 'any', 'as', 'axiom', 'card', 'case',
'channel', 'chaos', 'class', 'devt_relation', 'dom', 'elems',
'else', 'elif', 'end', 'exists', 'extend', 'false', 'for',
'hd', 'hide', 'if', 'in', 'is', 'inds', 'initialise', 'int',
'inter', 'isin', 'len', 'let', 'local', 'ltl_assertion',
'object', 'of', 'out', 'post', 'pre', 'read', 'real', 'rng',
'scheme', 'skip', 'stop', 'swap', 'then', 'theory',
'test_case', 'tl', 'transition_system', 'true', 'type',
'union', 'until', 'use', 'value', 'variable', 'while', 'with',
'write', '~isin', '-inflist', '-infset', '-list', '-set'),
prefix=r'\b',
suffix=r'\b'), Keyword),
(r'(variable|value)\b', Keyword.Declaration),
(r'--.*?\n', Comment),
(r'<:.*?:>', Comment),
(r'\{!.*?!\}', Comment),
(r'/\*.*?\*/', Comment),
(r'^[ \t]*([\w]+)[ \t]*:[^:]', Name.Function),
(r'(^[ \t]*)([\w]+)([ \t]*\([\w\s,]*\)[ \t]*)(is|as)',
bygroups(Text, Name.Function, Text, Keyword)),
(r'\b[A-Z]\w*\b', Keyword.Type),
(r'(true|false)\b', Keyword.Constant),
(r'".*"', String),
(r'\'.\'', String.Char),
(r'(><|->|-m->|/\\|<=|<<=|<\.|\|\||\|\^\||-~->|-~m->|\\/|>=|>>|'
r'\.>|\+\+|-\\|<->|=>|:-|~=|\*\*|<<|>>=|\+>|!!|\|=\||#)',
Operator),
(r'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
(r'0x[0-9a-f]+', Number.Hex),
(r'[0-9]+', Number.Integer),
(r'.', Text),
],
}
def analyse_text(text):
"""
Check for the most common text in the beginning of a RSL file.
"""
if re.search(r'scheme\s*.*?=\s*class\s*type', text, re.I) is not None:
return 1.0
class CrocLexer(RegexLexer):
"""
For `Croc <http://jfbillingsley.com/croc>`_ source.
"""
name = 'Croc'
filenames = ['*.croc']
aliases = ['croc']
mimetypes = ['text/x-crocsrc']
tokens = {
'root': [
(r'\n', Text),
(r'\s+', Text),
# Comments
(r'//(.*?)\n', Comment.Single),
(r'/\*', Comment.Multiline, 'nestedcomment'),
# Keywords
(words(
('as', 'assert', 'break', 'case', 'catch', 'class', 'continue',
'default', 'do', 'else', 'finally', 'for', 'foreach',
'function', 'global', 'namespace', 'if', 'import', 'in', 'is',
'local', 'module', 'return', 'scope', 'super', 'switch',
'this', 'throw', 'try', 'vararg', 'while', 'with', 'yield'),
suffix=r'\b'), Keyword),
(r'(false|true|null)\b', Keyword.Constant),
# FloatLiteral
(r'([0-9][0-9_]*)(?=[.eE])(\.[0-9][0-9_]*)?([eE][+\-]?[0-9_]+)?',
Number.Float),
# IntegerLiteral
# -- Binary
(r'0[bB][01][01_]*', Number.Bin),
# -- Hexadecimal
(r'0[xX][0-9a-fA-F][0-9a-fA-F_]*', Number.Hex),
# -- Decimal
(r'([0-9][0-9_]*)(?![.eE])', Number.Integer),
# CharacterLiteral
(r"""'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-9]{1,3}"""
r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|.)'""", String.Char),
# StringLiteral
# -- WysiwygString
(r'@"(""|[^"])*"', String),
(r'@`(``|[^`])*`', String),
(r"@'(''|[^'])*'", String),
# -- DoubleQuotedString
(r'"(\\\\|\\"|[^"])*"', String),
# Tokens
(r'(~=|\^=|%=|\*=|==|!=|>>>=|>>>|>>=|>>|>=|<=>|\?=|-\>'
r'|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.|/=)'
r'|[-/.&$@|\+<>!()\[\]{}?,;:=*%^~#\\]', Punctuation),
# Identifier
(r'[a-zA-Z_]\w*', Name),
],
'nestedcomment': [
(r'[^*/]+', Comment.Multiline),
(r'/\*', Comment.Multiline, '#push'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline),
],
}
class ResourceLexer(RegexLexer):
"""Lexer for `ICU Resource bundles
<http://userguide.icu-project.org/locale/resources>`_.
.. versionadded:: 2.0
"""
name = 'ResourceBundle'
aliases = ['resource', 'resourcebundle']
filenames = []
_types = (':table', ':array', ':string', ':bin', ':import', ':intvector',
':int', ':alias')
flags = re.MULTILINE | re.IGNORECASE
tokens = {
'root': [
(r'//.*?$', Comment),
(r'"', String, 'string'),
(r'-?\d+', Number.Integer),
(r'[,{}]', Operator),
(r'([^\s{:]+)(\s*)(%s?)' % '|'.join(_types),
bygroups(Name, Text, Keyword)),
(r'\s+', Text),
(words(_types), Keyword),
],
'string':
[(r'(\\x[0-9a-f]{2}|\\u[0-9a-f]{4}|\\U00[0-9a-f]{6}|'
r'\\[0-7]{1,3}|\\c.|\\[abtnvfre\'"?\\]|\\\{|[^"{\\])+', String),
(r'\{', String.Escape, 'msgname'), (r'"', String, '#pop')],
'msgname':
[(r'([^{},]+)(\s*)', bygroups(Name,
String.Escape), ('#pop', 'message'))],
'message':
[(r'\{', String.Escape, 'msgname'), (r'\}', String.Escape, '#pop'),
(r'(,)(\s*)([a-z]+)(\s*\})',
bygroups(Operator, String.Escape, Keyword, String.Escape), '#pop'),
(r'(,)(\s*)([a-z]+)(\s*)(,)(\s*)(offset)(\s*)(:)(\s*)(-?\d+)(\s*)',
bygroups(Operator, String.Escape, Keyword, String.Escape, Operator,
String.Escape, Operator.Word, String.Escape, Operator,
String.Escape, Number.Integer, String.Escape), 'choice'),
(r'(,)(\s*)([a-z]+)(\s*)(,)(\s*)',
bygroups(Operator, String.Escape, Keyword, String.Escape, Operator,
String.Escape), 'choice'), (r'\s+', String.Escape)],
'choice': [(r'(=|<|>|<=|>=|!=)(-?\d+)(\s*\{)',
bygroups(Operator, Number.Integer,
String.Escape), 'message'),
(r'([a-z]+)(\s*\{)', bygroups(Keyword.Type,
String.Escape), 'str'),
(r'\}', String.Escape, ('#pop', '#pop')),
(r'\s+', String.Escape)],
'str': [(r'\}', String.Escape, '#pop'),
(r'\{', String.Escape, 'msgname'), (r'[^{}]+', String)]
}
def analyse_text(text):
if text.startswith('root:table'):
return 1.0
class BSTLexer(RegexLexer):
"""
A lexer for BibTeX bibliography styles.
.. versionadded:: 2.2
"""
name = 'BST'
aliases = ['bst', 'bst-pybtex']
filenames = ['*.bst']
flags = re.IGNORECASE | re.MULTILINE
tokens = {
'root': [
include('whitespace'),
(words(['read', 'sort']), Keyword),
(words(['execute', 'integers', 'iterate', 'reverse', 'strings']),
Keyword, ('group')),
(words(['function', 'macro']), Keyword, ('group', 'group')),
(words(['entry']), Keyword, ('group', 'group', 'group')),
],
'group': [
include('whitespace'),
(r'\{', Punctuation, ('#pop', 'group-end', 'body')),
],
'group-end': [
include('whitespace'),
(r'\}', Punctuation, '#pop'),
],
'body': [
include('whitespace'),
(r"\'[^#\"\{\}\s]+", Name.Function),
(r'[^#\"\{\}\s]+\$', Name.Builtin),
(r'[^#\"\{\}\s]+', Name.Variable),
(r'"[^\"]*"', String),
(r'#-?\d+', Number),
(r'\{', Punctuation, ('group-end', 'body')),
default('#pop'),
],
'whitespace': [
(r'\s+', Text),
('%.*?$', Comment.SingleLine),
],
}
class PacmanConfLexer(RegexLexer):
"""
Lexer for `pacman.conf
<https://www.archlinux.org/pacman/pacman.conf.5.html>`_.
Actually, IniLexer works almost fine for this format,
but it yield error token. It is because pacman.conf has
a form without assignment like:
UseSyslog
Color
TotalDownload
CheckSpace
VerbosePkgLists
These are flags to switch on.
.. versionadded:: 2.1
"""
name = 'PacmanConf'
aliases = ['pacmanconf']
filenames = ['pacman.conf']
mimetypes = []
tokens = {
'root': [
# comment
(r'#.*$', Comment.Single),
# section header
(r'^\s*\[.*?\]\s*$', Keyword),
# variable definitions
# (Leading space is allowed...)
(r'(\w+)(\s*)(=)', bygroups(Name.Attribute, Text, Operator)),
# flags to on
(r'^(\s*)(\w+)(\s*)$', bygroups(Text, Name.Attribute, Text)),
# built-in special values
(
words(
(
'$repo', # repository
'$arch', # architecture
'%o', # outfile
'%u', # url
),
suffix=r'\b'),
Name.Variable),
# fallback
(r'.', Text),
],
}
class CLexer(CFamilyLexer):
"""
For C source code with preprocessor directives.
Additional options accepted:
`stdlibhighlighting`
Highlight common types found in the C/C++ standard library (e.g. `size_t`).
(default: ``True``).
`c99highlighting`
Highlight common types found in the C99 standard library (e.g. `int8_t`).
Actually, this includes all fixed-width integer types.
(default: ``True``).
`c11highlighting`
Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`).
(default: ``True``).
`platformhighlighting`
Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
(default: ``True``).
"""
name = 'C'
aliases = ['c']
filenames = ['*.c', '*.h', '*.idc']
mimetypes = ['text/x-chdr', 'text/x-csrc']
priority = 0.1
tokens = {
'statements': [(words(('_Alignas', '_Alignof', '_Noreturn', '_Generic',
'_Thread_local', '_Static_assert', '_Imaginary',
'noreturn', 'imaginary', 'complex'),
suffix=r'\b'), Keyword),
(words(('_Bool', '_Complex', '_Atomic'),
suffix=r'\b'), Keyword.Type), inherit]
}
def analyse_text(text):
if re.search(r'^\s*#include [<"]', text, re.MULTILINE):
return 0.1
if re.search(r'^\s*#ifn?def ', text, re.MULTILINE):
return 0.1
class BoogieLexer(RegexLexer):
"""
For `Boogie <https://boogie.codeplex.com/>`_ source code.
.. versionadded:: 2.1
"""
name = 'Boogie'
aliases = ['boogie']
filenames = ['*.bpl']
tokens = {
'root': [
# Whitespace and Comments
(r'\n', Text),
(r'\s+', Text),
(r'\\\n', Text), # line continuation
(r'//[/!](.*?)\n', Comment.Doc),
(r'//(.*?)\n', Comment.Single),
(r'/\*', Comment.Multiline, 'comment'),
(words(('axiom', 'break', 'call', 'ensures', 'else', 'exists',
'function', 'forall', 'if', 'invariant', 'modifies',
'procedure', 'requires', 'then', 'var', 'while'),
suffix=r'\b'), Keyword),
(words(('const', ), suffix=r'\b'), Keyword.Reserved),
(words(('bool', 'int', 'ref'), suffix=r'\b'), Keyword.Type),
include('numbers'),
(r"(>=|<=|:=|!=|==>|&&|\|\||[+/\-=>*<\[\]])", Operator),
(r'\{.*?\}', Generic.Emph), #triggers
(r"([{}():;,.])", Punctuation),
# Identifier
(r'[a-zA-Z_]\w*', Name),
],
'comment': [
(r'[^*/]+', Comment.Multiline),
(r'/\*', Comment.Multiline, '#push'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline),
],
'numbers': [
(r'[0-9]+', Number.Integer),
],
}
class PostgresLexer(PostgresBase, RegexLexer):
"""
Lexer for the PostgreSQL dialect of SQL.
.. versionadded:: 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(" ", r"\s+")
for s in DATATYPES + PSEUDO_TYPES) + r')\b', Name.Builtin),
(words(KEYWORDS, suffix=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&)?)(')", bygroups(String.Affix,
String.Single), 'string'),
# quoted identifier
(r'((?:U&)?)(")', bygroups(String.Affix,
String.Name), 'quoted-ident'),
(r'(?s)(\$)([^$]*)(\$)(.*?)(\$)(\2)(\$)', language_callback),
(r'[a-z_]\w*', Name),
# psql variable in SQL
(r""":(['"]?)[a-z]\w*\b\1""", Name.Variable),
(r'[;:()\[\]{},.]', Punctuation),
],
'multiline-comments':
[(r'/\*', Comment.Multiline, 'multiline-comments'),
(r'\*/', Comment.Multiline, '#pop'), (r'[^/*]+', Comment.Multiline),
(r'[/*]', Comment.Multiline)],
'string': [
(r"[^']+", String.Single),
(r"''", String.Single),
(r"'", String.Single, '#pop'),
],
'quoted-ident': [
(r'[^"]+', String.Name),
(r'""', String.Name),
(r'"', String.Name, '#pop'),
],
}
class EiffelLexer(RegexLexer):
"""
For `Eiffel <http://www.eiffel.com>`_ source code.
.. versionadded:: 2.0
"""
name = 'Eiffel'
aliases = ['eiffel']
filenames = ['*.e']
mimetypes = ['text/x-eiffel']
tokens = {
'root': [
(r'[^\S\n]+', Text),
(r'--.*?\n', Comment.Single),
(r'[^\S\n]+', Text),
# Please note that keyword and operator are case insensitive.
(r'(?i)(true|false|void|current|result|precursor)\b',
Keyword.Constant),
(r'(?i)(and(\s+then)?|not|xor|implies|or(\s+else)?)\b',
Operator.Word),
(words(
('across', 'agent', 'alias', 'all', 'as', 'assign', 'attached',
'attribute', 'check', 'class', 'convert', 'create', 'debug',
'deferred', 'detachable', 'do', 'else', 'elseif', 'end',
'ensure', 'expanded', 'export', 'external', 'feature', 'from',
'frozen', 'if', 'inherit', 'inspect', 'invariant', 'like',
'local', 'loop', 'none', 'note', 'obsolete', 'old', 'once',
'only', 'redefine', 'rename', 'require', 'rescue', 'retry',
'select', 'separate', 'then', 'undefine', 'until', 'variant',
'when'),
prefix=r'(?i)\b',
suffix=r'\b'), Keyword.Reserved),
(r'"\[(([^\]%]|\n)|%(.|\n)|\][^"])*?\]"', String),
(r'"([^"%\n]|%.)*?"', String),
include('numbers'),
(r"'([^'%]|%'|%%)'", String.Char),
(r"(//|\\\\|>=|<=|:=|/=|~|/~|[\\?!#%&@|+/\-=>*$<^\[\]])",
Operator),
(r"([{}():;,.])", Punctuation),
(r'([a-z]\w*)|([A-Z][A-Z0-9_]*[a-z]\w*)', Name),
(r'([A-Z][A-Z0-9_]*)', Name.Class),
(r'\n+', Text),
],
'numbers': [
(r'0[xX][a-fA-F0-9]+', Number.Hex),
(r'0[bB][01]+', Number.Bin),
(r'0[cC][0-7]+', Number.Oct),
(r'([0-9]+\.[0-9]*)|([0-9]*\.[0-9]+)', Number.Float),
(r'[0-9]+', Number.Integer),
],
}
class OpenEdgeLexer(RegexLexer):
"""
Lexer for `OpenEdge ABL (formerly Progress)
<http://web.progress.com/en/openedge/abl.html>`_ source code.
.. versionadded:: 1.5
"""
name = 'OpenEdge ABL'
aliases = ['openedge', 'abl', 'progress']
filenames = ['*.p', '*.cls']
mimetypes = ['text/x-openedge', 'application/x-openedge']
types = (r'(?i)(^|(?<=[^\w\-]))(CHARACTER|CHAR|CHARA|CHARAC|CHARACT|CHARACTE|'
r'COM-HANDLE|DATE|DATETIME|DATETIME-TZ|'
r'DECIMAL|DEC|DECI|DECIM|DECIMA|HANDLE|'
r'INT64|INTEGER|INT|INTE|INTEG|INTEGE|'
r'LOGICAL|LONGCHAR|MEMPTR|RAW|RECID|ROWID)\s*($|(?=[^\w\-]))')
keywords = words(OPENEDGEKEYWORDS,
prefix=r'(?i)(^|(?<=[^\w\-]))',
suffix=r'\s*($|(?=[^\w\-]))')
tokens = {
'root': [
(r'/\*', Comment.Multiline, 'comment'),
(r'\{', Comment.Preproc, 'preprocessor'),
(r'\s*&.*', Comment.Preproc),
(r'0[xX][0-9a-fA-F]+[LlUu]*', Number.Hex),
(r'(?i)(DEFINE|DEF|DEFI|DEFIN)\b', Keyword.Declaration),
(types, Keyword.Type),
(keywords, Name.Builtin),
(r'"(\\\\|\\"|[^"])*"', String.Double),
(r"'(\\\\|\\'|[^'])*'", String.Single),
(r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
(r'[0-9]+', Number.Integer),
(r'\s+', Text),
(r'[+*/=-]', Operator),
(r'[.:()]', Punctuation),
(r'.', Name.Variable), # Lazy catch-all
],
'comment': [
(r'[^*/]', Comment.Multiline),
(r'/\*', Comment.Multiline, '#push'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[*/]', Comment.Multiline)
],
'preprocessor': [
(r'[^{}]', Comment.Preproc),
(r'\{', Comment.Preproc, '#push'),
(r'\}', Comment.Preproc, '#pop'),
],
}
class MozPreprocHashLexer(RegexLexer):
"""
Lexer for Mozilla Preprocessor files (with '#' as the marker).
Other data is left untouched.
.. versionadded:: 2.0
"""
name = 'mozhashpreproc'
aliases = [name]
filenames = []
mimetypes = []
tokens = {
'root': [
(r'^#', Comment.Preproc, ('expr', 'exprstart')),
(r'.+', Other),
],
'exprstart': [
(r'(literal)(.*)', bygroups(Comment.Preproc, Text), '#pop:2'),
(words((
'define', 'undef', 'if', 'ifdef', 'ifndef', 'else', 'elif',
'elifdef', 'elifndef', 'endif', 'expand', 'filter', 'unfilter',
'include', 'includesubst', 'error')),
Comment.Preproc, '#pop'),
],
'expr': [
(words(('!', '!=', '==', '&&', '||')), Operator),
(r'(defined)(\()', bygroups(Keyword, Punctuation)),
(r'\)', Punctuation),
(r'[0-9]+', Number.Decimal),
(r'__\w+?__', Name.Variable),
(r'@\w+?@', Name.Class),
(r'\w+', Name),
(r'\n', Text, '#pop'),
(r'\s+', Text),
(r'\S', Punctuation),
],
}
class AmbientTalkLexer(RegexLexer):
"""
Lexer for `AmbientTalk <https://code.google.com/p/ambienttalk>`_ source code.
.. versionadded:: 2.0
"""
name = 'AmbientTalk'
filenames = ['*.at']
aliases = ['at', 'ambienttalk', 'ambienttalk/2']
mimetypes = ['text/x-ambienttalk']
flags = re.MULTILINE | re.DOTALL
builtin = words(('if:', 'then:', 'else:', 'when:', 'whenever:',
'discovered:', 'disconnected:', 'reconnected:',
'takenOffline:', 'becomes:', 'export:', 'as:', 'object:',
'actor:', 'mirror:', 'taggedAs:', 'mirroredBy:', 'is:'))
tokens = {
'root': [
(r'\s+', Text),
(r'//.*?\n', Comment.Single),
(r'/\*.*?\*/', Comment.Multiline),
(r'(def|deftype|import|alias|exclude)\b', Keyword),
(builtin, Name.Builtin),
(r'(true|false|nil)\b', Keyword.Constant),
(r'(~|lobby|jlobby|/)\.', Keyword.Constant, 'namespace'),
(r'"(\\\\|\\"|[^"])*"', String),
(r'\|', Punctuation, 'arglist'),
(r'<:|[*^!%&<>+=,./?-]|:=', Operator),
(r"`[a-zA-Z_]\w*", String.Symbol),
(r"[a-zA-Z_]\w*:", Name.Function),
(r"[{}()\[\];`]", Punctuation),
(r'(self|super)\b', Name.Variable.Instance),
(r"[a-zA-Z_]\w*", Name.Variable),
(r"@[a-zA-Z_]\w*", Name.Class),
(r"@\[", Name.Class, 'annotations'),
include('numbers'),
],
'numbers': [(r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
(r'\d+', Number.Integer)],
'namespace': [(r'[a-zA-Z_]\w*\.', Name.Namespace),
(r'[a-zA-Z_]\w*:', Name.Function, '#pop'),
(r'[a-zA-Z_]\w*(?!\.)', Name.Function, '#pop')],
'annotations': [(r"(.*?)\]", Name.Class, '#pop')],
'arglist': [
(r'\|', Punctuation, '#pop'),
(r'\s*(,)\s*', Punctuation),
(r'[a-zA-Z_]\w*', Name.Variable),
],
}
class MqlLexer(CppLexer):
"""
For `MQL4 <http://docs.mql4.com/>`_ and
`MQL5 <http://www.mql5.com/en/docs>`_ source code.
.. versionadded:: 2.0
"""
name = 'MQL'
aliases = ['mql', 'mq4', 'mq5', 'mql4', 'mql5']
filenames = ['*.mq4', '*.mq5', '*.mqh']
mimetypes = ['text/x-mql']
tokens = {
'statements': [
(words(_mql_builtins.keywords, suffix=r'\b'), Keyword),
(words(_mql_builtins.c_types, suffix=r'\b'), Keyword.Type),
(words(_mql_builtins.types, suffix=r'\b'), Name.Function),
(words(_mql_builtins.constants, suffix=r'\b'), Name.Constant),
(words(_mql_builtins.colors, prefix='(clr)?', suffix=r'\b'),
Name.Constant),
inherit,
],
}
class EzhilLexer(RegexLexer):
"""
Lexer for `Ezhil, a Tamil script-based programming language <http://ezhillang.org>`_
.. versionadded:: 2.1
"""
name = 'Ezhil'
aliases = ['ezhil']
filenames = ['*.n']
mimetypes = ['text/x-ezhil']
flags = re.MULTILINE | re.UNICODE
# Refer to tamil.utf8.tamil_letters from open-tamil for a stricter version of this.
# This much simpler version is close enough, and includes combining marks.
_TALETTERS = u'[a-zA-Z_]|[\u0b80-\u0bff]'
tokens = {
'root': [
include('keywords'),
(r'#.*\n', Comment.Single),
(r'[@+/*,^\-%]|[!<>=]=?|&&?|\|\|?', Operator),
(u'இல்', Operator.Word),
(words((u'assert', u'max', u'min',
u'நீளம்', u'சரம்_இடமாற்று', u'சரம்_கண்டுபிடி',
u'பட்டியல்', u'பின்இணை', u'வரிசைப்படுத்து',
u'எடு', u'தலைகீழ்', u'நீட்டிக்க', u'நுழைக்க', u'வை',
u'கோப்பை_திற', u'கோப்பை_எழுது', u'கோப்பை_மூடு',
u'pi', u'sin', u'cos', u'tan', u'sqrt', u'hypot', u'pow',
u'exp', u'log', u'log10', u'exit',
), suffix=r'\b'), Name.Builtin),
(r'(True|False)\b', Keyword.Constant),
(r'[^\S\n]+', Text),
include('identifier'),
include('literal'),
(r'[(){}\[\]:;.]', Punctuation),
],
'keywords': [
(u'பதிப்பி|தேர்ந்தெடு|தேர்வு|ஏதேனில்|ஆனால்|இல்லைஆனால்|இல்லை|ஆக|ஒவ்வொன்றாக|இல்|வரை|செய்|முடியேனில்|பின்கொடு|முடி|நிரல்பாகம்|தொடர்|நிறுத்து|நிரல்பாகம்', Keyword),
],
'identifier': [
(u'(?:'+_TALETTERS+u')(?:[0-9]|'+_TALETTERS+u')*', Name),
],
'literal': [
(r'".*?"', String),
(r'(?u)\d+((\.\d*)?[eE][+-]?\d+|\.\d*)', Number.Float),
(r'(?u)\d+', Number.Integer),
]
}
def __init__(self, **options):
super(EzhilLexer, self).__init__(**options)
self.encoding = options.get('encoding', 'utf-8')
