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

-:8bc578136279
+:4f20dba37ab6
 pygments.lexers.shell
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for various shells.
-:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
-from __future__ import unicode_literals
 import re
 from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups, include
 from pygments.token import Punctuation, \
 class BashLexer(RegexLexer):
 """
 Lexer for (ba|k|)sh shell scripts.
-*New in Pygments 0.6.*
+.. versionadded:: 0.6
 """
 name = 'Bash'
-aliases = ['bash', 'sh', 'ksh']
+aliases = ['bash', 'sh', 'ksh', 'shell']
 filenames = ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass',
-'.bashrc', 'bashrc', '.bash_*', 'bash_*']
+'.bashrc', 'bashrc', '.bash_*', 'bash_*', 'PKGBUILD']
 mimetypes = ['application/x-sh', 'application/x-shellscript']
 tokens = {
 'root': [
 include('basic'),
+(r'`', String.Backtick, 'backticks'),
+include('data'),
+include('interp'),
+],
+'interp': [
 (r'\$\(\(', Keyword, 'math'),
 (r'\$\(', Keyword, 'paren'),
-(r'\${#?', Keyword, 'curly'),
+(r'\$\{#?', String.Interpol, 'curly'),
-(r'`', String.Backtick, 'backticks'),
+(r'\$#?(\w+|.)', Name.Variable),
-include('data'),
 ],
 'basic': [
 (r'\b(if|fi|else|while|do|done|for|then|return|function|case|'
-r'select|continue|until|esac|elif)\s*\b',
+r'select|continue|until|esac|elif)(\s*)\b',
-Keyword),
+bygroups(Keyword, Text)),
 (r'\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|'
 r'complete|declare|dirs|disown|echo|enable|eval|exec|exit|'
 r'export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|'
 r'local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|'
 r'shopt|source|suspend|test|time|times|trap|true|type|typeset|'
 (r'<<<', Operator),  # here-string
 (r'<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
 (r'&&|\|\|', Operator),
 ],
 'data': [
-(r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
+(r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*"', String.Double),
-(r"(?s)\$?'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
+(r'"', String.Double, 'string'),
-(r';', Text),
+(r"(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
+(r"(?s)'.*?'", String.Single),
+(r';', Punctuation),
+(r'&', Punctuation),
+(r'\|', Punctuation),
 (r'\s+', Text),
-(r'[^=\s\[\]{}()$"\'`\\<]+', Text),
 (r'\d+(?= |\Z)', Number),
-(r'\$#?(\w+|.)', Name.Variable),
+(r'[^=\s\[\]{}()$"\'`\\<&|;]+', Text),
 (r'<', Text),
 ],
+'string': [
+(r'"', String.Double, '#pop'),
+(r'(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+', String.Double),
+include('interp'),
+],
 'curly': [
-(r'}', Keyword, '#pop'),
+(r'\}', String.Interpol, '#pop'),
 (r':-', Keyword),
-(r'[a-zA-Z0-9_]+', Name.Variable),
+(r'\w+', Name.Variable),
-(r'[^}:"\'`$]+', Punctuation),
+(r'[^}:"\'`$\\]+', Punctuation),
 (r':', Punctuation),
 include('root'),
 ],
 'paren': [
 (r'\)', Keyword, '#pop'),
 include('root'),
 ],
 'math': [
 (r'\)\)', Keyword, '#pop'),
 (r'[-+*/%^|&]|\*\*|\|\|', Operator),
+(r'\d+#\d+', Number),
+(r'\d+#(?! )', Number),
 (r'\d+', Number),
 include('root'),
 ],
 'backticks': [
 (r'`', String.Backtick, '#pop'),
 include('root'),
 ],
 }
 def analyse_text(text):
-return shebang_matches(text, r'(ba|z|)sh')
+if shebang_matches(text, r'(ba|z|)sh'):
+return 1
+if text.startswith('$ '):
+return 0.2
 class BashSessionLexer(Lexer):
 """
 Lexer for simplistic shell sessions.
-*New in Pygments 1.1.*
+.. versionadded:: 1.1
 """
 name = 'Bash Session'
 aliases = ['console']
 filenames = ['*.sh-session']
 class ShellSessionLexer(Lexer):
 """
 Lexer for shell sessions that works with different command prompts
-*New in Pygments 1.6.*
+.. versionadded:: 1.6
 """
 name = 'Shell Session'
 aliases = ['shell-session']
 filenames = ['*.shell-session']
 curcode = ''
 insertions = []
 for match in line_re.finditer(text):
 line = match.group()
-m = re.match(r'^((?:\[?\S+@[^$#%]+)[$#%])(.*\n?)', line)
+m = re.match(r'^((?:\[?\S+@[^$#%]+\]?\s*)[$#%])(.*\n?)', line)
 if m:
 # To support output lexers (say diff output), the output
 # needs to be broken by prompts whenever the output lexer
 # changes.
 if not insertions:
 class BatchLexer(RegexLexer):
 """
 Lexer for the DOS/Windows Batch file format.
-*New in Pygments 0.7.*
+.. versionadded:: 0.7
 """
 name = 'Batchfile'
-aliases = ['bat']
+aliases = ['bat', 'batch', 'dosbatch', 'winbatch']
 filenames = ['*.bat', '*.cmd']
 mimetypes = ['application/x-dos-batch']
 flags = re.MULTILINE | re.IGNORECASE
 (r"'.*?'", String.Single),
 # If made more specific, make sure you still allow expansions
 # like %~$VAR:zlt
 (r'%%?[~$:\w]+%?', Name.Variable),
 (r'::.*', Comment), # Technically :: only works at BOL
-(r'(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)),
+(r'\b(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)),
-(r'(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)),
+(r'\b(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)),
-(r'(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)),
+(r'\b(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)),
 (r'\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|'
 r'setlocal|shift|errorlevel|exist|defined|cmdextversion|'
 r'errorlevel|else|cd|md|del|deltree|cls|choice)\b', Keyword),
 (r'\b(equ|neq|lss|leq|gtr|geq)\b', Operator),
 include('basic'),
 class TcshLexer(RegexLexer):
 """
 Lexer for tcsh scripts.
-*New in Pygments 0.10.*
+.. versionadded:: 0.10
 """
 name = 'Tcsh'
 aliases = ['tcsh', 'csh']
 filenames = ['*.tcsh', '*.csh']
 tokens = {
 'root': [
 include('basic'),
 (r'\$\(', Keyword, 'paren'),
-(r'\${#?', Keyword, 'curly'),
+(r'\$\{#?', Keyword, 'curly'),
 (r'`', String.Backtick, 'backticks'),
 include('data'),
 ],
 'basic': [
 (r'\b(if|endif|else|while|then|foreach|case|default|'
 r'set|shift|sched|setenv|setpath|settc|setty|setxvers|shift|'
 r'source|stop|suspend|source|suspend|telltc|time|'
 r'umask|unalias|uncomplete|unhash|universe|unlimit|unset|unsetenv|'
 r'ver|wait|warp|watchlog|where|which)\s*\b',
 Name.Builtin),
-(r'#.*\n', Comment),
+(r'#.*', Comment),
 (r'\\[\w\W]', String.Escape),
 (r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
 (r'[\[\]{}()=]+', Operator),
 (r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
+(r';', Punctuation),
 ],
 'data': [
 (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
 (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
 (r'\s+', Text),
-(r'[^=\s\[\]{}()$"\'`\\]+', Text),
+(r'[^=\s\[\]{}()$"\'`\\;#]+', Text),
 (r'\d+(?= |\Z)', Number),
 (r'\$#?(\w+|.)', Name.Variable),
 ],
 'curly': [
-(r'}', Keyword, '#pop'),
+(r'\}', Keyword, '#pop'),
 (r':-', Keyword),
-(r'[a-zA-Z0-9_]+', Name.Variable),
+(r'\w+', Name.Variable),
 (r'[^}:"\'`$]+', Punctuation),
 (r':', Punctuation),
 include('root'),
 ],
 'paren': [
 class PowerShellLexer(RegexLexer):
 """
 For Windows PowerShell code.
-*New in Pygments 1.5.*
+.. versionadded:: 1.5
 """
 name = 'PowerShell'
-aliases = ['powershell', 'posh', 'ps1']
+aliases = ['powershell', 'posh', 'ps1', 'psm1']
-filenames = ['*.ps1']
+filenames = ['*.ps1','*.psm1']
 mimetypes = ['text/x-powershell']
 flags = re.DOTALL | re.IGNORECASE | re.MULTILINE
 keywords = (
 'validatecount until trap switch return ref process param parameter in '
 'if global: function foreach for finally filter end elseif else '
 'dynamicparam do default continue cmdletbinding break begin alias \\? '
 '% #script #private #local #global mandatory parametersetname position '
 'valuefrompipeline valuefrompipelinebypropertyname '
-'valuefromremainingarguments helpmessage try catch').split()
+'valuefromremainingarguments helpmessage try catch throw').split()
 operators = (
 'and as band bnot bor bxor casesensitive ccontains ceq cge cgt cle '
 'clike clt cmatch cne cnotcontains cnotlike cnotmatch contains '
 'creplace eq exact f file ge gt icontains ieq ige igt ile ilike ilt '
 'forwardhelptargetname functionality inputs link '
 'notes outputs parameter remotehelprunspace role synopsis').split()
 tokens = {
 'root': [
+# we need to count pairs of parentheses for correct highlight
+# of '$(...)' blocks in strings
+(r'\(', Punctuation, 'child'),
 (r'\s+', Text),
 (r'^(\s*#[#\s]*)(\.(?:%s))([^\n]*$)' % '|'.join(commenthelp),
 bygroups(Comment, String.Doc, Comment)),
 (r'#[^\n]*?$', Comment),
 (r'(&lt;|<)#', Comment.Multiline, 'multline'),
-(r'@"\n.*?\n"@', String.Heredoc),
+(r'@"\n', String.Heredoc, 'heredoc-double'),
 (r"@'\n.*?\n'@", String.Heredoc),
 # escaped syntax
 (r'`[\'"$@-]', Punctuation),
 (r'"', String.Double, 'string'),
 (r"'([^']|'')*'", String.Single),
-(r'(\$|@@|@)((global|script|private|env):)?[a-z0-9_]+',
+(r'(\$|@@|@)((global|script|private|env):)?\w+',
 Name.Variable),
 (r'(%s)\b' % '|'.join(keywords), Keyword),
 (r'-(%s)\b' % '|'.join(operators), Operator),
-(r'(%s)-[a-z_][a-z0-9_]*\b' % '|'.join(verbs), Name.Builtin),
+(r'(%s)-[a-z_]\w*\b' % '|'.join(verbs), Name.Builtin),
-(r'\[[a-z_\[][a-z0-9_. `,\[\]]*\]', Name.Constant),  # .net [type]s
+(r'\[[a-z_\[][\w. `,\[\]]*\]', Name.Constant),  # .net [type]s
-(r'-[a-z_][a-z0-9_]*', Name),
+(r'-[a-z_]\w*', Name),
 (r'\w+', Name),
-(r'[.,{}\[\]$()=+*/\\&%!~?^`|<>-]', Punctuation),
+(r'[.,;@{}\[\]$()=+*/\\&%!~?^`|<>-]|::', Punctuation),
+],
+'child': [
+(r'\)', Punctuation, '#pop'),
+include('root'),
 ],
 'multline': [
 (r'[^#&.]+', Comment.Multiline),
 (r'#(>|&gt;)', Comment.Multiline, '#pop'),
 (r'\.(%s)' % '|'.join(commenthelp), String.Doc),
 (r'[#&.]', Comment.Multiline),
 ],
 'string': [
+(r"`[0abfnrtv'\"$`]", String.Escape),
 (r'[^$`"]+', String.Double),
-(r'\$\(', String.Interpol, 'interpol'),
+(r'\$\(', Punctuation, 'child'),
-(r'`"|""', String.Double),
+(r'""', String.Double),
 (r'[`$]', String.Double),
 (r'"', String.Double, '#pop'),
 ],
-'interpol': [
+'heredoc-double': [
-(r'[^$)]+', String.Interpol),
+(r'\n"@', String.Heredoc, '#pop'),
-(r'\$\(', String.Interpol, '#push'),
+(r'\$\(', Punctuation, 'child'),
-(r'\)', String.Interpol, '#pop'),
+(r'[^@\n]+"]', String.Heredoc),
+(r".", String.Heredoc),
 ]
 }

Mercurial Repositories > eric / file comparison

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

ThirdParty/Pygments/pygments/lexers/shell.py