eric: comparison ThirdParty/Pygments/pygments/lexers/agile.py

-:ace8a08028f3
+:da76c71624de
 pygments.lexers.agile
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for agile languages.
-:copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 __all__ = ['PythonLexer', 'PythonConsoleLexer', 'PythonTracebackLexer',
 'Python3Lexer', 'Python3TracebackLexer', 'RubyLexer',
 'RubyConsoleLexer', 'PerlLexer', 'LuaLexer', 'MoonScriptLexer',
-'MiniDLexer', 'IoLexer', 'TclLexer', 'FactorLexer', 'FancyLexer']
+'CrocLexer', 'MiniDLexer', 'IoLexer', 'TclLexer', 'FactorLexer',
+'FancyLexer', 'DgLexer']
 # b/w compatibility
 from pygments.lexers.functional import SchemeLexer
 from pygments.lexers.jvm import IokeLexer, ClojureLexer
 """
 For `Python <http://www.python.org>`_ source code.
 """
 name = 'Python'
-aliases = ['python', 'py']
+aliases = ['python', 'py', 'sage']
-filenames = ['*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac']
+filenames = ['*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac', '*.sage']
 mimetypes = ['text/x-python', 'application/x-python']
 tokens = {
 'root': [
 (r'\n', Text),
 include('numbers'),
 ],
 'keywords': [
 (r'(assert|break|continue|del|elif|else|except|exec|'
 r'finally|for|global|if|lambda|pass|print|raise|'
-r'return|try|while|yield|as|with)\b', Keyword),
+r'return|try|while|yield(\s+from)?|as|with)\b', Keyword),
 ],
 'builtins': [
 (r'(?<!\.)(__import__|abs|all|any|apply|basestring|bin|bool|buffer|'
 r'bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|'
 r'complex|delattr|dict|dir|divmod|enumerate|eval|execfile|exit|'
 (r'', Text, '#pop') # all else: go back
 ],
 'fromimport': [
 (r'(?:[ \t]|\\\n)+', Text),
 (r'import\b', Keyword.Namespace, '#pop'),
+# if None occurs here, it's "raise x from None", since None can
+# never be a module name
+(r'None\b', Name.Builtin.Pseudo, '#pop'),
+# sadly, in "raise x from y" y will be highlighted as namespace too
 (r'[a-zA-Z_.][a-zA-Z0-9_.]*', Name.Namespace),
+# anything else here also means "raise x from y" and is therefore
+# not an error
+(r'', Text, '#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)
 ],
 tokens = PythonLexer.tokens.copy()
 tokens['keywords'] = [
 (r'(assert|break|continue|del|elif|else|except|'
 r'finally|for|global|if|lambda|pass|raise|nonlocal|'
-r'return|try|while|yield|as|with|True|False|None)\b', Keyword),
+r'return|try|while|yield(\s+from)?|as|with|True|False|None)\b',
+Keyword),
 ]
 tokens['builtins'] = [
 (r'(?<!\.)(__import__|abs|all|any|bin|bool|bytearray|bytes|'
 r'chr|classmethod|cmp|compile|complex|delattr|dict|dir|'
 r'divmod|enumerate|eval|filter|float|format|frozenset|getattr|'
 ]
 tokens['fromimport'] = [
 (r'(\s+)(import)\b', bygroups(Text, Keyword), '#pop'),
 (r'\.', Name.Namespace),
 (uni_name, Name.Namespace),
+(r'', Text, '#pop'),
 ]
 # don't highlight "%s" substitutions
 tokens['strings'] = [
 (r'[^\\\'"%\n]+', String),
 # quotes, percents and backslashes must be parsed one at a time
 bygroups(Text, Name.Builtin, Text, Number, Text)),
 (r'^(    )(.+)(\n)',
 bygroups(Text, using(PythonLexer), Text)),
 (r'^([ \t]*)(\.\.\.)(\n)',
 bygroups(Text, Comment, Text)), # for doctests...
-(r'^(.+)(: )(.+)(\n)',
+(r'^([^:]+)(: )(.+)(\n)',
 bygroups(Generic.Error, Text, Name, Text), '#pop'),
 (r'^([a-zA-Z_][a-zA-Z0-9_]*)(:?\n)',
 bygroups(Generic.Error, Text), '#pop')
 ],
 }
 bygroups(Text, Name.Builtin, Text, Number, Text, Name, Text)),
 (r'^(    )(.+)(\n)',
 bygroups(Text, using(Python3Lexer), Text)),
 (r'^([ \t]*)(\.\.\.)(\n)',
 bygroups(Text, Comment, Text)), # for doctests...
-(r'^(.+)(: )(.+)(\n)',
+(r'^([^:]+)(: )(.+)(\n)',
 bygroups(Generic.Error, Text, Name, Text), '#pop'),
 (r'^([a-zA-Z_][a-zA-Z0-9_]*)(:?\n)',
 bygroups(Generic.Error, Text), '#pop')
 ],
 }
 (r'\:@{0,2}([a-zA-Z_]\w*[\!\?]?|\*\*?|[-+]@?|'
 r'[/%&|^`~]|\[\]=?|<<|>>|<=?>|>=?|===?)', String.Symbol),
 (r":'(\\\\|\\'|[^'])*'", String.Symbol),
 (r"'(\\\\|\\'|[^'])*'", String.Single),
 (r':"', String.Symbol, 'simple-sym'),
+(r'([a-zA-Z_][a-zA-Z0-9]*)(:)',
+bygroups(String.Symbol, Punctuation)),  # Since Ruby 1.9
 (r'"', String.Double, 'simple-string'),
 (r'(?<!\.)`', String.Backtick, 'simple-backtick'),
 ]
 # double-quoted string and symbol
 (r'(BEGIN|END|alias|begin|break|case|defined\?|'
 r'do|else|elsif|end|ensure|for|if|in|next|redo|'
 r'rescue|raise|retry|return|super|then|undef|unless|until|when|'
 r'while|yield)\b', Keyword),
 # start of function, class and module names
-(r'(module)(\s+)([a-zA-Z_][a-zA-Z0-9_]*(::[a-zA-Z_][a-zA-Z0-9_]*)*)',
+(r'(module)(\s+)([a-zA-Z_][a-zA-Z0-9_]*'
+r'(?:::[a-zA-Z_][a-zA-Z0-9_]*)*)',
 bygroups(Keyword, Text, Name.Namespace)),
 (r'(def)(\s+)', bygroups(Keyword, Text), 'funcname'),
 (r'def(?=[*%&^`~+-/\[<>=])', Keyword, 'funcname'),
 (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
 # special methods
 heredoc_callback),
 # empty string heredocs
 (r'(<<-?)("|\')()(\2)(.*?\n)', heredoc_callback),
 (r'__END__', Comment.Preproc, 'end-part'),
 # multiline regex (after keywords or assignments)
-(r'(?:^|(?<=[=<>~!])|'
+(r'(?:^|(?<=[=<>~!:])|'
 r'(?<=(?:\s|;)when\s)|'
 r'(?<=(?:\s|;)or\s)|'
 r'(?<=(?:\s|;)and\s)|'
 r'(?<=(?:\s|;|\.)index\s)|'
 r'(?<=(?:\s|;|\.)scan\s)|'
 if token == Punctuation and value == ".":
 token = Operator
 yield index, token, value
+class CrocLexer(RegexLexer):
-class MiniDLexer(RegexLexer):
+"""
-"""
+For `Croc <http://jfbillingsley.com/croc>`_ source.
-For `MiniD <http://www.dsource.org/projects/minid>`_ (a D-like scripting
+"""
-language) source.
+name = 'Croc'
-"""
+filenames = ['*.croc']
-name = 'MiniD'
+aliases = ['croc']
-filenames = ['*.md']
+mimetypes = ['text/x-crocsrc']
-aliases = ['minid']
-mimetypes = ['text/x-minidsrc']
 tokens = {
 'root': [
 (r'\n', Text),
 (r'\s+', Text),
 # Comments
 (r'//(.*?)\n', Comment.Single),
-(r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+(r'/\*', Comment.Multiline, 'nestedcomment'),
-(r'/\+', Comment.Multiline, 'nestedcomment'),
 # Keywords
-(r'(as|assert|break|case|catch|class|continue|coroutine|default'
+(r'(as|assert|break|case|catch|class|continue|default'
 r'|do|else|finally|for|foreach|function|global|namespace'
-r'|if|import|in|is|local|module|return|super|switch'
+r'|if|import|in|is|local|module|return|scope|super|switch'
 r'|this|throw|try|vararg|while|with|yield)\b', Keyword),
 (r'(false|true|null)\b', Keyword.Constant),
 # FloatLiteral
-(r'([0-9][0-9_]*)?\.[0-9_]+([eE][+\-]?[0-9_]+)?', Number.Float),
+(r'([0-9][0-9_]*)(?=[.eE])(\.[0-9][0-9_]*)?([eE][+\-]?[0-9_]+)?',
+Number.Float),
 # IntegerLiteral
 # -- Binary
-(r'0[Bb][01_]+', Number),
+(r'0[bB][01][01_]*', Number),
-# -- Octal
-(r'0[Cc][0-7_]+', Number.Oct),
 # -- Hexadecimal
-(r'0[xX][0-9a-fA-F_]+', Number.Hex),
+(r'0[xX][0-9a-fA-F][0-9a-fA-F_]*', Number.Hex),
 # -- Decimal
-(r'(0|[1-9][0-9_]*)', Number.Integer),
+(r'([0-9][0-9_]*)(?![.eE])', Number.Integer),
 # CharacterLiteral
-(r"""'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-9]{1,3}"""
+(r"""'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-9]{1,3}"""
 r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|.)'""",
 String.Char
 ),
 # StringLiteral
 # -- WysiwygString
 (r'@"(""|[^"])*"', String),
-# -- AlternateWysiwygString
+(r'@`(``|[^`])*`', String),
-(r'`(``|.)*`', String),
+(r"@'(''|[^'])*'", String),
 # -- DoubleQuotedString
 (r'"(\\\\|\\"|[^"])*"', String),
 # Tokens
 (
 r'(~=|\^=|%=|\*=|==|!=|>>>=|>>>|>>=|>>|>=|<=>|\?=|-\>'
 ),
 # Identifier
 (r'[a-zA-Z_]\w*', Name),
 ],
 'nestedcomment': [
-(r'[^+/]+', Comment.Multiline),
+(r'[^*/]+', Comment.Multiline),
-(r'/\+', Comment.Multiline, '#push'),
+(r'/\*', Comment.Multiline, '#push'),
-(r'\+/', Comment.Multiline, '#pop'),
+(r'\*/', Comment.Multiline, '#pop'),
-(r'[+/]', Comment.Multiline),
+(r'[*/]', Comment.Multiline),
 ],
 }
+class MiniDLexer(CrocLexer):
+"""
+For MiniD source. MiniD is now known as Croc.
+"""
+name = 'MiniD'
+filenames = ['*.md']
+aliases = ['minid']
+mimetypes = ['text/x-minidsrc']
 class IoLexer(RegexLexer):
 """
 For `Io <http://iolanguage.com/>`_ (a small, prototype-based
 bygroups(Number.Integer, Text, Operator)),
 (r'\d+([eE][+-]?[0-9]+)|\d+\.\d+([eE][+-]?[0-9]+)?', Number.Float),
 (r'\d+', Number.Integer)
 ]
 }
+class DgLexer(RegexLexer):
+"""
+Lexer for `dg <http://pyos.github.com/dg>`_,
+a functional and object-oriented programming language
+running on the CPython 3 VM.
+*New in Pygments 1.6.*
+"""
+name = 'dg'
+aliases = ['dg']
+filenames = ['*.dg']
+mimetypes = ['text/x-dg']
+tokens = {
+'root': [
+# Whitespace:
+(r'\s+', Text),
+(r'#.*?$', Comment.Single),
+# Lexemes:
+#  Numbers
+(r'0[bB][01]+', Number.Bin),
+(r'0[oO][0-7]+', Number.Oct),
+(r'0[xX][\da-fA-F]+', Number.Hex),
+(r'[+-]?\d+\.\d+([eE][+-]?\d+)?[jJ]?', Number.Float),
+(r'[+-]?\d+[eE][+-]?\d+[jJ]?', Number.Float),
+(r'[+-]?\d+[jJ]?', Number.Integer),
+#  Character/String Literals
+(r"[br]*'''", String, combined('stringescape', 'tsqs', 'string')),
+(r'[br]*"""', String, combined('stringescape', 'tdqs', 'string')),
+(r"[br]*'", String, combined('stringescape', 'sqs', 'string')),
+(r'[br]*"', String, combined('stringescape', 'dqs', 'string')),
+#  Operators
+(r"`\w+'*`", Operator), # Infix links
+#   Reserved infix links
+(r'\b(or|and|if|else|where|is|in)\b', Operator.Word),
+(r'[!$%&*+\-./:<-@\\^|~;,]+', Operator),
+#  Identifiers
+#   Python 3 types
+(r"(?<!\.)(bool|bytearray|bytes|classmethod|complex|dict'?|"
+r"float|frozenset|int|list'?|memoryview|object|property|range|"
+r"set'?|slice|staticmethod|str|super|tuple'?|type)"
+r"(?!['\w])", Name.Builtin),
+#   Python 3 builtins + some more
+(r'(?<!\.)(__import__|abs|all|any|bin|bind|chr|cmp|compile|complex|'
+r'delattr|dir|divmod|drop|dropwhile|enumerate|eval|filter|flip|'
+r'foldl1?|format|fst|getattr|globals|hasattr|hash|head|hex|id|'
+r'init|input|isinstance|issubclass|iter|iterate|last|len|locals|'
+r'map|max|min|next|oct|open|ord|pow|print|repr|reversed|round|'
+r'setattr|scanl1?|snd|sorted|sum|tail|take|takewhile|vars|zip)'
+r"(?!['\w])", Name.Builtin),
+(r"(?<!\.)(self|Ellipsis|NotImplemented|None|True|False)(?!['\w])",
+Name.Builtin.Pseudo),
+(r"(?<!\.)[A-Z]\w*(Error|Exception|Warning)'*(?!['\w])",
+Name.Exception),
+(r"(?<!\.)(KeyboardInterrupt|SystemExit|StopIteration|"
+r"GeneratorExit)(?!['\w])", Name.Exception),
+#   Compiler-defined identifiers
+(r"(?<![\.\w])(import|inherit|for|while|switch|not|raise|unsafe|"
+r"yield|with)(?!['\w])", Keyword.Reserved),
+#   Other links
+(r"[A-Z_']+\b", Name),
+(r"[A-Z][\w']*\b", Keyword.Type),
+(r"\w+'*", Name),
+#  Blocks
+(r'[()]', Punctuation),
+],
+'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)
+],
+'string': [
+(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),
+(r'\n', String)
+],
+'dqs': [
+(r'"', String, '#pop')
+],
+'sqs': [
+(r"'", String, '#pop')
+],
+'tdqs': [
+(r'"""', String, '#pop')
+],
+'tsqs': [
+(r"'''", String, '#pop')
+],
+}

Mercurial Repositories > eric / file comparison

comparison: ThirdParty/Pygments/pygments/lexers/agile.py

ThirdParty/Pygments/pygments/lexers/agile.py