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

-:bf4d19a7cade
+:c2e9bf425554
 pygments.lexers.shell
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for various shells.
-:copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
-from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups, include
+from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups, \
+include, default, this, using, words
 from pygments.token import Punctuation, \
 Text, Comment, Operator, Keyword, Name, String, Number, Generic
 from pygments.util import shebang_matches
 __all__ = ['BashLexer', 'BashSessionLexer', 'TcshLexer', 'BatchLexer',
-'PowerShellLexer', 'ShellSessionLexer']
+'MSDOSSessionLexer', 'PowerShellLexer',
+'PowerShellSessionLexer', 'TcshSessionLexer', 'FishShellLexer']
-line_re  = re.compile('.*?\n')
+line_re = re.compile('.*?\n')
 class BashLexer(RegexLexer):
 """
 Lexer for (ba|k|)sh shell scripts.
 ],
 'interp': [
 (r'\$\(\(', Keyword, 'math'),
 (r'\$\(', Keyword, 'paren'),
 (r'\$\{#?', String.Interpol, 'curly'),
-(r'\$#?(\w+|.)', Name.Variable),
+(r'\$[a-fA-F_][a-fA-F0-9_]*', Name.Variable),  # user variable
+(r'\$(?:\d+|[#$?!_*@-])', Name.Variable),      # builtin
+(r'\$', Text),
 ],
 'basic': [
 (r'\b(if|fi|else|while|do|done|for|then|return|function|case|'
 r'select|continue|until|esac|elif)(\s*)\b',
 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'ulimit|umask|unalias|unset|wait)\s*\b(?!\.)',
+r'ulimit|umask|unalias|unset|wait)(?=[\s)`])',
 Name.Builtin),
-(r'#.*\n', Comment),
+(r'\A#!.+\n', Comment.Hashbang),
+(r'#.*\n', Comment.Single),
 (r'\\[\w\W]', String.Escape),
 (r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
 (r'[\[\]{}()=]', Operator),
 (r'<<<', Operator),  # here-string
 (r'<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
 return 1
 if text.startswith('$ '):
 return 0.2
-class BashSessionLexer(Lexer):
+class ShellSessionBaseLexer(Lexer):
 """
-Lexer for simplistic shell sessions.
+Base lexer for simplistic shell sessions.
-.. versionadded:: 1.1
+.. versionadded:: 2.1
 """
-name = 'Bash Session'
-aliases = ['console']
-filenames = ['*.sh-session']
-mimetypes = ['application/x-shell-session']
 def get_tokens_unprocessed(self, text):
-bashlexer = BashLexer(**self.options)
+innerlexer = self._innerLexerCls(**self.options)
 pos = 0
 curcode = ''
 insertions = []
 for match in line_re.finditer(text):
 line = match.group()
-m = re.match(r'^((?:\(\S+\))?(?:|sh\S*?|\w+\S+[@:]\S+(?:\s+\S+)'
+m = re.match(self._ps1rgx, line)
-r'?|\[\S+[@:][^\n]+\].+)[$#%])(.*\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:
 pos = match.start()
 insertions.append((len(curcode),
 [(0, Generic.Prompt, m.group(1))]))
 curcode += m.group(2)
-elif line.startswith('>'):
+elif line.startswith(self._ps2):
 insertions.append((len(curcode),
-[(0, Generic.Prompt, line[:1])]))
+[(0, Generic.Prompt, line[:len(self._ps2)])]))
-curcode += line[1:]
+curcode += line[len(self._ps2):]
 else:
 if insertions:
-toks = bashlexer.get_tokens_unprocessed(curcode)
+toks = innerlexer.get_tokens_unprocessed(curcode)
 for i, t, v in do_insertions(insertions, toks):
 yield pos+i, t, v
 yield match.start(), Generic.Output, line
 insertions = []
 curcode = ''
 if insertions:
 for i, t, v in do_insertions(insertions,
-bashlexer.get_tokens_unprocessed(curcode)):
+innerlexer.get_tokens_unprocessed(curcode)):
 yield pos+i, t, v
-class ShellSessionLexer(Lexer):
+class BashSessionLexer(ShellSessionBaseLexer):
 """
-Lexer for shell sessions that works with different command prompts
+Lexer for simplistic shell sessions.
-.. versionadded:: 1.6
+.. versionadded:: 1.1
 """
-name = 'Shell Session'
+name = 'Bash Session'
-aliases = ['shell-session']
+aliases = ['console', 'shell-session']
-filenames = ['*.shell-session']
+filenames = ['*.sh-session', '*.shell-session']
-mimetypes = ['application/x-sh-session']
+mimetypes = ['application/x-shell-session', 'application/x-sh-session']
-def get_tokens_unprocessed(self, text):
+_innerLexerCls = BashLexer
-bashlexer = BashLexer(**self.options)
+_ps1rgx = \
+r'^((?:(?:\[.*?\])|(?:\(\S+\))?(?:| |sh\S*?|\w+\S+[@:]\S+(?:\s+\S+)' \
-pos = 0
+r'?|\[\S+[@:][^\n]+\].+))\s*[$#%])(.*\n?)'
-curcode = ''
+_ps2 = '>'
-insertions = []
-for match in line_re.finditer(text):
-line = match.group()
-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:
-pos = match.start()
-insertions.append((len(curcode),
-[(0, Generic.Prompt, m.group(1))]))
-curcode += m.group(2)
-else:
-if insertions:
-toks = bashlexer.get_tokens_unprocessed(curcode)
-for i, t, v in do_insertions(insertions, toks):
-yield pos+i, t, v
-yield match.start(), Generic.Output, line
-insertions = []
-curcode = ''
-if insertions:
-for i, t, v in do_insertions(insertions,
-bashlexer.get_tokens_unprocessed(curcode)):
-yield pos+i, t, v
 class BatchLexer(RegexLexer):
 """
 Lexer for the DOS/Windows Batch file format.
 filenames = ['*.bat', '*.cmd']
 mimetypes = ['application/x-dos-batch']
 flags = re.MULTILINE | re.IGNORECASE
+_nl = r'\n\x1a'
+_punct = r'&<>|'
+_ws = r'\t\v\f\r ,;=\xa0'
+_space = r'(?:(?:(?:\^[%s])?[%s])+)' % (_nl, _ws)
+_keyword_terminator = (r'(?=(?:\^[%s]?)?[%s+./:[\\\]]|[%s%s(])' %
+(_nl, _ws, _nl, _punct))
+_token_terminator = r'(?=\^?[%s]|[%s%s])' % (_ws, _punct, _nl)
+_start_label = r'((?:(?<=^[^:])|^[^:]?)[%s]*)(:)' % _ws
+_label = r'(?:(?:[^%s%s%s+:^]|\^[%s]?[\w\W])*)' % (_nl, _punct, _ws, _nl)
+_label_compound = (r'(?:(?:[^%s%s%s+:^)]|\^[%s]?[^)])*)' %
+(_nl, _punct, _ws, _nl))
+_number = r'(?:-?(?:0[0-7]+|0x[\da-f]+|\d+)%s)' % _token_terminator
+_opword = r'(?:equ|geq|gtr|leq|lss|neq)'
+_string = r'(?:"[^%s"]*"?)' % _nl
+_variable = (r'(?:(?:%%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|'
+r'[^%%:%s]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%%%s^]|'
+r'\^[^%%%s])[^=%s]*=(?:[^%%%s^]|\^[^%%%s])*)?)?%%))|'
+r'(?:\^?![^!:%s]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:'
+r'[^!%s^]|\^[^!%s])[^=%s]*=(?:[^!%s^]|\^[^!%s])*)?)?\^?!))' %
+(_nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl))
+_core_token = r'(?:(?:(?:\^[%s]?)?[^%s%s%s])+)' % (_nl, _nl, _punct, _ws)
+_core_token_compound = r'(?:(?:(?:\^[%s]?)?[^%s%s%s)])+)' % (_nl, _nl,
+_punct, _ws)
+_token = r'(?:[%s]+|%s)' % (_punct, _core_token)
+_token_compound = r'(?:[%s]+|%s)' % (_punct, _core_token_compound)
+_stoken = (r'(?:[%s]+|(?:%s|%s|%s)+)' %
+(_punct, _string, _variable, _core_token))
+def _make_begin_state(compound, _core_token=_core_token,
+_core_token_compound=_core_token_compound,
+_keyword_terminator=_keyword_terminator,
+_nl=_nl, _punct=_punct, _string=_string,
+_space=_space, _start_label=_start_label,
+_stoken=_stoken, _token_terminator=_token_terminator,
+_variable=_variable, _ws=_ws):
+rest = '(?:%s|%s|[^"%%%s%s%s])*' % (_string, _variable, _nl, _punct,
+')' if compound else '')
+rest_of_line = r'(?:(?:[^%s^]|\^[%s]?[\w\W])*)' % (_nl, _nl)
+rest_of_line_compound = r'(?:(?:[^%s^)]|\^[%s]?[^)])*)' % (_nl, _nl)
+set_space = r'((?:(?:\^[%s]?)?[^\S\n])*)' % _nl
+suffix = ''
+if compound:
+_keyword_terminator = r'(?:(?=\))|%s)' % _keyword_terminator
+_token_terminator = r'(?:(?=\))|%s)' % _token_terminator
+suffix = '/compound'
+return [
+((r'\)', Punctuation, '#pop') if compound else
+(r'\)((?=\()|%s)%s' % (_token_terminator, rest_of_line),
+Comment.Single)),
+(r'(?=%s)' % _start_label, Text, 'follow%s' % suffix),
+(_space, using(this, state='text')),
+include('redirect%s' % suffix),
+(r'[%s]+' % _nl, Text),
+(r'\(', Punctuation, 'root/compound'),
+(r'@+', Punctuation),
+(r'((?:for|if|rem)(?:(?=(?:\^[%s]?)?/)|(?:(?!\^)|'
+r'(?<=m))(?:(?=\()|%s)))(%s?%s?(?:\^[%s]?)?/(?:\^[%s]?)?\?)' %
+(_nl, _token_terminator, _space,
+_core_token_compound if compound else _core_token, _nl, _nl),
+bygroups(Keyword, using(this, state='text')),
+'follow%s' % suffix),
+(r'(goto%s)(%s(?:\^[%s]?)?/(?:\^[%s]?)?\?%s)' %
+(_keyword_terminator, rest, _nl, _nl, rest),
+bygroups(Keyword, using(this, state='text')),
+'follow%s' % suffix),
+(words(('assoc', 'break', 'cd', 'chdir', 'cls', 'color', 'copy',
+'date', 'del', 'dir', 'dpath', 'echo', 'endlocal', 'erase',
+'exit', 'ftype', 'keys', 'md', 'mkdir', 'mklink', 'move',
+'path', 'pause', 'popd', 'prompt', 'pushd', 'rd', 'ren',
+'rename', 'rmdir', 'setlocal', 'shift', 'start', 'time',
+'title', 'type', 'ver', 'verify', 'vol'),
+suffix=_keyword_terminator), Keyword, 'follow%s' % suffix),
+(r'(call)(%s?)(:)' % _space,
+bygroups(Keyword, using(this, state='text'), Punctuation),
+'call%s' % suffix),
+(r'call%s' % _keyword_terminator, Keyword),
+(r'(for%s(?!\^))(%s)(/f%s)' %
+(_token_terminator, _space, _token_terminator),
+bygroups(Keyword, using(this, state='text'), Keyword),
+('for/f', 'for')),
+(r'(for%s(?!\^))(%s)(/l%s)' %
+(_token_terminator, _space, _token_terminator),
+bygroups(Keyword, using(this, state='text'), Keyword),
+('for/l', 'for')),
+(r'for%s(?!\^)' % _token_terminator, Keyword, ('for2', 'for')),
+(r'(goto%s)(%s?)(:?)' % (_keyword_terminator, _space),
+bygroups(Keyword, using(this, state='text'), Punctuation),
+'label%s' % suffix),
+(r'(if(?:(?=\()|%s)(?!\^))(%s?)((?:/i%s)?)(%s?)((?:not%s)?)(%s?)' %
+(_token_terminator, _space, _token_terminator, _space,
+_token_terminator, _space),
+bygroups(Keyword, using(this, state='text'), Keyword,
+using(this, state='text'), Keyword,
+using(this, state='text')), ('(?', 'if')),
+(r'rem(((?=\()|%s)%s?%s?.*|%s%s)' %
+(_token_terminator, _space, _stoken, _keyword_terminator,
+rest_of_line_compound if compound else rest_of_line),
+Comment.Single, 'follow%s' % suffix),
+(r'(set%s)%s(/a)' % (_keyword_terminator, set_space),
+bygroups(Keyword, using(this, state='text'), Keyword),
+'arithmetic%s' % suffix),
+(r'(set%s)%s((?:/p)?)%s((?:(?:(?:\^[%s]?)?[^"%s%s^=%s]|'
+r'\^[%s]?[^"=])+)?)((?:(?:\^[%s]?)?=)?)' %
+(_keyword_terminator, set_space, set_space, _nl, _nl, _punct,
+')' if compound else '', _nl, _nl),
+bygroups(Keyword, using(this, state='text'), Keyword,
+using(this, state='text'), using(this, state='variable'),
+Punctuation),
+'follow%s' % suffix),
+default('follow%s' % suffix)
+]
+def _make_follow_state(compound, _label=_label,
+_label_compound=_label_compound, _nl=_nl,
+_space=_space, _start_label=_start_label,
+_token=_token, _token_compound=_token_compound,
+_ws=_ws):
+suffix = '/compound' if compound else ''
+state = []
+if compound:
+state.append((r'(?=\))', Text, '#pop'))
+state += [
+(r'%s([%s]*)(%s)(.*)' %
+(_start_label, _ws, _label_compound if compound else _label),
+bygroups(Text, Punctuation, Text, Name.Label, Comment.Single)),
+include('redirect%s' % suffix),
+(r'(?=[%s])' % _nl, Text, '#pop'),
+(r'\|\|?|&&?', Punctuation, '#pop'),
+include('text')
+]
+return state
+def _make_arithmetic_state(compound, _nl=_nl, _punct=_punct,
+_string=_string, _variable=_variable, _ws=_ws):
+op = r'=+\-*/!~'
+state = []
+if compound:
+state.append((r'(?=\))', Text, '#pop'))
+state += [
+(r'0[0-7]+', Number.Oct),
+(r'0x[\da-f]+', Number.Hex),
+(r'\d+', Number.Integer),
+(r'[(),]+', Punctuation),
+(r'([%s]|%%|\^\^)+' % op, Operator),
+(r'(%s|%s|(\^[%s]?)?[^()%s%%^"%s%s%s]|\^[%s%s]?%s)+' %
+(_string, _variable, _nl, op, _nl, _punct, _ws, _nl, _ws,
+r'[^)]' if compound else r'[\w\W]'),
+using(this, state='variable')),
+(r'(?=[\x00|&])', Text, '#pop'),
+include('follow')
+]
+return state
+def _make_call_state(compound, _label=_label,
+_label_compound=_label_compound):
+state = []
+if compound:
+state.append((r'(?=\))', Text, '#pop'))
+state.append((r'(:?)(%s)' % (_label_compound if compound else _label),
+bygroups(Punctuation, Name.Label), '#pop'))
+return state
+def _make_label_state(compound, _label=_label,
+_label_compound=_label_compound, _nl=_nl,
+_punct=_punct, _string=_string, _variable=_variable):
+state = []
+if compound:
+state.append((r'(?=\))', Text, '#pop'))
+state.append((r'(%s?)((?:%s|%s|\^[%s]?%s|[^"%%^%s%s%s])*)' %
+(_label_compound if compound else _label, _string,
+_variable, _nl, r'[^)]' if compound else r'[\w\W]', _nl,
+_punct, r')' if compound else ''),
+bygroups(Name.Label, Comment.Single), '#pop'))
+return state
+def _make_redirect_state(compound,
+_core_token_compound=_core_token_compound,
+_nl=_nl, _punct=_punct, _stoken=_stoken,
+_string=_string, _space=_space,
+_variable=_variable, _ws=_ws):
+stoken_compound = (r'(?:[%s]+|(?:%s|%s|%s)+)' %
+(_punct, _string, _variable, _core_token_compound))
+return [
+(r'((?:(?<=[%s%s])\d)?)(>>?&|<&)([%s%s]*)(\d)' %
+(_nl, _ws, _nl, _ws),
+bygroups(Number.Integer, Punctuation, Text, Number.Integer)),
+(r'((?:(?<=[%s%s])(?<!\^[%s])\d)?)(>>?|<)(%s?%s)' %
+(_nl, _ws, _nl, _space, stoken_compound if compound else _stoken),
+bygroups(Number.Integer, Punctuation, using(this, state='text')))
+]
 tokens = {
-'root': [
+'root': _make_begin_state(False),
-# Lines can start with @ to prevent echo
+'follow': _make_follow_state(False),
-(r'^\s*@', Punctuation),
+'arithmetic': _make_arithmetic_state(False),
-(r'^(\s*)(rem\s.*)$', bygroups(Text, Comment)),
+'call': _make_call_state(False),
-(r'".*?"', String.Double),
+'label': _make_label_state(False),
-(r"'.*?'", String.Single),
+'redirect': _make_redirect_state(False),
-# If made more specific, make sure you still allow expansions
+'root/compound': _make_begin_state(True),
-# like %~$VAR:zlt
+'follow/compound': _make_follow_state(True),
-(r'%%?[~$:\w]+%?', Name.Variable),
+'arithmetic/compound': _make_arithmetic_state(True),
-(r'::.*', Comment), # Technically :: only works at BOL
+'call/compound': _make_call_state(True),
-(r'\b(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)),
+'label/compound': _make_label_state(True),
-(r'\b(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)),
+'redirect/compound': _make_redirect_state(True),
-(r'\b(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)),
+'variable-or-escape': [
-(r'\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|'
+(_variable, Name.Variable),
-r'setlocal|shift|errorlevel|exist|defined|cmdextversion|'
+(r'%%%%|\^[%s]?(\^!|[\w\W])' % _nl, String.Escape)
-r'errorlevel|else|cd|md|del|deltree|cls|choice)\b', Keyword),
+],
-(r'\b(equ|neq|lss|leq|gtr|geq)\b', Operator),
+'string': [
-include('basic'),
+(r'"', String.Double, '#pop'),
-(r'.', Text),
+(_variable, Name.Variable),
-],
+(r'\^!|%%', String.Escape),
-'echo': [
+(r'[^"%%^%s]+|[%%^]' % _nl, String.Double),
-# Escapes only valid within echo args?
+default('#pop')
-(r'\^\^|\^<|\^>|\^\|', String.Escape),
+],
-(r'\n', Text, '#pop'),
+'sqstring': [
-include('basic'),
+include('variable-or-escape'),
-(r'[^\'"^]+', Text),
+(r'[^%]+|%', String.Single)
 ],
-'basic': [
+'bqstring': [
-(r'".*?"', String.Double),
+include('variable-or-escape'),
-(r"'.*?'", String.Single),
+(r'[^%]+|%', String.Backtick)
-(r'`.*?`', String.Backtick),
+],
-(r'-?\d+', Number),
+'text': [
-(r',', Punctuation),
+(r'"', String.Double, 'string'),
-(r'=', Operator),
+include('variable-or-escape'),
-(r'/\S+', Name),
+(r'[^"%%^%s%s%s\d)]+|.' % (_nl, _punct, _ws), Text)
-(r':\w+', Name.Label),
+],
-(r'\w:\w+', Text),
+'variable': [
-(r'([<>|])(\s*)(\w+)', bygroups(Punctuation, Text, Name)),
+(r'"', String.Double, 'string'),
-],
+include('variable-or-escape'),
+(r'[^"%%^%s]+|.' % _nl, Name.Variable)
+],
+'for': [
+(r'(%s)(in)(%s)(\()' % (_space, _space),
+bygroups(using(this, state='text'), Keyword,
+using(this, state='text'), Punctuation), '#pop'),
+include('follow')
+],
+'for2': [
+(r'\)', Punctuation),
+(r'(%s)(do%s)' % (_space, _token_terminator),
+bygroups(using(this, state='text'), Keyword), '#pop'),
+(r'[%s]+' % _nl, Text),
+include('follow')
+],
+'for/f': [
+(r'(")((?:%s|[^"])*?")([%s%s]*)(\))' % (_variable, _nl, _ws),
+bygroups(String.Double, using(this, state='string'), Text,
+Punctuation)),
+(r'"', String.Double, ('#pop', 'for2', 'string')),
+(r"('(?:%s|[\w\W])*?')([%s%s]*)(\))" % (_variable, _nl, _ws),
+bygroups(using(this, state='sqstring'), Text, Punctuation)),
+(r'(`(?:%s|[\w\W])*?`)([%s%s]*)(\))' % (_variable, _nl, _ws),
+bygroups(using(this, state='bqstring'), Text, Punctuation)),
+include('for2')
+],
+'for/l': [
+(r'-?\d+', Number.Integer),
+include('for2')
+],
+'if': [
+(r'((?:cmdextversion|errorlevel)%s)(%s)(\d+)' %
+(_token_terminator, _space),
+bygroups(Keyword, using(this, state='text'),
+Number.Integer), '#pop'),
+(r'(defined%s)(%s)(%s)' % (_token_terminator, _space, _stoken),
+bygroups(Keyword, using(this, state='text'),
+using(this, state='variable')), '#pop'),
+(r'(exist%s)(%s%s)' % (_token_terminator, _space, _stoken),
+bygroups(Keyword, using(this, state='text')), '#pop'),
+(r'(%s%s?)(==)(%s?%s)' % (_stoken, _space, _space, _stoken),
+bygroups(using(this, state='text'), Operator,
+using(this, state='text')), '#pop'),
+(r'(%s%s)(%s)(%s%s)' % (_number, _space, _opword, _space, _number),
+bygroups(using(this, state='arithmetic'), Operator.Word,
+using(this, state='arithmetic')), '#pop'),
+(r'(%s%s)(%s)(%s%s)' % (_stoken, _space, _opword, _space, _stoken),
+bygroups(using(this, state='text'), Operator.Word,
+using(this, state='text')), '#pop')
+],
+'(?': [
+(_space, using(this, state='text')),
+(r'\(', Punctuation, ('#pop', 'else?', 'root/compound')),
+default('#pop')
+],
+'else?': [
+(_space, using(this, state='text')),
+(r'else%s' % _token_terminator, Keyword, '#pop'),
+default('#pop')
+]
 }
+class MSDOSSessionLexer(ShellSessionBaseLexer):
+"""
+Lexer for simplistic MSDOS sessions.
+.. versionadded:: 2.1
+"""
+name = 'MSDOS Session'
+aliases = ['doscon']
+filenames = []
+mimetypes = []
+_innerLexerCls = BatchLexer
+_ps1rgx = r'^([^>]+>)(.*\n?)'
+_ps2 = 'More? '
 class TcshLexer(RegexLexer):
 """
 Lexer for tcsh scripts.
 include('root'),
 ],
 }
+class TcshSessionLexer(ShellSessionBaseLexer):
+"""
+Lexer for Tcsh sessions.
+.. versionadded:: 2.1
+"""
+name = 'Tcsh Session'
+aliases = ['tcshcon']
+filenames = []
+mimetypes = []
+_innerLexerCls = TcshLexer
+_ps1rgx = r'^([^>]+>)(.*\n?)'
+_ps2 = '? '
 class PowerShellLexer(RegexLexer):
 """
 For Windows PowerShell code.
 .. versionadded:: 1.5
 """
 name = 'PowerShell'
 aliases = ['powershell', 'posh', 'ps1', 'psm1']
-filenames = ['*.ps1','*.psm1']
+filenames = ['*.ps1', '*.psm1']
 mimetypes = ['text/x-powershell']
 flags = re.DOTALL | re.IGNORECASE | re.MULTILINE
 keywords = (
 (r'\$\(', Punctuation, 'child'),
 (r'[^@\n]+"]', String.Heredoc),
 (r".", String.Heredoc),
 ]
 }
+class PowerShellSessionLexer(ShellSessionBaseLexer):
+"""
+Lexer for simplistic Windows PowerShell sessions.
+.. versionadded:: 2.1
+"""
+name = 'PowerShell Session'
+aliases = ['ps1con']
+filenames = []
+mimetypes = []
+_innerLexerCls = PowerShellLexer
+_ps1rgx = r'^(PS [^>]+> )(.*\n?)'
+_ps2 = '>> '
+class FishShellLexer(RegexLexer):
+"""
+Lexer for Fish shell scripts.
+.. versionadded:: 2.1
+"""
+name = 'Fish'
+aliases = ['fish', 'fishshell']
+filenames = ['*.fish', '*.load']
+mimetypes = ['application/x-fish']
+tokens = {
+'root': [
+include('basic'),
+include('data'),
+include('interp'),
+],
+'interp': [
+(r'\$\(\(', Keyword, 'math'),
+(r'\(', Keyword, 'paren'),
+(r'\$#?(\w+|.)', Name.Variable),
+],
+'basic': [
+(r'\b(begin|end|if|else|while|break|for|in|return|function|block|'
+r'case|continue|switch|not|and|or|set|echo|exit|pwd|true|false|'
+r'cd|count|test)(\s*)\b',
+bygroups(Keyword, Text)),
+(r'\b(alias|bg|bind|breakpoint|builtin|command|commandline|'
+r'complete|contains|dirh|dirs|emit|eval|exec|fg|fish|fish_config|'
+r'fish_indent|fish_pager|fish_prompt|fish_right_prompt|'
+r'fish_update_completions|fishd|funced|funcsave|functions|help|'
+r'history|isatty|jobs|math|mimedb|nextd|open|popd|prevd|psub|'
+r'pushd|random|read|set_color|source|status|trap|type|ulimit|'
+r'umask|vared|fc|getopts|hash|kill|printf|time|wait)\s*\b(?!\.)',
+Name.Builtin),
+(r'#.*\n', Comment),
+(r'\\[\w\W]', String.Escape),
+(r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
+(r'[\[\]()=]', Operator),
+(r'<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
+],
+'data': [
+(r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*"', String.Double),
+(r'"', String.Double, 'string'),
+(r"(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
+(r"(?s)'.*?'", String.Single),
+(r';', Punctuation),
+(r'&|\||\^|<|>', Operator),
+(r'\s+', Text),
+(r'\d+(?= |\Z)', Number),
+(r'[^=\s\[\]{}()$"\'`\\<&|;]+', Text),
+],
+'string': [
+(r'"', String.Double, '#pop'),
+(r'(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+', String.Double),
+include('interp'),
+],
+'paren': [
+(r'\)', Keyword, '#pop'),
+include('root'),
+],
+'math': [
+(r'\)\)', Keyword, '#pop'),
+(r'[-+*/%^|&]|\*\*|\|\|', Operator),
+(r'\d+#\d+', Number),
+(r'\d+#(?! )', Number),
+(r'\d+', Number),
+include('root'),
+],
+}

Mercurial Repositories > eric / file comparison

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

ThirdParty/Pygments/pygments/lexers/shell.py