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

-:91114a975eda
+:2f29a0b6e1c7
 pygments.lexers.agile
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for agile languages.
-:copyright: Copyright 2006-2009 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
-try:
-set
-except NameError:
-from sets import Set as set
 from pygments.lexer import Lexer, RegexLexer, ExtendedRegexLexer, \
 LexerContext, include, combined, do_insertions, bygroups, using
-from pygments.token import Error, Text, \
+from pygments.token import Error, Text, Other, \
 Comment, Operator, Keyword, Name, String, Number, Generic, Punctuation
 from pygments.util import get_bool_opt, get_list_opt, shebang_matches
 from pygments import unistring as uni
 For `Python <http://www.python.org>`_ source code.
 """
 name = 'Python'
 aliases = ['python', 'py']
-filenames = ['*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript']
+filenames = ['*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac']
 mimetypes = ['text/x-python', 'application/x-python']
 tokens = {
 'root': [
 (r'\n', Text),
 if line.startswith('>>> ') or line.startswith('... '):
 tb = 0
 insertions.append((len(curcode),
 [(0, Generic.Prompt, line[:4])]))
 curcode += line[4:]
-elif line.rstrip() == '...':
+elif line.rstrip() == '...' and not tb:
-tb = 0
+# only a new >>> prompt can end an exception block
+# otherwise an ellipsis in place of the traceback frames
+# will be mishandled
 insertions.append((len(curcode),
 [(0, Generic.Prompt, '...')]))
 curcode += line[3:]
 else:
 if curcode:
 tokens = {
 'root': [
 (r'^Traceback \(most recent call last\):\n', Generic.Traceback, 'intb'),
 # SyntaxError starts with this.
-(r'^(?=  File "[^"]+", line \d+\n)', Generic.Traceback, 'intb'),
+(r'^(?=  File "[^"]+", line \d+)', Generic.Traceback, 'intb'),
+(r'^.*\n', Other),
 ],
 'intb': [
 (r'^(  File )("[^"]+")(, line )(\d+)(, in )(.+)(\n)',
 bygroups(Text, Name.Builtin, Text, Number, Text, Name.Identifier, Text)),
 (r'^(  File )("[^"]+")(, line )(\d+)(\n)',
 name+'-regex'))
 # these must come after %<brace>!
 states['strings'] += [
 # %r regex
-(r'(%r([^a-zA-Z0-9]))([^\2\\]*(?:\\.[^\2\\]*)*)(\2[mixounse]*)',
+(r'(%r([^a-zA-Z0-9]))((?:\\\2|(?!\2).)*)(\2[mixounse]*)',
 intp_regex_callback),
 # regular fancy strings with qsw
-(r'%[qsw]([^a-zA-Z0-9])([^\1\\]*(?:\\.[^\1\\]*)*)\1', String.Other),
+(r'%[qsw]([^a-zA-Z0-9])((?:\\\1|(?!\1).)*)\1', String.Other),
-(r'(%[QWx]([^a-zA-Z0-9]))([^\2\\]*(?:\\.[^\2\\]*)*)(\2)',
+(r'(%[QWx]([^a-zA-Z0-9]))((?:\\\2|(?!\2).)*)(\2)',
 intp_string_callback),
 # special forms of fancy strings after operators or
 # in method calls with braces
-(r'(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:[^\3\\]*(?:\\.[^\3\\]*)*)\3)',
+(r'(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
 bygroups(Text, String.Other, None)),
 # and because of fixed width lookbehinds the whole thing a
 # second time for line startings...
-(r'^(\s*)(%([\t ])(?:[^\3\\]*(?:\\.[^\3\\]*)*)\3)',
+(r'^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
 bygroups(Text, String.Other, None)),
 # all regular fancy strings without qsw
-(r'(%([^a-zA-Z0-9\s]))([^\2\\]*(?:\\.[^\2\\]*)*)(\2)',
+(r'(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)',
 intp_string_callback),
 ]
 return states
 r'(?<=^sub!\s)|'
 r'(?<=^gsub!\s)|'
 r'(?<=^match\s)|'
 r'(?<=^if\s)|'
 r'(?<=^elsif\s)'
-r')(\s*)(/)(?!=)', bygroups(Text, String.Regex), 'multiline-regex'),
+r')(\s*)(/)', bygroups(Text, String.Regex), 'multiline-regex'),
 # multiline regex (in method calls)
 (r'(?<=\(|,)/', String.Regex, 'multiline-regex'),
 # multiline regex (this time the funny no whitespace rule)
 (r'(\s+)(/[^\s=])', String.Regex, 'multiline-regex'),
 # lex numbers and ignore following regular expressions which
 (r'\[(\\\\|\\\]|[^\]])*\][egimosx]*', String.Regex, '#pop'),
 (r'\((\\\\|\\\)|[^\)])*\)[egimosx]*', String.Regex, '#pop'),
 (r'@(\\\\|\\\@|[^\@])*@[egimosx]*', String.Regex, '#pop'),
 (r'%(\\\\|\\\%|[^\%])*%[egimosx]*', String.Regex, '#pop'),
 (r'\$(\\\\|\\\$|[^\$])*\$[egimosx]*', String.Regex, '#pop'),
-(r'!(\\\\|\\!|[^!])*![egimosx]*', String.Regex, '#pop'),
 ],
 'root': [
 (r'\#.*?$', Comment.Single),
 (r'^=[a-zA-Z0-9]+\s+.*?\n=cut', Comment.Multiline),
 (r'(case|continue|do|else|elsif|for|foreach|if|last|my|'
 (r's<(\\\\|\\>|[^>])*>\s*', String.Regex, 'balanced-regex'),
 (r's\[(\\\\|\\\]|[^\]])*\]\s*', String.Regex, 'balanced-regex'),
 (r's\((\\\\|\\\)|[^\)])*\)\s*', String.Regex, 'balanced-regex'),
 (r'm?/(\\\\|\\/|[^/\n])*/[gcimosx]*', String.Regex),
+(r'm(?=[/!\\{<\[\(@%\$])', String.Regex, 'balanced-regex'),
 (r'((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[gcimosx]*', String.Regex),
 (r'\s+', Text),
 (r'(abs|accept|alarm|atan2|bind|binmode|bless|caller|chdir|'
 r'chmod|chomp|chop|chown|chr|chroot|close|closedir|connect|'
 r'continue|cos|crypt|dbmclose|dbmopen|defined|delete|die|'
 (r'<([^\s>]+)>', String.Regexp),
 (r'(q|qq|qw|qr|qx)\{', String.Other, 'cb-string'),
 (r'(q|qq|qw|qr|qx)\(', String.Other, 'rb-string'),
 (r'(q|qq|qw|qr|qx)\[', String.Other, 'sb-string'),
 (r'(q|qq|qw|qr|qx)\<', String.Other, 'lt-string'),
-(r'(q|qq|qw|qr|qx)(.)[.\n]*?\1', String.Other),
+(r'(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2', String.Other),
 (r'package\s+', Keyword, 'modulename'),
 (r'sub\s+', Keyword, 'funcname'),
 (r'(\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|'
 r'!~|&&?|\|\||\.{1,3})', Operator),
 (r'[-+/*%=<>&^|!\\~]=?', Operator),
 'lt-string': [
 (r'\\[\<\>\\]', String.Other),
 (r'\\', String.Other),
 (r'\<', String.Other, 'lt-string'),
 (r'\>', String.Other, '#pop'),
-(r'[^\<\>]]+', String.Other)
+(r'[^\<\>]+', String.Other)
 ],
 'end-part': [
 (r'.+', Comment.Preproc, '#pop')
 ]
 }
 filenames = ['*.lua']
 mimetypes = ['text/x-lua', 'application/x-lua']
 tokens = {
 'root': [
+# lua allows a file to start with a shebang
+(r'#!(.*?)$', Comment.Preproc),
+(r'', Text, 'base'),
+],
+'base': [
 (r'(?s)--\[(=*)\[.*?\]\1\]', Comment.Multiline),
 ('--.*$', Comment.Single),
 (r'(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?', Number.Float),
 (r'(?i)\d+e[+-]?\d+', Number.Float),
 tokens = {
 'root': [
 include('command'),
 include('basic'),
 include('data'),
+(r'}', Keyword),  # HACK: somehow we miscounted our braces
 ],
 'command': _gen_command_rules(keyword_cmds_re, builtin_cmds_re),
 'command-in-brace': _gen_command_rules(keyword_cmds_re,
 builtin_cmds_re,
 "-in-brace"),
 (r'\]', Keyword, ('#pop', '#pop')),
 include('params')
 ],
 'string': [
 (r'\[', String.Double, 'string-square'),
-(r'(\\\\|\\[0-7]+|\\.|[^"])', String.Double),
+(r'(?s)(\\\\|\\[0-7]+|\\.|[^"\\])', String.Double),
 (r'"', String.Double, '#pop')
 ],
 'string-square': [
 (r'\[', String.Double, 'string-square'),
-(r'(\\\\|\\[0-7]+|\\.|[^\]])', String.Double),
+(r'(?s)(\\\\|\\[0-7]+|\\.|\\\n|[^\]\\])', String.Double),
 (r'\]', String.Double, '#pop')
 ],
 'brace': [
 (r'}', Keyword, '#pop'),
 include('command-in-brace'),
 #(r'(#e|#i|#b|#o|#d|#x)[\d.]+', Number),
 # strings, symbols and characters
 (r'"(\\\\|\\"|[^"])*"', String),
 (r"'" + valid_name, String.Symbol),
-(r"\\([()/'\".'_!Â§$%& ?;=+-]{1}|[a-zA-Z0-9]+)", String.Char),
+(r"\\([()/'\".'_!Â§$%& ?;=#+-]{1}|[a-zA-Z0-9]+)", String.Char),
 # constants
 (r'(#t|#f)', Name.Constant),
 # special operators

Mercurial Repositories > eric / file comparison

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

ThirdParty/Pygments/pygments/lexers/agile.py