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

-:a3cf077a8db3
+:25f42e208e08
 pygments.lexers.shell
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for various shells.
-:copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 from pygments.util import shebang_matches
 __all__ = ['BashLexer', 'BashSessionLexer', 'TcshLexer', 'BatchLexer',
 'SlurmBashLexer', 'MSDOSSessionLexer', 'PowerShellLexer',
-'PowerShellSessionLexer', 'TcshSessionLexer', 'FishShellLexer']
+'PowerShellSessionLexer', 'TcshSessionLexer', 'FishShellLexer',
+'ExeclineLexer']
 line_re = re.compile('.*?\n')
 class BashLexer(RegexLexer):
 line = match.group()
 if backslash_continuation:
 curcode += line
 backslash_continuation = curcode.endswith('\\\n')
 continue
 venv_match = self._venv.match(line)
 if venv_match:
 venv = venv_match.group(1)
 venv_whitespace = venv_match.group(2)
 insertions.append((len(curcode),
 flags = re.MULTILINE | re.IGNORECASE
 _nl = r'\n\x1a'
 _punct = r'&<>|'
 _ws = r'\t\v\f\r ,;=\xa0'
+_nlws = r'\s\x1a\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 = r'(?:(?:[^%s%s+:^]|\^[%s]?[\w\W])*)' % (_nlws, _punct, _nl)
-_label_compound = (r'(?:(?:[^%s%s%s+:^)]|\^[%s]?[^)])*)' %
+_label_compound = r'(?:(?:[^%s%s+:^)]|\^[%s]?[^)])*)' % (_nlws, _punct, _nl)
-(_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"]*(?:"|(?=[%s])))' % (_nl, _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 = r'(?:(?:(?:\^[%s]?)?[^"%s%s])+)' % (_nl, _nlws, _punct)
-_core_token_compound = r'(?:(?:(?:\^[%s]?)?[^"%s%s%s)])+)' % (_nl, _nl,
+_core_token_compound = r'(?:(?:(?:\^[%s]?)?[^"%s%s)])+)' % (_nl, _nlws, _punct)
-_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))
 include('text')
 ]
 return state
 def _make_arithmetic_state(compound, _nl=_nl, _punct=_punct,
-_string=_string, _variable=_variable, _ws=_ws):
+_string=_string, _variable=_variable,
+_ws=_ws, _nlws=_nlws):
 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)+' %
+(r'(%s|%s|(\^[%s]?)?[^()%s%%\^"%s%s]|\^[%s]?%s)+' %
-(_string, _variable, _nl, op, _nl, _punct, _ws, _nl, _ws,
+(_string, _variable, _nl, op, _nlws, _punct, _nlws,
 r'[^)]' if compound else r'[\w\W]'),
 using(this, state='variable')),
 (r'(?=[\x00|&])', Text, '#pop'),
 include('follow')
 ]
 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):
+_variable=_variable, _nlws=_nlws):
 stoken_compound = (r'(?:[%s]+|(?:%s|%s|%s)+)' %
 (_punct, _string, _variable, _core_token_compound))
 return [
-(r'((?:(?<=[%s%s])\d)?)(>>?&|<&)([%s%s]*)(\d)' %
+(r'((?:(?<=[%s])\d)?)(>>?&|<&)([%s]*)(\d)' %
-(_nl, _ws, _nl, _ws),
+(_nlws, _nlws),
 bygroups(Number.Integer, Punctuation, Text, Number.Integer)),
-(r'((?:(?<=[%s%s])(?<!\^[%s])\d)?)(>>?|<)(%s?%s)' %
+(r'((?:(?<=[%s])(?<!\^[%s])\d)?)(>>?|<)(%s?%s)' %
-(_nl, _ws, _nl, _space, stoken_compound if compound else _stoken),
+(_nlws, _nl, _space, stoken_compound if compound else _stoken),
 bygroups(Number.Integer, Punctuation, using(this, state='text')))
 ]
 tokens = {
 'root': _make_begin_state(False),
 (r'[^%]+|%', String.Backtick)
 ],
 'text': [
 (r'"', String.Double, 'string'),
 include('variable-or-escape'),
-(r'[^"%%^%s%s%s\d)]+|.' % (_nl, _punct, _ws), Text)
+(r'[^"%%^%s%s\d)]+|.' % (_nlws, _punct), Text)
 ],
 'variable': [
 (r'"', String.Double, 'string'),
 include('variable-or-escape'),
 (r'[^"%%^%s]+|.' % _nl, Name.Variable)
 bygroups(using(this, state='text'), Keyword), '#pop'),
 (r'[%s]+' % _nl, Text),
 include('follow')
 ],
 'for/f': [
-(r'(")((?:%s|[^"])*?")([%s%s]*)(\))' % (_variable, _nl, _ws),
+(r'(")((?:%s|[^"])*?")([%s]*)(\))' % (_variable, _nlws),
 bygroups(String.Double, using(this, state='string'), Text,
 Punctuation)),
 (r'"', String.Double, ('#pop', 'for2', 'string')),
-(r"('(?:%%%%|%s|[\w\W])*?')([%s%s]*)(\))" % (_variable, _nl, _ws),
+(r"('(?:%%%%|%s|[\w\W])*?')([%s]*)(\))" % (_variable, _nlws),
 bygroups(using(this, state='sqstring'), Text, Punctuation)),
-(r'(`(?:%%%%|%s|[\w\W])*?`)([%s%s]*)(\))' % (_variable, _nl, _ws),
+(r'(`(?:%%%%|%s|[\w\W])*?`)([%s]*)(\))' % (_variable, _nlws),
 bygroups(using(this, state='bqstring'), Text, Punctuation)),
 include('for2')
 ],
 'for/l': [
 (r'-?\d+', Number.Integer),
 aliases = ['ps1con']
 filenames = []
 mimetypes = []
 _innerLexerCls = PowerShellLexer
-_ps1rgx = re.compile(r'^(PS [^>]+> )(.*\n?)')
+_ps1rgx = re.compile(r'^((?:\[[^]]+\]: )?PS[^>]*> ?)(.*\n?)')
 _ps2 = '>> '
 class FishShellLexer(RegexLexer):
 """
 (r'\d+#(?! )', Number),
 (r'\d+', Number),
 include('root'),
 ],
 }
+class ExeclineLexer(RegexLexer):
+"""
+Lexer for Laurent Bercot's execline language
+(https://skarnet.org/software/execline).
+.. versionadded:: 2.7
+"""
+name = 'execline'
+aliases = ['execline']
+filenames = ['*.exec']
+tokens = {
+'root': [
+include('basic'),
+include('data'),
+include('interp')
+],
+'interp': [
+(r'\$\{', String.Interpol, 'curly'),
+(r'\$[\w@#]+', Name.Variable),  # user variable
+(r'\$', Text),
+],
+'basic': [
+(r'\b(background|backtick|cd|define|dollarat|elgetopt|'
+r'elgetpositionals|elglob|emptyenv|envfile|exec|execlineb|'
+r'exit|export|fdblock|fdclose|fdmove|fdreserve|fdswap|'
+r'forbacktickx|foreground|forstdin|forx|getcwd|getpid|heredoc|'
+r'homeof|if|ifelse|ifte|ifthenelse|importas|loopwhilex|'
+r'multidefine|multisubstitute|pipeline|piperw|posix-cd|'
+r'redirfd|runblock|shift|trap|tryexec|umask|unexport|wait|'
+r'withstdinas)\b', Name.Builtin),
+(r'\A#!.+\n', Comment.Hashbang),
+(r'#.*\n', Comment.Single),
+(r'[{}]', Operator)
+],
+'data': [
+(r'(?s)"(\\.|[^"\\$])*"', String.Double),
+(r'"', String.Double, 'string'),
+(r'\s+', Text),
+(r'[^\s{}$"\\]+', Text)
+],
+'string': [
+(r'"', String.Double, '#pop'),
+(r'(?s)(\\\\|\\.|[^"\\$])+', String.Double),
+include('interp'),
+],
+'curly': [
+(r'\}', String.Interpol, '#pop'),
+(r'[\w#@]+', Name.Variable),
+include('root')
+]
+}
+def analyse_text(text):
+if shebang_matches(text, r'execlineb'):
+return 1

Mercurial Repositories > eric / file comparison

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

eric6/ThirdParty/Pygments/pygments/lexers/shell.py