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

-:ace8a08028f3
+:da76c71624de
 pygments.lexers.text
 ~~~~~~~~~~~~~~~~~~~~
 Lexers for non-source code file types.
-: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
 from bisect import bisect
 'MakefileLexer', 'DiffLexer', 'IrcLogsLexer', 'TexLexer',
 'GroffLexer', 'ApacheConfLexer', 'BBCodeLexer', 'MoinWikiLexer',
 'RstLexer', 'VimLexer', 'GettextLexer', 'SquidConfLexer',
 'DebianControlLexer', 'DarcsPatchLexer', 'YamlLexer',
 'LighttpdConfLexer', 'NginxConfLexer', 'CMakeLexer', 'HttpLexer',
-'PyPyLogLexer']
+'PyPyLogLexer', 'RegeditLexer', 'HxmlLexer']
 class IniLexer(RegexLexer):
 """
 Lexer for configuration files in INI style.
 mimetypes = ['text/x-ini']
 tokens = {
 'root': [
 (r'\s+', Text),
-(r'[;#].*?$', Comment),
+(r'[;#].*', Comment.Single),
 (r'\[.*?\]$', Keyword),
 (r'(.*?)([ \t]*)(=)([ \t]*)(.*(?:\n[ \t].+)*)',
 bygroups(Name.Attribute, Text, Operator, Text, String))
 ]
 }
 def analyse_text(text):
 npos = text.find('\n')
 if npos < 3:
 return False
 return text[0] == '[' and text[npos-1] == ']'
+class RegeditLexer(RegexLexer):
+"""
+Lexer for `Windows Registry
+<http://en.wikipedia.org/wiki/Windows_Registry#.REG_files>`_ files produced
+by regedit.
+*New in Pygments 1.6.*
+"""
+name = 'reg'
+aliases = ['registry']
+filenames = ['*.reg']
+mimetypes = ['text/x-windows-registry']
+tokens = {
+'root': [
+(r'Windows Registry Editor.*', Text),
+(r'\s+', Text),
+(r'[;#].*', Comment.Single),
+(r'(\[)(-?)(HKEY_[A-Z_]+)(.*?\])$',
+bygroups(Keyword, Operator, Name.Builtin, Keyword)),
+# String keys, which obey somewhat normal escaping
+(r'("(?:\\"|\\\\|[^"])+")([ \t]*)(=)([ \t]*)',
+bygroups(Name.Attribute, Text, Operator, Text),
+'value'),
+# Bare keys (includes @)
+(r'(.*?)([ \t]*)(=)([ \t]*)',
+bygroups(Name.Attribute, Text, Operator, Text),
+'value'),
+],
+'value': [
+(r'-', Operator, '#pop'), # delete value
+(r'(dword|hex(?:\([0-9a-fA-F]\))?)(:)([0-9a-fA-F,]+)',
+bygroups(Name.Variable, Punctuation, Number), '#pop'),
+# As far as I know, .reg files do not support line continuation.
+(r'.*', String, '#pop'),
+]
+}
+def analyse_text(text):
+return text.startswith('Windows Registry Editor')
 class PropertiesLexer(RegexLexer):
 """
 Lexer for configuration files in Java's properties format.
 (r'#.*?\n', Comment),
 (r'(export)(\s+)(?=[a-zA-Z0-9_${}\t -]+\n)',
 bygroups(Keyword, Text), 'export'),
 (r'export\s+', Keyword),
 # assignment
-(r'([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)([ \t]*)((?:.*\\\n|.*\n)+)',
+(r'([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)([ \t]*)((?:.*\\\n)+|.*\n)',
 bygroups(Name.Variable, Text, Operator, Text, using(BashLexer))),
 # strings
 (r'(?s)"(\\\\|\\.|[^"\\])*"', String.Double),
 (r"(?s)'(\\\\|\\.|[^'\\])*'", String.Single),
 # targets
 'root': [
 (r'\s+', Text),
 (r'(#.*?)$', Comment),
 (r'(<[^\s>]+)(?:(\s+)(.*?))?(>)',
 bygroups(Name.Tag, Text, String, Name.Tag)),
-(r'([a-zA-Z][a-zA-Z0-9]*)(\s+)',
+(r'([a-zA-Z][a-zA-Z0-9_]*)(\s+)',
 bygroups(Name.Builtin, Text), 'value'),
 (r'\.+', Text),
 ],
 'value': [
 (r'$', Text, '#pop'),
 # Literal code blocks, with optional shebang
 (r'({{{)(\n#!.+)?', bygroups(Name.Builtin, Name.Namespace), 'codeblock'),
 (r'(\'\'\'?|\|\||`|__|~~|\^|,,|::)', Comment), # Formatting
 # Lists
 (r'^( +)([.*-])( )', bygroups(Text, Name.Builtin, Text)),
-(r'^( +)([a-zivx]{1,5}\.)( )', bygroups(Text, Name.Builtin, Text)),
+(r'^( +)([a-z]{1,5}\.)( )', bygroups(Text, Name.Builtin, Text)),
 # Other Formatting
 (r'\[\[\w+.*?\]\]', Keyword), # Macro
 (r'(\[[^\s\]]+)(\s+[^\]]+?)?(\])',
 bygroups(Keyword, String, Keyword)), # Link
 (r'^----+$', Keyword), # Horizontal rules
 yield match.start(3), Operator, match.group(3)
 yield match.start(4), Text, match.group(4)
 yield match.start(5), Literal, match.group(5)
 yield match.start(6), Text, match.group(6)
+def continuous_header_callback(self, match):
+yield match.start(1), Text, match.group(1)
+yield match.start(2), Literal, match.group(2)
+yield match.start(3), Text, match.group(3)
 def content_callback(self, match):
 content_type = getattr(self, 'content_type', None)
 content = match.group()
 offset = match.start()
 if content_type:
 Text, Name.Exception, Text),
 'headers'),
 ],
 'headers': [
 (r'([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)', header_callback),
+(r'([\t ]+)([^\r\n]+)(\r?\n|$)', continuous_header_callback),
 (r'\r?\n', Text, 'content')
 ],
 'content': [
 (r'.+', content_callback)
 ]
 (r"\[\w+\] {jit-backend-counts$", Keyword, "jit-backend-counts"),
 include("extra-stuff"),
 ],
 "jit-log": [
 (r"\[\w+\] jit-log-.*?}$", Keyword, "#pop"),
 (r"^\+\d+: ", Comment),
+(r"--end of the loop--", Comment),
 (r"[ifp]\d+", Name),
 (r"ptr\d+", Name),
 (r"(\()(\w+(?:\.\w+)?)(\))",
 bygroups(Punctuation, Name.Builtin, Punctuation)),
 (r"[\[\]=,()]", Punctuation),
 (r"(\d+\.\d+|inf|-inf)", Number.Float),
 (r"-?\d+", Number.Integer),
 (r"'.*'", String),
 (r"(None|descr|ConstClass|ConstPtr|TargetToken)", Name),
-(r"<.*?>", Name.Builtin),
+(r"<.*?>+", Name.Builtin),
 (r"(label|debug_merge_point|jump|finish)", Name.Class),
 (r"(int_add_ovf|int_add|int_sub_ovf|int_sub|int_mul_ovf|int_mul|"
 r"int_floordiv|int_mod|int_lshift|int_rshift|int_and|int_or|"
 r"int_xor|int_eq|int_ne|int_ge|int_gt|int_le|int_lt|int_is_zero|"
 r"int_is_true|"
 r"uint_floordiv|uint_ge|uint_lt|"
-r"float_add|float_sub|float_mul|float_truediv|"
+r"float_add|float_sub|float_mul|float_truediv|float_neg|"
 r"float_eq|float_ne|float_ge|float_gt|float_le|float_lt|float_abs|"
 r"ptr_eq|ptr_ne|instance_ptr_eq|instance_ptr_ne|"
 r"cast_int_to_float|cast_float_to_int|"
 r"force_token|quasiimmut_field|same_as|virtual_ref_finish|"
 r"virtual_ref|mark_opaque_ptr|"
 "extra-stuff": [
 (r"\s+", Text),
 (r"#.*?$", Comment),
 ],
 }
+class HxmlLexer(RegexLexer):
+"""
+Lexer for `haXe build <http://haxe.org/doc/compiler>`_ files.
+*New in Pygments 1.6.*
+"""
+name = 'Hxml'
+aliases = ['haxeml', 'hxml']
+filenames = ['*.hxml']
+tokens = {
+'root': [
+# Seperator
+(r'(--)(next)', bygroups(Punctuation, Generic.Heading)),
+# Compiler switches with one dash
+(r'(-)(prompt|debug|v)', bygroups(Punctuation, Keyword.Keyword)),
+# Compilerswitches with two dashes
+(r'(--)(neko-source|flash-strict|flash-use-stage|no-opt|no-traces|'
+r'no-inline|times|no-output)', bygroups(Punctuation, Keyword)),
+# Targets and other options that take an argument
+(r'(-)(cpp|js|neko|x|as3|swf9?|swf-lib|php|xml|main|lib|D|resource|'
+r'cp|cmd)( +)(.+)',
+bygroups(Punctuation, Keyword, Whitespace, String)),
+# Options that take only numerical arguments
+(r'(-)(swf-version)( +)(\d+)',
+bygroups(Punctuation, Keyword, Number.Integer)),
+# An Option that defines the size, the fps and the background
+# color of an flash movie
+(r'(-)(swf-header)( +)(\d+)(:)(\d+)(:)(\d+)(:)([A-Fa-f0-9]{6})',
+bygroups(Punctuation, Keyword, Whitespace, Number.Integer,
+Punctuation, Number.Integer, Punctuation, Number.Integer,
+Punctuation, Number.Hex)),
+# options with two dashes that takes arguments
+(r'(--)(js-namespace|php-front|php-lib|remap|gen-hx-classes)( +)'
+r'(.+)', bygroups(Punctuation, Keyword, Whitespace, String)),
+# Single line comment, multiline ones are not allowed.
+(r'#.*', Comment.Single)
+]
+}

Mercurial Repositories > eric / file comparison

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

ThirdParty/Pygments/pygments/lexers/text.py