diff options
Diffstat (limited to 'pygments/lexers/compiled.py')
| -rw-r--r-- | pygments/lexers/compiled.py | 5386 |
1 files changed, 23 insertions, 5363 deletions
diff --git a/pygments/lexers/compiled.py b/pygments/lexers/compiled.py index cdf0a6fc..a5601b17 100644 --- a/pygments/lexers/compiled.py +++ b/pygments/lexers/compiled.py @@ -3,5373 +3,33 @@ pygments.lexers.compiled ~~~~~~~~~~~~~~~~~~~~~~~~ - Lexers for compiled languages. + Just export lexer classes previously contained in this module. :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ -import re -from string import Template - -from pygments.lexer import Lexer, RegexLexer, include, bygroups, using, \ - this, combined, inherit, do_insertions, default, words -from pygments.util import get_bool_opt, get_list_opt -from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ - Number, Punctuation, Error, Literal, Generic -from pygments.scanner import Scanner - -# backwards compatibility from pygments.lexers.functional import OcamlLexer from pygments.lexers.jvm import JavaLexer, ScalaLexer - -__all__ = ['CLexer', 'CppLexer', 'DLexer', 'DelphiLexer', 'ECLexer', - 'NesCLexer', 'DylanLexer', 'ObjectiveCLexer', 'ObjectiveCppLexer', - 'FortranLexer', 'GLShaderLexer', 'PrologLexer', 'CythonLexer', - 'ValaLexer', 'OocLexer', 'GoLexer', 'FelixLexer', 'AdaLexer', - 'Modula2Lexer', 'BlitzMaxLexer', 'BlitzBasicLexer', 'NimrodLexer', - 'FantomLexer', 'RustLexer', 'CudaLexer', 'MonkeyLexer', 'SwigLexer', - 'DylanLidLexer', 'DylanConsoleLexer', 'CobolLexer', - 'CobolFreeformatLexer', 'LogosLexer', 'ClayLexer', 'PikeLexer', - 'ChapelLexer', 'EiffelLexer', 'Inform6Lexer', 'Inform7Lexer', - 'Inform6TemplateLexer', 'MqlLexer', 'SwiftLexer', 'NitLexer'] - - -class CFamilyLexer(RegexLexer): - """ - For C family source code. This is used as a base class to avoid repetitious - definitions. - """ - - #: optional Comment or Whitespace - _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+' - #: only one /* */ style comment - _ws1 = r'\s*(?:/[*].*?[*]/\s*)*' - - tokens = { - 'whitespace': [ - # preprocessor directives: without whitespace - ('^#if\s+0', Comment.Preproc, 'if0'), - ('^#', Comment.Preproc, 'macro'), - # or with whitespace - ('^(' + _ws1 + r')(#if\s+0)', - bygroups(using(this), Comment.Preproc), 'if0'), - ('^(' + _ws1 + ')(#)', - bygroups(using(this), Comment.Preproc), 'macro'), - (r'\n', Text), - (r'\s+', Text), - (r'\\\n', Text), # line continuation - (r'//(\n|(.|\n)*?[^\\]\n)', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - ], - 'statements': [ - (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+[LlUu]*', Number.Float), - (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float), - (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex), - (r'0[0-7]+[LlUu]*', Number.Oct), - (r'\d+[LlUu]*', Number.Integer), - (r'\*/', Error), - (r'[~!%^&*+=|?:<>/-]', Operator), - (r'[()\[\],.]', Punctuation), - (words(('auto', 'break', 'case', 'const', 'continue', 'default', 'do', - 'else', 'enum', 'extern', 'for', 'goto', 'if', 'register', - 'restricted', 'return', 'sizeof', 'static', 'struct', - 'switch', 'typedef', 'union', 'volatile', 'while'), - suffix=r'\b'), Keyword), - (r'(bool|int|long|float|short|double|char|unsigned|signed|void|' - r'[a-z_][a-z0-9_]*_t)\b', - Keyword.Type), - (words(('inline', '_inline', '__inline', 'naked', 'restrict', - 'thread', 'typename'), suffix=r'\b'), Keyword.Reserved), - # Vector intrinsics - (r'(__m(128i|128d|128|64))\b', Keyword.Reserved), - # Microsoft-isms - (words(( - 'asm', 'int8', 'based', 'except', 'int16', 'stdcall', 'cdecl', - 'fastcall', 'int32', 'declspec', 'finally', 'int64', 'try', - 'leave', 'wchar_t', 'w64', 'unaligned', 'raise', 'noop', - 'identifier', 'forceinline', 'assume'), - prefix=r'__', suffix=r'\b'), Keyword.Reserved), - (r'(true|false|NULL)\b', Name.Builtin), - (r'([a-zA-Z_]\w*)(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)), - ('[a-zA-Z_]\w*', Name), - ], - 'root': [ - include('whitespace'), - # functions - (r'((?:[\w*\s])+?(?:\s|[*]))' # return arguments - r'([a-zA-Z_]\w*)' # method name - r'(\s*\([^;]*?\))' # signature - r'(' + _ws + r')?({)', - bygroups(using(this), Name.Function, using(this), using(this), - Punctuation), - 'function'), - # function declarations - (r'((?:[\w*\s])+?(?:\s|[*]))' # return arguments - r'([a-zA-Z_]\w*)' # method name - r'(\s*\([^;]*?\))' # signature - r'(' + _ws + r')?(;)', - bygroups(using(this), Name.Function, using(this), using(this), - Punctuation)), - default('statement'), - ], - 'statement': [ - include('whitespace'), - include('statements'), - ('[{}]', Punctuation), - (';', Punctuation, '#pop'), - ], - 'function': [ - include('whitespace'), - include('statements'), - (';', Punctuation), - ('{', Punctuation, '#push'), - ('}', Punctuation, '#pop'), - ], - 'string': [ - (r'"', String, '#pop'), - (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|' - r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[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'), - ], - 'if0': [ - (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'), - (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'), - (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'), - (r'.*?\n', Comment), - ] - } - - stdlib_types = ['size_t', 'ssize_t', 'off_t', 'wchar_t', 'ptrdiff_t', - 'sig_atomic_t', 'fpos_t', 'clock_t', 'time_t', 'va_list', - 'jmp_buf', 'FILE', 'DIR', 'div_t', 'ldiv_t', 'mbstate_t', - 'wctrans_t', 'wint_t', 'wctype_t'] - c99_types = ['_Bool', '_Complex', 'int8_t', 'int16_t', 'int32_t', 'int64_t', - 'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int_least8_t', - 'int_least16_t', 'int_least32_t', 'int_least64_t', - 'uint_least8_t', 'uint_least16_t', 'uint_least32_t', - 'uint_least64_t', 'int_fast8_t', 'int_fast16_t', 'int_fast32_t', - 'int_fast64_t', 'uint_fast8_t', 'uint_fast16_t', 'uint_fast32_t', - 'uint_fast64_t', 'intptr_t', 'uintptr_t', 'intmax_t', - 'uintmax_t'] - - def __init__(self, **options): - self.stdlibhighlighting = get_bool_opt(options, - 'stdlibhighlighting', True) - self.c99highlighting = get_bool_opt(options, - 'c99highlighting', True) - RegexLexer.__init__(self, **options) - - def get_tokens_unprocessed(self, text): - for index, token, value in \ - RegexLexer.get_tokens_unprocessed(self, text): - if token is Name: - if self.stdlibhighlighting and value in self.stdlib_types: - token = Keyword.Type - elif self.c99highlighting and value in self.c99_types: - token = Keyword.Type - yield index, token, value - - -class CLexer(CFamilyLexer): - """ - For C source code with preprocessor directives. - """ - name = 'C' - aliases = ['c'] - filenames = ['*.c', '*.h', '*.idc'] - mimetypes = ['text/x-chdr', 'text/x-csrc'] - priority = 0.1 - - def analyse_text(text): - if re.search('#include [<"]', text): - return 0.1 - - -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(( - 'asm', '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', - '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'), - 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 PikeLexer(CppLexer): - """ - For `Pike <http://pike.lysator.liu.se/>`_ source code. - - .. versionadded:: 2.0 - """ - name = 'Pike' - aliases = ['pike'] - filenames = ['*.pike', '*.pmod'] - mimetypes = ['text/x-pike'] - - tokens = { - 'statements': [ - (words(( - 'catch', 'new', 'private', 'protected', 'public', 'gauge', - 'throw', 'throws', 'class', 'interface', 'implement', 'abstract', 'extends', 'from', - 'this', 'super', 'new', 'constant', 'final', 'static', 'import', 'use', 'extern', - 'inline', 'proto', 'break', 'continue', 'if', 'else', 'for', - 'while', 'do', 'switch', 'case', 'as', 'in', 'version', 'return', 'true', 'false', 'null', - '__VERSION__', '__MAJOR__', '__MINOR__', '__BUILD__', '__REAL_VERSION__', - '__REAL_MAJOR__', '__REAL_MINOR__', '__REAL_BUILD__', '__DATE__', '__TIME__', - '__FILE__', '__DIR__', '__LINE__', '__AUTO_BIGNUM__', '__NT__', '__PIKE__', - '__amigaos__', '_Pragma', 'static_assert', 'defined', 'sscanf'), suffix=r'\b'), - Keyword), - (r'(bool|int|long|float|short|double|char|string|object|void|mapping|' - r'array|multiset|program|function|lambda|mixed|' - r'[a-z_][a-z0-9_]*_t)\b', - Keyword.Type), - (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'), - (r'[~!%^&*+=|?:<>/-@]', Operator), - inherit, - ], - 'classname': [ - (r'[a-zA-Z_]\w*', Name.Class, '#pop'), - # template specification - (r'\s*(?=>)', Text, '#pop'), - ], - } - - -class SwigLexer(CppLexer): - """ - For `SWIG <http://www.swig.org/>`_ source code. - - .. versionadded:: 2.0 - """ - name = 'SWIG' - aliases = ['swig'] - filenames = ['*.swg', '*.i'] - mimetypes = ['text/swig'] - priority = 0.04 # Lower than C/C++ and Objective C/C++ - - tokens = { - 'statements': [ - # SWIG directives - (r'(%[a-z_][a-z0-9_]*)', Name.Function), - # Special variables - ('\$\**\&?\w+', Name), - # Stringification / additional preprocessor directives - (r'##*[a-zA-Z_]\w*', Comment.Preproc), - inherit, - ], - } - - # This is a far from complete set of SWIG directives - swig_directives = set(( - # Most common directives - '%apply', '%define', '%director', '%enddef', '%exception', '%extend', - '%feature', '%fragment', '%ignore', '%immutable', '%import', '%include', - '%inline', '%insert', '%module', '%newobject', '%nspace', '%pragma', - '%rename', '%shared_ptr', '%template', '%typecheck', '%typemap', - # Less common directives - '%arg', '%attribute', '%bang', '%begin', '%callback', '%catches', '%clear', - '%constant', '%copyctor', '%csconst', '%csconstvalue', '%csenum', - '%csmethodmodifiers', '%csnothrowexception', '%default', '%defaultctor', - '%defaultdtor', '%defined', '%delete', '%delobject', '%descriptor', - '%exceptionclass', '%exceptionvar', '%extend_smart_pointer', '%fragments', - '%header', '%ifcplusplus', '%ignorewarn', '%implicit', '%implicitconv', - '%init', '%javaconst', '%javaconstvalue', '%javaenum', '%javaexception', - '%javamethodmodifiers', '%kwargs', '%luacode', '%mutable', '%naturalvar', - '%nestedworkaround', '%perlcode', '%pythonabc', '%pythonappend', - '%pythoncallback', '%pythoncode', '%pythondynamic', '%pythonmaybecall', - '%pythonnondynamic', '%pythonprepend', '%refobject', '%shadow', '%sizeof', - '%trackobjects', '%types', '%unrefobject', '%varargs', '%warn', - '%warnfilter')) - - def analyse_text(text): - rv = 0 - # Search for SWIG directives, which are conventionally at the beginning of - # a line. The probability of them being within a line is low, so let another - # lexer win in this case. - matches = re.findall(r'^\s*(%[a-z_][a-z0-9_]*)', text, re.M) - for m in matches: - if m in SwigLexer.swig_directives: - rv = 0.98 - break - else: - rv = 0.91 # Fraction higher than MatlabLexer - return rv - - -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', 'virtual', '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, - ], - 'classname': [ - (r'[a-zA-Z_]\w*', Name.Class, '#pop'), - # template specification - (r'\s*(?=>)', Text, '#pop'), - ], - } - - -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 ClayLexer(RegexLexer): - """ - For `Clay <http://claylabs.com/clay/>`_ source. - - .. versionadded:: 2.0 - """ - name = 'Clay' - filenames = ['*.clay'] - aliases = ['clay'] - mimetypes = ['text/x-clay'] - tokens = { - 'root': [ - (r'\s', Text), - (r'//.*?$', Comment.Singleline), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - (r'\b(public|private|import|as|record|variant|instance' - r'|define|overload|default|external|alias' - r'|rvalue|ref|forward|inline|noinline|forceinline' - r'|enum|var|and|or|not|if|else|goto|return|while' - r'|switch|case|break|continue|for|in|true|false|try|catch|throw' - r'|finally|onerror|staticassert|eval|when|newtype' - r'|__FILE__|__LINE__|__COLUMN__|__ARG__' - r')\b', Keyword), - (r'[~!%^&*+=|:<>/-]', Operator), - (r'[#(){}\[\],;.]', Punctuation), - (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex), - (r'\d+[LlUu]*', Number.Integer), - (r'\b(true|false)\b', Name.Builtin), - (r'(?i)[a-z_?][a-z_?0-9]*', Name), - (r'"""', String, 'tdqs'), - (r'"', String, 'dqs'), - ], - 'strings': [ - (r'(?i)\\(x[0-9a-f]{2}|.)', String.Escape), - (r'.', String), - ], - 'nl': [ - (r'\n', String), - ], - 'dqs': [ - (r'"', String, '#pop'), - include('strings'), - ], - 'tdqs': [ - (r'"""', String, '#pop'), - include('strings'), - include('nl'), - ], - } - - -class DLexer(RegexLexer): - """ - For D source. - - .. versionadded:: 1.2 - """ - name = 'D' - filenames = ['*.d', '*.di'] - aliases = ['d'] - mimetypes = ['text/x-dsrc'] - - tokens = { - 'root': [ - (r'\n', Text), - (r'\s+', Text), - # (r'\\\n', Text), # line continuations - # Comments - (r'//(.*?)\n', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - (r'/\+', Comment.Multiline, 'nested_comment'), - # Keywords - (words(( - 'abstract', 'alias', 'align', 'asm', 'assert', 'auto', 'body', - 'break', 'case', 'cast', 'catch', 'class', 'const', 'continue', - 'debug', 'default', 'delegate', 'delete', 'deprecated', 'do', 'else', - 'enum', 'export', 'extern', 'finally', 'final', 'foreach_reverse', - 'foreach', 'for', 'function', 'goto', 'if', 'immutable', 'import', - 'interface', 'invariant', 'inout', 'in', 'is', 'lazy', 'mixin', - 'module', 'new', 'nothrow', 'out', 'override', 'package', 'pragma', - 'private', 'protected', 'public', 'pure', 'ref', 'return', 'scope', - 'shared', 'static', 'struct', 'super', 'switch', 'synchronized', - 'template', 'this', 'throw', 'try', 'typedef', 'typeid', 'typeof', - 'union', 'unittest', 'version', 'volatile', 'while', 'with', - '__gshared', '__traits', '__vector', '__parameters'), - suffix=r'\b'), - Keyword), - (words(( - 'bool', 'byte', 'cdouble', 'cent', 'cfloat', 'char', 'creal', - 'dchar', 'double', 'float', 'idouble', 'ifloat', 'int', 'ireal', - 'long', 'real', 'short', 'ubyte', 'ucent', 'uint', 'ulong', - 'ushort', 'void', 'wchar'), suffix=r'\b'), - Keyword.Type), - (r'(false|true|null)\b', Keyword.Constant), - (words(( - '__FILE__', '__MODULE__', '__LINE__', '__FUNCTION__', '__PRETTY_FUNCTION__' - '', '__DATE__', '__EOF__', '__TIME__', '__TIMESTAMP__', '__VENDOR__', - '__VERSION__'), suffix=r'\b'), - Keyword.Pseudo), - (r'macro\b', Keyword.Reserved), - (r'(string|wstring|dstring|size_t|ptrdiff_t)\b', Name.Builtin), - # FloatLiteral - # -- HexFloat - (r'0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)' - r'[pP][+\-]?[0-9_]+[fFL]?[i]?', Number.Float), - # -- DecimalFloat - (r'[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|' - r'\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?', Number.Float), - (r'\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?', Number.Float), - # IntegerLiteral - # -- Binary - (r'0[Bb][01_]+', Number.Bin), - # -- Octal - (r'0[0-7_]+', Number.Oct), - # -- Hexadecimal - (r'0[xX][0-9a-fA-F_]+', Number.Hex), - # -- Decimal - (r'(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?', Number.Integer), - # CharacterLiteral - (r"""'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}""" - r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'""", - String.Char), - # StringLiteral - # -- WysiwygString - (r'r"[^"]*"[cwd]?', String), - # -- AlternateWysiwygString - (r'`[^`]*`[cwd]?', String), - # -- DoubleQuotedString - (r'"(\\\\|\\"|[^"])*"[cwd]?', String), - # -- EscapeSequence - (r"\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}" - r"|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)", - String), - # -- HexString - (r'x"[0-9a-fA-F_\s]*"[cwd]?', String), - # -- DelimitedString - (r'q"\[', String, 'delimited_bracket'), - (r'q"\(', String, 'delimited_parenthesis'), - (r'q"<', String, 'delimited_angle'), - (r'q"{', String, 'delimited_curly'), - (r'q"([a-zA-Z_]\w*)\n.*?\n\1"', String), - (r'q"(.).*?\1"', String), - # -- TokenString - (r'q{', String, 'token_string'), - # Attributes - (r'@([a-zA-Z_]\w*)?', Name.Decorator), - # Tokens - (r'(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=' - r'|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)' - r'|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]', Punctuation), - # Identifier - (r'[a-zA-Z_]\w*', Name), - # Line - (r'#line\s.*\n', Comment.Special), - ], - 'nested_comment': [ - (r'[^+/]+', Comment.Multiline), - (r'/\+', Comment.Multiline, '#push'), - (r'\+/', Comment.Multiline, '#pop'), - (r'[+/]', Comment.Multiline), - ], - 'token_string': [ - (r'{', Punctuation, 'token_string_nest'), - (r'}', String, '#pop'), - include('root'), - ], - 'token_string_nest': [ - (r'{', Punctuation, '#push'), - (r'}', Punctuation, '#pop'), - include('root'), - ], - 'delimited_bracket': [ - (r'[^\[\]]+', String), - (r'\[', String, 'delimited_inside_bracket'), - (r'\]"', String, '#pop'), - ], - 'delimited_inside_bracket': [ - (r'[^\[\]]+', String), - (r'\[', String, '#push'), - (r'\]', String, '#pop'), - ], - 'delimited_parenthesis': [ - (r'[^\(\)]+', String), - (r'\(', String, 'delimited_inside_parenthesis'), - (r'\)"', String, '#pop'), - ], - 'delimited_inside_parenthesis': [ - (r'[^\(\)]+', String), - (r'\(', String, '#push'), - (r'\)', String, '#pop'), - ], - 'delimited_angle': [ - (r'[^<>]+', String), - (r'<', String, 'delimited_inside_angle'), - (r'>"', String, '#pop'), - ], - 'delimited_inside_angle': [ - (r'[^<>]+', String), - (r'<', String, '#push'), - (r'>', String, '#pop'), - ], - 'delimited_curly': [ - (r'[^{}]+', String), - (r'{', String, 'delimited_inside_curly'), - (r'}"', String, '#pop'), - ], - 'delimited_inside_curly': [ - (r'[^{}]+', String), - (r'{', String, '#push'), - (r'}', String, '#pop'), - ], - } - - -class DelphiLexer(Lexer): - """ - For `Delphi <http://www.borland.com/delphi/>`_ (Borland Object Pascal), - Turbo Pascal and Free Pascal source code. - - Additional options accepted: - - `turbopascal` - Highlight Turbo Pascal specific keywords (default: ``True``). - `delphi` - Highlight Borland Delphi specific keywords (default: ``True``). - `freepascal` - Highlight Free Pascal specific keywords (default: ``True``). - `units` - A list of units that should be considered builtin, supported are - ``System``, ``SysUtils``, ``Classes`` and ``Math``. - Default is to consider all of them builtin. - """ - name = 'Delphi' - aliases = ['delphi', 'pas', 'pascal', 'objectpascal'] - filenames = ['*.pas'] - mimetypes = ['text/x-pascal'] - - TURBO_PASCAL_KEYWORDS = ( - 'absolute', 'and', 'array', 'asm', 'begin', 'break', 'case', - 'const', 'constructor', 'continue', 'destructor', 'div', 'do', - 'downto', 'else', 'end', 'file', 'for', 'function', 'goto', - 'if', 'implementation', 'in', 'inherited', 'inline', 'interface', - 'label', 'mod', 'nil', 'not', 'object', 'of', 'on', 'operator', - 'or', 'packed', 'procedure', 'program', 'record', 'reintroduce', - 'repeat', 'self', 'set', 'shl', 'shr', 'string', 'then', 'to', - 'type', 'unit', 'until', 'uses', 'var', 'while', 'with', 'xor' - ) - - DELPHI_KEYWORDS = ( - 'as', 'class', 'except', 'exports', 'finalization', 'finally', - 'initialization', 'is', 'library', 'on', 'property', 'raise', - 'threadvar', 'try' - ) - - FREE_PASCAL_KEYWORDS = ( - 'dispose', 'exit', 'false', 'new', 'true' - ) - - BLOCK_KEYWORDS = set(( - 'begin', 'class', 'const', 'constructor', 'destructor', 'end', - 'finalization', 'function', 'implementation', 'initialization', - 'label', 'library', 'operator', 'procedure', 'program', 'property', - 'record', 'threadvar', 'type', 'unit', 'uses', 'var' - )) - - FUNCTION_MODIFIERS = set(( - 'alias', 'cdecl', 'export', 'inline', 'interrupt', 'nostackframe', - 'pascal', 'register', 'safecall', 'softfloat', 'stdcall', - 'varargs', 'name', 'dynamic', 'near', 'virtual', 'external', - 'override', 'assembler' - )) - - # XXX: those aren't global. but currently we know no way for defining - # them just for the type context. - DIRECTIVES = set(( - 'absolute', 'abstract', 'assembler', 'cppdecl', 'default', 'far', - 'far16', 'forward', 'index', 'oldfpccall', 'private', 'protected', - 'published', 'public' - )) - - BUILTIN_TYPES = set(( - 'ansichar', 'ansistring', 'bool', 'boolean', 'byte', 'bytebool', - 'cardinal', 'char', 'comp', 'currency', 'double', 'dword', - 'extended', 'int64', 'integer', 'iunknown', 'longbool', 'longint', - 'longword', 'pansichar', 'pansistring', 'pbool', 'pboolean', - 'pbyte', 'pbytearray', 'pcardinal', 'pchar', 'pcomp', 'pcurrency', - 'pdate', 'pdatetime', 'pdouble', 'pdword', 'pextended', 'phandle', - 'pint64', 'pinteger', 'plongint', 'plongword', 'pointer', - 'ppointer', 'pshortint', 'pshortstring', 'psingle', 'psmallint', - 'pstring', 'pvariant', 'pwidechar', 'pwidestring', 'pword', - 'pwordarray', 'pwordbool', 'real', 'real48', 'shortint', - 'shortstring', 'single', 'smallint', 'string', 'tclass', 'tdate', - 'tdatetime', 'textfile', 'thandle', 'tobject', 'ttime', 'variant', - 'widechar', 'widestring', 'word', 'wordbool' - )) - - BUILTIN_UNITS = { - 'System': ( - 'abs', 'acquireexceptionobject', 'addr', 'ansitoutf8', - 'append', 'arctan', 'assert', 'assigned', 'assignfile', - 'beginthread', 'blockread', 'blockwrite', 'break', 'chdir', - 'chr', 'close', 'closefile', 'comptocurrency', 'comptodouble', - 'concat', 'continue', 'copy', 'cos', 'dec', 'delete', - 'dispose', 'doubletocomp', 'endthread', 'enummodules', - 'enumresourcemodules', 'eof', 'eoln', 'erase', 'exceptaddr', - 'exceptobject', 'exclude', 'exit', 'exp', 'filepos', 'filesize', - 'fillchar', 'finalize', 'findclasshinstance', 'findhinstance', - 'findresourcehinstance', 'flush', 'frac', 'freemem', - 'get8087cw', 'getdir', 'getlasterror', 'getmem', - 'getmemorymanager', 'getmodulefilename', 'getvariantmanager', - 'halt', 'hi', 'high', 'inc', 'include', 'initialize', 'insert', - 'int', 'ioresult', 'ismemorymanagerset', 'isvariantmanagerset', - 'length', 'ln', 'lo', 'low', 'mkdir', 'move', 'new', 'odd', - 'olestrtostring', 'olestrtostrvar', 'ord', 'paramcount', - 'paramstr', 'pi', 'pos', 'pred', 'ptr', 'pucs4chars', 'random', - 'randomize', 'read', 'readln', 'reallocmem', - 'releaseexceptionobject', 'rename', 'reset', 'rewrite', 'rmdir', - 'round', 'runerror', 'seek', 'seekeof', 'seekeoln', - 'set8087cw', 'setlength', 'setlinebreakstyle', - 'setmemorymanager', 'setstring', 'settextbuf', - 'setvariantmanager', 'sin', 'sizeof', 'slice', 'sqr', 'sqrt', - 'str', 'stringofchar', 'stringtoolestr', 'stringtowidechar', - 'succ', 'swap', 'trunc', 'truncate', 'typeinfo', - 'ucs4stringtowidestring', 'unicodetoutf8', 'uniquestring', - 'upcase', 'utf8decode', 'utf8encode', 'utf8toansi', - 'utf8tounicode', 'val', 'vararrayredim', 'varclear', - 'widecharlentostring', 'widecharlentostrvar', - 'widechartostring', 'widechartostrvar', - 'widestringtoucs4string', 'write', 'writeln' - ), - 'SysUtils': ( - 'abort', 'addexitproc', 'addterminateproc', 'adjustlinebreaks', - 'allocmem', 'ansicomparefilename', 'ansicomparestr', - 'ansicomparetext', 'ansidequotedstr', 'ansiextractquotedstr', - 'ansilastchar', 'ansilowercase', 'ansilowercasefilename', - 'ansipos', 'ansiquotedstr', 'ansisamestr', 'ansisametext', - 'ansistrcomp', 'ansistricomp', 'ansistrlastchar', 'ansistrlcomp', - 'ansistrlicomp', 'ansistrlower', 'ansistrpos', 'ansistrrscan', - 'ansistrscan', 'ansistrupper', 'ansiuppercase', - 'ansiuppercasefilename', 'appendstr', 'assignstr', 'beep', - 'booltostr', 'bytetocharindex', 'bytetocharlen', 'bytetype', - 'callterminateprocs', 'changefileext', 'charlength', - 'chartobyteindex', 'chartobytelen', 'comparemem', 'comparestr', - 'comparetext', 'createdir', 'createguid', 'currentyear', - 'currtostr', 'currtostrf', 'date', 'datetimetofiledate', - 'datetimetostr', 'datetimetostring', 'datetimetosystemtime', - 'datetimetotimestamp', 'datetostr', 'dayofweek', 'decodedate', - 'decodedatefully', 'decodetime', 'deletefile', 'directoryexists', - 'diskfree', 'disksize', 'disposestr', 'encodedate', 'encodetime', - 'exceptionerrormessage', 'excludetrailingbackslash', - 'excludetrailingpathdelimiter', 'expandfilename', - 'expandfilenamecase', 'expanduncfilename', 'extractfiledir', - 'extractfiledrive', 'extractfileext', 'extractfilename', - 'extractfilepath', 'extractrelativepath', 'extractshortpathname', - 'fileage', 'fileclose', 'filecreate', 'filedatetodatetime', - 'fileexists', 'filegetattr', 'filegetdate', 'fileisreadonly', - 'fileopen', 'fileread', 'filesearch', 'fileseek', 'filesetattr', - 'filesetdate', 'filesetreadonly', 'filewrite', 'finalizepackage', - 'findclose', 'findcmdlineswitch', 'findfirst', 'findnext', - 'floattocurr', 'floattodatetime', 'floattodecimal', 'floattostr', - 'floattostrf', 'floattotext', 'floattotextfmt', 'fmtloadstr', - 'fmtstr', 'forcedirectories', 'format', 'formatbuf', 'formatcurr', - 'formatdatetime', 'formatfloat', 'freeandnil', 'getcurrentdir', - 'getenvironmentvariable', 'getfileversion', 'getformatsettings', - 'getlocaleformatsettings', 'getmodulename', 'getpackagedescription', - 'getpackageinfo', 'gettime', 'guidtostring', 'incamonth', - 'includetrailingbackslash', 'includetrailingpathdelimiter', - 'incmonth', 'initializepackage', 'interlockeddecrement', - 'interlockedexchange', 'interlockedexchangeadd', - 'interlockedincrement', 'inttohex', 'inttostr', 'isdelimiter', - 'isequalguid', 'isleapyear', 'ispathdelimiter', 'isvalidident', - 'languages', 'lastdelimiter', 'loadpackage', 'loadstr', - 'lowercase', 'msecstotimestamp', 'newstr', 'nextcharindex', 'now', - 'outofmemoryerror', 'quotedstr', 'raiselastoserror', - 'raiselastwin32error', 'removedir', 'renamefile', 'replacedate', - 'replacetime', 'safeloadlibrary', 'samefilename', 'sametext', - 'setcurrentdir', 'showexception', 'sleep', 'stralloc', 'strbufsize', - 'strbytetype', 'strcat', 'strcharlength', 'strcomp', 'strcopy', - 'strdispose', 'strecopy', 'strend', 'strfmt', 'stricomp', - 'stringreplace', 'stringtoguid', 'strlcat', 'strlcomp', 'strlcopy', - 'strlen', 'strlfmt', 'strlicomp', 'strlower', 'strmove', 'strnew', - 'strnextchar', 'strpas', 'strpcopy', 'strplcopy', 'strpos', - 'strrscan', 'strscan', 'strtobool', 'strtobooldef', 'strtocurr', - 'strtocurrdef', 'strtodate', 'strtodatedef', 'strtodatetime', - 'strtodatetimedef', 'strtofloat', 'strtofloatdef', 'strtoint', - 'strtoint64', 'strtoint64def', 'strtointdef', 'strtotime', - 'strtotimedef', 'strupper', 'supports', 'syserrormessage', - 'systemtimetodatetime', 'texttofloat', 'time', 'timestamptodatetime', - 'timestamptomsecs', 'timetostr', 'trim', 'trimleft', 'trimright', - 'tryencodedate', 'tryencodetime', 'tryfloattocurr', 'tryfloattodatetime', - 'trystrtobool', 'trystrtocurr', 'trystrtodate', 'trystrtodatetime', - 'trystrtofloat', 'trystrtoint', 'trystrtoint64', 'trystrtotime', - 'unloadpackage', 'uppercase', 'widecomparestr', 'widecomparetext', - 'widefmtstr', 'wideformat', 'wideformatbuf', 'widelowercase', - 'widesamestr', 'widesametext', 'wideuppercase', 'win32check', - 'wraptext' - ), - 'Classes': ( - 'activateclassgroup', 'allocatehwnd', 'bintohex', 'checksynchronize', - 'collectionsequal', 'countgenerations', 'deallocatehwnd', 'equalrect', - 'extractstrings', 'findclass', 'findglobalcomponent', 'getclass', - 'groupdescendantswith', 'hextobin', 'identtoint', - 'initinheritedcomponent', 'inttoident', 'invalidpoint', - 'isuniqueglobalcomponentname', 'linestart', 'objectbinarytotext', - 'objectresourcetotext', 'objecttexttobinary', 'objecttexttoresource', - 'pointsequal', 'readcomponentres', 'readcomponentresex', - 'readcomponentresfile', 'rect', 'registerclass', 'registerclassalias', - 'registerclasses', 'registercomponents', 'registerintegerconsts', - 'registernoicon', 'registernonactivex', 'smallpoint', 'startclassgroup', - 'teststreamformat', 'unregisterclass', 'unregisterclasses', - 'unregisterintegerconsts', 'unregistermoduleclasses', - 'writecomponentresfile' - ), - 'Math': ( - 'arccos', 'arccosh', 'arccot', 'arccoth', 'arccsc', 'arccsch', 'arcsec', - 'arcsech', 'arcsin', 'arcsinh', 'arctan2', 'arctanh', 'ceil', - 'comparevalue', 'cosecant', 'cosh', 'cot', 'cotan', 'coth', 'csc', - 'csch', 'cycletodeg', 'cycletograd', 'cycletorad', 'degtocycle', - 'degtograd', 'degtorad', 'divmod', 'doubledecliningbalance', - 'ensurerange', 'floor', 'frexp', 'futurevalue', 'getexceptionmask', - 'getprecisionmode', 'getroundmode', 'gradtocycle', 'gradtodeg', - 'gradtorad', 'hypot', 'inrange', 'interestpayment', 'interestrate', - 'internalrateofreturn', 'intpower', 'isinfinite', 'isnan', 'iszero', - 'ldexp', 'lnxp1', 'log10', 'log2', 'logn', 'max', 'maxintvalue', - 'maxvalue', 'mean', 'meanandstddev', 'min', 'minintvalue', 'minvalue', - 'momentskewkurtosis', 'netpresentvalue', 'norm', 'numberofperiods', - 'payment', 'periodpayment', 'poly', 'popnstddev', 'popnvariance', - 'power', 'presentvalue', 'radtocycle', 'radtodeg', 'radtograd', - 'randg', 'randomrange', 'roundto', 'samevalue', 'sec', 'secant', - 'sech', 'setexceptionmask', 'setprecisionmode', 'setroundmode', - 'sign', 'simpleroundto', 'sincos', 'sinh', 'slndepreciation', 'stddev', - 'sum', 'sumint', 'sumofsquares', 'sumsandsquares', 'syddepreciation', - 'tan', 'tanh', 'totalvariance', 'variance' - ) - } - - ASM_REGISTERS = set(( - 'ah', 'al', 'ax', 'bh', 'bl', 'bp', 'bx', 'ch', 'cl', 'cr0', - 'cr1', 'cr2', 'cr3', 'cr4', 'cs', 'cx', 'dh', 'di', 'dl', 'dr0', - 'dr1', 'dr2', 'dr3', 'dr4', 'dr5', 'dr6', 'dr7', 'ds', 'dx', - 'eax', 'ebp', 'ebx', 'ecx', 'edi', 'edx', 'es', 'esi', 'esp', - 'fs', 'gs', 'mm0', 'mm1', 'mm2', 'mm3', 'mm4', 'mm5', 'mm6', - 'mm7', 'si', 'sp', 'ss', 'st0', 'st1', 'st2', 'st3', 'st4', 'st5', - 'st6', 'st7', 'xmm0', 'xmm1', 'xmm2', 'xmm3', 'xmm4', 'xmm5', - 'xmm6', 'xmm7' - )) - - ASM_INSTRUCTIONS = set(( - 'aaa', 'aad', 'aam', 'aas', 'adc', 'add', 'and', 'arpl', 'bound', - 'bsf', 'bsr', 'bswap', 'bt', 'btc', 'btr', 'bts', 'call', 'cbw', - 'cdq', 'clc', 'cld', 'cli', 'clts', 'cmc', 'cmova', 'cmovae', - 'cmovb', 'cmovbe', 'cmovc', 'cmovcxz', 'cmove', 'cmovg', - 'cmovge', 'cmovl', 'cmovle', 'cmovna', 'cmovnae', 'cmovnb', - 'cmovnbe', 'cmovnc', 'cmovne', 'cmovng', 'cmovnge', 'cmovnl', - 'cmovnle', 'cmovno', 'cmovnp', 'cmovns', 'cmovnz', 'cmovo', - 'cmovp', 'cmovpe', 'cmovpo', 'cmovs', 'cmovz', 'cmp', 'cmpsb', - 'cmpsd', 'cmpsw', 'cmpxchg', 'cmpxchg486', 'cmpxchg8b', 'cpuid', - 'cwd', 'cwde', 'daa', 'das', 'dec', 'div', 'emms', 'enter', 'hlt', - 'ibts', 'icebp', 'idiv', 'imul', 'in', 'inc', 'insb', 'insd', - 'insw', 'int', 'int01', 'int03', 'int1', 'int3', 'into', 'invd', - 'invlpg', 'iret', 'iretd', 'iretw', 'ja', 'jae', 'jb', 'jbe', - 'jc', 'jcxz', 'jcxz', 'je', 'jecxz', 'jg', 'jge', 'jl', 'jle', - 'jmp', 'jna', 'jnae', 'jnb', 'jnbe', 'jnc', 'jne', 'jng', 'jnge', - 'jnl', 'jnle', 'jno', 'jnp', 'jns', 'jnz', 'jo', 'jp', 'jpe', - 'jpo', 'js', 'jz', 'lahf', 'lar', 'lcall', 'lds', 'lea', 'leave', - 'les', 'lfs', 'lgdt', 'lgs', 'lidt', 'ljmp', 'lldt', 'lmsw', - 'loadall', 'loadall286', 'lock', 'lodsb', 'lodsd', 'lodsw', - 'loop', 'loope', 'loopne', 'loopnz', 'loopz', 'lsl', 'lss', 'ltr', - 'mov', 'movd', 'movq', 'movsb', 'movsd', 'movsw', 'movsx', - 'movzx', 'mul', 'neg', 'nop', 'not', 'or', 'out', 'outsb', 'outsd', - 'outsw', 'pop', 'popa', 'popad', 'popaw', 'popf', 'popfd', 'popfw', - 'push', 'pusha', 'pushad', 'pushaw', 'pushf', 'pushfd', 'pushfw', - 'rcl', 'rcr', 'rdmsr', 'rdpmc', 'rdshr', 'rdtsc', 'rep', 'repe', - 'repne', 'repnz', 'repz', 'ret', 'retf', 'retn', 'rol', 'ror', - 'rsdc', 'rsldt', 'rsm', 'sahf', 'sal', 'salc', 'sar', 'sbb', - 'scasb', 'scasd', 'scasw', 'seta', 'setae', 'setb', 'setbe', - 'setc', 'setcxz', 'sete', 'setg', 'setge', 'setl', 'setle', - 'setna', 'setnae', 'setnb', 'setnbe', 'setnc', 'setne', 'setng', - 'setnge', 'setnl', 'setnle', 'setno', 'setnp', 'setns', 'setnz', - 'seto', 'setp', 'setpe', 'setpo', 'sets', 'setz', 'sgdt', 'shl', - 'shld', 'shr', 'shrd', 'sidt', 'sldt', 'smi', 'smint', 'smintold', - 'smsw', 'stc', 'std', 'sti', 'stosb', 'stosd', 'stosw', 'str', - 'sub', 'svdc', 'svldt', 'svts', 'syscall', 'sysenter', 'sysexit', - 'sysret', 'test', 'ud1', 'ud2', 'umov', 'verr', 'verw', 'wait', - 'wbinvd', 'wrmsr', 'wrshr', 'xadd', 'xbts', 'xchg', 'xlat', - 'xlatb', 'xor' - )) - - def __init__(self, **options): - Lexer.__init__(self, **options) - self.keywords = set() - if get_bool_opt(options, 'turbopascal', True): - self.keywords.update(self.TURBO_PASCAL_KEYWORDS) - if get_bool_opt(options, 'delphi', True): - self.keywords.update(self.DELPHI_KEYWORDS) - if get_bool_opt(options, 'freepascal', True): - self.keywords.update(self.FREE_PASCAL_KEYWORDS) - self.builtins = set() - for unit in get_list_opt(options, 'units', list(self.BUILTIN_UNITS)): - self.builtins.update(self.BUILTIN_UNITS[unit]) - - def get_tokens_unprocessed(self, text): - scanner = Scanner(text, re.DOTALL | re.MULTILINE | re.IGNORECASE) - stack = ['initial'] - in_function_block = False - in_property_block = False - was_dot = False - next_token_is_function = False - next_token_is_property = False - collect_labels = False - block_labels = set() - brace_balance = [0, 0] - - while not scanner.eos: - token = Error - - if stack[-1] == 'initial': - if scanner.scan(r'\s+'): - token = Text - elif scanner.scan(r'\{.*?\}|\(\*.*?\*\)'): - if scanner.match.startswith('$'): - token = Comment.Preproc - else: - token = Comment.Multiline - elif scanner.scan(r'//.*?$'): - token = Comment.Single - elif scanner.scan(r'[-+*\/=<>:;,.@\^]'): - token = Operator - # stop label highlighting on next ";" - if collect_labels and scanner.match == ';': - collect_labels = False - elif scanner.scan(r'[\(\)\[\]]+'): - token = Punctuation - # abort function naming ``foo = Function(...)`` - next_token_is_function = False - # if we are in a function block we count the open - # braces because ootherwise it's impossible to - # determine the end of the modifier context - if in_function_block or in_property_block: - if scanner.match == '(': - brace_balance[0] += 1 - elif scanner.match == ')': - brace_balance[0] -= 1 - elif scanner.match == '[': - brace_balance[1] += 1 - elif scanner.match == ']': - brace_balance[1] -= 1 - elif scanner.scan(r'[A-Za-z_][A-Za-z_0-9]*'): - lowercase_name = scanner.match.lower() - if lowercase_name == 'result': - token = Name.Builtin.Pseudo - elif lowercase_name in self.keywords: - token = Keyword - # if we are in a special block and a - # block ending keyword occours (and the parenthesis - # is balanced) we end the current block context - if (in_function_block or in_property_block) and \ - lowercase_name in self.BLOCK_KEYWORDS and \ - brace_balance[0] <= 0 and \ - brace_balance[1] <= 0: - in_function_block = False - in_property_block = False - brace_balance = [0, 0] - block_labels = set() - if lowercase_name in ('label', 'goto'): - collect_labels = True - elif lowercase_name == 'asm': - stack.append('asm') - elif lowercase_name == 'property': - in_property_block = True - next_token_is_property = True - elif lowercase_name in ('procedure', 'operator', - 'function', 'constructor', - 'destructor'): - in_function_block = True - next_token_is_function = True - # we are in a function block and the current name - # is in the set of registered modifiers. highlight - # it as pseudo keyword - elif in_function_block and \ - lowercase_name in self.FUNCTION_MODIFIERS: - token = Keyword.Pseudo - # if we are in a property highlight some more - # modifiers - elif in_property_block and \ - lowercase_name in ('read', 'write'): - token = Keyword.Pseudo - next_token_is_function = True - # if the last iteration set next_token_is_function - # to true we now want this name highlighted as - # function. so do that and reset the state - elif next_token_is_function: - # Look if the next token is a dot. If yes it's - # not a function, but a class name and the - # part after the dot a function name - if scanner.test(r'\s*\.\s*'): - token = Name.Class - # it's not a dot, our job is done - else: - token = Name.Function - next_token_is_function = False - # same for properties - elif next_token_is_property: - token = Name.Property - next_token_is_property = False - # Highlight this token as label and add it - # to the list of known labels - elif collect_labels: - token = Name.Label - block_labels.add(scanner.match.lower()) - # name is in list of known labels - elif lowercase_name in block_labels: - token = Name.Label - elif lowercase_name in self.BUILTIN_TYPES: - token = Keyword.Type - elif lowercase_name in self.DIRECTIVES: - token = Keyword.Pseudo - # builtins are just builtins if the token - # before isn't a dot - elif not was_dot and lowercase_name in self.builtins: - token = Name.Builtin - else: - token = Name - elif scanner.scan(r"'"): - token = String - stack.append('string') - elif scanner.scan(r'\#(\d+|\$[0-9A-Fa-f]+)'): - token = String.Char - elif scanner.scan(r'\$[0-9A-Fa-f]+'): - token = Number.Hex - elif scanner.scan(r'\d+(?![eE]|\.[^.])'): - token = Number.Integer - elif scanner.scan(r'\d+(\.\d+([eE][+-]?\d+)?|[eE][+-]?\d+)'): - token = Number.Float - else: - # if the stack depth is deeper than once, pop - if len(stack) > 1: - stack.pop() - scanner.get_char() - - elif stack[-1] == 'string': - if scanner.scan(r"''"): - token = String.Escape - elif scanner.scan(r"'"): - token = String - stack.pop() - elif scanner.scan(r"[^']*"): - token = String - else: - scanner.get_char() - stack.pop() - - elif stack[-1] == 'asm': - if scanner.scan(r'\s+'): - token = Text - elif scanner.scan(r'end'): - token = Keyword - stack.pop() - elif scanner.scan(r'\{.*?\}|\(\*.*?\*\)'): - if scanner.match.startswith('$'): - token = Comment.Preproc - else: - token = Comment.Multiline - elif scanner.scan(r'//.*?$'): - token = Comment.Single - elif scanner.scan(r"'"): - token = String - stack.append('string') - elif scanner.scan(r'@@[A-Za-z_][A-Za-z_0-9]*'): - token = Name.Label - elif scanner.scan(r'[A-Za-z_][A-Za-z_0-9]*'): - lowercase_name = scanner.match.lower() - if lowercase_name in self.ASM_INSTRUCTIONS: - token = Keyword - elif lowercase_name in self.ASM_REGISTERS: - token = Name.Builtin - else: - token = Name - elif scanner.scan(r'[-+*\/=<>:;,.@\^]+'): - token = Operator - elif scanner.scan(r'[\(\)\[\]]+'): - token = Punctuation - elif scanner.scan(r'\$[0-9A-Fa-f]+'): - token = Number.Hex - elif scanner.scan(r'\d+(?![eE]|\.[^.])'): - token = Number.Integer - elif scanner.scan(r'\d+(\.\d+([eE][+-]?\d+)?|[eE][+-]?\d+)'): - token = Number.Float - else: - scanner.get_char() - stack.pop() - - # save the dot!!!11 - if scanner.match.strip(): - was_dot = scanner.match == '.' - yield scanner.start_pos, token, scanner.match or '' - - -class DylanLexer(RegexLexer): - """ - For the `Dylan <http://www.opendylan.org/>`_ language. - - .. versionadded:: 0.7 - """ - - name = 'Dylan' - aliases = ['dylan'] - filenames = ['*.dylan', '*.dyl', '*.intr'] - mimetypes = ['text/x-dylan'] - - flags = re.IGNORECASE - - builtins = set(( - 'subclass', 'abstract', 'block', 'concrete', 'constant', 'class', - 'compiler-open', 'compiler-sideways', 'domain', 'dynamic', - 'each-subclass', 'exception', 'exclude', 'function', 'generic', - 'handler', 'inherited', 'inline', 'inline-only', 'instance', - 'interface', 'import', 'keyword', 'library', 'macro', 'method', - 'module', 'open', 'primary', 'required', 'sealed', 'sideways', - 'singleton', 'slot', 'thread', 'variable', 'virtual')) - - keywords = set(( - 'above', 'afterwards', 'begin', 'below', 'by', 'case', 'cleanup', - 'create', 'define', 'else', 'elseif', 'end', 'export', 'finally', - 'for', 'from', 'if', 'in', 'let', 'local', 'otherwise', 'rename', - 'select', 'signal', 'then', 'to', 'unless', 'until', 'use', 'when', - 'while')) - - operators = set(( - '~', '+', '-', '*', '|', '^', '=', '==', '~=', '~==', '<', '<=', - '>', '>=', '&', '|')) - - functions = set(( - 'abort', 'abs', 'add', 'add!', 'add-method', 'add-new', 'add-new!', - 'all-superclasses', 'always', 'any?', 'applicable-method?', 'apply', - 'aref', 'aref-setter', 'as', 'as-lowercase', 'as-lowercase!', - 'as-uppercase', 'as-uppercase!', 'ash', 'backward-iteration-protocol', - 'break', 'ceiling', 'ceiling/', 'cerror', 'check-type', 'choose', - 'choose-by', 'complement', 'compose', 'concatenate', 'concatenate-as', - 'condition-format-arguments', 'condition-format-string', 'conjoin', - 'copy-sequence', 'curry', 'default-handler', 'dimension', 'dimensions', - 'direct-subclasses', 'direct-superclasses', 'disjoin', 'do', - 'do-handlers', 'element', 'element-setter', 'empty?', 'error', 'even?', - 'every?', 'false-or', 'fill!', 'find-key', 'find-method', 'first', - 'first-setter', 'floor', 'floor/', 'forward-iteration-protocol', - 'function-arguments', 'function-return-values', - 'function-specializers', 'gcd', 'generic-function-mandatory-keywords', - 'generic-function-methods', 'head', 'head-setter', 'identity', - 'initialize', 'instance?', 'integral?', 'intersection', - 'key-sequence', 'key-test', 'last', 'last-setter', 'lcm', 'limited', - 'list', 'logand', 'logbit?', 'logior', 'lognot', 'logxor', 'make', - 'map', 'map-as', 'map-into', 'max', 'member?', 'merge-hash-codes', - 'min', 'modulo', 'negative', 'negative?', 'next-method', - 'object-class', 'object-hash', 'odd?', 'one-of', 'pair', 'pop', - 'pop-last', 'positive?', 'push', 'push-last', 'range', 'rank', - 'rcurry', 'reduce', 'reduce1', 'remainder', 'remove', 'remove!', - 'remove-duplicates', 'remove-duplicates!', 'remove-key!', - 'remove-method', 'replace-elements!', 'replace-subsequence!', - 'restart-query', 'return-allowed?', 'return-description', - 'return-query', 'reverse', 'reverse!', 'round', 'round/', - 'row-major-index', 'second', 'second-setter', 'shallow-copy', - 'signal', 'singleton', 'size', 'size-setter', 'slot-initialized?', - 'sort', 'sort!', 'sorted-applicable-methods', 'subsequence-position', - 'subtype?', 'table-protocol', 'tail', 'tail-setter', 'third', - 'third-setter', 'truncate', 'truncate/', 'type-error-expected-type', - 'type-error-value', 'type-for-copy', 'type-union', 'union', 'values', - 'vector', 'zero?')) - - valid_name = '\\\\?[a-z0-9' + re.escape('!&*<>|^$%@_-+~?/=') + ']+' - - def get_tokens_unprocessed(self, text): - for index, token, value in RegexLexer.get_tokens_unprocessed(self, text): - if token is Name: - lowercase_value = value.lower() - if lowercase_value in self.builtins: - yield index, Name.Builtin, value - continue - if lowercase_value in self.keywords: - yield index, Keyword, value - continue - if lowercase_value in self.functions: - yield index, Name.Builtin, value - continue - if lowercase_value in self.operators: - yield index, Operator, value - continue - yield index, token, value - - tokens = { - 'root': [ - # Whitespace - (r'\s+', Text), - - # single line comment - (r'//.*?\n', Comment.Single), - - # lid header - (r'([a-z0-9-]+)(:)([ \t]*)(.*(?:\n[ \t].+)*)', - bygroups(Name.Attribute, Operator, Text, String)), - - ('', Text, 'code') # no header match, switch to code - ], - 'code': [ - # Whitespace - (r'\s+', Text), - - # single line comment - (r'//.*?\n', Comment.Single), - - # multi-line comment - (r'/\*', Comment.Multiline, 'comment'), - - # strings and characters - (r'"', String, 'string'), - (r"'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'", String.Char), - - # binary integer - (r'#[bB][01]+', Number.Bin), - - # octal integer - (r'#[oO][0-7]+', Number.Oct), - - # floating point - (r'[-+]?(\d*\.\d+(e[-+]?\d+)?|\d+(\.\d*)?e[-+]?\d+)', Number.Float), - - # decimal integer - (r'[-+]?\d+', Number.Integer), - - # hex integer - (r'#[xX][0-9a-f]+', Number.Hex), - - # Macro parameters - (r'(\?' + valid_name + ')(:)' - r'(token|name|variable|expression|body|case-body|\*)', - bygroups(Name.Tag, Operator, Name.Builtin)), - (r'(\?)(:)(token|name|variable|expression|body|case-body|\*)', - bygroups(Name.Tag, Operator, Name.Builtin)), - (r'\?' + valid_name, Name.Tag), - - # Punctuation - (r'(=>|::|#\(|#\[|##|\?|\?\?|\?=|[(){}\[\],\.;])', Punctuation), - - # Most operators are picked up as names and then re-flagged. - # This one isn't valid in a name though, so we pick it up now. - (r':=', Operator), - - # Pick up #t / #f before we match other stuff with #. - (r'#[tf]', Literal), - - # #"foo" style keywords - (r'#"', String.Symbol, 'keyword'), - - # #rest, #key, #all-keys, etc. - (r'#[a-z0-9-]+', Keyword), - - # required-init-keyword: style keywords. - (valid_name + ':', Keyword), - - # class names - (r'<' + valid_name + '>', Name.Class), - - # define variable forms. - (r'\*' + valid_name + '\*', Name.Variable.Global), - - # define constant forms. - (r'\$' + valid_name, Name.Constant), - - # everything else. We re-flag some of these in the method above. - (valid_name, Name), - ], - 'comment': [ - (r'[^*/]', Comment.Multiline), - (r'/\*', Comment.Multiline, '#push'), - (r'\*/', Comment.Multiline, '#pop'), - (r'[*/]', Comment.Multiline) - ], - 'keyword': [ - (r'"', String.Symbol, '#pop'), - (r'[^\\"]+', String.Symbol), # all other characters - ], - 'string': [ - (r'"', String, '#pop'), - (r'\\([\\abfnrtv"\']|x[a-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 - ] - } - - -class DylanLidLexer(RegexLexer): - """ - For Dylan LID (Library Interchange Definition) files. - - .. versionadded:: 1.6 - """ - - name = 'DylanLID' - aliases = ['dylan-lid', 'lid'] - filenames = ['*.lid', '*.hdp'] - mimetypes = ['text/x-dylan-lid'] - - flags = re.IGNORECASE - - tokens = { - 'root': [ - # Whitespace - (r'\s+', Text), - - # single line comment - (r'//.*?\n', Comment.Single), - - # lid header - (r'(.*?)(:)([ \t]*)(.*(?:\n[ \t].+)*)', - bygroups(Name.Attribute, Operator, Text, String)), - ] - } - - -class DylanConsoleLexer(Lexer): - """ - For Dylan interactive console output like: - - .. sourcecode:: dylan-console - - ? let a = 1; - => 1 - ? a - => 1 - - This is based on a copy of the RubyConsoleLexer. - - .. versionadded:: 1.6 - """ - name = 'Dylan session' - aliases = ['dylan-console', 'dylan-repl'] - filenames = ['*.dylan-console'] - mimetypes = ['text/x-dylan-console'] - - _line_re = re.compile('.*?\n') - _prompt_re = re.compile('\?| ') - - def get_tokens_unprocessed(self, text): - dylexer = DylanLexer(**self.options) - - curcode = '' - insertions = [] - for match in self._line_re.finditer(text): - line = match.group() - m = self._prompt_re.match(line) - if m is not None: - end = m.end() - insertions.append((len(curcode), - [(0, Generic.Prompt, line[:end])])) - curcode += line[end:] - else: - if curcode: - for item in do_insertions(insertions, - dylexer.get_tokens_unprocessed(curcode)): - yield item - curcode = '' - insertions = [] - yield match.start(), Generic.Output, line - if curcode: - for item in do_insertions(insertions, - dylexer.get_tokens_unprocessed(curcode)): - yield item - - -def objective(baselexer): - """ - Generate a subclass of baselexer that accepts the Objective-C syntax - extensions. - """ - - # Have to be careful not to accidentally match JavaDoc/Doxygen syntax here, - # since that's quite common in ordinary C/C++ files. It's OK to match - # JavaDoc/Doxygen keywords that only apply to Objective-C, mind. - # - # The upshot of this is that we CANNOT match @class or @interface - _oc_keywords = re.compile(r'@(?:end|implementation|protocol)') - - # Matches [ <ws>? identifier <ws> ( identifier <ws>? ] | identifier? : ) - # (note the identifier is *optional* when there is a ':'!) - _oc_message = re.compile(r'\[\s*[a-zA-Z_]\w*\s+' - r'(?:[a-zA-Z_]\w*\s*\]|' - r'(?:[a-zA-Z_]\w*)?:)') - - class GeneratedObjectiveCVariant(baselexer): - """ - Implements Objective-C syntax on top of an existing C family lexer. - """ - - tokens = { - 'statements': [ - (r'@"', String, 'string'), - (r'@(YES|NO)', Number), - (r"@'(\\.|\\[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'@0x[0-9a-fA-F]+[Ll]?', Number.Hex), - (r'@0[0-7]+[Ll]?', Number.Oct), - (r'@\d+[Ll]?', Number.Integer), - (r'@\(', Literal, 'literal_number'), - (r'@\[', Literal, 'literal_array'), - (r'@\{', Literal, 'literal_dictionary'), - (words(( - '@selector', '@private', '@protected', '@public', '@encode', - '@synchronized', '@try', '@throw', '@catch', '@finally', - '@end', '@property', '@synthesize', '__bridge', '__bridge_transfer', - '__autoreleasing', '__block', '__weak', '__strong', 'weak', 'strong', - 'copy', 'retain', 'assign', 'unsafe_unretained', 'atomic', 'nonatomic', - 'readonly', 'readwrite', 'setter', 'getter', 'typeof', 'in', - 'out', 'inout', 'release', 'class', '@dynamic', '@optional', - '@required', '@autoreleasepool'), suffix=r'\b'), - Keyword), - (words(('id', 'instancetype', 'Class', 'IMP', 'SEL', 'BOOL', - 'IBOutlet', 'IBAction', 'unichar'), suffix=r'\b'), - Keyword.Type), - (r'@(true|false|YES|NO)\n', Name.Builtin), - (r'(YES|NO|nil|self|super)\b', Name.Builtin), - # Carbon types - (r'(Boolean|UInt8|SInt8|UInt16|SInt16|UInt32|SInt32)\b', Keyword.Type), - # Carbon built-ins - (r'(TRUE|FALSE)\b', Name.Builtin), - (r'(@interface|@implementation)(\s+)', bygroups(Keyword, Text), - ('#pop', 'oc_classname')), - (r'(@class|@protocol)(\s+)', bygroups(Keyword, Text), - ('#pop', 'oc_forward_classname')), - # @ can also prefix other expressions like @{...} or @(...) - (r'@', Punctuation), - inherit, - ], - 'oc_classname': [ - # interface definition that inherits - ('([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?(\s*)({)', - bygroups(Name.Class, Text, Name.Class, Text, Punctuation), - ('#pop', 'oc_ivars')), - ('([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?', - bygroups(Name.Class, Text, Name.Class), '#pop'), - # interface definition for a category - ('([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))(\s*)({)', - bygroups(Name.Class, Text, Name.Label, Text, Punctuation), - ('#pop', 'oc_ivars')), - ('([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))', - bygroups(Name.Class, Text, Name.Label), '#pop'), - # simple interface / implementation - ('([a-zA-Z$_][\w$]*)(\s*)({)', - bygroups(Name.Class, Text, Punctuation), ('#pop', 'oc_ivars')), - ('([a-zA-Z$_][\w$]*)', Name.Class, '#pop') - ], - 'oc_forward_classname': [ - ('([a-zA-Z$_][\w$]*)(\s*,\s*)', - bygroups(Name.Class, Text), 'oc_forward_classname'), - ('([a-zA-Z$_][\w$]*)(\s*;?)', - bygroups(Name.Class, Text), '#pop') - ], - 'oc_ivars': [ - include('whitespace'), - include('statements'), - (';', Punctuation), - ('{', Punctuation, '#push'), - ('}', Punctuation, '#pop'), - ], - 'root': [ - # methods - (r'^([-+])(\s*)' # method marker - r'(\(.*?\))?(\s*)' # return type - r'([a-zA-Z$_][\w$]*:?)', # begin of method name - bygroups(Punctuation, Text, using(this), - Text, Name.Function), - 'method'), - inherit, - ], - 'method': [ - include('whitespace'), - # TODO unsure if ellipses are allowed elsewhere, see - # discussion in Issue 789 - (r',', Punctuation), - (r'\.\.\.', Punctuation), - (r'(\(.*?\))(\s*)([a-zA-Z$_][\w$]*)', - bygroups(using(this), Text, Name.Variable)), - (r'[a-zA-Z$_][\w$]*:', Name.Function), - (';', Punctuation, '#pop'), - ('{', Punctuation, 'function'), - ('', Text, '#pop'), - ], - 'literal_number': [ - (r'\(', Punctuation, 'literal_number_inner'), - (r'\)', Literal, '#pop'), - include('statement'), - ], - 'literal_number_inner': [ - (r'\(', Punctuation, '#push'), - (r'\)', Punctuation, '#pop'), - include('statement'), - ], - 'literal_array': [ - (r'\[', Punctuation, 'literal_array_inner'), - (r'\]', Literal, '#pop'), - include('statement'), - ], - 'literal_array_inner': [ - (r'\[', Punctuation, '#push'), - (r'\]', Punctuation, '#pop'), - include('statement'), - ], - 'literal_dictionary': [ - (r'\}', Literal, '#pop'), - include('statement'), - ], - } - - def analyse_text(text): - if _oc_keywords.search(text): - return 1.0 - elif '@"' in text: # strings - return 0.8 - elif re.search('@[0-9]+', text): - return 0.7 - elif _oc_message.search(text): - return 0.8 - return 0 - - def get_tokens_unprocessed(self, text): - from pygments.lexers._cocoabuiltins import COCOA_INTERFACES, \ - COCOA_PROTOCOLS, COCOA_PRIMITIVES - - for index, token, value in \ - baselexer.get_tokens_unprocessed(self, text): - if token is Name or token is Name.Class: - if value in COCOA_INTERFACES or value in COCOA_PROTOCOLS \ - or value in COCOA_PRIMITIVES: - token = Name.Builtin.Pseudo - - yield index, token, value - - return GeneratedObjectiveCVariant - - -class ObjectiveCLexer(objective(CLexer)): - """ - For Objective-C source code with preprocessor directives. - """ - - name = 'Objective-C' - aliases = ['objective-c', 'objectivec', 'obj-c', 'objc'] - filenames = ['*.m', '*.h'] - mimetypes = ['text/x-objective-c'] - priority = 0.05 # Lower than C - - -class ObjectiveCppLexer(objective(CppLexer)): - """ - For Objective-C++ source code with preprocessor directives. - """ - - name = 'Objective-C++' - aliases = ['objective-c++', 'objectivec++', 'obj-c++', 'objc++'] - filenames = ['*.mm', '*.hh'] - mimetypes = ['text/x-objective-c++'] - priority = 0.05 # Lower than C++ - - -class FortranLexer(RegexLexer): - """ - Lexer for FORTRAN 90 code. - - .. versionadded:: 0.10 - """ - name = 'Fortran' - aliases = ['fortran'] - filenames = ['*.f', '*.f90', '*.F', '*.F90'] - mimetypes = ['text/x-fortran'] - flags = re.IGNORECASE - - # Data Types: INTEGER, REAL, COMPLEX, LOGICAL, CHARACTER and DOUBLE PRECISION - # Operators: **, *, +, -, /, <, >, <=, >=, ==, /= - # Logical (?): NOT, AND, OR, EQV, NEQV - - # Builtins: - # http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Table-of-Intrinsic-Functions.html - - tokens = { - 'root': [ - (r'!.*\n', Comment), - include('strings'), - include('core'), - (r'[a-z]\w*', Name.Variable), - include('nums'), - (r'[\s]+', Text), - ], - 'core': [ - # Statements - (words(( - 'ABSTRACT', 'ACCEPT', 'ALL', 'ALLSTOP', 'ALLOCATABLE', 'ALLOCATE', - 'ARRAY', 'ASSIGN', 'ASSOCIATE', 'ASYNCHRONOUS', 'BACKSPACE', 'BIND', - 'BLOCK', 'BLOCKDATA', 'BYTE', 'CALL', 'CASE', 'CLASS', 'CLOSE', - 'CODIMENSION', 'COMMON', 'CONCURRRENT', 'CONTIGUOUS', 'CONTAINS', - 'CONTINUE', 'CRITICAL', 'CYCLE', 'DATA', 'DEALLOCATE', 'DECODE', - 'DEFERRED', 'DIMENSION', 'DO', 'ELEMENTAL', 'ELSE', 'ENCODE', 'END', - 'ENTRY', 'ENUM', 'ENUMERATOR', 'EQUIVALENCE', 'EXIT', 'EXTENDS', - 'EXTERNAL', 'EXTRINSIC', 'FILE', 'FINAL', 'FORALL', 'FORMAT', - 'FUNCTION', 'GENERIC', 'GOTO', 'IF', 'IMAGES', 'IMPLICIT', - 'IMPORT', 'IMPURE', 'INCLUDE', 'INQUIRE', 'INTENT', 'INTERFACE', - 'INTRINSIC', 'IS', 'LOCK', 'MEMORY', 'MODULE', 'NAMELIST', 'NULLIFY', - 'NONE', 'NON_INTRINSIC', 'NON_OVERRIDABLE', 'NOPASS', 'OPEN', 'OPTIONAL', - 'OPTIONS', 'PARAMETER', 'PASS', 'PAUSE', 'POINTER', 'PRINT', 'PRIVATE', - 'PROGRAM', 'PROCEDURE', 'PROTECTED', 'PUBLIC', 'PURE', 'READ', - 'RECURSIVE', 'RESULT', 'RETURN', 'REWIND', 'SAVE', 'SELECT', 'SEQUENCE', - 'STOP', 'SUBMODULE', 'SUBROUTINE', 'SYNC', 'SYNCALL', 'SYNCIMAGES', - 'SYNCMEMORY', 'TARGET', 'THEN', 'TYPE', 'UNLOCK', 'USE', 'VALUE', - 'VOLATILE', 'WHERE', 'WRITE', 'WHILE'), prefix=r'\b', suffix=r'\s*\b'), - Keyword), - - # Data Types - (words(( - 'CHARACTER', 'COMPLEX', 'DOUBLE PRECISION', 'DOUBLE COMPLEX', 'INTEGER', - 'LOGICAL', 'REAL', 'C_INT', 'C_SHORT', 'C_LONG', 'C_LONG_LONG', 'C_SIGNED_CHAR', - 'C_SIZE_T', 'C_INT8_T', 'C_INT16_T', 'C_INT32_T', 'C_INT64_T', 'C_INT_LEAST8_T', - 'C_INT_LEAST16_T', 'C_INT_LEAST32_T', 'C_INT_LEAST64_T', 'C_INT_FAST8_T', - 'C_INT_FAST16_T', 'C_INT_FAST32_T', 'C_INT_FAST64_T', 'C_INTMAX_T', - 'C_INTPTR_T', 'C_FLOAT', 'C_DOUBLE', 'C_LONG_DOUBLE', 'C_FLOAT_COMPLEX', - 'C_DOUBLE_COMPLEX', 'C_LONG_DOUBLE_COMPLEX', 'C_BOOL', 'C_CHAR', 'C_PTR', - 'C_FUNPTR'), prefix=r'\b', suffix=r'\s*\b'), - Keyword.Type), - - # Operators - (r'(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)', Operator), - - (r'(::)', Keyword.Declaration), - - (r'[()\[\],:&%;]', Punctuation), - # Intrinsics - (words(( - 'Abort', 'Abs', 'Access', 'AChar', 'ACos', 'ACosH', 'AdjustL', - 'AdjustR', 'AImag', 'AInt', 'Alarm', 'All', 'Allocated', 'ALog', - 'AMax', 'AMin', 'AMod', 'And', 'ANInt', 'Any', 'ASin', 'ASinH', - 'Associated', 'ATan', 'ATanH', 'Atomic_Define', 'Atomic_Ref', - 'BesJ', 'BesJN', 'Bessel_J0', 'Bessel_J1', 'Bessel_JN', 'Bessel_Y0', - 'Bessel_Y1', 'Bessel_YN', 'BesY', 'BesYN', 'BGE', 'BGT', 'BLE', - 'BLT', 'Bit_Size', 'BTest', 'CAbs', 'CCos', 'Ceiling', 'CExp', - 'Char', 'ChDir', 'ChMod', 'CLog', 'Cmplx', 'Command_Argument_Count', - 'Complex', 'Conjg', 'Cos', 'CosH', 'Count', 'CPU_Time', 'CShift', - 'CSin', 'CSqRt', 'CTime', 'C_Funloc', 'C_Loc', 'C_Associated', - 'C_Null_Ptr', 'C_Null_Funptr', 'C_F_Pointer', 'C_F_ProcPointer', - 'C_Null_Char', 'C_Alert', 'C_Backspace', 'C_Form_Feed', 'C_FunLoc', - 'C_Loc', 'C_Sizeof', 'C_New_Line', 'C_Carriage_Return', - 'C_Horizontal_Tab', 'C_Vertical_Tab', 'DAbs', 'DACos', 'DASin', - 'DATan', 'Date_and_Time', 'DbesJ', 'DbesJ', 'DbesJN', 'DbesY', - 'DbesY', 'DbesYN', 'Dble', 'DCos', 'DCosH', 'DDiM', 'DErF', - 'DErFC', 'DExp', 'Digits', 'DiM', 'DInt', 'DLog', 'DLog', 'DMax', - 'DMin', 'DMod', 'DNInt', 'Dot_Product', 'DProd', 'DSign', 'DSinH', - 'DShiftL', 'DShiftR', 'DSin', 'DSqRt', 'DTanH', 'DTan', 'DTime', - 'EOShift', 'Epsilon', 'ErF', 'ErFC', 'ErFC_Scaled', 'ETime', - 'Execute_Command_Line', 'Exit', 'Exp', 'Exponent', 'Extends_Type_Of', - 'FDate', 'FGet', 'FGetC', 'FindLoc', 'Float', 'Floor', 'Flush', - 'FNum', 'FPutC', 'FPut', 'Fraction', 'FSeek', 'FStat', 'FTell', - 'Gamma', 'GError', 'GetArg', 'Get_Command', 'Get_Command_Argument', - 'Get_Environment_Variable', 'GetCWD', 'GetEnv', 'GetGId', 'GetLog', - 'GetPId', 'GetUId', 'GMTime', 'HostNm', 'Huge', 'Hypot', 'IAbs', - 'IAChar', 'IAll', 'IAnd', 'IAny', 'IArgC', 'IBClr', 'IBits', - 'IBSet', 'IChar', 'IDate', 'IDiM', 'IDInt', 'IDNInt', 'IEOr', - 'IErrNo', 'IFix', 'Imag', 'ImagPart', 'Image_Index', 'Index', - 'Int', 'IOr', 'IParity', 'IRand', 'IsaTty', 'IShft', 'IShftC', - 'ISign', 'Iso_C_Binding', 'Is_Contiguous', 'Is_Iostat_End', - 'Is_Iostat_Eor', 'ITime', 'Kill', 'Kind', 'LBound', 'LCoBound', - 'Len', 'Len_Trim', 'LGe', 'LGt', 'Link', 'LLe', 'LLt', 'LnBlnk', - 'Loc', 'Log', 'Log_Gamma', 'Logical', 'Long', 'LShift', 'LStat', - 'LTime', 'MaskL', 'MaskR', 'MatMul', 'Max', 'MaxExponent', - 'MaxLoc', 'MaxVal', 'MClock', 'Merge', 'Merge_Bits', 'Move_Alloc', - 'Min', 'MinExponent', 'MinLoc', 'MinVal', 'Mod', 'Modulo', 'MvBits', - 'Nearest', 'New_Line', 'NInt', 'Norm2', 'Not', 'Null', 'Num_Images', - 'Or', 'Pack', 'Parity', 'PError', 'Precision', 'Present', 'Product', - 'Radix', 'Rand', 'Random_Number', 'Random_Seed', 'Range', 'Real', - 'RealPart', 'Rename', 'Repeat', 'Reshape', 'RRSpacing', 'RShift', - 'Same_Type_As', 'Scale', 'Scan', 'Second', 'Selected_Char_Kind', - 'Selected_Int_Kind', 'Selected_Real_Kind', 'Set_Exponent', 'Shape', - 'ShiftA', 'ShiftL', 'ShiftR', 'Short', 'Sign', 'Signal', 'SinH', - 'Sin', 'Sleep', 'Sngl', 'Spacing', 'Spread', 'SqRt', 'SRand', - 'Stat', 'Storage_Size', 'Sum', 'SymLnk', 'System', 'System_Clock', - 'Tan', 'TanH', 'Time', 'This_Image', 'Tiny', 'TrailZ', 'Transfer', - 'Transpose', 'Trim', 'TtyNam', 'UBound', 'UCoBound', 'UMask', - 'Unlink', 'Unpack', 'Verify', 'XOr', 'ZAbs', 'ZCos', 'ZExp', - 'ZLog', 'ZSin', 'ZSqRt'), prefix=r'\b', suffix=r'\s*\b'), - Name.Builtin), - - # Booleans - (r'\.(true|false)\.', Name.Builtin), - # Comparing Operators - (r'\.(eq|ne|lt|le|gt|ge|not|and|or|eqv|neqv)\.', Operator.Word), - ], - - 'strings': [ - (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double), - (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single), - ], - - 'nums': [ - (r'\d+(?![.e])(_[a-z]\w+)?', Number.Integer), - (r'[+-]?\d*\.\d+(e[-+]?\d+)?(_[a-z]\w+)?', Number.Float), - (r'[+-]?\d+\.\d*(e[-+]?\d+)?(_[a-z]\w+)?', Number.Float), - ], - } - - -class GLShaderLexer(RegexLexer): - """ - GLSL (OpenGL Shader) lexer. - - .. versionadded:: 1.1 - """ - name = 'GLSL' - aliases = ['glsl'] - filenames = ['*.vert', '*.frag', '*.geo'] - mimetypes = ['text/x-glslsrc'] - - tokens = { - 'root': [ - (r'^#.*', Comment.Preproc), - (r'//.*', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - (r'\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?', - Operator), - (r'[?:]', Operator), # quick hack for ternary - (r'\bdefined\b', Operator), - (r'[;{}(),\[\]]', Punctuation), - # FIXME when e is present, no decimal point needed - (r'[+-]?\d*\.\d+([eE][-+]?\d+)?', Number.Float), - (r'[+-]?\d+\.\d*([eE][-+]?\d+)?', Number.Float), - (r'0[xX][0-9a-fA-F]*', Number.Hex), - (r'0[0-7]*', Number.Oct), - (r'[1-9][0-9]*', Number.Integer), - (words(( - 'attribute', 'const', 'uniform', 'varying', 'centroid', 'break', - 'continue', 'do', 'for', 'while', 'if', 'else', 'in', 'out', - 'inout', 'float', 'int', 'void', 'bool', 'true', 'false', - 'invariant', 'discard', 'return', 'mat2', 'mat3' 'mat4', - 'mat2x2', 'mat3x2', 'mat4x2', 'mat2x3', 'mat3x3', 'mat4x3', - 'mat2x4', 'mat3x4', 'mat4x4', 'vec2', 'vec3', 'vec4', - 'ivec2', 'ivec3', 'ivec4', 'bvec2', 'bvec3', 'bvec4', - 'sampler1D', 'sampler2D', 'sampler3D' 'samplerCube', - 'sampler1DShadow', 'sampler2DShadow', 'struct'), - prefix=r'\b', suffix=r'\b'), - Keyword), - (words(( - 'asm', 'class', 'union', 'enum', 'typedef', 'template', 'this', - 'packed', 'goto', 'switch', 'default', 'inline', 'noinline', - 'volatile', 'public', 'static', 'extern', 'external', 'interface', - 'long', 'short', 'double', 'half', 'fixed', 'unsigned', 'lowp', - 'mediump', 'highp', 'precision', 'input', 'output', - 'hvec2', 'hvec3', 'hvec4', 'dvec2', 'dvec3', 'dvec4', - 'fvec2', 'fvec3', 'fvec4', 'sampler2DRect', 'sampler3DRect', - 'sampler2DRectShadow', 'sizeof', 'cast', 'namespace', 'using'), - prefix=r'\b', suffix=r'\b'), - Keyword), # future use - (r'[a-zA-Z_][a-zA-Z_0-9]*', Name), - (r'\.', Punctuation), - (r'\s+', Text), - ], - } - - -class PrologLexer(RegexLexer): - """ - Lexer for Prolog files. - """ - name = 'Prolog' - aliases = ['prolog'] - filenames = ['*.prolog', '*.pro', '*.pl'] - mimetypes = ['text/x-prolog'] - - flags = re.UNICODE - - tokens = { - 'root': [ - (r'^#.*', Comment.Single), - (r'/\*', Comment.Multiline, 'nested-comment'), - (r'%.*', Comment.Single), - # character literal - (r'0\'.', String.Char), - (r'0b[01]+', Number.Bin), - (r'0o[0-7]+', Number.Oct), - (r'0x[0-9a-fA-F]+', Number.Hex), - # literal with prepended base - (r'\d\d?\'[a-zA-Z0-9]+', Number.Integer), - (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float), - (r'\d+', Number.Integer), - (r'[\[\](){}|.,;!]', Punctuation), - (r':-|-->', Punctuation), - (r'"(?:\\x[0-9a-fA-F]+\\|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|' - r'\\[0-7]+\\|\\["\nabcefnrstv]|[^\\"])*"', String.Double), - (r"'(?:''|[^'])*'", String.Atom), # quoted atom - # Needs to not be followed by an atom. - # (r'=(?=\s|[a-zA-Z\[])', Operator), - (r'is\b', Operator), - (r'(<|>|=<|>=|==|=:=|=|/|//|\*|\+|-)(?=\s|[a-zA-Z0-9\[])', - Operator), - (r'(mod|div|not)\b', Operator), - (r'_', Keyword), # The don't-care variable - (r'([a-z]+)(:)', bygroups(Name.Namespace, Punctuation)), - (u'([a-z\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]' - u'[\w$\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]*)' - u'(\\s*)(:-|-->)', - bygroups(Name.Function, Text, Operator)), # function defn - (u'([a-z\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]' - u'[\w$\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]*)' - u'(\\s*)(\\()', - bygroups(Name.Function, Text, Punctuation)), - (u'[a-z\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]' - u'[\w$\u00c0-\u1fff\u3040-\ud7ff\ue000-\uffef]*', - String.Atom), # atom, characters - # This one includes ! - (u'[#&*+\\-./:<=>?@\\\\^~\u00a1-\u00bf\u2010-\u303f]+', - String.Atom), # atom, graphics - (r'[A-Z_]\w*', Name.Variable), - (u'\\s+|[\u2000-\u200f\ufff0-\ufffe\uffef]', Text), - ], - 'nested-comment': [ - (r'\*/', Comment.Multiline, '#pop'), - (r'/\*', Comment.Multiline, '#push'), - (r'[^*/]+', Comment.Multiline), - (r'[*/]', Comment.Multiline), - ], - } - - def analyse_text(text): - return ':-' in text - - -class CythonLexer(RegexLexer): - """ - For Pyrex and `Cython <http://cython.org>`_ source code. - - .. versionadded:: 1.1 - """ - - name = 'Cython' - aliases = ['cython', 'pyx', 'pyrex'] - filenames = ['*.pyx', '*.pxd', '*.pxi'] - mimetypes = ['text/x-cython', 'application/x-cython'] - - tokens = { - 'root': [ - (r'\n', Text), - (r'^(\s*)("""(?:.|\n)*?""")', bygroups(Text, String.Doc)), - (r"^(\s*)('''(?:.|\n)*?''')", bygroups(Text, String.Doc)), - (r'[^\S\n]+', Text), - (r'#.*$', Comment), - (r'[]{}:(),;[]', Punctuation), - (r'\\\n', Text), - (r'\\', Text), - (r'(in|is|and|or|not)\b', Operator.Word), - (r'(<)([a-zA-Z0-9.?]+)(>)', - bygroups(Punctuation, Keyword.Type, Punctuation)), - (r'!=|==|<<|>>|[-~+/*%=<>&^|.?]', Operator), - (r'(from)(\d+)(<=)(\s+)(<)(\d+)(:)', - bygroups(Keyword, Number.Integer, Operator, Name, Operator, - Name, Punctuation)), - include('keywords'), - (r'(def|property)(\s+)', bygroups(Keyword, Text), 'funcname'), - (r'(cp?def)(\s+)', bygroups(Keyword, Text), 'cdef'), - (r'(class|struct)(\s+)', bygroups(Keyword, Text), 'classname'), - (r'(from)(\s+)', bygroups(Keyword, Text), 'fromimport'), - (r'(c?import)(\s+)', bygroups(Keyword, Text), 'import'), - include('builtins'), - include('backtick'), - ('(?:[rR]|[uU][rR]|[rR][uU])"""', String, 'tdqs'), - ("(?:[rR]|[uU][rR]|[rR][uU])'''", String, 'tsqs'), - ('(?:[rR]|[uU][rR]|[rR][uU])"', String, 'dqs'), - ("(?:[rR]|[uU][rR]|[rR][uU])'", String, 'sqs'), - ('[uU]?"""', String, combined('stringescape', 'tdqs')), - ("[uU]?'''", String, combined('stringescape', 'tsqs')), - ('[uU]?"', String, combined('stringescape', 'dqs')), - ("[uU]?'", String, combined('stringescape', 'sqs')), - include('name'), - include('numbers'), - ], - 'keywords': [ - (words(( - 'assert', 'break', 'by', 'continue', 'ctypedef', 'del', 'elif', - 'else', 'except', 'except?', 'exec', 'finally', 'for', 'gil', - 'global', 'if', 'include', 'lambda', 'nogil', 'pass', 'print', - 'raise', 'return', 'try', 'while', 'yield', 'as', 'with'), suffix=r'\b'), - Keyword), - (r'(DEF|IF|ELIF|ELSE)\b', Comment.Preproc), - ], - 'builtins': [ - (words(( - '__import__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', - 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', - 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'delattr', - 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', - 'file', 'filter', 'float', 'frozenset', 'getattr', 'globals', - 'hasattr', 'hash', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', - 'issubclass', 'iter', 'len', 'list', 'locals', 'long', 'map', 'max', - 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'property', - 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', - 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', - 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', - 'vars', 'xrange', 'zip'), prefix=r'(?<!\.)', suffix=r'\b'), - Name.Builtin), - (r'(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|NULL' - r')\b', Name.Builtin.Pseudo), - (words(( - 'ArithmeticError', 'AssertionError', 'AttributeError', - 'BaseException', 'DeprecationWarning', 'EOFError', 'EnvironmentError', - 'Exception', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', - 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', - 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', - 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', - 'OverflowWarning', 'PendingDeprecationWarning', 'ReferenceError', - 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', - 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', - 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', - 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', - 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', - 'ZeroDivisionError'), prefix=r'(?<!\.)', suffix=r'\b'), - Name.Exception), - ], - 'numbers': [ - (r'(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float), - (r'0\d+', Number.Oct), - (r'0[xX][a-fA-F0-9]+', Number.Hex), - (r'\d+L', Number.Integer.Long), - (r'\d+', Number.Integer) - ], - 'backtick': [ - ('`.*?`', String.Backtick), - ], - 'name': [ - (r'@\w+', Name.Decorator), - ('[a-zA-Z_]\w*', Name), - ], - 'funcname': [ - ('[a-zA-Z_]\w*', Name.Function, '#pop') - ], - 'cdef': [ - (r'(public|readonly|extern|api|inline)\b', Keyword.Reserved), - (r'(struct|enum|union|class)\b', Keyword), - (r'([a-zA-Z_]\w*)(\s*)(?=[(:#=]|$)', - bygroups(Name.Function, Text), '#pop'), - (r'([a-zA-Z_]\w*)(\s*)(,)', - bygroups(Name.Function, Text, Punctuation)), - (r'from\b', Keyword, '#pop'), - (r'as\b', Keyword), - (r':', Punctuation, '#pop'), - (r'(?=["\'])', Text, '#pop'), - (r'[a-zA-Z_]\w*', Keyword.Type), - (r'.', Text), - ], - 'classname': [ - ('[a-zA-Z_]\w*', Name.Class, '#pop') - ], - 'import': [ - (r'(\s+)(as)(\s+)', bygroups(Text, Keyword, Text)), - (r'[a-zA-Z_][\w.]*', Name.Namespace), - (r'(\s*)(,)(\s*)', bygroups(Text, Operator, Text)), - default('#pop') # all else: go back - ], - 'fromimport': [ - (r'(\s+)(c?import)\b', bygroups(Text, Keyword), '#pop'), - (r'[a-zA-Z_.][\w.]*', Name.Namespace), - # ``cdef foo from "header"``, or ``for foo from 0 < i < 10`` - default('#pop'), - ], - 'stringescape': [ - (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|' - r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape) - ], - 'strings': [ - (r'%(\([a-zA-Z0-9]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?' - '[hlL]?[diouxXeEfFgGcrs%]', String.Interpol), - (r'[^\\\'"%\n]+', String), - # quotes, percents and backslashes must be parsed one at a time - (r'[\'"\\]', String), - # unhandled string formatting sign - (r'%', String) - # newlines are an error (use "nl" state) - ], - 'nl': [ - (r'\n', String) - ], - 'dqs': [ - (r'"', String, '#pop'), - (r'\\\\|\\"|\\\n', String.Escape), # included here again for raw strings - include('strings') - ], - 'sqs': [ - (r"'", String, '#pop'), - (r"\\\\|\\'|\\\n", String.Escape), # included here again for raw strings - include('strings') - ], - 'tdqs': [ - (r'"""', String, '#pop'), - include('strings'), - include('nl') - ], - 'tsqs': [ - (r"'''", String, '#pop'), - include('strings'), - include('nl') - ], - } - - -class ValaLexer(RegexLexer): - """ - For Vala source code with preprocessor directives. - - .. versionadded:: 1.1 - """ - name = 'Vala' - aliases = ['vala', 'vapi'] - filenames = ['*.vala', '*.vapi'] - mimetypes = ['text/x-vala'] - - tokens = { - 'whitespace': [ - (r'^\s*#if\s+0', Comment.Preproc, 'if0'), - (r'\n', Text), - (r'\s+', Text), - (r'\\\n', Text), # line continuation - (r'//(\n|(.|\n)*?[^\\]\n)', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - ], - 'statements': [ - (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'0x[0-9a-fA-F]+[Ll]?', Number.Hex), - (r'0[0-7]+[Ll]?', Number.Oct), - (r'\d+[Ll]?', Number.Integer), - (r'[~!%^&*+=|?:<>/-]', Operator), - (r'(\[)(Compact|Immutable|(?:Boolean|Simple)Type)(\])', - bygroups(Punctuation, Name.Decorator, Punctuation)), - # TODO: "correctly" parse complex code attributes - (r'(\[)(CCode|(?:Integer|Floating)Type)', - bygroups(Punctuation, Name.Decorator)), - (r'[()\[\],.]', Punctuation), - (words(( - 'as', 'base', 'break', 'case', 'catch', 'construct', 'continue', - 'default', 'delete', 'do', 'else', 'enum', 'finally', 'for', - 'foreach', 'get', 'if', 'in', 'is', 'lock', 'new', 'out', 'params', - 'return', 'set', 'sizeof', 'switch', 'this', 'throw', 'try', - 'typeof', 'while', 'yield'), suffix=r'\b'), - Keyword), - (words(( - 'abstract', 'const', 'delegate', 'dynamic', 'ensures', 'extern', - 'inline', 'internal', 'override', 'owned', 'private', 'protected', - 'public', 'ref', 'requires', 'signal', 'static', 'throws', 'unowned', - 'var', 'virtual', 'volatile', 'weak', 'yields'), suffix=r'\b'), - Keyword.Declaration), - (r'(namespace|using)(\s+)', bygroups(Keyword.Namespace, Text), - 'namespace'), - (r'(class|errordomain|interface|struct)(\s+)', - bygroups(Keyword.Declaration, Text), 'class'), - (r'(\.)([a-zA-Z_]\w*)', - bygroups(Operator, Name.Attribute)), - # void is an actual keyword, others are in glib-2.0.vapi - (words(( - 'void', 'bool', 'char', 'double', 'float', 'int', 'int8', 'int16', - 'int32', 'int64', 'long', 'short', 'size_t', 'ssize_t', 'string', - 'time_t', 'uchar', 'uint', 'uint8', 'uint16', 'uint32', 'uint64', - 'ulong', 'unichar', 'ushort'), suffix=r'\b'), - Keyword.Type), - (r'(true|false|null)\b', Name.Builtin), - ('[a-zA-Z_]\w*', Name), - ], - 'root': [ - include('whitespace'), - ('', Text, 'statement'), - ], - 'statement': [ - include('whitespace'), - include('statements'), - ('[{}]', Punctuation), - (';', Punctuation, '#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 - ], - 'if0': [ - (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'), - (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'), - (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'), - (r'.*?\n', Comment), - ], - 'class': [ - (r'[a-zA-Z_]\w*', Name.Class, '#pop') - ], - 'namespace': [ - (r'[a-zA-Z_][\w.]*', Name.Namespace, '#pop') - ], - } - - -class OocLexer(RegexLexer): - """ - For `Ooc <http://ooc-lang.org/>`_ source code - - .. versionadded:: 1.2 - """ - name = 'Ooc' - aliases = ['ooc'] - filenames = ['*.ooc'] - mimetypes = ['text/x-ooc'] - - tokens = { - 'root': [ - (words(( - 'class', 'interface', 'implement', 'abstract', 'extends', 'from', - 'this', 'super', 'new', 'const', 'final', 'static', 'import', - 'use', 'extern', 'inline', 'proto', 'break', 'continue', - 'fallthrough', 'operator', 'if', 'else', 'for', 'while', 'do', - 'switch', 'case', 'as', 'in', 'version', 'return', 'true', - 'false', 'null'), prefix=r'\b', suffix=r'\b'), - Keyword), - (r'include\b', Keyword, 'include'), - (r'(cover)([ \t]+)(from)([ \t]+)(\w+[*@]?)', - bygroups(Keyword, Text, Keyword, Text, Name.Class)), - (r'(func)((?:[ \t]|\\\n)+)(~[a-z_]\w*)', - bygroups(Keyword, Text, Name.Function)), - (r'\bfunc\b', Keyword), - # Note: %= and ^= not listed on http://ooc-lang.org/syntax - (r'//.*', Comment), - (r'(?s)/\*.*?\*/', Comment.Multiline), - (r'(==?|\+=?|-[=>]?|\*=?|/=?|:=|!=?|%=?|\?|>{1,3}=?|<{1,3}=?|\.\.|' - r'&&?|\|\|?|\^=?)', Operator), - (r'(\.)([ \t]*)([a-z]\w*)', bygroups(Operator, Text, - Name.Function)), - (r'[A-Z][A-Z0-9_]+', Name.Constant), - (r'[A-Z]\w*([@*]|\[[ \t]*\])?', Name.Class), - - (r'([a-z]\w*(?:~[a-z]\w*)?)((?:[ \t]|\\\n)*)(?=\()', - bygroups(Name.Function, Text)), - (r'[a-z]\w*', Name.Variable), - - # : introduces types - (r'[:(){}\[\];,]', Punctuation), - - (r'0x[0-9a-fA-F]+', Number.Hex), - (r'0c[0-9]+', Number.Oct), - (r'0b[01]+', Number.Bin), - (r'[0-9_]\.[0-9_]*(?!\.)', Number.Float), - (r'[0-9_]+', Number.Decimal), - - (r'"(?:\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\"])*"', - String.Double), - (r"'(?:\\.|\\[0-9]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", - String.Char), - (r'@', Punctuation), # pointer dereference - (r'\.', Punctuation), # imports or chain operator - - (r'\\[ \t\n]', Text), - (r'[ \t]+', Text), - ], - 'include': [ - (r'[\w/]+', Name), - (r',', Punctuation), - (r'[ \t]', Text), - (r'[;\n]', Text, '#pop'), - ], - } - - -class GoLexer(RegexLexer): - """ - For `Go <http://golang.org>`_ source. - """ - name = 'Go' - filenames = ['*.go'] - aliases = ['go'] - mimetypes = ['text/x-gosrc'] - - flags = re.MULTILINE | re.UNICODE - - tokens = { - 'root': [ - (r'\n', Text), - (r'\s+', Text), - (r'\\\n', Text), # line continuations - (r'//(.*?)\n', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - (r'(import|package)\b', Keyword.Namespace), - (r'(var|func|struct|map|chan|type|interface|const)\b', - Keyword.Declaration), - (words(( - 'break', 'default', 'select', 'case', 'defer', 'go', - 'else', 'goto', 'switch', 'fallthrough', 'if', 'range', - 'continue', 'for', 'return'), suffix=r'\b'), - Keyword), - (r'(true|false|iota|nil)\b', Keyword.Constant), - # It seems the builtin types aren't actually keywords, but - # can be used as functions. So we need two declarations. - (words(( - 'uint', 'uint8', 'uint16', 'uint32', 'uint64', - 'int', 'int8', 'int16', 'int32', 'int64', - 'float', 'float32', 'float64', - 'complex64', 'complex128', 'byte', 'rune', - 'string', 'bool', 'error', 'uintptr', - 'print', 'println', 'panic', 'recover', 'close', 'complex', - 'real', 'imag', 'len', 'cap', 'append', 'copy', 'delete', - 'new', 'make'), suffix=r'\b(\()'), - bygroups(Name.Builtin, Punctuation)), - (words(( - 'uint', 'uint8', 'uint16', 'uint32', 'uint64', - 'int', 'int8', 'int16', 'int32', 'int64', - 'float', 'float32', 'float64', - 'complex64', 'complex128', 'byte', 'rune', - 'string', 'bool', 'error', 'uintptr'), suffix=r'\b'), - Keyword.Type), - # imaginary_lit - (r'\d+i', Number), - (r'\d+\.\d*([Ee][-+]\d+)?i', Number), - (r'\.\d+([Ee][-+]\d+)?i', Number), - (r'\d+[Ee][-+]\d+i', Number), - # float_lit - (r'\d+(\.\d+[eE][+\-]?\d+|' - r'\.\d*|[eE][+\-]?\d+)', Number.Float), - (r'\.\d+([eE][+\-]?\d+)?', Number.Float), - # int_lit - # -- octal_lit - (r'0[0-7]+', Number.Oct), - # -- hex_lit - (r'0[xX][0-9a-fA-F]+', Number.Hex), - # -- decimal_lit - (r'(0|[1-9][0-9]*)', Number.Integer), - # char_lit - (r"""'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}""" - r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'""", - String.Char), - # StringLiteral - # -- raw_string_lit - (r'`[^`]*`', String), - # -- interpreted_string_lit - (r'"(\\\\|\\"|[^"])*"', String), - # Tokens - (r'(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\|' - r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])', Operator), - (r'[|^<>=!()\[\]{}.,;:]', Punctuation), - # identifier - (r'[^\W\d]\w*', Name.Other), - ] - } - - -class FelixLexer(RegexLexer): - """ - For `Felix <http://www.felix-lang.org>`_ source code. - - .. versionadded:: 1.2 - """ - - name = 'Felix' - aliases = ['felix', 'flx'] - filenames = ['*.flx', '*.flxh'] - mimetypes = ['text/x-felix'] - - preproc = ( - 'elif', 'else', 'endif', 'if', 'ifdef', 'ifndef', - ) - - keywords = ( - '_', '_deref', 'all', 'as', - 'assert', 'attempt', 'call', 'callback', 'case', 'caseno', 'cclass', - 'code', 'compound', 'ctypes', 'do', 'done', 'downto', 'elif', 'else', - 'endattempt', 'endcase', 'endif', 'endmatch', 'enum', 'except', - 'exceptions', 'expect', 'finally', 'for', 'forall', 'forget', 'fork', - 'functor', 'goto', 'ident', 'if', 'incomplete', 'inherit', 'instance', - 'interface', 'jump', 'lambda', 'loop', 'match', 'module', 'namespace', - 'new', 'noexpand', 'nonterm', 'obj', 'of', 'open', 'parse', 'raise', - 'regexp', 'reglex', 'regmatch', 'rename', 'return', 'the', 'then', - 'to', 'type', 'typecase', 'typedef', 'typematch', 'typeof', 'upto', - 'when', 'whilst', 'with', 'yield', - ) - - keyword_directives = ( - '_gc_pointer', '_gc_type', 'body', 'comment', 'const', 'export', - 'header', 'inline', 'lval', 'macro', 'noinline', 'noreturn', - 'package', 'private', 'pod', 'property', 'public', 'publish', - 'requires', 'todo', 'virtual', 'use', - ) - - keyword_declarations = ( - 'def', 'let', 'ref', 'val', 'var', - ) - - keyword_types = ( - 'unit', 'void', 'any', 'bool', - 'byte', 'offset', - 'address', 'caddress', 'cvaddress', 'vaddress', - 'tiny', 'short', 'int', 'long', 'vlong', - 'utiny', 'ushort', 'vshort', 'uint', 'ulong', 'uvlong', - 'int8', 'int16', 'int32', 'int64', - 'uint8', 'uint16', 'uint32', 'uint64', - 'float', 'double', 'ldouble', - 'complex', 'dcomplex', 'lcomplex', - 'imaginary', 'dimaginary', 'limaginary', - 'char', 'wchar', 'uchar', - 'charp', 'charcp', 'ucharp', 'ucharcp', - 'string', 'wstring', 'ustring', - 'cont', - 'array', 'varray', 'list', - 'lvalue', 'opt', 'slice', - ) - - keyword_constants = ( - 'false', 'true', - ) - - operator_words = ( - 'and', 'not', 'in', 'is', 'isin', 'or', 'xor', - ) - - name_builtins = ( - '_svc', 'while', - ) - - name_pseudo = ( - 'root', 'self', 'this', - ) - - decimal_suffixes = '([tTsSiIlLvV]|ll|LL|([iIuU])(8|16|32|64))?' - - tokens = { - 'root': [ - include('whitespace'), - - # Keywords - (words(('axiom', 'ctor', 'fun', 'gen', 'proc', 'reduce', - 'union'), suffix=r'\b'), - Keyword, 'funcname'), - (words(('class', 'cclass', 'cstruct', 'obj', 'struct'), suffix=r'\b'), - Keyword, 'classname'), - (r'(instance|module|typeclass)\b', Keyword, 'modulename'), - - (words(keywords, suffix=r'\b'), Keyword), - (words(keyword_directives, suffix=r'\b'), Name.Decorator), - (words(keyword_declarations, suffix=r'\b'), Keyword.Declaration), - (words(keyword_types, suffix=r'\b'), Keyword.Type), - (words(keyword_constants, suffix=r'\b'), Keyword.Constant), - - # Operators - include('operators'), - - # Float Literal - # -- Hex Float - (r'0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)' - r'[pP][+\-]?[0-9_]+[lLfFdD]?', Number.Float), - # -- DecimalFloat - (r'[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|' - r'\.[0-9_]*|[eE][+\-]?[0-9_]+)[lLfFdD]?', Number.Float), - (r'\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[lLfFdD]?', - Number.Float), - - # IntegerLiteral - # -- Binary - (r'0[Bb][01_]+%s' % decimal_suffixes, Number.Bin), - # -- Octal - (r'0[0-7_]+%s' % decimal_suffixes, Number.Oct), - # -- Hexadecimal - (r'0[xX][0-9a-fA-F_]+%s' % decimal_suffixes, Number.Hex), - # -- Decimal - (r'(0|[1-9][0-9_]*)%s' % decimal_suffixes, Number.Integer), - - # Strings - ('([rR][cC]?|[cC][rR])"""', String, 'tdqs'), - ("([rR][cC]?|[cC][rR])'''", String, 'tsqs'), - ('([rR][cC]?|[cC][rR])"', String, 'dqs'), - ("([rR][cC]?|[cC][rR])'", String, 'sqs'), - ('[cCfFqQwWuU]?"""', String, combined('stringescape', 'tdqs')), - ("[cCfFqQwWuU]?'''", String, combined('stringescape', 'tsqs')), - ('[cCfFqQwWuU]?"', String, combined('stringescape', 'dqs')), - ("[cCfFqQwWuU]?'", String, combined('stringescape', 'sqs')), - - # Punctuation - (r'[\[\]{}:(),;?]', Punctuation), - - # Labels - (r'[a-zA-Z_]\w*:>', Name.Label), - - # Identifiers - (r'(%s)\b' % '|'.join(name_builtins), Name.Builtin), - (r'(%s)\b' % '|'.join(name_pseudo), Name.Builtin.Pseudo), - (r'[a-zA-Z_]\w*', Name), - ], - 'whitespace': [ - (r'\n', Text), - (r'\s+', Text), - - include('comment'), - - # Preprocessor - (r'#\s*if\s+0', Comment.Preproc, 'if0'), - (r'#', Comment.Preproc, 'macro'), - ], - 'operators': [ - (r'(%s)\b' % '|'.join(operator_words), Operator.Word), - (r'!=|==|<<|>>|\|\||&&|[-~+/*%=<>&^|.$]', Operator), - ], - 'comment': [ - (r'//(.*?)\n', Comment.Single), - (r'/[*]', Comment.Multiline, 'comment2'), - ], - 'comment2': [ - (r'[^\/*]', Comment.Multiline), - (r'/[*]', Comment.Multiline, '#push'), - (r'[*]/', Comment.Multiline, '#pop'), - (r'[\/*]', Comment.Multiline), - ], - 'if0': [ - (r'^\s*#if.*?(?<!\\)\n', Comment, '#push'), - (r'^\s*#endif.*?(?<!\\)\n', Comment, '#pop'), - (r'.*?\n', Comment), - ], - 'macro': [ - include('comment'), - (r'(import|include)(\s+)(<[^>]*?>)', - bygroups(Comment.Preproc, Text, String), '#pop'), - (r'(import|include)(\s+)("[^"]*?")', - bygroups(Comment.Preproc, Text, String), '#pop'), - (r"(import|include)(\s+)('[^']*?')", - bygroups(Comment.Preproc, Text, String), '#pop'), - (r'[^/\n]+', Comment.Preproc), - # (r'/[*](.|\n)*?[*]/', Comment), - # (r'//.*?\n', Comment, '#pop'), - (r'/', Comment.Preproc), - (r'(?<=\\)\n', Comment.Preproc), - (r'\n', Comment.Preproc, '#pop'), - ], - 'funcname': [ - include('whitespace'), - (r'[a-zA-Z_]\w*', Name.Function, '#pop'), - # anonymous functions - (r'(?=\()', Text, '#pop'), - ], - 'classname': [ - include('whitespace'), - (r'[a-zA-Z_]\w*', Name.Class, '#pop'), - # anonymous classes - (r'(?=\{)', Text, '#pop'), - ], - 'modulename': [ - include('whitespace'), - (r'\[', Punctuation, ('modulename2', 'tvarlist')), - default('modulename2'), - ], - 'modulename2': [ - include('whitespace'), - (r'([a-zA-Z_]\w*)', Name.Namespace, '#pop:2'), - ], - 'tvarlist': [ - include('whitespace'), - include('operators'), - (r'\[', Punctuation, '#push'), - (r'\]', Punctuation, '#pop'), - (r',', Punctuation), - (r'(with|where)\b', Keyword), - (r'[a-zA-Z_]\w*', Name), - ], - 'stringescape': [ - (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|' - r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape) - ], - 'strings': [ - (r'%(\([a-zA-Z0-9]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?' - '[hlL]?[diouxXeEfFgGcrs%]', String.Interpol), - (r'[^\\\'"%\n]+', String), - # quotes, percents and backslashes must be parsed one at a time - (r'[\'"\\]', String), - # unhandled string formatting sign - (r'%', String) - # newlines are an error (use "nl" state) - ], - 'nl': [ - (r'\n', String) - ], - 'dqs': [ - (r'"', String, '#pop'), - # included here again for raw strings - (r'\\\\|\\"|\\\n', String.Escape), - include('strings') - ], - 'sqs': [ - (r"'", String, '#pop'), - # included here again for raw strings - (r"\\\\|\\'|\\\n", String.Escape), - include('strings') - ], - 'tdqs': [ - (r'"""', String, '#pop'), - include('strings'), - include('nl') - ], - 'tsqs': [ - (r"'''", String, '#pop'), - include('strings'), - include('nl') - ], - } - - -class AdaLexer(RegexLexer): - """ - For Ada source code. - - .. versionadded:: 1.3 - """ - - name = 'Ada' - aliases = ['ada', 'ada95', 'ada2005'] - filenames = ['*.adb', '*.ads', '*.ada'] - mimetypes = ['text/x-ada'] - - flags = re.MULTILINE | re.I # Ignore case - - tokens = { - 'root': [ - (r'[^\S\n]+', Text), - (r'--.*?\n', Comment.Single), - (r'[^\S\n]+', Text), - (r'function|procedure|entry', Keyword.Declaration, 'subprogram'), - (r'(subtype|type)(\s+)([a-z0-9_]+)', - bygroups(Keyword.Declaration, Text, Keyword.Type), 'type_def'), - (r'task|protected', Keyword.Declaration), - (r'(subtype)(\s+)', bygroups(Keyword.Declaration, Text)), - (r'(end)(\s+)', bygroups(Keyword.Reserved, Text), 'end'), - (r'(pragma)(\s+)(\w+)', bygroups(Keyword.Reserved, Text, - Comment.Preproc)), - (r'(true|false|null)\b', Keyword.Constant), - (words(( - 'Address', 'Byte', 'Boolean', 'Character', 'Controlled', 'Count', 'Cursor', - 'Duration', 'File_Mode', 'File_Type', 'Float', 'Generator', 'Integer', 'Long_Float', - 'Long_Integer', 'Long_Long_Float', 'Long_Long_Integer', 'Natural', 'Positive', - 'Reference_Type', 'Short_Float', 'Short_Integer', 'Short_Short_Float', - 'Short_Short_Integer', 'String', 'Wide_Character', 'Wide_String'), suffix=r'\b'), - Keyword.Type), - (r'(and(\s+then)?|in|mod|not|or(\s+else)|rem)\b', Operator.Word), - (r'generic|private', Keyword.Declaration), - (r'package', Keyword.Declaration, 'package'), - (r'array\b', Keyword.Reserved, 'array_def'), - (r'(with|use)(\s+)', bygroups(Keyword.Namespace, Text), 'import'), - (r'([a-z0-9_]+)(\s*)(:)(\s*)(constant)', - bygroups(Name.Constant, Text, Punctuation, Text, - Keyword.Reserved)), - (r'<<[a-z0-9_]+>>', Name.Label), - (r'([a-z0-9_]+)(\s*)(:)(\s*)(declare|begin|loop|for|while)', - bygroups(Name.Label, Text, Punctuation, Text, Keyword.Reserved)), - (words(( - 'abort', 'abs', 'abstract', 'accept', 'access', 'aliased', 'all', - 'array', 'at', 'begin', 'body', 'case', 'constant', 'declare', - 'delay', 'delta', 'digits', 'do', 'else', 'elsif', 'end', 'entry', - 'exception', 'exit', 'interface', 'for', 'goto', 'if', 'is', 'limited', - 'loop', 'new', 'null', 'of', 'or', 'others', 'out', 'overriding', - 'pragma', 'protected', 'raise', 'range', 'record', 'renames', 'requeue', - 'return', 'reverse', 'select', 'separate', 'subtype', 'synchronized', - 'task', 'tagged', 'terminate', 'then', 'type', 'until', 'when', - 'while', 'xor'), prefix=r'\b', suffix=r'\b'), - Keyword.Reserved), - (r'"[^"]*"', String), - include('attribute'), - include('numbers'), - (r"'[^']'", String.Character), - (r'([a-z0-9_]+)(\s*|[(,])', bygroups(Name, using(this))), - (r"(<>|=>|:=|[()|:;,.'])", Punctuation), - (r'[*<>+=/&-]', Operator), - (r'\n+', Text), - ], - 'numbers': [ - (r'[0-9_]+#[0-9a-f]+#', Number.Hex), - (r'[0-9_]+\.[0-9_]*', Number.Float), - (r'[0-9_]+', Number.Integer), - ], - 'attribute': [ - (r"(')(\w+)", bygroups(Punctuation, Name.Attribute)), - ], - 'subprogram': [ - (r'\(', Punctuation, ('#pop', 'formal_part')), - (r';', Punctuation, '#pop'), - (r'is\b', Keyword.Reserved, '#pop'), - (r'"[^"]+"|[a-z0-9_]+', Name.Function), - include('root'), - ], - 'end': [ - ('(if|case|record|loop|select)', Keyword.Reserved), - ('"[^"]+"|[\w.]+', Name.Function), - ('\s+', Text), - (';', Punctuation, '#pop'), - ], - 'type_def': [ - (r';', Punctuation, '#pop'), - (r'\(', Punctuation, 'formal_part'), - (r'with|and|use', Keyword.Reserved), - (r'array\b', Keyword.Reserved, ('#pop', 'array_def')), - (r'record\b', Keyword.Reserved, ('record_def')), - (r'(null record)(;)', bygroups(Keyword.Reserved, Punctuation), '#pop'), - include('root'), - ], - 'array_def': [ - (r';', Punctuation, '#pop'), - (r'([a-z0-9_]+)(\s+)(range)', bygroups(Keyword.Type, Text, - Keyword.Reserved)), - include('root'), - ], - 'record_def': [ - (r'end record', Keyword.Reserved, '#pop'), - include('root'), - ], - 'import': [ - (r'[a-z0-9_.]+', Name.Namespace, '#pop'), - default('#pop'), - ], - 'formal_part': [ - (r'\)', Punctuation, '#pop'), - (r'[a-z0-9_]+', Name.Variable), - (r',|:[^=]', Punctuation), - (r'(in|not|null|out|access)\b', Keyword.Reserved), - include('root'), - ], - 'package': [ - ('body', Keyword.Declaration), - ('is\s+new|renames', Keyword.Reserved), - ('is', Keyword.Reserved, '#pop'), - (';', Punctuation, '#pop'), - ('\(', Punctuation, 'package_instantiation'), - ('([\w.]+)', Name.Class), - include('root'), - ], - 'package_instantiation': [ - (r'("[^"]+"|[a-z0-9_]+)(\s+)(=>)', bygroups(Name.Variable, - Text, Punctuation)), - (r'[a-z0-9._\'"]', Text), - (r'\)', Punctuation, '#pop'), - include('root'), - ], - } - - -class Modula2Lexer(RegexLexer): - """ - For `Modula-2 <http://www.modula2.org/>`_ source code. - - Additional options that determine which keywords are highlighted: - - `pim` - Select PIM Modula-2 dialect (default: True). - `iso` - Select ISO Modula-2 dialect (default: False). - `objm2` - Select Objective Modula-2 dialect (default: False). - `gm2ext` - Also highlight GNU extensions (default: False). - - .. versionadded:: 1.3 - """ - name = 'Modula-2' - aliases = ['modula2', 'm2'] - filenames = ['*.def', '*.mod'] - mimetypes = ['text/x-modula2'] - - flags = re.MULTILINE | re.DOTALL - - tokens = { - 'whitespace': [ - (r'\n+', Text), # blank lines - (r'\s+', Text), # whitespace - ], - 'identifiers': [ - (r'([a-zA-Z_\$][\w\$]*)', Name), - ], - 'numliterals': [ - (r'[01]+B', Number.Bin), # binary number (ObjM2) - (r'[0-7]+B', Number.Oct), # octal number (PIM + ISO) - (r'[0-7]+C', Number.Oct), # char code (PIM + ISO) - (r'[0-9A-F]+C', Number.Hex), # char code (ObjM2) - (r'[0-9A-F]+H', Number.Hex), # hexadecimal number - (r'[0-9]+\.[0-9]+E[+-][0-9]+', Number.Float), # real number - (r'[0-9]+\.[0-9]+', Number.Float), # real number - (r'[0-9]+', Number.Integer), # decimal whole number - ], - 'strings': [ - (r"'(\\\\|\\'|[^'])*'", String), # single quoted string - (r'"(\\\\|\\"|[^"])*"', String), # double quoted string - ], - 'operators': [ - (r'[*/+=#~&<>\^-]', Operator), - (r':=', Operator), # assignment - (r'@', Operator), # pointer deref (ISO) - (r'\.\.', Operator), # ellipsis or range - (r'`', Operator), # Smalltalk message (ObjM2) - (r'::', Operator), # type conversion (ObjM2) - ], - 'punctuation': [ - (r'[\(\)\[\]{},.:;|]', Punctuation), - ], - 'comments': [ - (r'//.*?\n', Comment.Single), # ObjM2 - (r'/\*(.*?)\*/', Comment.Multiline), # ObjM2 - (r'\(\*([^\$].*?)\*\)', Comment.Multiline), - # TO DO: nesting of (* ... *) comments - ], - 'pragmas': [ - (r'\(\*\$(.*?)\*\)', Comment.Preproc), # PIM - (r'<\*(.*?)\*>', Comment.Preproc), # ISO + ObjM2 - ], - 'root': [ - include('whitespace'), - include('comments'), - include('pragmas'), - include('identifiers'), - include('numliterals'), - include('strings'), - include('operators'), - include('punctuation'), - ] - } - - pim_reserved_words = [ - # 40 reserved words - 'AND', 'ARRAY', 'BEGIN', 'BY', 'CASE', 'CONST', 'DEFINITION', - 'DIV', 'DO', 'ELSE', 'ELSIF', 'END', 'EXIT', 'EXPORT', 'FOR', - 'FROM', 'IF', 'IMPLEMENTATION', 'IMPORT', 'IN', 'LOOP', 'MOD', - 'MODULE', 'NOT', 'OF', 'OR', 'POINTER', 'PROCEDURE', 'QUALIFIED', - 'RECORD', 'REPEAT', 'RETURN', 'SET', 'THEN', 'TO', 'TYPE', - 'UNTIL', 'VAR', 'WHILE', 'WITH', - ] - - pim_pervasives = [ - # 31 pervasives - 'ABS', 'BITSET', 'BOOLEAN', 'CAP', 'CARDINAL', 'CHAR', 'CHR', 'DEC', - 'DISPOSE', 'EXCL', 'FALSE', 'FLOAT', 'HALT', 'HIGH', 'INC', 'INCL', - 'INTEGER', 'LONGINT', 'LONGREAL', 'MAX', 'MIN', 'NEW', 'NIL', 'ODD', - 'ORD', 'PROC', 'REAL', 'SIZE', 'TRUE', 'TRUNC', 'VAL', - ] - - iso_reserved_words = [ - # 46 reserved words - 'AND', 'ARRAY', 'BEGIN', 'BY', 'CASE', 'CONST', 'DEFINITION', 'DIV', - 'DO', 'ELSE', 'ELSIF', 'END', 'EXCEPT', 'EXIT', 'EXPORT', 'FINALLY', - 'FOR', 'FORWARD', 'FROM', 'IF', 'IMPLEMENTATION', 'IMPORT', 'IN', - 'LOOP', 'MOD', 'MODULE', 'NOT', 'OF', 'OR', 'PACKEDSET', 'POINTER', - 'PROCEDURE', 'QUALIFIED', 'RECORD', 'REPEAT', 'REM', 'RETRY', - 'RETURN', 'SET', 'THEN', 'TO', 'TYPE', 'UNTIL', 'VAR', 'WHILE', - 'WITH', - ] - - iso_pervasives = [ - # 42 pervasives - 'ABS', 'BITSET', 'BOOLEAN', 'CAP', 'CARDINAL', 'CHAR', 'CHR', 'CMPLX', - 'COMPLEX', 'DEC', 'DISPOSE', 'EXCL', 'FALSE', 'FLOAT', 'HALT', 'HIGH', - 'IM', 'INC', 'INCL', 'INT', 'INTEGER', 'INTERRUPTIBLE', 'LENGTH', - 'LFLOAT', 'LONGCOMPLEX', 'LONGINT', 'LONGREAL', 'MAX', 'MIN', 'NEW', - 'NIL', 'ODD', 'ORD', 'PROC', 'PROTECTION', 'RE', 'REAL', 'SIZE', - 'TRUE', 'TRUNC', 'UNINTERRUBTIBLE', 'VAL', - ] - - objm2_reserved_words = [ - # base language, 42 reserved words - 'AND', 'ARRAY', 'BEGIN', 'BY', 'CASE', 'CONST', 'DEFINITION', 'DIV', - 'DO', 'ELSE', 'ELSIF', 'END', 'ENUM', 'EXIT', 'FOR', 'FROM', 'IF', - 'IMMUTABLE', 'IMPLEMENTATION', 'IMPORT', 'IN', 'IS', 'LOOP', 'MOD', - 'MODULE', 'NOT', 'OF', 'OPAQUE', 'OR', 'POINTER', 'PROCEDURE', - 'RECORD', 'REPEAT', 'RETURN', 'SET', 'THEN', 'TO', 'TYPE', - 'UNTIL', 'VAR', 'VARIADIC', 'WHILE', - # OO extensions, 16 reserved words - 'BYCOPY', 'BYREF', 'CLASS', 'CONTINUE', 'CRITICAL', 'INOUT', 'METHOD', - 'ON', 'OPTIONAL', 'OUT', 'PRIVATE', 'PROTECTED', 'PROTOCOL', 'PUBLIC', - 'SUPER', 'TRY', - ] - - objm2_pervasives = [ - # base language, 38 pervasives - 'ABS', 'BITSET', 'BOOLEAN', 'CARDINAL', 'CHAR', 'CHR', 'DISPOSE', - 'FALSE', 'HALT', 'HIGH', 'INTEGER', 'INRANGE', 'LENGTH', 'LONGCARD', - 'LONGINT', 'LONGREAL', 'MAX', 'MIN', 'NEG', 'NEW', 'NEXTV', 'NIL', - 'OCTET', 'ODD', 'ORD', 'PRED', 'PROC', 'READ', 'REAL', 'SUCC', 'TMAX', - 'TMIN', 'TRUE', 'TSIZE', 'UNICHAR', 'VAL', 'WRITE', 'WRITEF', - # OO extensions, 3 pervasives - 'OBJECT', 'NO', 'YES', - ] - - gnu_reserved_words = [ - # 10 additional reserved words - 'ASM', '__ATTRIBUTE__', '__BUILTIN__', '__COLUMN__', '__DATE__', - '__FILE__', '__FUNCTION__', '__LINE__', '__MODULE__', 'VOLATILE', - ] - - gnu_pervasives = [ - # 21 identifiers, actually from pseudo-module SYSTEM - # but we will highlight them as if they were pervasives - 'BITSET8', 'BITSET16', 'BITSET32', 'CARDINAL8', 'CARDINAL16', - 'CARDINAL32', 'CARDINAL64', 'COMPLEX32', 'COMPLEX64', 'COMPLEX96', - 'COMPLEX128', 'INTEGER8', 'INTEGER16', 'INTEGER32', 'INTEGER64', - 'REAL8', 'REAL16', 'REAL32', 'REAL96', 'REAL128', 'THROW', - ] - - def __init__(self, **options): - self.reserved_words = set() - self.pervasives = set() - # ISO Modula-2 - if get_bool_opt(options, 'iso', False): - self.reserved_words.update(self.iso_reserved_words) - self.pervasives.update(self.iso_pervasives) - # Objective Modula-2 - elif get_bool_opt(options, 'objm2', False): - self.reserved_words.update(self.objm2_reserved_words) - self.pervasives.update(self.objm2_pervasives) - # PIM Modula-2 (DEFAULT) - else: - self.reserved_words.update(self.pim_reserved_words) - self.pervasives.update(self.pim_pervasives) - # GNU extensions - if get_bool_opt(options, 'gm2ext', False): - self.reserved_words.update(self.gnu_reserved_words) - self.pervasives.update(self.gnu_pervasives) - # initialise - RegexLexer.__init__(self, **options) - - def get_tokens_unprocessed(self, text): - for index, token, value in RegexLexer.get_tokens_unprocessed(self, text): - # check for reserved words and pervasives - if token is Name: - if value in self.reserved_words: - token = Keyword.Reserved - elif value in self.pervasives: - token = Keyword.Pervasive - # return result - yield index, token, value - - -class BlitzMaxLexer(RegexLexer): - """ - For `BlitzMax <http://blitzbasic.com>`_ source code. - - .. versionadded:: 1.4 - """ - - name = 'BlitzMax' - aliases = ['blitzmax', 'bmax'] - filenames = ['*.bmx'] - mimetypes = ['text/x-bmx'] - - bmax_vopwords = r'\b(Shl|Shr|Sar|Mod)\b' - bmax_sktypes = r'@{1,2}|[!#$%]' - bmax_lktypes = r'\b(Int|Byte|Short|Float|Double|Long)\b' - bmax_name = r'[a-z_]\w*' - bmax_var = (r'(%s)(?:(?:([ \t]*)(%s)|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)' - r'|([ \t]*)(:)([ \t]*)(?:%s|(%s)))(?:([ \t]*)(Ptr))?)') % \ - (bmax_name, bmax_sktypes, bmax_lktypes, bmax_name) - bmax_func = bmax_var + r'?((?:[ \t]|\.\.\n)*)([(])' - - flags = re.MULTILINE | re.IGNORECASE - tokens = { - 'root': [ - # Text - (r'[ \t]+', Text), - (r'\.\.\n', Text), # Line continuation - # Comments - (r"'.*?\n", Comment.Single), - (r'([ \t]*)\bRem\n(\n|.)*?\s*\bEnd([ \t]*)Rem', Comment.Multiline), - # Data types - ('"', String.Double, 'string'), - # Numbers - (r'[0-9]+\.[0-9]*(?!\.)', Number.Float), - (r'\.[0-9]*(?!\.)', Number.Float), - (r'[0-9]+', Number.Integer), - (r'\$[0-9a-f]+', Number.Hex), - (r'\%[10]+', Number.Bin), - # Other - (r'(?:(?:(:)?([ \t]*)(:?%s|([+\-*/&|~]))|Or|And|Not|[=<>^]))' % - (bmax_vopwords), Operator), - (r'[(),.:\[\]]', Punctuation), - (r'(?:#[\w \t]*)', Name.Label), - (r'(?:\?[\w \t]*)', Comment.Preproc), - # Identifiers - (r'\b(New)\b([ \t]?)([(]?)(%s)' % (bmax_name), - bygroups(Keyword.Reserved, Text, Punctuation, Name.Class)), - (r'\b(Import|Framework|Module)([ \t]+)(%s\.%s)' % - (bmax_name, bmax_name), - bygroups(Keyword.Reserved, Text, Keyword.Namespace)), - (bmax_func, bygroups(Name.Function, Text, Keyword.Type, - Operator, Text, Punctuation, Text, - Keyword.Type, Name.Class, Text, - Keyword.Type, Text, Punctuation)), - (bmax_var, bygroups(Name.Variable, Text, Keyword.Type, Operator, - Text, Punctuation, Text, Keyword.Type, - Name.Class, Text, Keyword.Type)), - (r'\b(Type|Extends)([ \t]+)(%s)' % (bmax_name), - bygroups(Keyword.Reserved, Text, Name.Class)), - # Keywords - (r'\b(Ptr)\b', Keyword.Type), - (r'\b(Pi|True|False|Null|Self|Super)\b', Keyword.Constant), - (r'\b(Local|Global|Const|Field)\b', Keyword.Declaration), - (words(( - 'TNullMethodException', 'TNullFunctionException', - 'TNullObjectException', 'TArrayBoundsException', - 'TRuntimeException'), prefix=r'\b', suffix=r'\b'), Name.Exception), - (words(( - 'Strict', 'SuperStrict', 'Module', 'ModuleInfo', - 'End', 'Return', 'Continue', 'Exit', 'Public', 'Private', - 'Var', 'VarPtr', 'Chr', 'Len', 'Asc', 'SizeOf', 'Sgn', 'Abs', 'Min', 'Max', - 'New', 'Release', 'Delete', 'Incbin', 'IncbinPtr', 'IncbinLen', - 'Framework', 'Include', 'Import', 'Extern', 'EndExtern', - 'Function', 'EndFunction', 'Type', 'EndType', 'Extends', 'Method', 'EndMethod', - 'Abstract', 'Final', 'If', 'Then', 'Else', 'ElseIf', 'EndIf', - 'For', 'To', 'Next', 'Step', 'EachIn', 'While', 'Wend', 'EndWhile', - 'Repeat', 'Until', 'Forever', 'Select', 'Case', 'Default', 'EndSelect', - 'Try', 'Catch', 'EndTry', 'Throw', 'Assert', 'Goto', 'DefData', 'ReadData', - 'RestoreData'), prefix=r'\b', suffix=r'\b'), - Keyword.Reserved), - # Final resolve (for variable names and such) - (r'(%s)' % (bmax_name), Name.Variable), - ], - 'string': [ - (r'""', String.Double), - (r'"C?', String.Double, '#pop'), - (r'[^"]+', String.Double), - ], - } - - -class BlitzBasicLexer(RegexLexer): - """ - For `BlitzBasic <http://blitzbasic.com>`_ source code. - - .. versionadded:: 2.0 - """ - - name = 'BlitzBasic' - aliases = ['blitzbasic', 'b3d', 'bplus'] - filenames = ['*.bb', '*.decls'] - mimetypes = ['text/x-bb'] - - bb_sktypes = r'@{1,2}|[#$%]' - bb_name = r'[a-z]\w*' - bb_var = (r'(%s)(?:([ \t]*)(%s)|([ \t]*)([.])([ \t]*)(?:(%s)))?') % \ - (bb_name, bb_sktypes, bb_name) - - flags = re.MULTILINE | re.IGNORECASE - tokens = { - 'root': [ - # Text - (r'[ \t]+', Text), - # Comments - (r";.*?\n", Comment.Single), - # Data types - ('"', String.Double, 'string'), - # Numbers - (r'[0-9]+\.[0-9]*(?!\.)', Number.Float), - (r'\.[0-9]+(?!\.)', Number.Float), - (r'[0-9]+', Number.Integer), - (r'\$[0-9a-f]+', Number.Hex), - (r'\%[10]+', Number.Bin), - # Other - (words(('Shl', 'Shr', 'Sar', 'Mod', 'Or', 'And', 'Not', - 'Abs', 'Sgn', 'Handle', 'Int', 'Float', 'Str', - 'First', 'Last', 'Before', 'After'), - prefix=r'\b', suffix=r'\b'), - Operator), - (r'([+\-*/~=<>^])', Operator), - (r'[(),:\[\]\\]', Punctuation), - (r'\.([ \t]*)(%s)' % bb_name, Name.Label), - # Identifiers - (r'\b(New)\b([ \t]+)(%s)' % (bb_name), - bygroups(Keyword.Reserved, Text, Name.Class)), - (r'\b(Gosub|Goto)\b([ \t]+)(%s)' % (bb_name), - bygroups(Keyword.Reserved, Text, Name.Label)), - (r'\b(Object)\b([ \t]*)([.])([ \t]*)(%s)\b' % (bb_name), - bygroups(Operator, Text, Punctuation, Text, Name.Class)), - (r'\b%s\b([ \t]*)(\()' % bb_var, - bygroups(Name.Function, Text, Keyword.Type, Text, Punctuation, - Text, Name.Class, Text, Punctuation)), - (r'\b(Function)\b([ \t]+)%s' % bb_var, - bygroups(Keyword.Reserved, Text, Name.Function, Text, Keyword.Type, - Text, Punctuation, Text, Name.Class)), - (r'\b(Type)([ \t]+)(%s)' % (bb_name), - bygroups(Keyword.Reserved, Text, Name.Class)), - # Keywords - (r'\b(Pi|True|False|Null)\b', Keyword.Constant), - (r'\b(Local|Global|Const|Field|Dim)\b', Keyword.Declaration), - (words(( - 'End', 'Return', 'Exit', 'Chr', 'Len', 'Asc', 'New', 'Delete', 'Insert', - 'Include', 'Function', 'Type', 'If', 'Then', 'Else', 'ElseIf', 'EndIf', - 'For', 'To', 'Next', 'Step', 'Each', 'While', 'Wend', - 'Repeat', 'Until', 'Forever', 'Select', 'Case', 'Default', - 'Goto', 'Gosub', 'Data', 'Read', 'Restore'), prefix=r'\b', suffix=r'\b'), - Keyword.Reserved), - # Final resolve (for variable names and such) - # (r'(%s)' % (bb_name), Name.Variable), - (bb_var, bygroups(Name.Variable, Text, Keyword.Type, - Text, Punctuation, Text, Name.Class)), - ], - 'string': [ - (r'""', String.Double), - (r'"C?', String.Double, '#pop'), - (r'[^"]+', String.Double), - ], - } - - -class NimrodLexer(RegexLexer): - """ - For `Nimrod <http://nimrod-code.org/>`_ source code. - - .. versionadded:: 1.5 - """ - - name = 'Nimrod' - aliases = ['nimrod', 'nim'] - filenames = ['*.nim', '*.nimrod'] - mimetypes = ['text/x-nimrod'] - - flags = re.MULTILINE | re.IGNORECASE | re.UNICODE - - def underscorize(words): - newWords = [] - new = "" - for word in words: - for ch in word: - new += (ch + "_?") - newWords.append(new) - new = "" - return "|".join(newWords) - - keywords = [ - 'addr', 'and', 'as', 'asm', 'atomic', 'bind', 'block', 'break', - 'case', 'cast', 'const', 'continue', 'converter', 'discard', - 'distinct', 'div', 'elif', 'else', 'end', 'enum', 'except', 'finally', - 'for', 'generic', 'if', 'implies', 'in', 'yield', - 'is', 'isnot', 'iterator', 'lambda', 'let', 'macro', 'method', - 'mod', 'not', 'notin', 'object', 'of', 'or', 'out', 'proc', - 'ptr', 'raise', 'ref', 'return', 'shl', 'shr', 'template', 'try', - 'tuple', 'type', 'when', 'while', 'with', 'without', 'xor' - ] - - keywordsPseudo = [ - 'nil', 'true', 'false' - ] - - opWords = [ - 'and', 'or', 'not', 'xor', 'shl', 'shr', 'div', 'mod', 'in', - 'notin', 'is', 'isnot' - ] - - types = [ - 'int', 'int8', 'int16', 'int32', 'int64', 'float', 'float32', 'float64', - 'bool', 'char', 'range', 'array', 'seq', 'set', 'string' - ] - - tokens = { - 'root': [ - (r'##.*$', String.Doc), - (r'#.*$', Comment), - (r'\*|=|>|<|\+|-|/|@|\$|~|&|%|\!|\?|\||\\|\[|\]', Operator), - (r'\.\.|\.|,|\[\.|\.\]|{\.|\.}|\(\.|\.\)|{|}|\(|\)|:|\^|`|;', - Punctuation), - - # Strings - (r'(?:[\w]+)"', String, 'rdqs'), - (r'"""', String, 'tdqs'), - ('"', String, 'dqs'), - - # Char - ("'", String.Char, 'chars'), - - # Keywords - (r'(%s)\b' % underscorize(opWords), Operator.Word), - (r'(p_?r_?o_?c_?\s)(?![\(\[\]])', Keyword, 'funcname'), - (r'(%s)\b' % underscorize(keywords), Keyword), - (r'(%s)\b' % underscorize(['from', 'import', 'include']), - Keyword.Namespace), - (r'(v_?a_?r)\b', Keyword.Declaration), - (r'(%s)\b' % underscorize(types), Keyword.Type), - (r'(%s)\b' % underscorize(keywordsPseudo), Keyword.Pseudo), - # Identifiers - (r'\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*', Name), - # Numbers - (r'[0-9][0-9_]*(?=([eE.]|\'[fF](32|64)))', - Number.Float, ('float-suffix', 'float-number')), - (r'0[xX][a-f0-9][a-f0-9_]*', Number.Hex, 'int-suffix'), - (r'0[bB][01][01_]*', Number.Bin, 'int-suffix'), - (r'0o[0-7][0-7_]*', Number.Oct, 'int-suffix'), - (r'[0-9][0-9_]*', Number.Integer, 'int-suffix'), - # Whitespace - (r'\s+', Text), - (r'.+$', Error), - ], - 'chars': [ - (r'\\([\\abcefnrtvl"\']|x[a-f0-9]{2}|[0-9]{1,3})', String.Escape), - (r"'", String.Char, '#pop'), - (r".", String.Char) - ], - 'strings': [ - (r'(?<!\$)\$(\d+|#|\w+)+', String.Interpol), - (r'[^\\\'"\$\n]+', String), - # quotes, dollars and backslashes must be parsed one at a time - (r'[\'"\\]', String), - # unhandled string formatting sign - (r'\$', String) - # newlines are an error (use "nl" state) - ], - 'dqs': [ - (r'\\([\\abcefnrtvl"\']|\n|x[a-f0-9]{2}|[0-9]{1,3})', - String.Escape), - (r'"', String, '#pop'), - include('strings') - ], - 'rdqs': [ - (r'"(?!")', String, '#pop'), - (r'""', String.Escape), - include('strings') - ], - 'tdqs': [ - (r'"""(?!")', String, '#pop'), - include('strings'), - include('nl') - ], - 'funcname': [ - (r'((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*', Name.Function, '#pop'), - (r'`.+`', Name.Function, '#pop') - ], - 'nl': [ - (r'\n', String) - ], - 'float-number': [ - (r'\.(?!\.)[0-9_]*', Number.Float), - (r'[eE][+-]?[0-9][0-9_]*', Number.Float), - default('#pop') - ], - 'float-suffix': [ - (r'\'[fF](32|64)', Number.Float), - default('#pop') - ], - 'int-suffix': [ - (r'\'[iI](32|64)', Number.Integer.Long), - (r'\'[iI](8|16)', Number.Integer), - default('#pop') - ], - } - - -class FantomLexer(RegexLexer): - """ - For Fantom source code. - - .. versionadded:: 1.5 - """ - name = 'Fantom' - aliases = ['fan'] - filenames = ['*.fan'] - mimetypes = ['application/x-fantom'] - - # often used regexes - def s(str): - return Template(str).substitute( - dict( - pod = r'[\"\w\.]+', - eos = r'\n|;', - id = r'[a-zA-Z_]\w*', - # all chars which can be part of type definition. Starts with - # either letter, or [ (maps), or | (funcs) - type = r'(?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?', - ) - ) - - tokens = { - 'comments': [ - (r'(?s)/\*.*?\*/', Comment.Multiline), # Multiline - (r'//.*?\n', Comment.Single), # Single line - # TODO: highlight references in fandocs - (r'\*\*.*?\n', Comment.Special), # Fandoc - (r'#.*\n', Comment.Single) # Shell-style - ], - 'literals': [ - (r'\b-?[\d_]+(ns|ms|sec|min|hr|day)', Number), # Duration - (r'\b-?[\d_]*\.[\d_]+(ns|ms|sec|min|hr|day)', Number), - # Duration with dot - (r'\b-?(\d+)?\.\d+(f|F|d|D)?', Number.Float), # Float/Decimal - (r'\b-?0x[0-9a-fA-F_]+', Number.Hex), # Hex - (r'\b-?[\d_]+', Number.Integer), # Int - (r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'", String.Char), # Char - (r'"', Punctuation, 'insideStr'), # Opening quote - (r'`', Punctuation, 'insideUri'), # Opening accent - (r'\b(true|false|null)\b', Keyword.Constant), # Bool & null - (r'(?:(\w+)(::))?(\w+)(<\|)(.*?)(\|>)', # DSL - bygroups(Name.Namespace, Punctuation, Name.Class, - Punctuation, String, Punctuation)), - (r'(?:(\w+)(::))?(\w+)?(#)(\w+)?', # Type/slot literal - bygroups(Name.Namespace, Punctuation, Name.Class, - Punctuation, Name.Function)), - (r'\[,\]', Literal), # Empty list - (s(r'($type)(\[,\])'), # Typed empty list - bygroups(using(this, state='inType'), Literal)), - (r'\[:\]', Literal), # Empty Map - (s(r'($type)(\[:\])'), - bygroups(using(this, state='inType'), Literal)), - ], - 'insideStr': [ - (r'\\\\', String.Escape), # Escaped backslash - (r'\\"', String.Escape), # Escaped " - (r'\\`', String.Escape), # Escaped ` - (r'\$\w+', String.Interpol), # Subst var - (r'\${.*?}', String.Interpol), # Subst expr - (r'"', Punctuation, '#pop'), # Closing quot - (r'.', String) # String content - ], - 'insideUri': [ # TODO: remove copy/paste str/uri - (r'\\\\', String.Escape), # Escaped backslash - (r'\\"', String.Escape), # Escaped " - (r'\\`', String.Escape), # Escaped ` - (r'\$\w+', String.Interpol), # Subst var - (r'\${.*?}', String.Interpol), # Subst expr - (r'`', Punctuation, '#pop'), # Closing tick - (r'.', String.Backtick) # URI content - ], - 'protectionKeywords': [ - (r'\b(public|protected|private|internal)\b', Keyword), - ], - 'typeKeywords': [ - (r'\b(abstract|final|const|native|facet|enum)\b', Keyword), - ], - 'methodKeywords': [ - (r'\b(abstract|native|once|override|static|virtual|final)\b', - Keyword), - ], - 'fieldKeywords': [ - (r'\b(abstract|const|final|native|override|static|virtual|' - r'readonly)\b', Keyword) - ], - 'otherKeywords': [ - (words(( - 'try', 'catch', 'throw', 'finally', 'for', 'if', 'else', 'while', - 'as', 'is', 'isnot', 'switch', 'case', 'default', 'continue', - 'break', 'do', 'return', 'get', 'set'), prefix=r'\b', suffix=r'\b'), - Keyword), - (r'\b(it|this|super)\b', Name.Builtin.Pseudo), - ], - 'operators': [ - (r'\+\+|\-\-|\+|\-|\*|/|\|\||&&|<=>|<=|<|>=|>|=|!|\[|\]', Operator) - ], - 'inType': [ - (r'[\[\]\|\->:\?]', Punctuation), - (s(r'$id'), Name.Class), - default('#pop'), - - ], - 'root': [ - include('comments'), - include('protectionKeywords'), - include('typeKeywords'), - include('methodKeywords'), - include('fieldKeywords'), - include('literals'), - include('otherKeywords'), - include('operators'), - (r'using\b', Keyword.Namespace, 'using'), # Using stmt - (r'@\w+', Name.Decorator, 'facet'), # Symbol - (r'(class|mixin)(\s+)(\w+)', bygroups(Keyword, Text, Name.Class), - 'inheritance'), # Inheritance list - - ### Type var := val - (s(r'($type)([ \t]+)($id)(\s*)(:=)'), - bygroups(using(this, state = 'inType'), Text, - Name.Variable, Text, Operator)), - - ### var := val - (s(r'($id)(\s*)(:=)'), - bygroups(Name.Variable, Text, Operator)), - - ### .someId( or ->someId( ### - (s(r'(\.|(?:\->))($id)(\s*)(\()'), - bygroups(Operator, Name.Function, Text, Punctuation), - 'insideParen'), - - ### .someId or ->someId - (s(r'(\.|(?:\->))($id)'), - bygroups(Operator, Name.Function)), - - ### new makeXXX ( #### - (r'(new)(\s+)(make\w*)(\s*)(\()', - bygroups(Keyword, Text, Name.Function, Text, Punctuation), - 'insideMethodDeclArgs'), - - ### Type name ( #### - (s(r'($type)([ \t]+)' # Return type and whitespace - r'($id)(\s*)(\()'), # method name + open brace - bygroups(using(this, state = 'inType'), Text, - Name.Function, Text, Punctuation), - 'insideMethodDeclArgs'), - - ### ArgType argName, ##### - (s(r'($type)(\s+)($id)(\s*)(,)'), - bygroups(using(this, state='inType'), Text, Name.Variable, - Text, Punctuation)), - - #### ArgType argName) #### - ## Covered in 'insideParen' state - - ### ArgType argName -> ArgType| ### - (s(r'($type)(\s+)($id)(\s*)(\->)(\s*)($type)(\|)'), - bygroups(using(this, state='inType'), Text, Name.Variable, - Text, Punctuation, Text, using(this, state = 'inType'), - Punctuation)), - - ### ArgType argName| ### - (s(r'($type)(\s+)($id)(\s*)(\|)'), - bygroups(using(this, state='inType'), Text, Name.Variable, - Text, Punctuation)), - - ### Type var - (s(r'($type)([ \t]+)($id)'), - bygroups(using(this, state='inType'), Text, - Name.Variable)), - - (r'\(', Punctuation, 'insideParen'), - (r'\{', Punctuation, 'insideBrace'), - (r'.', Text) - ], - 'insideParen': [ - (r'\)', Punctuation, '#pop'), - include('root'), - ], - 'insideMethodDeclArgs': [ - (r'\)', Punctuation, '#pop'), - (s(r'($type)(\s+)($id)(\s*)(\))'), - bygroups(using(this, state='inType'), Text, Name.Variable, - Text, Punctuation), '#pop'), - include('root'), - ], - 'insideBrace': [ - (r'\}', Punctuation, '#pop'), - include('root'), - ], - 'inheritance': [ - (r'\s+', Text), # Whitespace - (r':|,', Punctuation), - (r'(?:(\w+)(::))?(\w+)', - bygroups(Name.Namespace, Punctuation, Name.Class)), - (r'{', Punctuation, '#pop') - ], - 'using': [ - (r'[ \t]+', Text), # consume whitespaces - (r'(\[)(\w+)(\])', - bygroups(Punctuation, Comment.Special, Punctuation)), # ffi - (r'(\")?([\w\.]+)(\")?', - bygroups(Punctuation, Name.Namespace, Punctuation)), # podname - (r'::', Punctuation, 'usingClass'), - default('#pop') - ], - 'usingClass': [ - (r'[ \t]+', Text), # consume whitespaces - (r'(as)(\s+)(\w+)', - bygroups(Keyword.Declaration, Text, Name.Class), '#pop:2'), - (r'[\w\$]+', Name.Class), - default('#pop:2') # jump out to root state - ], - 'facet': [ - (r'\s+', Text), - (r'{', Punctuation, 'facetFields'), - default('#pop') - ], - 'facetFields': [ - include('comments'), - include('literals'), - include('operators'), - (r'\s+', Text), - (r'(\s*)(\w+)(\s*)(=)', bygroups(Text, Name, Text, Operator)), - (r'}', Punctuation, '#pop'), - (r'.', Text) - ], - } - - -class RustLexer(RegexLexer): - """ - Lexer for the Rust programming language (version 0.9). - - .. versionadded:: 1.6 - """ - name = 'Rust' - filenames = ['*.rs'] - aliases = ['rust'] - mimetypes = ['text/x-rustsrc'] - - tokens = { - 'root': [ - # Whitespace and Comments - (r'\n', Text), - (r'\s+', Text), - (r'//[/!](.*?)\n', Comment.Doc), - (r'//(.*?)\n', Comment.Single), - (r'/\*', Comment.Multiline, 'comment'), - - # Keywords - (words(( - 'as', 'box', 'break', 'continue', 'do', 'else', 'enum', 'extern', - 'fn', 'for', 'if', 'impl', 'in', 'loop', 'match', 'mut', 'priv', - 'proc', 'pub', 'ref', 'return', 'static', '\'static', 'struct', - 'trait', 'true', 'type', 'unsafe', 'while'), suffix=r'\b'), - Keyword), - (words(('alignof', 'be', 'const', 'offsetof', 'pure', 'sizeof', - 'typeof', 'once', 'unsized', 'yield'), suffix=r'\b'), - Keyword.Reserved), - (r'(mod|use)\b', Keyword.Namespace), - (r'(true|false)\b', Keyword.Constant), - (r'let\b', Keyword.Declaration), - (words(('u8', 'u16', 'u32', 'u64', 'i8', 'i16', 'i32', 'i64', 'uint', - 'int', 'f32', 'f64', 'str', 'bool'), suffix=r'\b'), - Keyword.Type), - (r'self\b', Name.Builtin.Pseudo), - # Prelude - (words(( - 'Freeze', 'Pod', 'Send', 'Sized', 'Add', 'Sub', 'Mul', 'Div', 'Rem', 'Neg', 'Not', 'BitAnd', - 'BitOr', 'BitXor', 'Drop', 'Shl', 'Shr', 'Index', 'Option', 'Some', 'None', 'Result', - 'Ok', 'Err', 'from_str', 'range', 'print', 'println', 'Any', 'AnyOwnExt', 'AnyRefExt', - 'AnyMutRefExt', 'Ascii', 'AsciiCast', 'OnwedAsciiCast', 'AsciiStr', - 'IntoBytes', 'Bool', 'ToCStr', 'Char', 'Clone', 'DeepClone', 'Eq', 'ApproxEq', - 'Ord', 'TotalEq', 'Ordering', 'Less', 'Equal', 'Greater', 'Equiv', 'Container', - 'Mutable', 'Map', 'MutableMap', 'Set', 'MutableSet', 'Default', 'FromStr', - 'Hash', 'FromIterator', 'Extendable', 'Iterator', 'DoubleEndedIterator', - 'RandomAccessIterator', 'CloneableIterator', 'OrdIterator', - 'MutableDoubleEndedIterator', 'ExactSize', 'Times', 'Algebraic', - 'Trigonometric', 'Exponential', 'Hyperbolic', 'Bitwise', 'BitCount', - 'Bounded', 'Integer', 'Fractional', 'Real', 'RealExt', 'Num', 'NumCast', - 'CheckedAdd', 'CheckedSub', 'CheckedMul', 'Orderable', 'Signed', - 'Unsigned', 'Round', 'Primitive', 'Int', 'Float', 'ToStrRadix', - 'ToPrimitive', 'FromPrimitive', 'GenericPath', 'Path', 'PosixPath', - 'WindowsPath', 'RawPtr', 'Buffer', 'Writer', 'Reader', 'Seek', - 'SendStr', 'SendStrOwned', 'SendStrStatic', 'IntoSendStr', 'Str', - 'StrVector', 'StrSlice', 'OwnedStr', 'IterBytes', 'ToStr', 'IntoStr', - 'CopyableTuple', 'ImmutableTuple', 'ImmutableEqVector', 'ImmutableTotalOrdVector', - 'ImmutableCopyableVector', 'OwnedVector', 'OwnedCopyableVector', - 'OwnedEqVector', 'MutableVector', 'MutableTotalOrdVector', - 'Vector', 'VectorVector', 'CopyableVector', 'ImmutableVector', - 'Port', 'Chan', 'SharedChan', 'spawn', 'drop'), suffix=r'\b'), - Name.Builtin), - (r'(ImmutableTuple\d+|Tuple\d+)\b', Name.Builtin), - # Borrowed pointer - (r'(&)(\'[A-Za-z_]\w*)?', bygroups(Operator, Name)), - # Labels - (r'\'[A-Za-z_]\w*:', Name.Label), - # Character Literal - (r"""'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}""" - r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|.)'""", - String.Char), - # Lifetime - (r"""'[a-zA-Z_]\w*""", Name.Label), - # Binary Literal - (r'0b[01_]+', Number.Bin, 'number_lit'), - # Octal Literal - (r'0o[0-7_]+', Number.Oct, 'number_lit'), - # Hexadecimal Literal - (r'0[xX][0-9a-fA-F_]+', Number.Hex, 'number_lit'), - # Decimal Literal - (r'[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|' - r'\.[0-9_]*|[eE][+\-]?[0-9_]+)', Number.Float, 'number_lit'), - (r'[0-9][0-9_]*', Number.Integer, 'number_lit'), - # String Literal - (r'"', String, 'string'), - (r'r(#*)".*?"\1', String.Raw), - - # Operators and Punctuation - (r'[{}()\[\],.;]', Punctuation), - (r'[+\-*/%&|<>^!~@=:?]', Operator), - - # Identifier - (r'[a-zA-Z_]\w*', Name), - - # Attributes - (r'#\[', Comment.Preproc, 'attribute['), - # Macros - (r'([A-Za-z_]\w*)!\s*([A-Za-z_]\w*)?\s*\{', - bygroups(Comment.Preproc, Name), 'macro{'), - (r'([A-Za-z_]\w*)!\s*([A-Za-z_]\w*)?\(', - bygroups(Comment.Preproc, Name), 'macro('), - ], - 'comment': [ - (r'[^*/]+', Comment.Multiline), - (r'/\*', Comment.Multiline, '#push'), - (r'\*/', Comment.Multiline, '#pop'), - (r'[*/]', Comment.Multiline), - ], - 'number_lit': [ - (r'(([ui](8|16|32|64)?)|(f(32|64)?))?', Keyword, '#pop'), - ], - 'string': [ - (r'"', String, '#pop'), - (r"""\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}""" - r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}""", String.Escape), - (r'[^\\"]+', String), - (r'\\', String), - ], - 'macro{': [ - (r'\{', Operator, '#push'), - (r'\}', Operator, '#pop'), - ], - 'macro(': [ - (r'\(', Operator, '#push'), - (r'\)', Operator, '#pop'), - ], - 'attribute_common': [ - (r'"', String, 'string'), - (r'\[', Comment.Preproc, 'attribute['), - (r'\(', Comment.Preproc, 'attribute('), - ], - 'attribute[': [ - include('attribute_common'), - (r'\];?', Comment.Preproc, '#pop'), - (r'[^"\]]+', Comment.Preproc), - ], - 'attribute(': [ - include('attribute_common'), - (r'\);?', Comment.Preproc, '#pop'), - (r'[^"\)]+', Comment.Preproc), - ], - } - - -class CudaLexer(CLexer): - """ - For NVIDIA `CUDA™ <http://developer.nvidia.com/category/zone/cuda-zone>`_ - source. - - .. versionadded:: 1.6 - """ - name = 'CUDA' - filenames = ['*.cu', '*.cuh'] - aliases = ['cuda', 'cu'] - mimetypes = ['text/x-cuda'] - - function_qualifiers = set(('__device__', '__global__', '__host__', - '__noinline__', '__forceinline__')) - variable_qualifiers = set(('__device__', '__constant__', '__shared__', - '__restrict__')) - vector_types = set(('char1', 'uchar1', 'char2', 'uchar2', 'char3', 'uchar3', - 'char4', 'uchar4', 'short1', 'ushort1', 'short2', 'ushort2', - 'short3', 'ushort3', 'short4', 'ushort4', 'int1', 'uint1', - 'int2', 'uint2', 'int3', 'uint3', 'int4', 'uint4', 'long1', - 'ulong1', 'long2', 'ulong2', 'long3', 'ulong3', 'long4', - 'ulong4', 'longlong1', 'ulonglong1', 'longlong2', - 'ulonglong2', 'float1', 'float2', 'float3', 'float4', - 'double1', 'double2', 'dim3')) - variables = set(('gridDim', 'blockIdx', 'blockDim', 'threadIdx', 'warpSize')) - functions = set(('__threadfence_block', '__threadfence', '__threadfence_system', - '__syncthreads', '__syncthreads_count', '__syncthreads_and', - '__syncthreads_or')) - execution_confs = set(('<<<', '>>>')) - - def get_tokens_unprocessed(self, text): - for index, token, value in CLexer.get_tokens_unprocessed(self, text): - if token is Name: - if value in self.variable_qualifiers: - token = Keyword.Type - elif value in self.vector_types: - token = Keyword.Type - elif value in self.variables: - token = Name.Builtin - elif value in self.execution_confs: - token = Keyword.Pseudo - elif value in self.function_qualifiers: - token = Keyword.Reserved - elif value in self.functions: - token = Name.Function - yield index, token, value - - -class MonkeyLexer(RegexLexer): - """ - For - `Monkey <https://en.wikipedia.org/wiki/Monkey_(programming_language)>`_ - source code. - - .. versionadded:: 1.6 - """ - - name = 'Monkey' - aliases = ['monkey'] - filenames = ['*.monkey'] - mimetypes = ['text/x-monkey'] - - name_variable = r'[a-z_]\w*' - name_function = r'[A-Z]\w*' - name_constant = r'[A-Z_][A-Z0-9_]*' - name_class = r'[A-Z]\w*' - name_module = r'[a-z0-9_]*' - - keyword_type = r'(?:Int|Float|String|Bool|Object|Array|Void)' - # ? == Bool // % == Int // # == Float // $ == String - keyword_type_special = r'[?%#$]' - - flags = re.MULTILINE - - tokens = { - 'root': [ - # Text - (r'\s+', Text), - # Comments - (r"'.*", Comment), - (r'(?i)^#rem\b', Comment.Multiline, 'comment'), - # preprocessor directives - (r'(?i)^(?:#If|#ElseIf|#Else|#EndIf|#End|#Print|#Error)\b', Comment.Preproc), - # preprocessor variable (any line starting with '#' that is not a directive) - (r'^#', Comment.Preproc, 'variables'), - # String - ('"', String.Double, 'string'), - # Numbers - (r'[0-9]+\.[0-9]*(?!\.)', Number.Float), - (r'\.[0-9]+(?!\.)', Number.Float), - (r'[0-9]+', Number.Integer), - (r'\$[0-9a-fA-Z]+', Number.Hex), - (r'\%[10]+', Number.Bin), - # Native data types - (r'\b%s\b' % keyword_type, Keyword.Type), - # Exception handling - (r'(?i)\b(?:Try|Catch|Throw)\b', Keyword.Reserved), - (r'Throwable', Name.Exception), - # Builtins - (r'(?i)\b(?:Null|True|False)\b', Name.Builtin), - (r'(?i)\b(?:Self|Super)\b', Name.Builtin.Pseudo), - (r'\b(?:HOST|LANG|TARGET|CONFIG)\b', Name.Constant), - # Keywords - (r'(?i)^(Import)(\s+)(.*)(\n)', - bygroups(Keyword.Namespace, Text, Name.Namespace, Text)), - (r'(?i)^Strict\b.*\n', Keyword.Reserved), - (r'(?i)(Const|Local|Global|Field)(\s+)', - bygroups(Keyword.Declaration, Text), 'variables'), - (r'(?i)(New|Class|Interface|Extends|Implements)(\s+)', - bygroups(Keyword.Reserved, Text), 'classname'), - (r'(?i)(Function|Method)(\s+)', - bygroups(Keyword.Reserved, Text), 'funcname'), - (r'(?i)(?:End|Return|Public|Private|Extern|Property|' - r'Final|Abstract)\b', Keyword.Reserved), - # Flow Control stuff - (r'(?i)(?:If|Then|Else|ElseIf|EndIf|' - r'Select|Case|Default|' - r'While|Wend|' - r'Repeat|Until|Forever|' - r'For|To|Until|Step|EachIn|Next|' - r'Exit|Continue)\s+', Keyword.Reserved), - # not used yet - (r'(?i)\b(?:Module|Inline)\b', Keyword.Reserved), - # Array - (r'[\[\]]', Punctuation), - # Other - (r'<=|>=|<>|\*=|/=|\+=|-=|&=|~=|\|=|[-&*/^+=<>|~]', Operator), - (r'(?i)(?:Not|Mod|Shl|Shr|And|Or)', Operator.Word), - (r'[\(\){}!#,.:]', Punctuation), - # catch the rest - (r'%s\b' % name_constant, Name.Constant), - (r'%s\b' % name_function, Name.Function), - (r'%s\b' % name_variable, Name.Variable), - ], - 'funcname': [ - (r'(?i)%s\b' % name_function, Name.Function), - (r':', Punctuation, 'classname'), - (r'\s+', Text), - (r'\(', Punctuation, 'variables'), - (r'\)', Punctuation, '#pop') - ], - 'classname': [ - (r'%s\.' % name_module, Name.Namespace), - (r'%s\b' % keyword_type, Keyword.Type), - (r'%s\b' % name_class, Name.Class), - # array (of given size) - (r'(\[)(\s*)(\d*)(\s*)(\])', - bygroups(Punctuation, Text, Number.Integer, Text, Punctuation)), - # generics - (r'\s+(?!<)', Text, '#pop'), - (r'<', Punctuation, '#push'), - (r'>', Punctuation, '#pop'), - (r'\n', Text, '#pop'), - default('#pop') - ], - 'variables': [ - (r'%s\b' % name_constant, Name.Constant), - (r'%s\b' % name_variable, Name.Variable), - (r'%s' % keyword_type_special, Keyword.Type), - (r'\s+', Text), - (r':', Punctuation, 'classname'), - (r',', Punctuation, '#push'), - default('#pop') - ], - 'string': [ - (r'[^"~]+', String.Double), - (r'~q|~n|~r|~t|~z|~~', String.Escape), - (r'"', String.Double, '#pop'), - ], - 'comment': [ - (r'(?i)^#rem.*?', Comment.Multiline, "#push"), - (r'(?i)^#end.*?', Comment.Multiline, "#pop"), - (r'\n', Comment.Multiline), - (r'.+', Comment.Multiline), - ], - } - - -class CobolLexer(RegexLexer): - """ - Lexer for OpenCOBOL code. - - .. versionadded:: 1.6 - """ - name = 'COBOL' - aliases = ['cobol'] - filenames = ['*.cob', '*.COB', '*.cpy', '*.CPY'] - mimetypes = ['text/x-cobol'] - flags = re.IGNORECASE | re.MULTILINE - - # Data Types: by PICTURE and USAGE - # Operators: **, *, +, -, /, <, >, <=, >=, =, <> - # Logical (?): NOT, AND, OR - - # Reserved words: - # http://opencobol.add1tocobol.com/#reserved-words - # Intrinsics: - # http://opencobol.add1tocobol.com/#does-opencobol-implement-any-intrinsic-functions - - tokens = { - 'root': [ - include('comment'), - include('strings'), - include('core'), - include('nums'), - (r'[a-z0-9]([_a-z0-9\-]*[a-z0-9]+)?', Name.Variable), - # (r'[\s]+', Text), - (r'[ \t]+', Text), - ], - 'comment': [ - (r'(^.{6}[*/].*\n|^.{6}|\*>.*\n)', Comment), - ], - 'core': [ - # Figurative constants - (r'(^|(?<=[^0-9a-z_\-]))(ALL\s+)?' - r'((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)' - r'\s*($|(?=[^0-9a-z_\-]))', - Name.Constant), - - # Reserved words STATEMENTS and other bolds - (r'(^|(?<=[^0-9a-z_\-]))' - r'(ACCEPT|ADD|ALLOCATE|CALL|CANCEL|CLOSE|COMPUTE|' - r'CONFIGURATION|CONTINUE|' - r'DATA|DELETE|DISPLAY|DIVIDE|DIVISION|ELSE|END|END-ACCEPT|' - r'END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DISPLAY|' - r'END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|' - r'END-PERFORM|END-READ|END-RETURN|END-REWRITE|END-SEARCH|' - r'END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|' - r'ENVIRONMENT|EVALUATE|EXIT|FD|FILE|FILE-CONTROL|FOREVER|' - r'FREE|GENERATE|GO|GOBACK|' - r'IDENTIFICATION|IF|INITIALIZE|' - r'INITIATE|INPUT-OUTPUT|INSPECT|INVOKE|I-O-CONTROL|LINKAGE|' - r'LOCAL-STORAGE|MERGE|MOVE|MULTIPLY|OPEN|' - r'PERFORM|PROCEDURE|PROGRAM-ID|RAISE|READ|RELEASE|RESUME|' - r'RETURN|REWRITE|SCREEN|' - r'SD|SEARCH|SECTION|SET|SORT|START|STOP|STRING|SUBTRACT|' - r'SUPPRESS|TERMINATE|THEN|UNLOCK|UNSTRING|USE|VALIDATE|' - r'WORKING-STORAGE|WRITE)' - r'\s*($|(?=[^0-9a-z_\-]))', Keyword.Reserved), - - # Reserved words - (r'(^|(?<=[^0-9a-z_\-]))' - r'(ACCESS|ADDRESS|ADVANCING|AFTER|ALL|' - r'ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|' - r'ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE' - r'ANY|ARE|AREA|AREAS|ARGUMENT-NUMBER|ARGUMENT-VALUE|AS|' - r'ASCENDING|ASSIGN|AT|AUTO|AUTO-SKIP|AUTOMATIC|AUTOTERMINATE|' - r'BACKGROUND-COLOR|BASED|BEEP|BEFORE|BELL|' - r'BLANK|' - r'BLINK|BLOCK|BOTTOM|BY|BYTE-LENGTH|CHAINING|' - r'CHARACTER|CHARACTERS|CLASS|CODE|CODE-SET|COL|COLLATING|' - r'COLS|COLUMN|COLUMNS|COMMA|COMMAND-LINE|COMMIT|COMMON|' - r'CONSTANT|CONTAINS|CONTENT|CONTROL|' - r'CONTROLS|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRT|' - r'CURRENCY|CURSOR|CYCLE|DATE|DAY|DAY-OF-WEEK|DE|DEBUGGING|' - r'DECIMAL-POINT|DECLARATIVES|DEFAULT|DELIMITED|' - r'DELIMITER|DEPENDING|DESCENDING|DETAIL|DISK|' - r'DOWN|DUPLICATES|DYNAMIC|EBCDIC|' - r'ENTRY|ENVIRONMENT-NAME|ENVIRONMENT-VALUE|EOL|EOP|' - r'EOS|ERASE|ERROR|ESCAPE|EXCEPTION|' - r'EXCLUSIVE|EXTEND|EXTERNAL|' - r'FILE-ID|FILLER|FINAL|FIRST|FIXED|FLOAT-LONG|FLOAT-SHORT|' - r'FOOTING|FOR|FOREGROUND-COLOR|FORMAT|FROM|FULL|FUNCTION|' - r'FUNCTION-ID|GIVING|GLOBAL|GROUP|' - r'HEADING|HIGHLIGHT|I-O|ID|' - r'IGNORE|IGNORING|IN|INDEX|INDEXED|INDICATE|' - r'INITIAL|INITIALIZED|INPUT|' - r'INTO|INTRINSIC|INVALID|IS|JUST|JUSTIFIED|KEY|LABEL|' - r'LAST|LEADING|LEFT|LENGTH|LIMIT|LIMITS|LINAGE|' - r'LINAGE-COUNTER|LINE|LINES|LOCALE|LOCK|' - r'LOWLIGHT|MANUAL|MEMORY|MINUS|MODE|' - r'MULTIPLE|NATIONAL|NATIONAL-EDITED|NATIVE|' - r'NEGATIVE|NEXT|NO|NULL|NULLS|NUMBER|NUMBERS|NUMERIC|' - r'NUMERIC-EDITED|OBJECT-COMPUTER|OCCURS|OF|OFF|OMITTED|ON|ONLY|' - r'OPTIONAL|ORDER|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|' - r'OVERLINE|PACKED-DECIMAL|PADDING|PAGE|PARAGRAPH|' - r'PLUS|POINTER|POSITION|POSITIVE|PRESENT|PREVIOUS|' - r'PRINTER|PRINTING|PROCEDURE-POINTER|PROCEDURES|' - r'PROCEED|PROGRAM|PROGRAM-POINTER|PROMPT|QUOTE|' - r'QUOTES|RANDOM|RD|RECORD|RECORDING|RECORDS|RECURSIVE|' - r'REDEFINES|REEL|REFERENCE|RELATIVE|REMAINDER|REMOVAL|' - r'RENAMES|REPLACING|REPORT|REPORTING|REPORTS|REPOSITORY|' - r'REQUIRED|RESERVE|RETURNING|REVERSE-VIDEO|REWIND|' - r'RIGHT|ROLLBACK|ROUNDED|RUN|SAME|SCROLL|' - r'SECURE|SEGMENT-LIMIT|SELECT|SENTENCE|SEPARATE|' - r'SEQUENCE|SEQUENTIAL|SHARING|SIGN|SIGNED|SIGNED-INT|' - r'SIGNED-LONG|SIGNED-SHORT|SIZE|SORT-MERGE|SOURCE|' - r'SOURCE-COMPUTER|SPECIAL-NAMES|STANDARD|' - r'STANDARD-1|STANDARD-2|STATUS|SUM|' - r'SYMBOLIC|SYNC|SYNCHRONIZED|TALLYING|TAPE|' - r'TEST|THROUGH|THRU|TIME|TIMES|TO|TOP|TRAILING|' - r'TRANSFORM|TYPE|UNDERLINE|UNIT|UNSIGNED|' - r'UNSIGNED-INT|UNSIGNED-LONG|UNSIGNED-SHORT|UNTIL|UP|' - r'UPDATE|UPON|USAGE|USING|VALUE|VALUES|VARYING|WAIT|WHEN|' - r'WITH|WORDS|YYYYDDD|YYYYMMDD)' - r'\s*($|(?=[^0-9a-z_\-]))', Keyword.Pseudo), - - # inactive reserved words - (r'(^|(?<=[^0-9a-z_\-]))' - r'(ACTIVE-CLASS|ALIGNED|ANYCASE|ARITHMETIC|ATTRIBUTE|B-AND|' - r'B-NOT|B-OR|B-XOR|BIT|BOOLEAN|CD|CENTER|CF|CH|CHAIN|CLASS-ID|' - r'CLASSIFICATION|COMMUNICATION|CONDITION|DATA-POINTER|' - r'DESTINATION|DISABLE|EC|EGI|EMI|ENABLE|END-RECEIVE|' - r'ENTRY-CONVENTION|EO|ESI|EXCEPTION-OBJECT|EXPANDS|FACTORY|' - r'FLOAT-BINARY-16|FLOAT-BINARY-34|FLOAT-BINARY-7|' - r'FLOAT-DECIMAL-16|FLOAT-DECIMAL-34|FLOAT-EXTENDED|FORMAT|' - r'FUNCTION-POINTER|GET|GROUP-USAGE|IMPLEMENTS|INFINITY|' - r'INHERITS|INTERFACE|INTERFACE-ID|INVOKE|LC_ALL|LC_COLLATE|' - r'LC_CTYPE|LC_MESSAGES|LC_MONETARY|LC_NUMERIC|LC_TIME|' - r'LINE-COUNTER|MESSAGE|METHOD|METHOD-ID|NESTED|NONE|NORMAL|' - r'OBJECT|OBJECT-REFERENCE|OPTIONS|OVERRIDE|PAGE-COUNTER|PF|PH|' - r'PROPERTY|PROTOTYPE|PURGE|QUEUE|RAISE|RAISING|RECEIVE|' - r'RELATION|REPLACE|REPRESENTS-NOT-A-NUMBER|RESET|RESUME|RETRY|' - r'RF|RH|SECONDS|SEGMENT|SELF|SEND|SOURCES|STATEMENT|STEP|' - r'STRONG|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUPER|SYMBOL|' - r'SYSTEM-DEFAULT|TABLE|TERMINAL|TEXT|TYPEDEF|UCS-4|UNIVERSAL|' - r'USER-DEFAULT|UTF-16|UTF-8|VAL-STATUS|VALID|VALIDATE|' - r'VALIDATE-STATUS)\s*($|(?=[^0-9a-z_\-]))', Error), - - # Data Types - (r'(^|(?<=[^0-9a-z_\-]))' - r'(PIC\s+.+?(?=(\s|\.\s))|PICTURE\s+.+?(?=(\s|\.\s))|' - r'(COMPUTATIONAL)(-[1-5X])?|(COMP)(-[1-5X])?|' - r'BINARY-C-LONG|' - r'BINARY-CHAR|BINARY-DOUBLE|BINARY-LONG|BINARY-SHORT|' - r'BINARY)\s*($|(?=[^0-9a-z_\-]))', Keyword.Type), - - # Operators - (r'(\*\*|\*|\+|-|/|<=|>=|<|>|==|/=|=)', Operator), - - # (r'(::)', Keyword.Declaration), - - (r'([(),;:&%.])', Punctuation), - - # Intrinsics - (r'(^|(?<=[^0-9a-z_\-]))(ABS|ACOS|ANNUITY|ASIN|ATAN|BYTE-LENGTH|' - r'CHAR|COMBINED-DATETIME|CONCATENATE|COS|CURRENT-DATE|' - r'DATE-OF-INTEGER|DATE-TO-YYYYMMDD|DAY-OF-INTEGER|DAY-TO-YYYYDDD|' - r'EXCEPTION-(?:FILE|LOCATION|STATEMENT|STATUS)|EXP10|EXP|E|' - r'FACTORIAL|FRACTION-PART|INTEGER-OF-(?:DATE|DAY|PART)|INTEGER|' - r'LENGTH|LOCALE-(?:DATE|TIME(?:-FROM-SECONDS)?)|LOG(?:10)?|' - r'LOWER-CASE|MAX|MEAN|MEDIAN|MIDRANGE|MIN|MOD|NUMVAL(?:-C)?|' - r'ORD(?:-MAX|-MIN)?|PI|PRESENT-VALUE|RANDOM|RANGE|REM|REVERSE|' - r'SECONDS-FROM-FORMATTED-TIME|SECONDS-PAST-MIDNIGHT|SIGN|SIN|SQRT|' - r'STANDARD-DEVIATION|STORED-CHAR-LENGTH|SUBSTITUTE(?:-CASE)?|' - r'SUM|TAN|TEST-DATE-YYYYMMDD|TEST-DAY-YYYYDDD|TRIM|' - r'UPPER-CASE|VARIANCE|WHEN-COMPILED|YEAR-TO-YYYY)\s*' - r'($|(?=[^0-9a-z_\-]))', Name.Function), - - # Booleans - (r'(^|(?<=[^0-9a-z_\-]))(true|false)\s*($|(?=[^0-9a-z_\-]))', Name.Builtin), - # Comparing Operators - (r'(^|(?<=[^0-9a-z_\-]))(equal|equals|ne|lt|le|gt|ge|' - r'greater|less|than|not|and|or)\s*($|(?=[^0-9a-z_\-]))', Operator.Word), - ], - - # \"[^\"\n]*\"|\'[^\'\n]*\' - 'strings': [ - # apparently strings can be delimited by EOL if they are continued - # in the next line - (r'"[^"\n]*("|\n)', String.Double), - (r"'[^'\n]*('|\n)", String.Single), - ], - - 'nums': [ - (r'\d+(\s*|\.$|$)', Number.Integer), - (r'[+-]?\d*\.\d+([eE][-+]?\d+)?', Number.Float), - (r'[+-]?\d+\.\d*([eE][-+]?\d+)?', Number.Float), - ], - } - - -class CobolFreeformatLexer(CobolLexer): - """ - Lexer for Free format OpenCOBOL code. - - .. versionadded:: 1.6 - """ - name = 'COBOLFree' - aliases = ['cobolfree'] - filenames = ['*.cbl', '*.CBL'] - mimetypes = [] - flags = re.IGNORECASE | re.MULTILINE - - tokens = { - 'comment': [ - (r'(\*>.*\n|^\w*\*.*$)', Comment), - ], - } - - -class LogosLexer(ObjectiveCppLexer): - """ - For Logos + Objective-C source code with preprocessor directives. - - .. versionadded:: 1.6 - """ - - name = 'Logos' - aliases = ['logos'] - filenames = ['*.x', '*.xi', '*.xm', '*.xmi'] - mimetypes = ['text/x-logos'] - priority = 0.25 - - tokens = { - 'statements': [ - (r'(%orig|%log)\b', Keyword), - (r'(%c)\b(\()(\s*)([a-zA-Z$_][\w$]*)(\s*)(\))', - bygroups(Keyword, Punctuation, Text, Name.Class, Text, Punctuation)), - (r'(%init)\b(\()', - bygroups(Keyword, Punctuation), 'logos_init_directive'), - (r'(%init)(?=\s*;)', bygroups(Keyword)), - (r'(%hook|%group)(\s+)([a-zA-Z$_][\w$]+)', - bygroups(Keyword, Text, Name.Class), '#pop'), - (r'(%subclass)(\s+)', bygroups(Keyword, Text), - ('#pop', 'logos_classname')), - inherit, - ], - 'logos_init_directive': [ - ('\s+', Text), - (',', Punctuation, ('logos_init_directive', '#pop')), - ('([a-zA-Z$_][\w$]*)(\s*)(=)(\s*)([^);]*)', - bygroups(Name.Class, Text, Punctuation, Text, Text)), - ('([a-zA-Z$_][\w$]*)', Name.Class), - ('\)', Punctuation, '#pop'), - ], - 'logos_classname': [ - ('([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?', - bygroups(Name.Class, Text, Name.Class), '#pop'), - ('([a-zA-Z$_][\w$]*)', Name.Class, '#pop') - ], - 'root': [ - (r'(%subclass)(\s+)', bygroups(Keyword, Text), - 'logos_classname'), - (r'(%hook|%group)(\s+)([a-zA-Z$_][\w$]+)', - bygroups(Keyword, Text, Name.Class)), - (r'(%config)(\s*\(\s*)(\w+)(\s*=\s*)(.*?)(\s*\)\s*)', - bygroups(Keyword, Text, Name.Variable, Text, String, Text)), - (r'(%ctor)(\s*)({)', bygroups(Keyword, Text, Punctuation), - 'function'), - (r'(%new)(\s*)(\()(\s*.*?\s*)(\))', - bygroups(Keyword, Text, Keyword, String, Keyword)), - (r'(\s*)(%end)(\s*)', bygroups(Text, Keyword, Text)), - inherit, - ], - } - - _logos_keywords = re.compile(r'%(?:hook|ctor|init|c\()') - - def analyse_text(text): - if LogosLexer._logos_keywords.search(text): - return 1.0 - return 0 - - -class ChapelLexer(RegexLexer): - """ - For `Chapel <http://chapel.cray.com/>`_ source. - - .. versionadded:: 2.0 - """ - name = 'Chapel' - filenames = ['*.chpl'] - aliases = ['chapel', 'chpl'] - # mimetypes = ['text/x-chapel'] - - tokens = { - 'root': [ - (r'\n', Text), - (r'\s+', Text), - (r'\\\n', Text), - - (r'//(.*?)\n', Comment.Single), - (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), - - (r'(config|const|in|inout|out|param|ref|type|var)\b', - Keyword.Declaration), - (r'(false|nil|true)\b', Keyword.Constant), - (r'(bool|complex|imag|int|opaque|range|real|string|uint)\b', - Keyword.Type), - (words(( - 'align', 'atomic', 'begin', 'break', 'by', 'cobegin', 'coforall', - 'continue', 'delete', 'dmapped', 'do', 'domain', 'else', 'enum', - 'export', 'extern', 'for', 'forall', 'if', 'index', 'inline', - 'iter', 'label', 'lambda', 'let', 'local', 'new', 'noinit', 'on', - 'otherwise', 'pragma', 'reduce', 'return', 'scan', 'select', - 'serial', 'single', 'sparse', 'subdomain', 'sync', 'then', 'use', - 'when', 'where', 'while', 'with', 'yield', 'zip'), suffix=r'\b'), - Keyword), - (r'(proc)((?:\s|\\\s)+)', bygroups(Keyword, Text), 'procname'), - (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text), - 'classname'), - - # imaginary integers - (r'\d+i', Number), - (r'\d+\.\d*([Ee][-+]\d+)?i', Number), - (r'\.\d+([Ee][-+]\d+)?i', Number), - (r'\d+[Ee][-+]\d+i', Number), - - # reals cannot end with a period due to lexical ambiguity with - # .. operator. See reference for rationale. - (r'(\d*\.\d+)([eE][+-]?[0-9]+)?i?', Number.Float), - (r'\d+[eE][+-]?[0-9]+i?', Number.Float), - - # integer literals - # -- binary - (r'0[bB][0-1]+', Number.Bin), - # -- hex - (r'0[xX][0-9a-fA-F]+', Number.Hex), - # -- octal - (r'0[oO][0-7]+', Number.Oct), - # -- decimal - (r'[0-9]+', Number.Integer), - - # strings - (r'["\'](\\\\|\\"|[^"\'])*["\']', String), - - # tokens - (r'(=|\+=|-=|\*=|/=|\*\*=|%=|&=|\|=|\^=|&&=|\|\|=|<<=|>>=|' - r'<=>|<~>|\.\.|by|#|\.\.\.|' - r'&&|\|\||!|&|\||\^|~|<<|>>|' - r'==|!=|<=|>=|<|>|' - r'[+\-*/%]|\*\*)', Operator), - (r'[:;,.?()\[\]{}]', Punctuation), - - # identifiers - (r'[a-zA-Z_][\w$]*', Name.Other), - ], - 'classname': [ - (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'), - ], - 'procname': [ - (r'[a-zA-Z_][\w$]*', Name.Function, '#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][0-1]+', 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 Inform6Lexer(RegexLexer): - """ - For `Inform 6 <http://inform-fiction.org/>`_ source code. - - .. versionadded:: 2.0 - """ - - name = 'Inform 6' - aliases = ['inform6', 'i6'] - filenames = ['*.inf'] - - flags = re.MULTILINE | re.DOTALL | re.UNICODE - - _name = r'[a-zA-Z_][a-zA-Z_0-9]*' - - # Inform 7 maps these four character classes to their ASCII - # equivalents. To support Inform 6 inclusions within Inform 7, - # Inform6Lexer maps them too. - _dash = u'\\-\u2010-\u2014' - _dquote = u'"\u201c\u201d' - _squote = u"'\u2018\u2019" - _newline = u'\\n\u0085\u2028\u2029' - - tokens = { - 'root': [ - (r'(\A(!%%[^%s]*[%s])+)?' % (_newline, _newline), Comment.Preproc, - 'directive') - ], - '_whitespace': [ - (r'\s+', Text), - (r'![^%s]*' % _newline, Comment.Single) - ], - 'default': [ - include('_whitespace'), - (r'\[', Punctuation, 'many-values'), # Array initialization - (r':|(?=;)', Punctuation, '#pop'), - (r'<', Punctuation), # Second angle bracket in an action statement - default(('expression', '_expression')) - ], - - # Expressions - '_expression': [ - include('_whitespace'), - (r'(?=sp\b)', Text, '#pop'), - (r'(?=[%s%s$0-9#a-zA-Z_])' % (_dquote, _squote), Text, - ('#pop', 'value')), - (r'\+\+|[%s]{1,2}(?!>)|~~?' % _dash, Operator), - (r'(?=[()\[%s,?@{:;])' % _dash, Text, '#pop') - ], - 'expression': [ - include('_whitespace'), - (r'\(', Punctuation, ('expression', '_expression')), - (r'\)', Punctuation, '#pop'), - (r'\[', Punctuation, ('#pop', 'statements', 'locals')), - (r'>(?=(\s+|(![^%s]*))*[>;])' % _newline, Punctuation), - (r'\+\+|[%s]{2}(?!>)' % _dash, Operator), - (r',', Punctuation, '_expression'), - (r'&&?|\|\|?|[=~><]?=|[%s]{1,2}>?|\.\.?[&#]?|::|[<>+*/%%]' % _dash, - Operator, '_expression'), - (r'(has|hasnt|in|notin|ofclass|or|provides)\b', Operator.Word, - '_expression'), - (r'sp\b', Name), - (r'\?~?', Name.Label, 'label?'), - (r'[@{]', Error), - default('#pop') - ], - '_assembly-expression': [ - (r'\(', Punctuation, ('#push', '_expression')), - (r'[\[\]]', Punctuation), - (r'[%s]>' % _dash, Punctuation, '_expression'), - (r'sp\b', Keyword.Pseudo), - (r';', Punctuation, '#pop:3'), - include('expression') - ], - '_for-expression': [ - (r'\)', Punctuation, '#pop:2'), - (r':', Punctuation, '#pop'), - include('expression') - ], - '_keyword-expression': [ - (r'(from|near|to)\b', Keyword, '_expression'), - include('expression') - ], - '_list-expression': [ - (r',', Punctuation, '#pop'), - include('expression') - ], - '_object-expression': [ - (r'has\b', Keyword.Declaration, '#pop'), - include('_list-expression') - ], - - # Values - 'value': [ - include('_whitespace'), - # Strings - (r'[%s][^@][%s]' % (_squote, _squote), String.Char, '#pop'), - (r'([%s])(@{[0-9a-fA-F]{1,4}})([%s])' % (_squote, _squote), - bygroups(String.Char, String.Escape, String.Char), '#pop'), - (r'([%s])(@..)([%s])' % (_squote, _squote), - bygroups(String.Char, String.Escape, String.Char), '#pop'), - (r'[%s]' % _squote, String.Single, ('#pop', 'dictionary-word')), - (r'[%s]' % _dquote, String.Double, ('#pop', 'string')), - # Numbers - (r'\$[+%s][0-9]*\.?[0-9]*([eE][+%s]?[0-9]+)?' % (_dash, _dash), - Number.Float, '#pop'), - (r'\$[0-9a-fA-F]+', Number.Hex, '#pop'), - (r'\$\$[01]+', Number.Bin, '#pop'), - (r'[0-9]+', Number.Integer, '#pop'), - # Values prefixed by hashes - (r'(##|#a\$)(%s)' % _name, bygroups(Operator, Name), '#pop'), - (r'(#g\$)(%s)' % _name, - bygroups(Operator, Name.Variable.Global), '#pop'), - (r'#[nw]\$', Operator, ('#pop', 'obsolete-dictionary-word')), - (r'(#r\$)(%s)' % _name, bygroups(Operator, Name.Function), '#pop'), - (r'#', Name.Builtin, ('#pop', 'system-constant')), - # System functions - (words(( - 'child', 'children', 'elder', 'eldest', 'glk', 'indirect', 'metaclass', - 'parent', 'random', 'sibling', 'younger', 'youngest'), suffix=r'\b'), - Name.Builtin, '#pop'), - # Metaclasses - (r'(?i)(Class|Object|Routine|String)\b', Name.Builtin, '#pop'), - # Veneer routines - (words(( - 'Box__Routine', 'CA__Pr', 'CDefArt', 'CInDefArt', 'Cl__Ms', - 'Copy__Primitive', 'CP__Tab', 'DA__Pr', 'DB__Pr', 'DefArt', 'Dynam__String', - 'EnglishNumber', 'Glk__Wrap', 'IA__Pr', 'IB__Pr', 'InDefArt', 'Main__', - 'Meta__class', 'OB__Move', 'OB__Remove', 'OC__Cl', 'OP__Pr', 'Print__Addr', - 'Print__PName', 'PrintShortName', 'RA__Pr', 'RA__Sc', 'RL__Pr', 'R_Process', - 'RT__ChG', 'RT__ChGt', 'RT__ChLDB', 'RT__ChLDW', 'RT__ChPR', 'RT__ChPrintA', - 'RT__ChPrintC', 'RT__ChPrintO', 'RT__ChPrintS', 'RT__ChPS', 'RT__ChR', - 'RT__ChSTB', 'RT__ChSTW', 'RT__ChT', 'RT__Err', 'RT__TrPS', 'RV__Pr', - 'Symb__Tab', 'Unsigned__Compare', 'WV__Pr', 'Z__Region'), - prefix='(?i)', suffix=r'\b'), - Name.Builtin, '#pop'), - # Other built-in symbols - (words(( - 'call', 'copy', 'create', 'DEBUG', 'destroy', 'DICT_CHAR_SIZE', - 'DICT_ENTRY_BYTES', 'DICT_IS_UNICODE', 'DICT_WORD_SIZE', 'false', - 'FLOAT_INFINITY', 'FLOAT_NAN', 'FLOAT_NINFINITY', 'GOBJFIELD_CHAIN', - 'GOBJFIELD_CHILD', 'GOBJFIELD_NAME', 'GOBJFIELD_PARENT', - 'GOBJFIELD_PROPTAB', 'GOBJFIELD_SIBLING', 'GOBJ_EXT_START', - 'GOBJ_TOTAL_LENGTH', 'Grammar__Version', 'INDIV_PROP_START', 'INFIX', - 'infix__watching', 'MODULE_MODE', 'name', 'nothing', 'NUM_ATTR_BYTES', 'print', - 'print_to_array', 'recreate', 'remaining', 'self', 'sender', 'STRICT_MODE', - 'sw__var', 'sys__glob0', 'sys__glob1', 'sys__glob2', 'sys_statusline_flag', - 'TARGET_GLULX', 'TARGET_ZCODE', 'temp__global2', 'temp__global3', - 'temp__global4', 'temp_global', 'true', 'USE_MODULES', 'WORDSIZE'), - prefix='(?i)', suffix=r'\b'), - Name.Builtin, '#pop'), - # Other values - (_name, Name, '#pop') - ], - # Strings - 'dictionary-word': [ - (r'[~^]+', String.Escape), - (r'[^~^\\@({%s]+' % _squote, String.Single), - (r'[({]', String.Single), - (r'@{[0-9a-fA-F]{,4}}', String.Escape), - (r'@..', String.Escape), - (r'[%s]' % _squote, String.Single, '#pop') - ], - 'string': [ - (r'[~^]+', String.Escape), - (r'[^~^\\@({%s]+' % _dquote, String.Double), - (r'[({]', String.Double), - (r'\\', String.Escape), - (r'@(\\\s*[%s]\s*)*@((\\\s*[%s]\s*)*[0-9])*' % - (_newline, _newline), String.Escape), - (r'@(\\\s*[%s]\s*)*{((\\\s*[%s]\s*)*[0-9a-fA-F]){,4}' - r'(\\\s*[%s]\s*)*}' % (_newline, _newline, _newline), - String.Escape), - (r'@(\\\s*[%s]\s*)*.(\\\s*[%s]\s*)*.' % (_newline, _newline), - String.Escape), - (r'[%s]' % _dquote, String.Double, '#pop') - ], - 'plain-string': [ - (r'[^~^\\({\[\]%s]+' % _dquote, String.Double), - (r'[~^({\[\]]', String.Double), - (r'\\', String.Escape), - (r'[%s]' % _dquote, String.Double, '#pop') - ], - # Names - '_constant': [ - include('_whitespace'), - (_name, Name.Constant, '#pop'), - include('value') - ], - '_global': [ - include('_whitespace'), - (_name, Name.Variable.Global, '#pop'), - include('value') - ], - 'label?': [ - include('_whitespace'), - (r'(%s)?' % _name, Name.Label, '#pop') - ], - 'variable?': [ - include('_whitespace'), - (r'(%s)?' % _name, Name.Variable, '#pop') - ], - # Values after hashes - 'obsolete-dictionary-word': [ - (r'\S[a-zA-Z_0-9]*', String.Other, '#pop') - ], - 'system-constant': [ - include('_whitespace'), - (_name, Name.Builtin, '#pop') - ], - - # Directives - 'directive': [ - include('_whitespace'), - (r'#', Punctuation), - (r';', Punctuation, '#pop'), - (r'\[', Punctuation, - ('default', 'statements', 'locals', 'routine-name?')), - (words(( - 'abbreviate', 'endif', 'dictionary', 'ifdef', 'iffalse', 'ifndef', 'ifnot', - 'iftrue', 'ifv3', 'ifv5', 'release', 'serial', 'switches', 'system_file', - 'version'), prefix='(?i)', suffix=r'\b'), - Keyword, 'default'), - (r'(?i)(array|global)\b', Keyword, - ('default', 'directive-keyword?', '_global')), - (r'(?i)attribute\b', Keyword, ('default', 'alias?', '_constant')), - (r'(?i)class\b', Keyword, - ('object-body', 'duplicates', 'class-name')), - (r'(?i)(constant|default)\b', Keyword, - ('default', 'expression', '_constant')), - (r'(?i)(end\b)(.*)', bygroups(Keyword, Text)), - (r'(?i)(extend|verb)\b', Keyword, 'grammar'), - (r'(?i)fake_action\b', Keyword, ('default', '_constant')), - (r'(?i)import\b', Keyword, 'manifest'), - (r'(?i)(include|link)\b', Keyword, - ('default', 'before-plain-string')), - (r'(?i)(lowstring|undef)\b', Keyword, ('default', '_constant')), - (r'(?i)message\b', Keyword, ('default', 'diagnostic')), - (r'(?i)(nearby|object)\b', Keyword, - ('object-body', '_object-head')), - (r'(?i)property\b', Keyword, - ('default', 'alias?', '_constant', 'property-keyword*')), - (r'(?i)replace\b', Keyword, - ('default', 'routine-name?', 'routine-name?')), - (r'(?i)statusline\b', Keyword, ('default', 'directive-keyword?')), - (r'(?i)stub\b', Keyword, ('default', 'routine-name?')), - (r'(?i)trace\b', Keyword, - ('default', 'trace-keyword?', 'trace-keyword?')), - (r'(?i)zcharacter\b', Keyword, - ('default', 'directive-keyword?', 'directive-keyword?')), - (_name, Name.Class, ('object-body', '_object-head')) - ], - # [, Replace, Stub - 'routine-name?': [ - include('_whitespace'), - (r'(%s)?' % _name, Name.Function, '#pop') - ], - 'locals': [ - include('_whitespace'), - (r';', Punctuation, '#pop'), - (r'\*', Punctuation), - (_name, Name.Variable) - ], - # Array - 'many-values': [ - include('_whitespace'), - (r';', Punctuation), - (r'\]', Punctuation, '#pop'), - (r':', Error), - default(('expression', '_expression')) - ], - # Attribute, Property - 'alias?': [ - include('_whitespace'), - (r'alias\b', Keyword, ('#pop', '_constant')), - default('#pop') - ], - # Class, Object, Nearby - 'class-name': [ - include('_whitespace'), - (r'(?=[,;]|(class|has|private|with)\b)', Text, '#pop'), - (_name, Name.Class, '#pop') - ], - 'duplicates': [ - include('_whitespace'), - (r'\(', Punctuation, ('#pop', 'expression', '_expression')), - default('#pop') - ], - '_object-head': [ - (r'[%s]>' % _dash, Punctuation), - (r'(class|has|private|with)\b', Keyword.Declaration, '#pop'), - include('_global') - ], - 'object-body': [ - include('_whitespace'), - (r';', Punctuation, '#pop:2'), - (r',', Punctuation), - (r'class\b', Keyword.Declaration, 'class-segment'), - (r'(has|private|with)\b', Keyword.Declaration), - (r':', Error), - default(('_object-expression', '_expression')) - ], - 'class-segment': [ - include('_whitespace'), - (r'(?=[,;]|(class|has|private|with)\b)', Text, '#pop'), - (_name, Name.Class), - default('value') - ], - # Extend, Verb - 'grammar': [ - include('_whitespace'), - (r'=', Punctuation, ('#pop', 'default')), - (r'\*', Punctuation, ('#pop', 'grammar-line')), - default('_directive-keyword') - ], - 'grammar-line': [ - include('_whitespace'), - (r';', Punctuation, '#pop'), - (r'[/*]', Punctuation), - (r'[%s]>' % _dash, Punctuation, 'value'), - (r'(noun|scope)\b', Keyword, '=routine'), - default('_directive-keyword') - ], - '=routine': [ - include('_whitespace'), - (r'=', Punctuation, 'routine-name?'), - default('#pop') - ], - # Import - 'manifest': [ - include('_whitespace'), - (r';', Punctuation, '#pop'), - (r',', Punctuation), - (r'(?i)(global\b)?', Keyword, '_global') - ], - # Include, Link, Message - 'diagnostic': [ - include('_whitespace'), - (r'[%s]' % _dquote, String.Double, ('#pop', 'message-string')), - default(('#pop', 'before-plain-string', 'directive-keyword?')) - ], - 'before-plain-string': [ - include('_whitespace'), - (r'[%s]' % _dquote, String.Double, ('#pop', 'plain-string')) - ], - 'message-string': [ - (r'[~^]+', String.Escape), - include('plain-string') - ], - - # Keywords used in directives - '_directive-keyword!': [ - include('_whitespace'), - (words(( - 'additive', 'alias', 'buffer', 'class', 'creature', 'data', 'error', 'fatalerror', - 'first', 'has', 'held', 'initial', 'initstr', 'last', 'long', 'meta', 'multi', - 'multiexcept', 'multiheld', 'multiinside', 'noun', 'number', 'only', 'private', - 'replace', 'reverse', 'scope', 'score', 'special', 'string', 'table', 'terminating', - 'time', 'topic', 'warning', 'with'), suffix=r'\b'), - Keyword, '#pop'), - (r'[%s]{1,2}>|[+=]' % _dash, Punctuation, '#pop') - ], - '_directive-keyword': [ - include('_directive-keyword!'), - include('value') - ], - 'directive-keyword?': [ - include('_directive-keyword!'), - default('#pop') - ], - 'property-keyword*': [ - include('_whitespace'), - (r'(additive|long)\b', Keyword), - default('#pop') - ], - 'trace-keyword?': [ - include('_whitespace'), - (words(( - 'assembly', 'dictionary', 'expressions', 'lines', 'linker', - 'objects', 'off', 'on', 'symbols', 'tokens', 'verbs'), suffix=r'\b'), - Keyword, '#pop'), - default('#pop') - ], - - # Statements - 'statements': [ - include('_whitespace'), - (r'\]', Punctuation, '#pop'), - (r'[;{}]', Punctuation), - (words(( - 'box', 'break', 'continue', 'default', 'give', 'inversion', - 'new_line', 'quit', 'read', 'remove', 'return', 'rfalse', 'rtrue', - 'spaces', 'string', 'until'), suffix=r'\b'), - Keyword, 'default'), - (r'(do|else)\b', Keyword), - (r'(font|style)\b', Keyword, - ('default', 'miscellaneous-keyword?')), - (r'for\b', Keyword, ('for', '(?')), - (r'(if|switch|while)', Keyword, - ('expression', '_expression', '(?')), - (r'(jump|save|restore)\b', Keyword, ('default', 'label?')), - (r'objectloop\b', Keyword, - ('_keyword-expression', 'variable?', '(?')), - (r'print(_ret)?\b|(?=[%s])' % _dquote, Keyword, 'print-list'), - (r'\.', Name.Label, 'label?'), - (r'@', Keyword, 'opcode'), - (r'#(?![agrnw]\$|#)', Punctuation, 'directive'), - (r'<', Punctuation, 'default'), - (r'(move\b)?', Keyword, - ('default', '_keyword-expression', '_expression')) - ], - 'miscellaneous-keyword?': [ - include('_whitespace'), - (r'(bold|fixed|from|near|off|on|reverse|roman|to|underline)\b', - Keyword, '#pop'), - (r'(a|A|an|address|char|name|number|object|property|string|the|' - r'The)\b(?=(\s+|(![^%s]*))*\))' % _newline, Keyword.Pseudo, - '#pop'), - (r'%s(?=(\s+|(![^%s]*))*\))' % (_name, _newline), Name.Function, - '#pop'), - default('#pop') - ], - '(?': [ - include('_whitespace'), - (r'\(?', Punctuation, '#pop') - ], - 'for': [ - include('_whitespace'), - (r';?', Punctuation, ('_for-expression', '_expression')) - ], - 'print-list': [ - include('_whitespace'), - (r';', Punctuation, '#pop'), - (r':', Error), - default(('_list-expression', '_expression', '_list-expression', 'form')) - ], - 'form': [ - include('_whitespace'), - (r'\(', Punctuation, ('#pop', 'miscellaneous-keyword?')), - default('#pop') - ], - - # Assembly - 'opcode': [ - include('_whitespace'), - (r'[%s]' % _dquote, String.Double, ('operands', 'plain-string')), - (_name, Keyword, 'operands') - ], - 'operands': [ - (r':', Error), - default(('_assembly-expression', '_expression')) - ] - } - - def get_tokens_unprocessed(self, text): - # 'in' is either a keyword or an operator. - # If the token two tokens after 'in' is ')', 'in' is a keyword: - # objectloop(a in b) - # Otherwise, it is an operator: - # objectloop(a in b && true) - objectloop_queue = [] - objectloop_token_count = -1 - previous_token = None - for index, token, value in RegexLexer.get_tokens_unprocessed(self, - text): - if previous_token is Name.Variable and value == 'in': - objectloop_queue = [[index, token, value]] - objectloop_token_count = 2 - elif objectloop_token_count > 0: - if token not in Comment and token not in Text: - objectloop_token_count -= 1 - objectloop_queue.append((index, token, value)) - else: - if objectloop_token_count == 0: - if objectloop_queue[-1][2] == ')': - objectloop_queue[0][1] = Keyword - while objectloop_queue: - yield objectloop_queue.pop(0) - objectloop_token_count = -1 - yield index, token, value - if token not in Comment and token not in Text: - previous_token = token - while objectloop_queue: - yield objectloop_queue.pop(0) - - -class Inform7Lexer(RegexLexer): - """ - For `Inform 7 <http://inform7.com/>`_ source code. - - .. versionadded:: 2.0 - """ - - name = 'Inform 7' - aliases = ['inform7', 'i7'] - filenames = ['*.ni', '*.i7x'] - - flags = re.MULTILINE | re.DOTALL | re.UNICODE - - _dash = Inform6Lexer._dash - _dquote = Inform6Lexer._dquote - _newline = Inform6Lexer._newline - _start = r'\A|(?<=[%s])' % _newline - - # There are three variants of Inform 7, differing in how to - # interpret at signs and braces in I6T. In top-level inclusions, at - # signs in the first column are inweb syntax. In phrase definitions - # and use options, tokens in braces are treated as I7. Use options - # also interpret "{N}". - tokens = {} - token_variants = ['+i6t-not-inline', '+i6t-inline', '+i6t-use-option'] - - for level in token_variants: - tokens[level] = { - '+i6-root': list(Inform6Lexer.tokens['root']), - '+i6t-root': [ # For Inform6TemplateLexer - (r'[^%s]*' % Inform6Lexer._newline, Comment.Preproc, - ('directive', '+p')) - ], - 'root': [ - (r'(\|?\s)+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'[%s]' % _dquote, Generic.Heading, - ('+main', '+titling', '+titling-string')), - default(('+main', '+heading?')) - ], - '+titling-string': [ - (r'[^%s]+' % _dquote, Generic.Heading), - (r'[%s]' % _dquote, Generic.Heading, '#pop') - ], - '+titling': [ - (r'\[', Comment.Multiline, '+comment'), - (r'[^%s.;:|%s]+' % (_dquote, _newline), Generic.Heading), - (r'[%s]' % _dquote, Generic.Heading, '+titling-string'), - (r'[%s]{2}|(?<=[\s%s])\|[\s%s]' % (_newline, _dquote, _dquote), - Text, ('#pop', '+heading?')), - (r'[.;:]|(?<=[\s%s])\|' % _dquote, Text, '#pop'), - (r'[|%s]' % _newline, Generic.Heading) - ], - '+main': [ - (r'(?i)[^%s:a\[(|%s]+' % (_dquote, _newline), Text), - (r'[%s]' % _dquote, String.Double, '+text'), - (r':', Text, '+phrase-definition'), - (r'(?i)\bas\b', Text, '+use-option'), - (r'\[', Comment.Multiline, '+comment'), - (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash), - bygroups(Punctuation, - using(this, state=('+i6-root', 'directive'), - i6t='+i6t-not-inline'), Punctuation)), - (r'(%s|(?<=[\s;:.%s]))\|\s|[%s]{2,}' % - (_start, _dquote, _newline), Text, '+heading?'), - (r'(?i)[a(|%s]' % _newline, Text) - ], - '+phrase-definition': [ - (r'\s+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash), - bygroups(Punctuation, - using(this, state=('+i6-root', 'directive', - 'default', 'statements'), - i6t='+i6t-inline'), Punctuation), '#pop'), - default('#pop') - ], - '+use-option': [ - (r'\s+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash), - bygroups(Punctuation, - using(this, state=('+i6-root', 'directive'), - i6t='+i6t-use-option'), Punctuation), '#pop'), - default('#pop') - ], - '+comment': [ - (r'[^\[\]]+', Comment.Multiline), - (r'\[', Comment.Multiline, '#push'), - (r'\]', Comment.Multiline, '#pop') - ], - '+text': [ - (r'[^\[%s]+' % _dquote, String.Double), - (r'\[.*?\]', String.Interpol), - (r'[%s]' % _dquote, String.Double, '#pop') - ], - '+heading?': [ - (r'(\|?\s)+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'[%s]{4}\s+' % _dash, Text, '+documentation-heading'), - (r'[%s]{1,3}' % _dash, Text), - (r'(?i)(volume|book|part|chapter|section)\b[^%s]*' % _newline, - Generic.Heading, '#pop'), - default('#pop') - ], - '+documentation-heading': [ - (r'\s+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'(?i)documentation\s+', Text, '+documentation-heading2'), - default('#pop') - ], - '+documentation-heading2': [ - (r'\s+', Text), - (r'\[', Comment.Multiline, '+comment'), - (r'[%s]{4}\s' % _dash, Text, '+documentation'), - default('#pop:2') - ], - '+documentation': [ - (r'(?i)(%s)\s*(chapter|example)\s*:[^%s]*' % - (_start, _newline), Generic.Heading), - (r'(?i)(%s)\s*section\s*:[^%s]*' % (_start, _newline), - Generic.Subheading), - (r'((%s)\t.*?[%s])+' % (_start, _newline), - using(this, state='+main')), - (r'[^%s\[]+|[%s\[]' % (_newline, _newline), Text), - (r'\[', Comment.Multiline, '+comment'), - ], - '+i6t-not-inline': [ - (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline), - Comment.Preproc), - (r'(%s)@([%s]+|Purpose:)[^%s]*' % (_start, _dash, _newline), - Comment.Preproc), - (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline), - Generic.Heading, '+p') - ], - '+i6t-use-option': [ - include('+i6t-not-inline'), - (r'({)(N)(})', bygroups(Punctuation, Text, Punctuation)) - ], - '+i6t-inline': [ - (r'({)(\S[^}]*)?(})', - bygroups(Punctuation, using(this, state='+main'), - Punctuation)) - ], - '+i6t': [ - (r'({[%s])(![^}]*)(}?)' % _dash, - bygroups(Punctuation, Comment.Single, Punctuation)), - (r'({[%s])(lines)(:)([^}]*)(}?)' % _dash, - bygroups(Punctuation, Keyword, Punctuation, Text, - Punctuation), '+lines'), - (r'({[%s])([^:}]*)(:?)([^}]*)(}?)' % _dash, - bygroups(Punctuation, Keyword, Punctuation, Text, - Punctuation)), - (r'(\(\+)(.*?)(\+\)|\Z)', - bygroups(Punctuation, using(this, state='+main'), - Punctuation)) - ], - '+p': [ - (r'[^@]+', Comment.Preproc), - (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline), - Comment.Preproc, '#pop'), - (r'(%s)@([%s]|Purpose:)' % (_start, _dash), Comment.Preproc), - (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline), - Generic.Heading), - (r'@', Comment.Preproc) - ], - '+lines': [ - (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline), - Comment.Preproc), - (r'(%s)@([%s]|Purpose:)[^%s]*' % (_start, _dash, _newline), - Comment.Preproc), - (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline), - Generic.Heading, '+p'), - (r'(%s)@[a-zA-Z_0-9]*[ %s]' % (_start, _newline), Keyword), - (r'![^%s]*' % _newline, Comment.Single), - (r'({)([%s]endlines)(})' % _dash, - bygroups(Punctuation, Keyword, Punctuation), '#pop'), - (r'[^@!{]+?([%s]|\Z)|.' % _newline, Text) - ] - } - # Inform 7 can include snippets of Inform 6 template language, - # so all of Inform6Lexer's states are copied here, with - # modifications to account for template syntax. Inform7Lexer's - # own states begin with '+' to avoid name conflicts. Some of - # Inform6Lexer's states begin with '_': these are not modified. - # They deal with template syntax either by including modified - # states, or by matching r'' then pushing to modified states. - for token in Inform6Lexer.tokens: - if token == 'root': - continue - tokens[level][token] = list(Inform6Lexer.tokens[token]) - if not token.startswith('_'): - tokens[level][token][:0] = [include('+i6t'), include(level)] - - def __init__(self, **options): - level = options.get('i6t', '+i6t-not-inline') - if level not in self._all_tokens: - self._tokens = self.__class__.process_tokendef(level) - else: - self._tokens = self._all_tokens[level] - RegexLexer.__init__(self, **options) - - -class Inform6TemplateLexer(Inform7Lexer): - """ - For `Inform 6 template - <http://inform7.com/sources/src/i6template/Woven/index.html>`_ code. - - .. versionadded:: 2.0 - """ - - name = 'Inform 6 template' - aliases = ['i6t'] - filenames = ['*.i6t'] - - def get_tokens_unprocessed(self, text, stack=('+i6t-root',)): - return Inform7Lexer.get_tokens_unprocessed(self, text, stack) - - -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(( - 'input', '_Digits', '_Point', '_LastError', '_Period', '_RandomSeed', - '_StopFlag', '_Symbol', '_UninitReason', 'Ask', 'Bars', 'Bid', - 'Close', 'Digits', 'High', 'Low', 'Open', 'Point', 'Time', - 'Volume'), suffix=r'\b'), - Keyword), - (words(( - 'void', 'char', 'uchar', 'bool', 'short', 'ushort', 'int', 'uint', - 'color', 'long', 'ulong', 'datetime', 'float', 'double', - 'string'), suffix=r'\b'), - Keyword.Type), - (words(( - 'Alert', 'CheckPointer', 'Comment', 'DebugBreak', 'ExpertRemove', - 'GetPointer', 'GetTickCount', 'MessageBox', 'PeriodSeconds', 'PlaySound', - 'Print', 'PrintFormat', 'ResetLastError', 'ResourceCreate', 'ResourceFree', - 'ResourceReadImage', 'ResourceSave', 'SendFTP', 'SendMail', 'SendNotification', - 'Sleep', 'TerminalClose', 'TesterStatistics', 'ZeroMemory', - 'ArrayBsearch', 'ArrayCopy', 'ArrayCompare', 'ArrayFree', 'ArrayGetAsSeries', - 'ArrayInitialize', 'ArrayFill', 'ArrayIsSeries', 'ArrayIsDynamic', - 'ArrayMaximum', 'ArrayMinimum', 'ArrayRange', 'ArrayResize', - 'ArraySetAsSeries', 'ArraySize', 'ArraySort', 'ArrayCopyRates', - 'ArrayCopySeries', 'ArrayDimension', - 'CharToString', 'DoubleToString', 'EnumToString', 'NormalizeDouble', - 'StringToDouble', 'StringToInteger', 'StringToTime', 'TimeToString', - 'IntegerToString', 'ShortToString', 'ShortArrayToString', - 'StringToShortArray', 'CharArrayToString', 'StringToCharArray', - 'ColorToARGB', 'ColorToString', 'StringToColor', 'StringFormat', - 'CharToStr', 'DoubleToStr', 'StrToDouble', 'StrToInteger', 'StrToTime', 'TimeToStr', - 'MathAbs', 'MathArccos', 'MathArcsin', 'MathArctan', 'MathCeil', 'MathCos', 'MathExp', - 'MathFloor', 'MathLog', 'MathMax', 'MathMin', 'MathMod', 'MathPow', 'MathRand', - 'MathRound', 'MathSin', 'MathSqrt', 'MathSrand', 'MathTan', 'MathIsValidNumber', - 'StringAdd', 'StringBufferLen', 'StringCompare', 'StringConcatenate', 'StringFill', - 'StringFind', 'StringGetCharacter', 'StringInit', 'StringLen', 'StringReplace', - 'StringSetCharacter', 'StringSplit', 'StringSubstr', 'StringToLower', 'StringToUpper', - 'StringTrimLeft', 'StringTrimRight', 'StringGetChar', 'StringSetChar', - 'TimeCurrent', 'TimeTradeServer', 'TimeLocal', 'TimeGMT', 'TimeDaylightSavings', - 'TimeGMTOffset', 'TimeToStruct', 'StructToTime', 'Day', 'DayOfWeek', 'DayOfYear', - 'Hour', 'Minute', 'Month', 'Seconds', 'TimeDay', 'TimeDayOfWeek', 'TimeDayOfYear', 'TimeHour', - 'TimeMinute', 'TimeMonth', 'TimeSeconds', 'TimeYear', 'Year', - 'AccountInfoDouble', 'AccountInfoInteger', 'AccountInfoString', 'AccountBalance', - 'AccountCredit', 'AccountCompany', 'AccountCurrency', 'AccountEquity', - 'AccountFreeMargin', 'AccountFreeMarginCheck', 'AccountFreeMarginMode', - 'AccountLeverage', 'AccountMargin', 'AccountName', 'AccountNumber', 'AccountProfit', - 'AccountServer', 'AccountStopoutLevel', 'AccountStopoutMode', - 'GetLastError', 'IsStopped', 'UninitializeReason', 'MQLInfoInteger', 'MQLInfoString', - 'Symbol', 'Period', 'Digits', 'Point', 'IsConnected', 'IsDemo', 'IsDllsAllowed', - 'IsExpertEnabled', 'IsLibrariesAllowed', 'IsOptimization', 'IsTesting', - 'IsTradeAllowed', - 'IsTradeContextBusy', 'IsVisualMode', 'TerminalCompany', 'TerminalName', - 'TerminalPath', - 'SymbolsTotal', 'SymbolName', 'SymbolSelect', 'SymbolIsSynchronized', - 'SymbolInfoDouble', - 'SymbolInfoInteger', 'SymbolInfoString', 'SymbolInfoTick', - 'SymbolInfoSessionQuote', - 'SymbolInfoSessionTrade', 'MarketInfo', - 'SeriesInfoInteger', 'CopyRates', 'CopyTime', 'CopyOpen', - 'CopyHigh', 'CopyLow', 'CopyClose', - 'CopyTickVolume', 'CopyRealVolume', 'CopySpread', 'iBars', 'iBarShift', 'iClose', - 'iHigh', 'iHighest', 'iLow', 'iLowest', 'iOpen', 'iTime', 'iVolume', - 'HideTestIndicators', 'Period', 'RefreshRates', 'Symbol', 'WindowBarsPerChart', - 'WindowExpertName', 'WindowFind', 'WindowFirstVisibleBar', 'WindowHandle', - 'WindowIsVisible', 'WindowOnDropped', 'WindowPriceMax', 'WindowPriceMin', - 'WindowPriceOnDropped', 'WindowRedraw', 'WindowScreenShot', - 'WindowTimeOnDropped', 'WindowsTotal', 'WindowXOnDropped', 'WindowYOnDropped', - 'OrderClose', 'OrderCloseBy', 'OrderClosePrice', 'OrderCloseTime', 'OrderComment', - 'OrderCommission', 'OrderDelete', 'OrderExpiration', 'OrderLots', 'OrderMagicNumber', - 'OrderModify', 'OrderOpenPrice', 'OrderOpenTime', 'OrderPrint', 'OrderProfit', - 'OrderSelect', 'OrderSend', 'OrdersHistoryTotal', 'OrderStopLoss', 'OrdersTotal', - 'OrderSwap', 'OrderSymbol', 'OrderTakeProfit', 'OrderTicket', 'OrderType', - 'GlobalVariableCheck', 'GlobalVariableTime', - 'GlobalVariableDel', 'GlobalVariableGet', 'GlobalVariableName', - 'GlobalVariableSet', 'GlobalVariablesFlush', 'GlobalVariableTemp', - 'GlobalVariableSetOnCondition', 'GlobalVariablesDeleteAll', - 'GlobalVariablesTotal', 'GlobalVariableCheck', 'GlobalVariableTime', - 'GlobalVariableDel', 'GlobalVariableGet', - 'GlobalVariableName', 'GlobalVariableSet', 'GlobalVariablesFlush', - 'GlobalVariableTemp', 'GlobalVariableSetOnCondition', - 'GlobalVariablesDeleteAll', 'GlobalVariablesTotal', - 'GlobalVariableCheck', 'GlobalVariableTime', 'GlobalVariableDel', - 'GlobalVariableGet', 'GlobalVariableName', 'GlobalVariableSet', - 'GlobalVariablesFlush', 'GlobalVariableTemp', - 'GlobalVariableSetOnCondition', 'GlobalVariablesDeleteAll', - 'GlobalVariablesTotal', - 'FileFindFirst', 'FileFindNext', 'FileFindClose', 'FileOpen', 'FileDelete', - 'FileFlush', 'FileGetInteger', 'FileIsEnding', 'FileIsLineEnding', - 'FileClose', 'FileIsExist', 'FileCopy', 'FileMove', 'FileReadArray', - 'FileReadBool', 'FileReadDatetime', 'FileReadDouble', 'FileReadFloat', - 'FileReadInteger', 'FileReadLong', 'FileReadNumber', 'FileReadString', - 'FileReadStruct', 'FileSeek', 'FileSize', 'FileTell', 'FileWrite', - 'FileWriteArray', 'FileWriteDouble', 'FileWriteFloat', 'FileWriteInteger', - 'FileWriteLong', 'FileWriteString', 'FileWriteStruct', 'FolderCreate', - 'FolderDelete', 'FolderClean', 'FileOpenHistory', - 'IndicatorSetDouble', 'IndicatorSetInteger', 'IndicatorSetString', - 'SetIndexBuffer', 'IndicatorBuffers', 'IndicatorCounted', 'IndicatorDigits', - 'IndicatorShortName', 'SetIndexArrow', 'SetIndexDrawBegin', - 'SetIndexEmptyValue', 'SetIndexLabel', 'SetIndexShift', - 'SetIndexStyle', 'SetLevelStyle', 'SetLevelValue', - 'ObjectCreate', 'ObjectName', 'ObjectDelete', 'ObjectsDeleteAll', - 'ObjectFind', 'ObjectGetTimeByValue', 'ObjectGetValueByTime', - 'ObjectMove', 'ObjectsTotal', 'ObjectGetDouble', 'ObjectGetInteger', - 'ObjectGetString', 'ObjectSetDouble', 'ObjectSetInteger', - 'ObjectSetString', 'TextSetFont', 'TextOut', 'TextGetSize', - 'ObjectDescription', 'ObjectGet', 'ObjectGetFiboDescription', - 'ObjectGetShiftByValue', 'ObjectGetValueByShift', 'ObjectSet', - 'ObjectSetFiboDescription', 'ObjectSetText', 'ObjectType', - 'iAC', 'iAD', 'iADX', 'iAlligator', 'iAO', 'iATR', 'iBearsPower', - 'iBands', 'iBandsOnArray', 'iBullsPower', 'iCCI', 'iCCIOnArray', - 'iCustom', 'iDeMarker', 'iEnvelopes', 'iEnvelopesOnArray', - 'iForce', 'iFractals', 'iGator', 'iIchimoku', 'iBWMFI', 'iMomentum', - 'iMomentumOnArray', 'iMFI', 'iMA', 'iMAOnArray', 'iOsMA', 'iMACD', - 'iOBV', 'iSAR', 'iRSI', 'iRSIOnArray', 'iRVI', 'iStdDev', 'iStdDevOnArray', - 'iStochastic', 'iWPR', - 'EventSetMillisecondTimer', 'EventSetTimer', - 'EventKillTimer', 'EventChartCustom'), suffix=r'\b'), - Name.Function), - (words(( - 'CHARTEVENT_KEYDOWN', 'CHARTEVENT_MOUSE_MOVE', - 'CHARTEVENT_OBJECT_CREATE', - 'CHARTEVENT_OBJECT_CHANGE', 'CHARTEVENT_OBJECT_DELETE', - 'CHARTEVENT_CLICK', - 'CHARTEVENT_OBJECT_CLICK', 'CHARTEVENT_OBJECT_DRAG', - 'CHARTEVENT_OBJECT_ENDEDIT', - 'CHARTEVENT_CHART_CHANGE', 'CHARTEVENT_CUSTOM', - 'CHARTEVENT_CUSTOM_LAST', - 'PERIOD_CURRENT', 'PERIOD_M1', 'PERIOD_M2', 'PERIOD_M3', - 'PERIOD_M4', 'PERIOD_M5', - 'PERIOD_M6', 'PERIOD_M10', 'PERIOD_M12', 'PERIOD_M15', - 'PERIOD_M20', 'PERIOD_M30', - 'PERIOD_H1', 'PERIOD_H2', 'PERIOD_H3', 'PERIOD_H4', - 'PERIOD_H6', 'PERIOD_H8', - 'PERIOD_H12', 'PERIOD_D1', 'PERIOD_W1', 'PERIOD_MN1', - 'CHART_IS_OBJECT', 'CHART_BRING_TO_TOP', - 'CHART_MOUSE_SCROLL', 'CHART_EVENT_MOUSE_MOVE', - 'CHART_EVENT_OBJECT_CREATE', - 'CHART_EVENT_OBJECT_DELETE', 'CHART_MODE', 'CHART_FOREGROUND', - 'CHART_SHIFT', - 'CHART_AUTOSCROLL', 'CHART_SCALE', 'CHART_SCALEFIX', - 'CHART_SCALEFIX_11', - 'CHART_SCALE_PT_PER_BAR', 'CHART_SHOW_OHLC', - 'CHART_SHOW_BID_LINE', - 'CHART_SHOW_ASK_LINE', 'CHART_SHOW_LAST_LINE', - 'CHART_SHOW_PERIOD_SEP', - 'CHART_SHOW_GRID', 'CHART_SHOW_VOLUMES', - 'CHART_SHOW_OBJECT_DESCR', - 'CHART_VISIBLE_BARS', 'CHART_WINDOWS_TOTAL', - 'CHART_WINDOW_IS_VISIBLE', - 'CHART_WINDOW_HANDLE', 'CHART_WINDOW_YDISTANCE', - 'CHART_FIRST_VISIBLE_BAR', - 'CHART_WIDTH_IN_BARS', 'CHART_WIDTH_IN_PIXELS', - 'CHART_HEIGHT_IN_PIXELS', - 'CHART_COLOR_BACKGROUND', 'CHART_COLOR_FOREGROUND', - 'CHART_COLOR_GRID', - 'CHART_COLOR_VOLUME', 'CHART_COLOR_CHART_UP', - 'CHART_COLOR_CHART_DOWN', - 'CHART_COLOR_CHART_LINE', 'CHART_COLOR_CANDLE_BULL', - 'CHART_COLOR_CANDLE_BEAR', - 'CHART_COLOR_BID', 'CHART_COLOR_ASK', 'CHART_COLOR_LAST', - 'CHART_COLOR_STOP_LEVEL', - 'CHART_SHOW_TRADE_LEVELS', 'CHART_DRAG_TRADE_LEVELS', - 'CHART_SHOW_DATE_SCALE', - 'CHART_SHOW_PRICE_SCALE', 'CHART_SHIFT_SIZE', - 'CHART_FIXED_POSITION', - 'CHART_FIXED_MAX', 'CHART_FIXED_MIN', 'CHART_POINTS_PER_BAR', - 'CHART_PRICE_MIN', - 'CHART_PRICE_MAX', 'CHART_COMMENT', 'CHART_BEGIN', - 'CHART_CURRENT_POS', 'CHART_END', - 'CHART_BARS', 'CHART_CANDLES', 'CHART_LINE', 'CHART_VOLUME_HIDE', - 'CHART_VOLUME_TICK', 'CHART_VOLUME_REAL', - 'OBJ_VLINE', 'OBJ_HLINE', 'OBJ_TREND', 'OBJ_TRENDBYANGLE', 'OBJ_CYCLES', - 'OBJ_CHANNEL', 'OBJ_STDDEVCHANNEL', 'OBJ_REGRESSION', 'OBJ_PITCHFORK', - 'OBJ_GANNLINE', 'OBJ_GANNFAN', 'OBJ_GANNGRID', 'OBJ_FIBO', - 'OBJ_FIBOTIMES', 'OBJ_FIBOFAN', 'OBJ_FIBOARC', 'OBJ_FIBOCHANNEL', - 'OBJ_EXPANSION', 'OBJ_RECTANGLE', 'OBJ_TRIANGLE', 'OBJ_ELLIPSE', - 'OBJ_ARROW_THUMB_UP', 'OBJ_ARROW_THUMB_DOWN', - 'OBJ_ARROW_UP', 'OBJ_ARROW_DOWN', - 'OBJ_ARROW_STOP', 'OBJ_ARROW_CHECK', 'OBJ_ARROW_LEFT_PRICE', - 'OBJ_ARROW_RIGHT_PRICE', 'OBJ_ARROW_BUY', 'OBJ_ARROW_SELL', - 'OBJ_ARROW', - 'OBJ_TEXT', 'OBJ_LABEL', 'OBJ_BUTTON', 'OBJ_BITMAP', - 'OBJ_BITMAP_LABEL', - 'OBJ_EDIT', 'OBJ_EVENT', 'OBJ_RECTANGLE_LABEL', - 'OBJPROP_TIME1', 'OBJPROP_PRICE1', 'OBJPROP_TIME2', - 'OBJPROP_PRICE2', 'OBJPROP_TIME3', - 'OBJPROP_PRICE3', 'OBJPROP_COLOR', 'OBJPROP_STYLE', - 'OBJPROP_WIDTH', - 'OBJPROP_BACK', 'OBJPROP_RAY', 'OBJPROP_ELLIPSE', - 'OBJPROP_SCALE', - 'OBJPROP_ANGLE', 'OBJPROP_ARROWCODE', 'OBJPROP_TIMEFRAMES', - 'OBJPROP_DEVIATION', 'OBJPROP_FONTSIZE', 'OBJPROP_CORNER', - 'OBJPROP_XDISTANCE', 'OBJPROP_YDISTANCE', 'OBJPROP_FIBOLEVELS', - 'OBJPROP_LEVELCOLOR', 'OBJPROP_LEVELSTYLE', 'OBJPROP_LEVELWIDTH', - 'OBJPROP_FIRSTLEVEL', 'OBJPROP_COLOR', 'OBJPROP_STYLE', 'OBJPROP_WIDTH', - 'OBJPROP_BACK', 'OBJPROP_ZORDER', 'OBJPROP_FILL', 'OBJPROP_HIDDEN', - 'OBJPROP_SELECTED', 'OBJPROP_READONLY', 'OBJPROP_TYPE', 'OBJPROP_TIME', - 'OBJPROP_SELECTABLE', 'OBJPROP_CREATETIME', 'OBJPROP_LEVELS', - 'OBJPROP_LEVELCOLOR', 'OBJPROP_LEVELSTYLE', 'OBJPROP_LEVELWIDTH', - 'OBJPROP_ALIGN', 'OBJPROP_FONTSIZE', 'OBJPROP_RAY_RIGHT', 'OBJPROP_RAY', - 'OBJPROP_ELLIPSE', 'OBJPROP_ARROWCODE', 'OBJPROP_TIMEFRAMES', 'OBJPROP_ANCHOR', - 'OBJPROP_XDISTANCE', 'OBJPROP_YDISTANCE', 'OBJPROP_DRAWLINES', 'OBJPROP_STATE', - 'OBJPROP_CHART_ID', 'OBJPROP_XSIZE', 'OBJPROP_YSIZE', 'OBJPROP_XOFFSET', - 'OBJPROP_YOFFSET', 'OBJPROP_PERIOD', 'OBJPROP_DATE_SCALE', 'OBJPROP_PRICE_SCALE', - 'OBJPROP_CHART_SCALE', 'OBJPROP_BGCOLOR', 'OBJPROP_CORNER', 'OBJPROP_BORDER_TYPE', - 'OBJPROP_BORDER_COLOR', 'OBJPROP_PRICE', 'OBJPROP_LEVELVALUE', 'OBJPROP_SCALE', - 'OBJPROP_ANGLE', 'OBJPROP_DEVIATION', - 'OBJPROP_NAME', 'OBJPROP_TEXT', 'OBJPROP_TOOLTIP', 'OBJPROP_LEVELTEXT', - 'OBJPROP_FONT', 'OBJPROP_BMPFILE', 'OBJPROP_SYMBOL', - 'BORDER_FLAT', 'BORDER_RAISED', 'BORDER_SUNKEN', 'ALIGN_LEFT', 'ALIGN_CENTER', - 'ALIGN_RIGHT', 'ANCHOR_LEFT_UPPER', 'ANCHOR_LEFT', 'ANCHOR_LEFT_LOWER', - 'ANCHOR_LOWER', 'ANCHOR_RIGHT_LOWER', 'ANCHOR_RIGHT', 'ANCHOR_RIGHT_UPPER', - 'ANCHOR_UPPER', 'ANCHOR_CENTER', 'ANCHOR_TOP', 'ANCHOR_BOTTOM', - 'CORNER_LEFT_UPPER', 'CORNER_LEFT_LOWER', 'CORNER_RIGHT_LOWER', - 'CORNER_RIGHT_UPPER', - 'OBJ_NO_PERIODS', 'EMPTY', 'OBJ_PERIOD_M1', 'OBJ_PERIOD_M5', 'OBJ_PERIOD_M15', - 'OBJ_PERIOD_M30', 'OBJ_PERIOD_H1', 'OBJ_PERIOD_H4', 'OBJ_PERIOD_D1', - 'OBJ_PERIOD_W1', 'OBJ_PERIOD_MN1', 'OBJ_ALL_PERIODS', - 'GANN_UP_TREND', 'GANN_DOWN_TREND', - 'SYMBOL_THUMBSUP', 'SYMBOL_THUMBSDOWN', - 'SYMBOL_ARROWUP', 'SYMBOL_ARROWDOWN', - 'SYMBOL_STOPSIGN', 'SYMBOL_CHECKSIGN', - 'SYMBOL_LEFTPRICE', 'SYMBOL_RIGHTPRICE', - 'PRICE_CLOSE', 'PRICE_OPEN', 'PRICE_HIGH', 'PRICE_LOW', - 'PRICE_MEDIAN', 'PRICE_TYPICAL', 'PRICE_WEIGHTED', - 'VOLUME_TICK', 'VOLUME_REAL', - 'STO_LOWHIGH', 'STO_CLOSECLOSE', - 'MODE_OPEN', 'MODE_LOW', 'MODE_HIGH', 'MODE_CLOSE', 'MODE_VOLUME', 'MODE_TIME', - 'MODE_SMA', 'MODE_EMA', 'MODE_SMMA', 'MODE_LWMA', - 'MODE_MAIN', 'MODE_SIGNAL', 'MODE_MAIN', - 'MODE_PLUSDI', 'MODE_MINUSDI', 'MODE_UPPER', - 'MODE_LOWER', 'MODE_GATORJAW', 'MODE_GATORTEETH', - 'MODE_GATORLIPS', 'MODE_TENKANSEN', - 'MODE_KIJUNSEN', 'MODE_SENKOUSPANA', - 'MODE_SENKOUSPANB', 'MODE_CHINKOUSPAN', - 'DRAW_LINE', 'DRAW_SECTION', 'DRAW_HISTOGRAM', - 'DRAW_ARROW', 'DRAW_ZIGZAG', 'DRAW_NONE', - 'STYLE_SOLID', 'STYLE_DASH', 'STYLE_DOT', - 'STYLE_DASHDOT', 'STYLE_DASHDOTDOT', - 'DRAW_NONE', 'DRAW_LINE', 'DRAW_SECTION', 'DRAW_HISTOGRAM', - 'DRAW_ARROW', 'DRAW_ZIGZAG', 'DRAW_FILLING', - 'INDICATOR_DATA', 'INDICATOR_COLOR_INDEX', - 'INDICATOR_CALCULATIONS', 'INDICATOR_DIGITS', - 'INDICATOR_HEIGHT', 'INDICATOR_LEVELS', - 'INDICATOR_LEVELCOLOR', 'INDICATOR_LEVELSTYLE', - 'INDICATOR_LEVELWIDTH', 'INDICATOR_MINIMUM', - 'INDICATOR_MAXIMUM', 'INDICATOR_LEVELVALUE', - 'INDICATOR_SHORTNAME', 'INDICATOR_LEVELTEXT', - 'TERMINAL_BUILD', 'TERMINAL_CONNECTED', - 'TERMINAL_DLLS_ALLOWED', 'TERMINAL_TRADE_ALLOWED', - 'TERMINAL_EMAIL_ENABLED', - 'TERMINAL_FTP_ENABLED', 'TERMINAL_MAXBARS', - 'TERMINAL_CODEPAGE', 'TERMINAL_CPU_CORES', - 'TERMINAL_DISK_SPACE', 'TERMINAL_MEMORY_PHYSICAL', - 'TERMINAL_MEMORY_TOTAL', - 'TERMINAL_MEMORY_AVAILABLE', 'TERMINAL_MEMORY_USED', - 'TERMINAL_X64', - 'TERMINAL_OPENCL_SUPPORT', 'TERMINAL_LANGUAGE', - 'TERMINAL_COMPANY', 'TERMINAL_NAME', - 'TERMINAL_PATH', 'TERMINAL_DATA_PATH', - 'TERMINAL_COMMONDATA_PATH', - 'MQL_PROGRAM_TYPE', 'MQL_DLLS_ALLOWED', - 'MQL_TRADE_ALLOWED', 'MQL_DEBUG', - 'MQL_PROFILER', 'MQL_TESTER', 'MQL_OPTIMIZATION', - 'MQL_VISUAL_MODE', - 'MQL_FRAME_MODE', 'MQL_LICENSE_TYPE', 'MQL_PROGRAM_NAME', - 'MQL_PROGRAM_PATH', - 'PROGRAM_SCRIPT', 'PROGRAM_EXPERT', - 'PROGRAM_INDICATOR', 'LICENSE_FREE', - 'LICENSE_DEMO', 'LICENSE_FULL', 'LICENSE_TIME', - 'MODE_LOW', 'MODE_HIGH', 'MODE_TIME', 'MODE_BID', - 'MODE_ASK', 'MODE_POINT', - 'MODE_DIGITS', 'MODE_SPREAD', 'MODE_STOPLEVEL', - 'MODE_LOTSIZE', 'MODE_TICKVALUE', - 'MODE_TICKSIZE', 'MODE_SWAPLONG', - 'MODE_SWAPSHORT', 'MODE_STARTING', - 'MODE_EXPIRATION', 'MODE_TRADEALLOWED', - 'MODE_MINLOT', 'MODE_LOTSTEP', 'MODE_MAXLOT', - 'MODE_SWAPTYPE', 'MODE_PROFITCALCMODE', - 'MODE_MARGINCALCMODE', 'MODE_MARGININIT', - 'MODE_MARGINMAINTENANCE', 'MODE_MARGINHEDGED', - 'MODE_MARGINREQUIRED', 'MODE_FREEZELEVEL', - 'SUNDAY', 'MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', - 'FRIDAY', 'SATURDAY', - 'ACCOUNT_LOGIN', 'ACCOUNT_TRADE_MODE', - 'ACCOUNT_LEVERAGE', - 'ACCOUNT_LIMIT_ORDERS', 'ACCOUNT_MARGIN_SO_MODE', - 'ACCOUNT_TRADE_ALLOWED', 'ACCOUNT_TRADE_EXPERT', - 'ACCOUNT_BALANCE', - 'ACCOUNT_CREDIT', 'ACCOUNT_PROFIT', 'ACCOUNT_EQUITY', - 'ACCOUNT_MARGIN', - 'ACCOUNT_FREEMARGIN', 'ACCOUNT_MARGIN_LEVEL', - 'ACCOUNT_MARGIN_SO_CALL', - 'ACCOUNT_MARGIN_SO_SO', 'ACCOUNT_NAME', - 'ACCOUNT_SERVER', 'ACCOUNT_CURRENCY', - 'ACCOUNT_COMPANY', 'ACCOUNT_TRADE_MODE_DEMO', - 'ACCOUNT_TRADE_MODE_CONTEST', - 'ACCOUNT_TRADE_MODE_REAL', 'ACCOUNT_STOPOUT_MODE_PERCENT', - 'ACCOUNT_STOPOUT_MODE_MONEY', - 'STAT_INITIAL_DEPOSIT', 'STAT_WITHDRAWAL', 'STAT_PROFIT', - 'STAT_GROSS_PROFIT', - 'STAT_GROSS_LOSS', 'STAT_MAX_PROFITTRADE', - 'STAT_MAX_LOSSTRADE', 'STAT_CONPROFITMAX', - 'STAT_CONPROFITMAX_TRADES', 'STAT_MAX_CONWINS', - 'STAT_MAX_CONPROFIT_TRADES', - 'STAT_CONLOSSMAX', 'STAT_CONLOSSMAX_TRADES', - 'STAT_MAX_CONLOSSES', - 'STAT_MAX_CONLOSS_TRADES', 'STAT_BALANCEMIN', - 'STAT_BALANCE_DD', - 'STAT_BALANCEDD_PERCENT', 'STAT_BALANCE_DDREL_PERCENT', - 'STAT_BALANCE_DD_RELATIVE', 'STAT_EQUITYMIN', - 'STAT_EQUITY_DD', - 'STAT_EQUITYDD_PERCENT', 'STAT_EQUITY_DDREL_PERCENT', - 'STAT_EQUITY_DD_RELATIVE', 'STAT_EXPECTED_PAYOFF', - 'STAT_PROFIT_FACTOR', - 'STAT_RECOVERY_FACTOR', 'STAT_SHARPE_RATIO', - 'STAT_MIN_MARGINLEVEL', - 'STAT_CUSTOM_ONTESTER', 'STAT_DEALS', 'STAT_TRADES', - 'STAT_PROFIT_TRADES', - 'STAT_LOSS_TRADES', 'STAT_SHORT_TRADES', 'STAT_LONG_TRADES', - 'STAT_PROFIT_SHORTTRADES', 'STAT_PROFIT_LONGTRADES', - 'STAT_PROFITTRADES_AVGCON', 'STAT_LOSSTRADES_AVGCON', - 'SERIES_BARS_COUNT', 'SERIES_FIRSTDATE', 'SERIES_LASTBAR_DATE', - 'SERIES_SERVER_FIRSTDATE', 'SERIES_TERMINAL_FIRSTDATE', - 'SERIES_SYNCHRONIZED', - 'OP_BUY', 'OP_SELL', 'OP_BUYLIMIT', 'OP_SELLLIMIT', - 'OP_BUYSTOP', 'OP_SELLSTOP', - 'TRADE_ACTION_DEAL', 'TRADE_ACTION_PENDING', - 'TRADE_ACTION_SLTP', - 'TRADE_ACTION_MODIFY', 'TRADE_ACTION_REMOVE', - '__DATE__', '__DATETIME__', '__LINE__', '__FILE__', - '__PATH__', '__FUNCTION__', - '__FUNCSIG__', '__MQLBUILD__', '__MQL4BUILD__', - 'M_E', 'M_LOG2E', 'M_LOG10E', 'M_LN2', 'M_LN10', - 'M_PI', 'M_PI_2', 'M_PI_4', 'M_1_PI', - 'M_2_PI', 'M_2_SQRTPI', 'M_SQRT2', 'M_SQRT1_2', - 'CHAR_MIN', 'CHAR_MAX', 'UCHAR_MAX', - 'SHORT_MIN', 'SHORT_MAX', 'USHORT_MAX', - 'INT_MIN', 'INT_MAX', 'UINT_MAX', - 'LONG_MIN', 'LONG_MAX', 'ULONG_MAX', - 'DBL_MIN', 'DBL_MAX', 'DBL_EPSILON', 'DBL_DIG', 'DBL_MANT_DIG', - 'DBL_MAX_10_EXP', 'DBL_MAX_EXP', 'DBL_MIN_10_EXP', 'DBL_MIN_EXP', - 'FLT_MIN', 'FLT_MAX', 'FLT_EPSILON', - 'FLT_DIG', 'FLT_MANT_DIG', 'FLT_MAX_10_EXP', - 'FLT_MAX_EXP', 'FLT_MIN_10_EXP', 'FLT_MIN_EXP', 'REASON_PROGRAM' - 'REASON_REMOVE', 'REASON_RECOMPILE', - 'REASON_CHARTCHANGE', 'REASON_CHARTCLOSE', - 'REASON_PARAMETERS', 'REASON_ACCOUNT', - 'REASON_TEMPLATE', 'REASON_INITFAILED', - 'REASON_CLOSE', 'POINTER_INVALID' - 'POINTER_DYNAMIC', 'POINTER_AUTOMATIC', - 'NULL', 'EMPTY', 'EMPTY_VALUE', 'CLR_NONE', 'WHOLE_ARRAY', - 'CHARTS_MAX', 'clrNONE', 'EMPTY_VALUE', 'INVALID_HANDLE', - 'IS_DEBUG_MODE', 'IS_PROFILE_MODE', 'NULL', 'WHOLE_ARRAY', 'WRONG_VALUE', - 'ERR_NO_ERROR', 'ERR_NO_RESULT', 'ERR_COMMON_ERROR', - 'ERR_INVALID_TRADE_PARAMETERS', - 'ERR_SERVER_BUSY', 'ERR_OLD_VERSION', 'ERR_NO_CONNECTION', - 'ERR_NOT_ENOUGH_RIGHTS', - 'ERR_TOO_FREQUENT_REQUESTS', 'ERR_MALFUNCTIONAL_TRADE', - 'ERR_ACCOUNT_DISABLED', - 'ERR_INVALID_ACCOUNT', 'ERR_TRADE_TIMEOUT', - 'ERR_INVALID_PRICE', 'ERR_INVALID_STOPS', - 'ERR_INVALID_TRADE_VOLUME', 'ERR_MARKET_CLOSED', - 'ERR_TRADE_DISABLED', - 'ERR_NOT_ENOUGH_MONEY', 'ERR_PRICE_CHANGED', - 'ERR_OFF_QUOTES', 'ERR_BROKER_BUSY', - 'ERR_REQUOTE', 'ERR_ORDER_LOCKED', - 'ERR_LONG_POSITIONS_ONLY_ALLOWED', 'ERR_TOO_MANY_REQUESTS', - 'ERR_TRADE_MODIFY_DENIED', 'ERR_TRADE_CONTEXT_BUSY', - 'ERR_TRADE_EXPIRATION_DENIED', - 'ERR_TRADE_TOO_MANY_ORDERS', 'ERR_TRADE_HEDGE_PROHIBITED', - 'ERR_TRADE_PROHIBITED_BY_FIFO', - 'FILE_READ', 'FILE_WRITE', 'FILE_BIN', 'FILE_CSV', 'FILE_TXT', - 'FILE_ANSI', 'FILE_UNICODE', - 'FILE_SHARE_READ', 'FILE_SHARE_WRITE', 'FILE_REWRITE', - 'FILE_COMMON', 'FILE_EXISTS', - 'FILE_CREATE_DATE', 'FILE_MODIFY_DATE', - 'FILE_ACCESS_DATE', 'FILE_SIZE', 'FILE_POSITION', - 'FILE_END', 'FILE_LINE_END', 'FILE_IS_COMMON', - 'FILE_IS_TEXT', 'FILE_IS_BINARY', - 'FILE_IS_CSV', 'FILE_IS_ANSI', 'FILE_IS_READABLE', 'FILE_IS_WRITABLE', - 'SEEK_SET', 'SEEK_CUR', 'SEEK_END', 'CP_ACP', - 'CP_OEMCP', 'CP_MACCP', 'CP_THREAD_ACP', - 'CP_SYMBOL', 'CP_UTF7', 'CP_UTF8', 'IDOK', 'IDCANCEL', 'IDABORT', - 'IDRETRY', 'IDIGNORE', 'IDYES', 'IDNO', 'IDTRYAGAIN', 'IDCONTINUE', - 'MB_OK', 'MB_OKCANCEL', 'MB_ABORTRETRYIGNORE', 'MB_YESNOCANCEL', - 'MB_YESNO', 'MB_RETRYCANCEL', - 'MB_CANCELTRYCONTINUE', 'MB_ICONSTOP', 'MB_ICONERROR', - 'MB_ICONHAND', 'MB_ICONQUESTION', - 'MB_ICONEXCLAMATION', 'MB_ICONWARNING', - 'MB_ICONINFORMATION', 'MB_ICONASTERISK', - 'MB_DEFBUTTON1', 'MB_DEFBUTTON2', 'MB_DEFBUTTON3', - 'MB_DEFBUTTON4'), suffix=r'\b'), - Name.Constant), - (words(( - 'Black', 'DarkGreen', 'DarkSlateGray', 'Olive', - 'Green', 'Teal', 'Navy', 'Purple', - 'Maroon', 'Indigo', 'MidnightBlue', 'DarkBlue', - 'DarkOliveGreen', 'SaddleBrown', - 'ForestGreen', 'OliveDrab', 'SeaGreen', - 'DarkGoldenrod', 'DarkSlateBlue', - 'Sienna', 'MediumBlue', 'Brown', 'DarkTurquoise', - 'DimGray', 'LightSeaGreen', - 'DarkViolet', 'FireBrick', 'MediumVioletRed', - 'MediumSeaGreen', 'Chocolate', - 'Crimson', 'SteelBlue', 'Goldenrod', 'MediumSpringGreen', - 'LawnGreen', 'CadetBlue', - 'DarkOrchid', 'YellowGreen', 'LimeGreen', 'OrangeRed', - 'DarkOrange', 'Orange', - 'Gold', 'Yellow', 'Chartreuse', 'Lime', 'SpringGreen', - 'Aqua', 'DeepSkyBlue', 'Blue', - 'Magenta', 'Red', 'Gray', 'SlateGray', 'Peru', 'BlueViolet', - 'LightSlateGray', 'DeepPink', - 'MediumTurquoise', 'DodgerBlue', 'Turquoise', 'RoyalBlue', - 'SlateBlue', 'DarkKhaki', - 'IndianRed', 'MediumOrchid', 'GreenYellow', - 'MediumAquamarine', 'DarkSeaGreen', - 'Tomato', 'RosyBrown', 'Orchid', 'MediumPurple', - 'PaleVioletRed', 'Coral', 'CornflowerBlue', - 'DarkGray', 'SandyBrown', 'MediumSlateBlue', - 'Tan', 'DarkSalmon', 'BurlyWood', - 'HotPink', 'Salmon', 'Violet', 'LightCoral', 'SkyBlue', - 'LightSalmon', 'Plum', - 'Khaki', 'LightGreen', 'Aquamarine', 'Silver', - 'LightSkyBlue', 'LightSteelBlue', - 'LightBlue', 'PaleGreen', 'Thistle', 'PowderBlue', - 'PaleGoldenrod', 'PaleTurquoise', - 'LightGray', 'Wheat', 'NavajoWhite', 'Moccasin', - 'LightPink', 'Gainsboro', 'PeachPuff', - 'Pink', 'Bisque', 'LightGoldenrod', 'BlanchedAlmond', - 'LemonChiffon', 'Beige', - 'AntiqueWhite', 'PapayaWhip', 'Cornsilk', - 'LightYellow', 'LightCyan', 'Linen', - 'Lavender', 'MistyRose', 'OldLace', 'WhiteSmoke', - 'Seashell', 'Ivory', 'Honeydew', - 'AliceBlue', 'LavenderBlush', 'MintCream', 'Snow', - 'White'), prefix='(clr)?', suffix=r'\b'), - Name.Constant), - inherit, - ], - } - - -class SwiftLexer(ObjectiveCLexer): - """ - For `Swift <https://developer.apple.com/swift/>`_ source. - """ - name = 'Swift' - filenames = ['*.swift'] - aliases = ['swift'] - mimetypes = ['text/x-swift'] - - keywords_decl = set(('class', 'deinit', 'enum', 'extension', 'func', 'import', - 'init', 'let', 'protocol', 'static', 'struct', 'subscript', - 'typealias', 'var')) - keywords_stmt = set(('break', 'case', 'continue', 'default', 'do', 'else', - 'fallthrough', 'if', 'in', 'for', 'return', 'switch', - 'where', 'while')) - keywords_type = set(('as', 'dynamicType', 'is', 'new', 'super', 'self', 'Self', - 'Type', '__COLUMN__', '__FILE__', '__FUNCTION__', - '__LINE__')) - keywords_resrv = set(('associativity', 'didSet', 'get', 'infix', 'inout', 'left', - 'mutating', 'none', 'nonmutating', 'operator', 'override', - 'postfix', 'precedence', 'prefix', 'right', 'set', - 'unowned', 'unowned(safe)', 'unowned(unsafe)', 'weak', - 'willSet')) - operators = set(('->',)) - - def get_tokens_unprocessed(self, text): - for index, token, value in ObjectiveCLexer.get_tokens_unprocessed(self, text): - if token is Name: - if value in self.keywords_decl: - token = Keyword - elif value in self.keywords_stmt: - token = Keyword - elif value in self.keywords_type: - token = Keyword.Type - elif value in self.keywords_resrv: - token = Keyword.Reserved - elif value in self.operators: - token = Operator - yield index, token, value - - -class NitLexer(RegexLexer): - """ - For `nit <http://nitlanguage.org>`_ source. - - .. versionadded:: 2.0 - """ - - name = 'Nit' - aliases = ['nit'] - filenames = ['*.nit'] - tokens = { - 'root': [ - (r'#.*?$', Comment.Single), - (words(( - 'package', 'module', 'import', 'class', 'abstract', 'interface', - 'universal', 'enum', 'end', 'fun', 'type', 'init', 'redef', - 'isa', 'do', 'readable', 'writable', 'var', 'intern', 'extern', - 'public', 'protected', 'private', 'intrude', 'if', 'then', - 'else', 'while', 'loop', 'for', 'in', 'and', 'or', 'not', - 'implies', 'return', 'continue', 'break', 'abort', 'assert', - 'new', 'is', 'once', 'super', 'self', 'true', 'false', 'nullable', - 'null', 'as', 'isset', 'label', '__debug__'), suffix='(?=( |\n|\t|\r|\())'), - Keyword), - (r'[A-Z][A-Za-z0-9_]*', Name.Class), - (r'"""(([^\'\\]|\\.)|\\r|\\n)*(({{?)?(""?{{?)*""""*)', String), # Simple long string - (r'\'\'\'(((\\.|[^\'\\])|\\r|\\n)|\'((\\.|[^\'\\])|\\r|\\n)|' - r'\'\'((\\.|[^\'\\])|\\r|\\n))*\'\'\'', String), # Simple long string alt - (r'"""(([^\'\\]|\\.)|\\r|\\n)*((""?)?({{?""?)*{{{{*)', String), # Start long string - (r'}}}(((\\.|[^\'\\])|\\r|\\n))*(""?)?({{?""?)*{{{{*', String), # Mid long string - (r'}}}(((\\.|[^\'\\])|\\r|\\n))*({{?)?(""?{{?)*""""*', String), # End long string - (r'"(\\.|([^"}{\\]))*"', String), # Simple String - (r'"(\\.|([^"}{\\]))*{', String), # Start string - (r'}(\\.|([^"}{\\]))*{', String), # Mid String - (r'}(\\.|([^"}{\\]))*"', String), # End String - (r'(\'[^\'\\]\')|(\'\\.\')', String.Char), - (r'[0-9]+', Number.Integer), - (r'[0-9]*.[0-9]+', Number.Float), - (r'0(x|X)[0-9A-Fa-f]+', Number.Hex), - (r'[a-z][A-Za-z0-9_]*', Name), - (r'_[A-Za-z0-9_]+', Name.Variable.Instance), - (r'==|!=|<==>|>=|>>|>|<=|<<|<|\+|-|=|/|\*|%|\+=|-=|!|@', Operator), - (r'\(|\)|\[|\]|,|\.\.\.|\.\.|\.|::|:', Punctuation), - (r'`{[^`]*`}', Text), # Extern blocks won't be Lexed by Nit - ('(\r|\n| |\t)+', Text), - ], - } +from pygments.lexers.c_like.c_cpp import CLexer, CppLexer +from pygments.lexers.c_like.d import DLexer +from pygments.lexers.c_like.objective import ObjectiveCLexer, \ + ObjectiveCppLexer, LogosLexer +from pygments.lexers.c_like.go import GoLexer +from pygments.lexers.c_like.rust import RustLexer +from pygments.lexers.c_like.other import ECLexer, ValaLexer, CudaLexer +from pygments.lexers.pascal import DelphiLexer, Modula2Lexer, AdaLexer +from pygments.lexers.cobol import CobolLexer, CobolFreeformatLexer +from pygments.lexers.fortran import FortranLexer +from pygments.lexers.prolog import PrologLexer +from pygments.lexers.python import CythonLexer +from pygments.lexers.graphics import GLShaderLexer +from pygments.lexers.misc.blitz import BlitzBasicLexer, BlitzMaxLexer, \ + MonkeyLexer +from pygments.lexers.misc.dylan import DylanLexer, DylanLidLexer, \ + DylanConsoleLexer +from pygments.lexers.misc.ooc import OocLexer +from pygments.lexers.misc.felix import FelixLexer +from pygments.lexers.misc.nimrod import NimrodLexer + +__all__ = [] |