revsetlang.py
834 lines
| 27.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / revsetlang.py
|
r31024 | # revsetlang.py - parser, tokenizer and utility for revision set language | ||
# | ||||
# Copyright 2010 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
from __future__ import absolute_import | ||||
import string | ||||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
node, | ||||
parser, | ||||
pycompat, | ||||
|
r41257 | smartset, | ||
|
r31606 | util, | ||
|
r31024 | ) | ||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r31024 | |||
elements = { | ||||
# token-type: binding-strength, primary, prefix, infix, suffix | ||||
"(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None), | ||||
|
r33416 | "[": (21, None, None, ("subscript", 1, "]"), None), | ||
"#": (21, None, None, ("relation", 21), None), | ||||
|
r31024 | "##": (20, None, None, ("_concat", 20), None), | ||
"~": (18, None, None, ("ancestor", 18), None), | ||||
"^": (18, None, None, ("parent", 18), "parentpost"), | ||||
"-": (5, None, ("negate", 19), ("minus", 5), None), | ||||
|
r35556 | "::": (17, "dagrangeall", ("dagrangepre", 17), ("dagrange", 17), | ||
"dagrangepost"), | ||||
"..": (17, "dagrangeall", ("dagrangepre", 17), ("dagrange", 17), | ||||
"dagrangepost"), | ||||
|
r31024 | ":": (15, "rangeall", ("rangepre", 15), ("range", 15), "rangepost"), | ||
"not": (10, None, ("not", 10), None, None), | ||||
"!": (10, None, ("not", 10), None, None), | ||||
"and": (5, None, None, ("and", 5), None), | ||||
"&": (5, None, None, ("and", 5), None), | ||||
"%": (5, None, None, ("only", 5), "onlypost"), | ||||
"or": (4, None, None, ("or", 4), None), | ||||
"|": (4, None, None, ("or", 4), None), | ||||
"+": (4, None, None, ("or", 4), None), | ||||
"=": (3, None, None, ("keyvalue", 3), None), | ||||
",": (2, None, None, ("list", 2), None), | ||||
")": (0, None, None, None, None), | ||||
|
r33416 | "]": (0, None, None, None, None), | ||
|
r31024 | "symbol": (0, "symbol", None, None, None), | ||
"string": (0, "string", None, None, None), | ||||
"end": (0, None, None, None, None), | ||||
} | ||||
|
r32291 | keywords = {'and', 'or', 'not'} | ||
|
r31024 | |||
|
r34274 | symbols = {} | ||
|
r32291 | _quoteletters = {'"', "'"} | ||
|
r33416 | _simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%")) | ||
|
r31384 | |||
|
r31024 | # default set of valid characters for the initial letter of symbols | ||
|
r31383 | _syminitletters = set(pycompat.iterbytestr( | ||
string.ascii_letters.encode('ascii') + | ||||
string.digits.encode('ascii') + | ||||
|
r38806 | '._@')) | set(map(pycompat.bytechr, pycompat.xrange(128, 256))) | ||
|
r31024 | |||
# default set of valid characters for non-initial letters of symbols | ||||
|
r31383 | _symletters = _syminitletters | set(pycompat.iterbytestr('-/')) | ||
|
r31024 | |||
def tokenize(program, lookup=None, syminitletters=None, symletters=None): | ||||
''' | ||||
Parse a revset statement into a stream of tokens | ||||
``syminitletters`` is the set of valid characters for the initial | ||||
letter of symbols. | ||||
By default, character ``c`` is recognized as valid for initial | ||||
letter of symbols, if ``c.isalnum() or c in '._@' or ord(c) > 127``. | ||||
``symletters`` is the set of valid characters for non-initial | ||||
letters of symbols. | ||||
By default, character ``c`` is recognized as valid for non-initial | ||||
letters of symbols, if ``c.isalnum() or c in '-._/@' or ord(c) > 127``. | ||||
Check that @ is a valid unquoted token character (issue3686): | ||||
|
r34133 | >>> list(tokenize(b"@::")) | ||
|
r31024 | [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)] | ||
''' | ||||
|
r37793 | if not isinstance(program, bytes): | ||
raise error.ProgrammingError('revset statement must be bytes, got %r' | ||||
% program) | ||||
|
r31441 | program = pycompat.bytestr(program) | ||
|
r31024 | if syminitletters is None: | ||
syminitletters = _syminitletters | ||||
if symletters is None: | ||||
symletters = _symletters | ||||
if program and lookup: | ||||
# attempt to parse old-style ranges first to deal with | ||||
# things like old-tag which contain query metacharacters | ||||
parts = program.split(':', 1) | ||||
if all(lookup(sym) for sym in parts if sym): | ||||
if parts[0]: | ||||
yield ('symbol', parts[0], 0) | ||||
if len(parts) > 1: | ||||
s = len(parts[0]) | ||||
yield (':', None, s) | ||||
if parts[1]: | ||||
yield ('symbol', parts[1], s + 1) | ||||
yield ('end', None, len(program)) | ||||
return | ||||
pos, l = 0, len(program) | ||||
while pos < l: | ||||
|
r31441 | c = program[pos] | ||
|
r31024 | if c.isspace(): # skip inter-token whitespace | ||
pass | ||||
elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully | ||||
yield ('::', None, pos) | ||||
pos += 1 # skip ahead | ||||
elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully | ||||
yield ('..', None, pos) | ||||
pos += 1 # skip ahead | ||||
elif c == '#' and program[pos:pos + 2] == '##': # look ahead carefully | ||||
yield ('##', None, pos) | ||||
pos += 1 # skip ahead | ||||
|
r31384 | elif c in _simpleopletters: # handle simple operators | ||
|
r31024 | yield (c, None, pos) | ||
|
r31384 | elif (c in _quoteletters or c == 'r' and | ||
|
r31024 | program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings | ||
if c == 'r': | ||||
pos += 1 | ||||
|
r31441 | c = program[pos] | ||
|
r31024 | decode = lambda x: x | ||
else: | ||||
decode = parser.unescapestr | ||||
pos += 1 | ||||
s = pos | ||||
while pos < l: # find closing quote | ||||
|
r31441 | d = program[pos] | ||
|
r31024 | if d == '\\': # skip over escaped characters | ||
pos += 2 | ||||
continue | ||||
if d == c: | ||||
yield ('string', decode(program[s:pos]), s) | ||||
break | ||||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
# gather up a symbol/keyword | ||||
elif c in syminitletters: | ||||
s = pos | ||||
pos += 1 | ||||
while pos < l: # find end of symbol | ||||
|
r31441 | d = program[pos] | ||
|
r31024 | if d not in symletters: | ||
break | ||||
|
r31441 | if d == '.' and program[pos - 1] == '.': # special case for .. | ||
|
r31024 | pos -= 1 | ||
break | ||||
pos += 1 | ||||
sym = program[s:pos] | ||||
if sym in keywords: # operator keywords | ||||
yield (sym, None, s) | ||||
elif '-' in sym: | ||||
# some jerk gave us foo-bar-baz, try to check if it's a symbol | ||||
if lookup and lookup(sym): | ||||
# looks like a real symbol | ||||
yield ('symbol', sym, s) | ||||
else: | ||||
# looks like an expression | ||||
parts = sym.split('-') | ||||
for p in parts[:-1]: | ||||
if p: # possible consecutive - | ||||
yield ('symbol', p, s) | ||||
s += len(p) | ||||
|
r39360 | yield ('-', None, s) | ||
|
r31024 | s += 1 | ||
if parts[-1]: # possible trailing - | ||||
yield ('symbol', parts[-1], s) | ||||
else: | ||||
yield ('symbol', sym, s) | ||||
pos -= 1 | ||||
else: | ||||
raise error.ParseError(_("syntax error in revset '%s'") % | ||||
program, pos) | ||||
pos += 1 | ||||
yield ('end', None, pos) | ||||
# helpers | ||||
_notset = object() | ||||
def getsymbol(x): | ||||
if x and x[0] == 'symbol': | ||||
return x[1] | ||||
raise error.ParseError(_('not a symbol')) | ||||
def getstring(x, err): | ||||
if x and (x[0] == 'string' or x[0] == 'symbol'): | ||||
return x[1] | ||||
raise error.ParseError(err) | ||||
def getinteger(x, err, default=_notset): | ||||
if not x and default is not _notset: | ||||
return default | ||||
try: | ||||
return int(getstring(x, err)) | ||||
except ValueError: | ||||
raise error.ParseError(err) | ||||
|
r31997 | def getboolean(x, err): | ||
|
r37102 | value = stringutil.parsebool(getsymbol(x)) | ||
|
r31997 | if value is not None: | ||
return value | ||||
raise error.ParseError(err) | ||||
|
r31024 | def getlist(x): | ||
if not x: | ||||
return [] | ||||
if x[0] == 'list': | ||||
return list(x[1:]) | ||||
return [x] | ||||
def getrange(x, err): | ||||
if not x: | ||||
raise error.ParseError(err) | ||||
op = x[0] | ||||
if op == 'range': | ||||
return x[1], x[2] | ||||
elif op == 'rangepre': | ||||
return None, x[1] | ||||
elif op == 'rangepost': | ||||
return x[1], None | ||||
elif op == 'rangeall': | ||||
return None, None | ||||
raise error.ParseError(err) | ||||
def getargs(x, min, max, err): | ||||
l = getlist(x) | ||||
if len(l) < min or (max >= 0 and len(l) > max): | ||||
raise error.ParseError(err) | ||||
return l | ||||
def getargsdict(x, funcname, keys): | ||||
return parser.buildargsdict(getlist(x), funcname, parser.splitargspec(keys), | ||||
keyvaluenode='keyvalue', keynode='symbol') | ||||
|
r34046 | # cache of {spec: raw parsed tree} built internally | ||
_treecache = {} | ||||
def _cachedtree(spec): | ||||
# thread safe because parse() is reentrant and dict.__setitem__() is atomic | ||||
tree = _treecache.get(spec) | ||||
if tree is None: | ||||
_treecache[spec] = tree = parse(spec) | ||||
return tree | ||||
def _build(tmplspec, *repls): | ||||
"""Create raw parsed tree from a template revset statement | ||||
|
r34133 | >>> _build(b'f(_) and _', (b'string', b'1'), (b'symbol', b'2')) | ||
|
r34046 | ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2')) | ||
""" | ||||
template = _cachedtree(tmplspec) | ||||
return parser.buildtree(template, ('symbol', '_'), *repls) | ||||
|
r34048 | def _match(patspec, tree): | ||
"""Test if a tree matches the given pattern statement; return the matches | ||||
|
r34133 | >>> _match(b'f(_)', parse(b'f()')) | ||
>>> _match(b'f(_)', parse(b'f(1)')) | ||||
|
r34048 | [('func', ('symbol', 'f'), ('symbol', '1')), ('symbol', '1')] | ||
|
r34133 | >>> _match(b'f(_)', parse(b'f(1, 2)')) | ||
|
r34048 | """ | ||
pattern = _cachedtree(patspec) | ||||
return parser.matchtree(pattern, tree, ('symbol', '_'), | ||||
{'keyvalue', 'list'}) | ||||
|
r31024 | def _matchonly(revs, bases): | ||
|
r34048 | return _match('ancestors(_) and not ancestors(_)', ('and', revs, bases)) | ||
|
r31024 | |||
def _fixops(x): | ||||
"""Rewrite raw parsed tree to resolve ambiguous syntax which cannot be | ||||
handled well by our simple top-down parser""" | ||||
if not isinstance(x, tuple): | ||||
return x | ||||
op = x[0] | ||||
if op == 'parent': | ||||
# x^:y means (x^) : y, not x ^ (:y) | ||||
# x^: means (x^) :, not x ^ (:) | ||||
post = ('parentpost', x[1]) | ||||
if x[2][0] == 'dagrangepre': | ||||
return _fixops(('dagrange', post, x[2][1])) | ||||
|
r35556 | elif x[2][0] == 'dagrangeall': | ||
return _fixops(('dagrangepost', post)) | ||||
|
r31024 | elif x[2][0] == 'rangepre': | ||
return _fixops(('range', post, x[2][1])) | ||||
elif x[2][0] == 'rangeall': | ||||
return _fixops(('rangepost', post)) | ||||
elif op == 'or': | ||||
# make number of arguments deterministic: | ||||
# x + y + z -> (or x y z) -> (or (list x y z)) | ||||
return (op, _fixops(('list',) + x[1:])) | ||||
|
r33416 | elif op == 'subscript' and x[1][0] == 'relation': | ||
# x#y[z] ternary | ||||
return _fixops(('relsubscript', x[1][1], x[1][2], x[2])) | ||||
|
r31024 | |||
return (op,) + tuple(_fixops(y) for y in x[1:]) | ||||
|
r34013 | def _analyze(x): | ||
|
r31024 | if x is None: | ||
return x | ||||
op = x[0] | ||||
if op == 'minus': | ||||
|
r34046 | return _analyze(_build('_ and not _', *x[1:])) | ||
|
r31024 | elif op == 'only': | ||
|
r34046 | return _analyze(_build('only(_, _)', *x[1:])) | ||
|
r31024 | elif op == 'onlypost': | ||
|
r34046 | return _analyze(_build('only(_)', x[1])) | ||
|
r35556 | elif op == 'dagrangeall': | ||
raise error.ParseError(_("can't use '::' in this context")) | ||||
|
r31024 | elif op == 'dagrangepre': | ||
|
r34046 | return _analyze(_build('ancestors(_)', x[1])) | ||
|
r31024 | elif op == 'dagrangepost': | ||
|
r34046 | return _analyze(_build('descendants(_)', x[1])) | ||
|
r31024 | elif op == 'negate': | ||
s = getstring(x[1], _("can't negate that")) | ||||
|
r34013 | return _analyze(('string', '-' + s)) | ||
|
r41258 | elif op in ('string', 'symbol', 'smartset'): | ||
|
r31024 | return x | ||
elif op == 'rangeall': | ||||
|
r34013 | return (op, None) | ||
elif op in {'or', 'not', 'rangepre', 'rangepost', 'parentpost'}: | ||||
return (op, _analyze(x[1])) | ||||
|
r31024 | elif op == 'group': | ||
|
r34013 | return _analyze(x[1]) | ||
elif op in {'and', 'dagrange', 'range', 'parent', 'ancestor', 'relation', | ||||
'subscript'}: | ||||
ta = _analyze(x[1]) | ||||
tb = _analyze(x[2]) | ||||
return (op, ta, tb) | ||||
|
r33416 | elif op == 'relsubscript': | ||
|
r34013 | ta = _analyze(x[1]) | ||
tb = _analyze(x[2]) | ||||
tc = _analyze(x[3]) | ||||
return (op, ta, tb, tc) | ||||
|
r31024 | elif op == 'list': | ||
|
r34013 | return (op,) + tuple(_analyze(y) for y in x[1:]) | ||
|
r31024 | elif op == 'keyvalue': | ||
|
r34013 | return (op, x[1], _analyze(x[2])) | ||
|
r31024 | elif op == 'func': | ||
|
r34013 | return (op, x[1], _analyze(x[2])) | ||
|
r31024 | raise ValueError('invalid operator %r' % op) | ||
|
r34013 | def analyze(x): | ||
|
r31024 | """Transform raw parsed tree to evaluatable tree which can be fed to | ||
optimize() or getset() | ||||
All pseudo operations should be mapped to real operations or functions | ||||
defined in methods or symbols table respectively. | ||||
""" | ||||
|
r34013 | return _analyze(x) | ||
|
r31024 | |||
|
r34273 | def _optimize(x): | ||
|
r31024 | if x is None: | ||
return 0, x | ||||
op = x[0] | ||||
|
r41258 | if op in ('string', 'symbol', 'smartset'): | ||
|
r34273 | return 0.5, x # single revisions are small | ||
|
r31024 | elif op == 'and': | ||
|
r34273 | wa, ta = _optimize(x[1]) | ||
wb, tb = _optimize(x[2]) | ||||
|
r31024 | w = min(wa, wb) | ||
|
r34067 | # (draft/secret/_notpublic() & ::x) have a fast path | ||
m = _match('_() & ancestors(_)', ('and', ta, tb)) | ||||
if m and getsymbol(m[1]) in {'draft', 'secret', '_notpublic'}: | ||||
return w, _build('_phaseandancestors(_, _)', m[1], m[2]) | ||||
|
r31024 | # (::x and not ::y)/(not ::y and ::x) have a fast path | ||
|
r34046 | m = _matchonly(ta, tb) or _matchonly(tb, ta) | ||
if m: | ||||
return w, _build('only(_, _)', *m[1:]) | ||||
|
r31024 | |||
|
r34048 | m = _match('not _', tb) | ||
if m: | ||||
return wa, ('difference', ta, m[1]) | ||||
|
r31024 | if wa > wb: | ||
|
r34022 | op = 'andsmally' | ||
|
r34013 | return w, (op, ta, tb) | ||
|
r31024 | elif op == 'or': | ||
# fast path for machine-generated expression, that is likely to have | ||||
# lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()' | ||||
ws, ts, ss = [], [], [] | ||||
def flushss(): | ||||
if not ss: | ||||
return | ||||
if len(ss) == 1: | ||||
w, t = ss[0] | ||||
else: | ||||
s = '\0'.join(t[1] for w, t in ss) | ||||
|
r34046 | y = _build('_list(_)', ('string', s)) | ||
|
r34273 | w, t = _optimize(y) | ||
|
r31024 | ws.append(w) | ||
ts.append(t) | ||||
del ss[:] | ||||
for y in getlist(x[1]): | ||||
|
r34273 | w, t = _optimize(y) | ||
|
r31024 | if t is not None and (t[0] == 'string' or t[0] == 'symbol'): | ||
ss.append((w, t)) | ||||
continue | ||||
flushss() | ||||
ws.append(w) | ||||
ts.append(t) | ||||
flushss() | ||||
if len(ts) == 1: | ||||
return ws[0], ts[0] # 'or' operation is fully optimized out | ||||
|
r34013 | return max(ws), (op, ('list',) + tuple(ts)) | ||
|
r31024 | elif op == 'not': | ||
# Optimize not public() to _notpublic() because we have a fast version | ||||
|
r34048 | if _match('public()', x[1]): | ||
|
r34273 | o = _optimize(_build('_notpublic()')) | ||
|
r31024 | return o[0], o[1] | ||
else: | ||||
|
r34273 | o = _optimize(x[1]) | ||
|
r34013 | return o[0], (op, o[1]) | ||
|
r31024 | elif op == 'rangeall': | ||
|
r34273 | return 1, x | ||
|
r31024 | elif op in ('rangepre', 'rangepost', 'parentpost'): | ||
|
r34273 | o = _optimize(x[1]) | ||
|
r34013 | return o[0], (op, o[1]) | ||
|
r33415 | elif op in ('dagrange', 'range'): | ||
|
r34273 | wa, ta = _optimize(x[1]) | ||
wb, tb = _optimize(x[2]) | ||||
|
r34013 | return wa + wb, (op, ta, tb) | ||
|
r33416 | elif op in ('parent', 'ancestor', 'relation', 'subscript'): | ||
|
r34273 | w, t = _optimize(x[1]) | ||
|
r34013 | return w, (op, t, x[2]) | ||
|
r33416 | elif op == 'relsubscript': | ||
|
r34273 | w, t = _optimize(x[1]) | ||
|
r34013 | return w, (op, t, x[2], x[3]) | ||
|
r31024 | elif op == 'list': | ||
|
r34273 | ws, ts = zip(*(_optimize(y) for y in x[1:])) | ||
|
r31024 | return sum(ws), (op,) + ts | ||
elif op == 'keyvalue': | ||||
|
r34273 | w, t = _optimize(x[2]) | ||
|
r31024 | return w, (op, x[1], t) | ||
elif op == 'func': | ||||
f = getsymbol(x[1]) | ||||
|
r34273 | wa, ta = _optimize(x[2]) | ||
|
r34274 | w = getattr(symbols.get(f), '_weight', 1) | ||
|
r38644 | m = _match('commonancestors(_)', ta) | ||
# Optimize heads(commonancestors(_)) because we have a fast version | ||||
if f == 'heads' and m: | ||||
return w + wa, _build('_commonancestorheads(_)', m[1]) | ||||
|
r34013 | return w + wa, (op, x[1], ta) | ||
|
r31024 | raise ValueError('invalid operator %r' % op) | ||
def optimize(tree): | ||||
"""Optimize evaluatable tree | ||||
All pseudo operations should be transformed beforehand. | ||||
""" | ||||
|
r34273 | _weight, newtree = _optimize(tree) | ||
|
r31024 | return newtree | ||
# the set of valid characters for the initial letter of symbols in | ||||
# alias declarations and definitions | ||||
|
r34071 | _aliassyminitletters = _syminitletters | {'$'} | ||
|
r31024 | |||
def _parsewith(spec, lookup=None, syminitletters=None): | ||||
"""Generate a parse tree of given spec with given tokenizing options | ||||
|
r34133 | >>> _parsewith(b'foo($1)', syminitletters=_aliassyminitletters) | ||
|
r31024 | ('func', ('symbol', 'foo'), ('symbol', '$1')) | ||
|
r34133 | >>> _parsewith(b'$1') | ||
|
r31024 | Traceback (most recent call last): | ||
... | ||||
ParseError: ("syntax error in revset '$1'", 0) | ||||
|
r34133 | >>> _parsewith(b'foo bar') | ||
|
r31024 | Traceback (most recent call last): | ||
... | ||||
ParseError: ('invalid token', 4) | ||||
""" | ||||
|
r37778 | if lookup and spec.startswith('revset(') and spec.endswith(')'): | ||
lookup = None | ||||
|
r31024 | p = parser.parser(elements) | ||
tree, pos = p.parse(tokenize(spec, lookup=lookup, | ||||
syminitletters=syminitletters)) | ||||
if pos != len(spec): | ||||
raise error.ParseError(_('invalid token'), pos) | ||||
return _fixops(parser.simplifyinfixops(tree, ('list', 'or'))) | ||||
class _aliasrules(parser.basealiasrules): | ||||
"""Parsing and expansion rule set of revset aliases""" | ||||
_section = _('revset alias') | ||||
@staticmethod | ||||
def _parse(spec): | ||||
"""Parse alias declaration/definition ``spec`` | ||||
This allows symbol names to use also ``$`` as an initial letter | ||||
(for backward compatibility), and callers of this function should | ||||
examine whether ``$`` is used also for unexpected symbols or not. | ||||
""" | ||||
return _parsewith(spec, syminitletters=_aliassyminitletters) | ||||
@staticmethod | ||||
def _trygetfunc(tree): | ||||
if tree[0] == 'func' and tree[1][0] == 'symbol': | ||||
return tree[1][1], getlist(tree[2]) | ||||
|
r33336 | def expandaliases(tree, aliases, warn=None): | ||
"""Expand aliases in a tree, aliases is a list of (name, value) tuples""" | ||||
aliases = _aliasrules.buildmap(aliases) | ||||
|
r31024 | tree = _aliasrules.expand(aliases, tree) | ||
# warn about problematic (but not referred) aliases | ||||
|
r33336 | if warn is not None: | ||
for name, alias in sorted(aliases.iteritems()): | ||||
if alias.error and not alias.warned: | ||||
warn(_('warning: %s\n') % (alias.error)) | ||||
alias.warned = True | ||||
|
r31024 | return tree | ||
def foldconcat(tree): | ||||
"""Fold elements to be concatenated by `##` | ||||
""" | ||||
|
r41258 | if (not isinstance(tree, tuple) | ||
or tree[0] in ('string', 'symbol', 'smartset')): | ||||
|
r31024 | return tree | ||
if tree[0] == '_concat': | ||||
pending = [tree] | ||||
l = [] | ||||
while pending: | ||||
e = pending.pop() | ||||
if e[0] == '_concat': | ||||
pending.extend(reversed(e[1:])) | ||||
elif e[0] in ('string', 'symbol'): | ||||
l.append(e[1]) | ||||
else: | ||||
msg = _("\"##\" can't concatenate \"%s\" element") % (e[0]) | ||||
raise error.ParseError(msg) | ||||
return ('string', ''.join(l)) | ||||
else: | ||||
return tuple(foldconcat(t) for t in tree) | ||||
def parse(spec, lookup=None): | ||||
|
r36703 | try: | ||
return _parsewith(spec, lookup=lookup) | ||||
except error.ParseError as inst: | ||||
if len(inst.args) > 1: # has location | ||||
|
r36709 | loc = inst.args[1] | ||
|
r36703 | # Remove newlines -- spaces are equivalent whitespace. | ||
spec = spec.replace('\n', ' ') | ||||
# We want the caret to point to the place in the template that | ||||
# failed to parse, but in a hint we get a open paren at the | ||||
# start. Therefore, we print "loc + 1" spaces (instead of "loc") | ||||
# to line up the caret with the location of the error. | ||||
|
r36709 | inst.hint = spec + '\n' + ' ' * (loc + 1) + '^ ' + _('here') | ||
|
r36703 | raise | ||
|
r31024 | |||
|
r31604 | def _quote(s): | ||
|
r31605 | r"""Quote a value in order to make it safe for the revset engine. | ||
|
r34133 | >>> _quote(b'asdf') | ||
|
r31605 | "'asdf'" | ||
|
r34133 | >>> _quote(b"asdf'\"") | ||
|
r31605 | '\'asdf\\\'"\'' | ||
|
r34133 | >>> _quote(b'asdf\'') | ||
|
r31606 | "'asdf\\''" | ||
|
r31605 | >>> _quote(1) | ||
"'1'" | ||||
""" | ||||
|
r37102 | return "'%s'" % stringutil.escapestr(pycompat.bytestr(s)) | ||
|
r31604 | |||
|
r35614 | def _formatargtype(c, arg): | ||
if c == 'd': | ||||
|
r41254 | return 'rev(%d)' % int(arg) | ||
|
r35614 | elif c == 's': | ||
return _quote(arg) | ||||
elif c == 'r': | ||||
|
r37793 | if not isinstance(arg, bytes): | ||
raise TypeError | ||||
|
r35614 | parse(arg) # make sure syntax errors are confined | ||
return '(%s)' % arg | ||||
elif c == 'n': | ||||
return _quote(node.hex(arg)) | ||||
elif c == 'b': | ||||
try: | ||||
return _quote(arg.branch()) | ||||
except AttributeError: | ||||
raise TypeError | ||||
raise error.ParseError(_('unexpected revspec format character %s') % c) | ||||
def _formatlistexp(s, t): | ||||
l = len(s) | ||||
if l == 0: | ||||
return "_list('')" | ||||
elif l == 1: | ||||
return _formatargtype(t, s[0]) | ||||
elif t == 'd': | ||||
|
r41256 | return _formatintlist(s) | ||
|
r35614 | elif t == 's': | ||
return "_list(%s)" % _quote("\0".join(s)) | ||||
elif t == 'n': | ||||
return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s) | ||||
elif t == 'b': | ||||
try: | ||||
return "_list('%s')" % "\0".join(a.branch() for a in s) | ||||
except AttributeError: | ||||
raise TypeError | ||||
m = l // 2 | ||||
return '(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t)) | ||||
|
r41256 | def _formatintlist(data): | ||
try: | ||||
l = len(data) | ||||
if l == 0: | ||||
return "_list('')" | ||||
elif l == 1: | ||||
return _formatargtype('d', data[0]) | ||||
return "_intlist('%s')" % "\0".join('%d' % int(a) for a in data) | ||||
except (TypeError, ValueError): | ||||
raise error.ParseError(_('invalid argument for revspec')) | ||||
|
r35615 | def _formatparamexp(args, t): | ||
return ', '.join(_formatargtype(t, a) for a in args) | ||||
_formatlistfuncs = { | ||||
'l': _formatlistexp, | ||||
'p': _formatparamexp, | ||||
} | ||||
|
r31024 | def formatspec(expr, *args): | ||
''' | ||||
This is a convenience function for using revsets internally, and | ||||
escapes arguments appropriately. Aliases are intentionally ignored | ||||
so that intended expression behavior isn't accidentally subverted. | ||||
Supported arguments: | ||||
%r = revset expression, parenthesized | ||||
|
r41254 | %d = rev(int(arg)), no quoting | ||
|
r31024 | %s = string(arg), escaped and single-quoted | ||
%b = arg.branch(), escaped and single-quoted | ||||
%n = hex(arg), single-quoted | ||||
%% = a literal '%' | ||||
|
r35615 | Prefixing the type with 'l' specifies a parenthesized list of that type, | ||
and 'p' specifies a list of function parameters of that type. | ||||
|
r31024 | |||
|
r34133 | >>> formatspec(b'%r:: and %lr', b'10 or 11', (b"this()", b"that()")) | ||
|
r31024 | '(10 or 11):: and ((this()) or (that()))' | ||
|
r34133 | >>> formatspec(b'%d:: and not %d::', 10, 20) | ||
|
r41254 | 'rev(10):: and not rev(20)::' | ||
|
r34133 | >>> formatspec(b'%ld or %ld', [], [1]) | ||
|
r41254 | "_list('') or rev(1)" | ||
|
r34133 | >>> formatspec(b'keyword(%s)', b'foo\\xe9') | ||
|
r31024 | "keyword('foo\\\\xe9')" | ||
|
r34133 | >>> b = lambda: b'default' | ||
|
r31024 | >>> b.branch = b | ||
|
r34133 | >>> formatspec(b'branch(%b)', b) | ||
|
r31024 | "branch('default')" | ||
|
r34133 | >>> formatspec(b'root(%ls)', [b'a', b'b', b'c', b'd']) | ||
|
r35613 | "root(_list('a\\\\x00b\\\\x00c\\\\x00d'))" | ||
|
r35615 | >>> formatspec(b'sort(%r, %ps)', b':', [b'desc', b'user']) | ||
"sort((:), 'desc', 'user')" | ||||
|
r35840 | >>> formatspec(b'%ls', [b'a', b"'"]) | ||
|
r35613 | "_list('a\\\\x00\\\\'')" | ||
|
r31024 | ''' | ||
|
r41255 | parsed = _parseargs(expr, args) | ||
ret = [] | ||||
for t, arg in parsed: | ||||
if t is None: | ||||
ret.append(arg) | ||||
|
r41257 | elif t == 'baseset': | ||
if isinstance(arg, set): | ||||
arg = sorted(arg) | ||||
ret.append(_formatintlist(list(arg))) | ||||
|
r41255 | else: | ||
raise error.ProgrammingError("unknown revspec item type: %r" % t) | ||||
return b''.join(ret) | ||||
|
r41258 | def spectree(expr, *args): | ||
"""similar to formatspec but return a parsed and optimized tree""" | ||||
parsed = _parseargs(expr, args) | ||||
ret = [] | ||||
inputs = [] | ||||
for t, arg in parsed: | ||||
if t is None: | ||||
ret.append(arg) | ||||
elif t == 'baseset': | ||||
newtree = ('smartset', smartset.baseset(arg)) | ||||
inputs.append(newtree) | ||||
ret.append("$") | ||||
else: | ||||
raise error.ProgrammingError("unknown revspec item type: %r" % t) | ||||
expr = b''.join(ret) | ||||
tree = _parsewith(expr, syminitletters=_aliassyminitletters) | ||||
tree = parser.buildtree(tree, ('symbol', '$'), *inputs) | ||||
tree = foldconcat(tree) | ||||
tree = analyze(tree) | ||||
tree = optimize(tree) | ||||
return tree | ||||
|
r41255 | def _parseargs(expr, args): | ||
"""parse the expression and replace all inexpensive args | ||||
return a list of tuple [(arg-type, arg-value)] | ||||
Arg-type can be: | ||||
|
r41257 | * None: a string ready to be concatenated into a final spec | ||
* 'baseset': an iterable of revisions | ||||
|
r41255 | """ | ||
|
r31440 | expr = pycompat.bytestr(expr) | ||
|
r35574 | argiter = iter(args) | ||
|
r35571 | ret = [] | ||
|
r31024 | pos = 0 | ||
while pos < len(expr): | ||||
|
r35572 | q = expr.find('%', pos) | ||
if q < 0: | ||||
|
r41255 | ret.append((None, expr[pos:])) | ||
|
r35572 | break | ||
|
r41255 | ret.append((None, expr[pos:q])) | ||
|
r35572 | pos = q + 1 | ||
|
r35611 | try: | ||
d = expr[pos] | ||||
except IndexError: | ||||
raise error.ParseError(_('incomplete revspec format character')) | ||||
|
r35573 | if d == '%': | ||
|
r41255 | ret.append((None, d)) | ||
|
r35610 | pos += 1 | ||
continue | ||||
try: | ||||
arg = next(argiter) | ||||
except StopIteration: | ||||
raise error.ParseError(_('missing argument for revspec')) | ||||
|
r35615 | f = _formatlistfuncs.get(d) | ||
if f: | ||||
|
r41255 | # a list of some type, might be expensive, do not replace | ||
|
r35573 | pos += 1 | ||
|
r41257 | islist = (d == 'l') | ||
|
r35611 | try: | ||
d = expr[pos] | ||||
except IndexError: | ||||
raise error.ParseError(_('incomplete revspec format character')) | ||||
|
r41257 | if islist and d == 'd' and arg: | ||
|
r41275 | # we don't create a baseset yet, because it come with an | ||
# extra cost. If we are going to serialize it we better | ||||
# skip it. | ||||
ret.append(('baseset', arg)) | ||||
pos += 1 | ||||
continue | ||||
|
r35612 | try: | ||
|
r41255 | ret.append((None, f(list(arg), d))) | ||
|
r35612 | except (TypeError, ValueError): | ||
raise error.ParseError(_('invalid argument for revspec')) | ||||
|
r35573 | else: | ||
|
r41255 | # a single entry, not expensive, replace | ||
|
r35612 | try: | ||
|
r41255 | ret.append((None, _formatargtype(d, arg))) | ||
|
r35612 | except (TypeError, ValueError): | ||
raise error.ParseError(_('invalid argument for revspec')) | ||||
|
r31024 | pos += 1 | ||
|
r35610 | try: | ||
next(argiter) | ||||
raise error.ParseError(_('too many revspec arguments specified')) | ||||
except StopIteration: | ||||
pass | ||||
|
r41255 | return ret | ||
|
r31024 | |||
def prettyformat(tree): | ||||
return parser.prettyformat(tree, ('string', 'symbol')) | ||||
def depth(tree): | ||||
if isinstance(tree, tuple): | ||||
return max(map(depth, tree)) + 1 | ||||
else: | ||||
return 0 | ||||
def funcsused(tree): | ||||
if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'): | ||||
return set() | ||||
else: | ||||
funcs = set() | ||||
for s in tree[1:]: | ||||
funcs |= funcsused(s) | ||||
if tree[0] == 'func': | ||||
funcs.add(tree[1][1]) | ||||
return funcs | ||||
|
r35510 | |||
_hashre = util.re.compile('[0-9a-fA-F]{1,40}$') | ||||
def _ishashlikesymbol(symbol): | ||||
"""returns true if the symbol looks like a hash""" | ||||
return _hashre.match(symbol) | ||||
def gethashlikesymbols(tree): | ||||
"""returns the list of symbols of the tree that look like hashes | ||||
|
r35900 | >>> gethashlikesymbols(parse(b'3::abe3ff')) | ||
|
r35510 | ['3', 'abe3ff'] | ||
|
r35900 | >>> gethashlikesymbols(parse(b'precursors(.)')) | ||
|
r35510 | [] | ||
|
r35900 | >>> gethashlikesymbols(parse(b'precursors(34)')) | ||
|
r35510 | ['34'] | ||
|
r35900 | >>> gethashlikesymbols(parse(b'abe3ffZ')) | ||
|
r35510 | [] | ||
""" | ||||
if not tree: | ||||
return [] | ||||
if tree[0] == "symbol": | ||||
if _ishashlikesymbol(tree[1]): | ||||
return [tree[1]] | ||||
elif len(tree) >= 3: | ||||
results = [] | ||||
for subtree in tree[1:]: | ||||
results += gethashlikesymbols(subtree) | ||||
return results | ||||
return [] | ||||