--- a/mercurial/revsetlang.py Sun Oct 06 09:45:02 2019 -0400
+++ b/mercurial/revsetlang.py Sun Oct 06 09:48:39 2019 -0400
@@ -22,63 +22,63 @@
elements = {
# token-type: binding-strength, primary, prefix, infix, suffix
- "(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None),
- "[": (21, None, None, ("subscript", 1, "]"), None),
- "#": (21, None, None, ("relation", 21), None),
- "##": (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),
- "::": (
+ b"(": (21, None, (b"group", 1, b")"), (b"func", 1, b")"), None),
+ b"[": (21, None, None, (b"subscript", 1, b"]"), None),
+ b"#": (21, None, None, (b"relation", 21), None),
+ b"##": (20, None, None, (b"_concat", 20), None),
+ b"~": (18, None, None, (b"ancestor", 18), None),
+ b"^": (18, None, None, (b"parent", 18), b"parentpost"),
+ b"-": (5, None, (b"negate", 19), (b"minus", 5), None),
+ b"::": (
17,
- "dagrangeall",
- ("dagrangepre", 17),
- ("dagrange", 17),
- "dagrangepost",
+ b"dagrangeall",
+ (b"dagrangepre", 17),
+ (b"dagrange", 17),
+ b"dagrangepost",
),
- "..": (
+ b"..": (
17,
- "dagrangeall",
- ("dagrangepre", 17),
- ("dagrange", 17),
- "dagrangepost",
+ b"dagrangeall",
+ (b"dagrangepre", 17),
+ (b"dagrange", 17),
+ b"dagrangepost",
),
- ":": (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),
- "]": (0, None, None, None, None),
- "symbol": (0, "symbol", None, None, None),
- "string": (0, "string", None, None, None),
- "end": (0, None, None, None, None),
+ b":": (15, b"rangeall", (b"rangepre", 15), (b"range", 15), b"rangepost"),
+ b"not": (10, None, (b"not", 10), None, None),
+ b"!": (10, None, (b"not", 10), None, None),
+ b"and": (5, None, None, (b"and", 5), None),
+ b"&": (5, None, None, (b"and", 5), None),
+ b"%": (5, None, None, (b"only", 5), b"onlypost"),
+ b"or": (4, None, None, (b"or", 4), None),
+ b"|": (4, None, None, (b"or", 4), None),
+ b"+": (4, None, None, (b"or", 4), None),
+ b"=": (3, None, None, (b"keyvalue", 3), None),
+ b",": (2, None, None, (b"list", 2), None),
+ b")": (0, None, None, None, None),
+ b"]": (0, None, None, None, None),
+ b"symbol": (0, b"symbol", None, None, None),
+ b"string": (0, b"string", None, None, None),
+ b"end": (0, None, None, None, None),
}
-keywords = {'and', 'or', 'not'}
+keywords = {b'and', b'or', b'not'}
symbols = {}
-_quoteletters = {'"', "'"}
-_simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%"))
+_quoteletters = {b'"', b"'"}
+_simpleopletters = set(pycompat.iterbytestr(b"()[]#:=,-|&+!~^%"))
# default set of valid characters for the initial letter of symbols
_syminitletters = set(
pycompat.iterbytestr(
pycompat.sysbytes(string.ascii_letters)
+ pycompat.sysbytes(string.digits)
- + '._@'
+ + b'._@'
)
) | set(map(pycompat.bytechr, pycompat.xrange(128, 256)))
# default set of valid characters for non-initial letters of symbols
-_symletters = _syminitletters | set(pycompat.iterbytestr('-/'))
+_symletters = _syminitletters | set(pycompat.iterbytestr(b'-/'))
def tokenize(program, lookup=None, syminitletters=None, symletters=None):
@@ -104,7 +104,7 @@
'''
if not isinstance(program, bytes):
raise error.ProgrammingError(
- 'revset statement must be bytes, got %r' % program
+ b'revset statement must be bytes, got %r' % program
)
program = pycompat.bytestr(program)
if syminitletters is None:
@@ -115,16 +115,16 @@
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)
+ parts = program.split(b':', 1)
if all(lookup(sym) for sym in parts if sym):
if parts[0]:
- yield ('symbol', parts[0], 0)
+ yield (b'symbol', parts[0], 0)
if len(parts) > 1:
s = len(parts[0])
- yield (':', None, s)
+ yield (b':', None, s)
if parts[1]:
- yield ('symbol', parts[1], s + 1)
- yield ('end', None, len(program))
+ yield (b'symbol', parts[1], s + 1)
+ yield (b'end', None, len(program))
return
pos, l = 0, len(program)
@@ -133,28 +133,28 @@
if c.isspace(): # skip inter-token whitespace
pass
elif (
- c == ':' and program[pos : pos + 2] == '::'
+ c == b':' and program[pos : pos + 2] == b'::'
): # look ahead carefully
- yield ('::', None, pos)
+ yield (b'::', None, pos)
pos += 1 # skip ahead
elif (
- c == '.' and program[pos : pos + 2] == '..'
+ c == b'.' and program[pos : pos + 2] == b'..'
): # look ahead carefully
- yield ('..', None, pos)
+ yield (b'..', None, pos)
pos += 1 # skip ahead
elif (
- c == '#' and program[pos : pos + 2] == '##'
+ c == b'#' and program[pos : pos + 2] == b'##'
): # look ahead carefully
- yield ('##', None, pos)
+ yield (b'##', None, pos)
pos += 1 # skip ahead
elif c in _simpleopletters: # handle simple operators
yield (c, None, pos)
elif (
c in _quoteletters
- or c == 'r'
- and program[pos : pos + 2] in ("r'", 'r"')
+ or c == b'r'
+ and program[pos : pos + 2] in (b"r'", b'r"')
): # handle quoted strings
- if c == 'r':
+ if c == b'r':
pos += 1
c = program[pos]
decode = lambda x: x
@@ -164,15 +164,15 @@
s = pos
while pos < l: # find closing quote
d = program[pos]
- if d == '\\': # skip over escaped characters
+ if d == b'\\': # skip over escaped characters
pos += 2
continue
if d == c:
- yield ('string', decode(program[s:pos]), s)
+ yield (b'string', decode(program[s:pos]), s)
break
pos += 1
else:
- raise error.ParseError(_("unterminated string"), s)
+ raise error.ParseError(_(b"unterminated string"), s)
# gather up a symbol/keyword
elif c in syminitletters:
s = pos
@@ -181,38 +181,40 @@
d = program[pos]
if d not in symletters:
break
- if d == '.' and program[pos - 1] == '.': # special case for ..
+ if (
+ d == b'.' and program[pos - 1] == b'.'
+ ): # special case for ..
pos -= 1
break
pos += 1
sym = program[s:pos]
if sym in keywords: # operator keywords
yield (sym, None, s)
- elif '-' in sym:
+ elif b'-' 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)
+ yield (b'symbol', sym, s)
else:
# looks like an expression
- parts = sym.split('-')
+ parts = sym.split(b'-')
for p in parts[:-1]:
if p: # possible consecutive -
- yield ('symbol', p, s)
+ yield (b'symbol', p, s)
s += len(p)
- yield ('-', None, s)
+ yield (b'-', None, s)
s += 1
if parts[-1]: # possible trailing -
- yield ('symbol', parts[-1], s)
+ yield (b'symbol', parts[-1], s)
else:
- yield ('symbol', sym, s)
+ yield (b'symbol', sym, s)
pos -= 1
else:
raise error.ParseError(
- _("syntax error in revset '%s'") % program, pos
+ _(b"syntax error in revset '%s'") % program, pos
)
pos += 1
- yield ('end', None, pos)
+ yield (b'end', None, pos)
# helpers
@@ -221,13 +223,13 @@
def getsymbol(x):
- if x and x[0] == 'symbol':
+ if x and x[0] == b'symbol':
return x[1]
- raise error.ParseError(_('not a symbol'))
+ raise error.ParseError(_(b'not a symbol'))
def getstring(x, err):
- if x and (x[0] == 'string' or x[0] == 'symbol'):
+ if x and (x[0] == b'string' or x[0] == b'symbol'):
return x[1]
raise error.ParseError(err)
@@ -251,7 +253,7 @@
def getlist(x):
if not x:
return []
- if x[0] == 'list':
+ if x[0] == b'list':
return list(x[1:])
return [x]
@@ -260,13 +262,13 @@
if not x:
raise error.ParseError(err)
op = x[0]
- if op == 'range':
+ if op == b'range':
return x[1], x[2]
- elif op == 'rangepre':
+ elif op == b'rangepre':
return None, x[1]
- elif op == 'rangepost':
+ elif op == b'rangepost':
return x[1], None
- elif op == 'rangeall':
+ elif op == b'rangeall':
return None, None
raise error.ParseError(err)
@@ -277,7 +279,7 @@
If any of the sides omitted, and if no default provided, ParseError will
be raised.
"""
- if x and (x[0] == 'string' or x[0] == 'symbol'):
+ if x and (x[0] == b'string' or x[0] == b'symbol'):
n = getinteger(x, err1)
return n, n
a, b = getrange(x, err1)
@@ -296,8 +298,8 @@
getlist(x),
funcname,
parser.splitargspec(keys),
- keyvaluenode='keyvalue',
- keynode='symbol',
+ keyvaluenode=b'keyvalue',
+ keynode=b'symbol',
)
@@ -320,7 +322,7 @@
('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2'))
"""
template = _cachedtree(tmplspec)
- return parser.buildtree(template, ('symbol', '_'), *repls)
+ return parser.buildtree(template, (b'symbol', b'_'), *repls)
def _match(patspec, tree):
@@ -333,12 +335,12 @@
"""
pattern = _cachedtree(patspec)
return parser.matchtree(
- pattern, tree, ('symbol', '_'), {'keyvalue', 'list'}
+ pattern, tree, (b'symbol', b'_'), {b'keyvalue', b'list'}
)
def _matchonly(revs, bases):
- return _match('ancestors(_) and not ancestors(_)', ('and', revs, bases))
+ return _match(b'ancestors(_) and not ancestors(_)', (b'and', revs, bases))
def _fixops(x):
@@ -348,25 +350,25 @@
return x
op = x[0]
- if op == 'parent':
+ if op == b'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]))
- elif x[2][0] == 'dagrangeall':
- return _fixops(('dagrangepost', post))
- elif x[2][0] == 'rangepre':
- return _fixops(('range', post, x[2][1]))
- elif x[2][0] == 'rangeall':
- return _fixops(('rangepost', post))
- elif op == 'or':
+ post = (b'parentpost', x[1])
+ if x[2][0] == b'dagrangepre':
+ return _fixops((b'dagrange', post, x[2][1]))
+ elif x[2][0] == b'dagrangeall':
+ return _fixops((b'dagrangepost', post))
+ elif x[2][0] == b'rangepre':
+ return _fixops((b'range', post, x[2][1]))
+ elif x[2][0] == b'rangeall':
+ return _fixops((b'rangepost', post))
+ elif op == b'or':
# make number of arguments deterministic:
# x + y + z -> (or x y z) -> (or (list x y z))
- return (op, _fixops(('list',) + x[1:]))
- elif op == 'subscript' and x[1][0] == 'relation':
+ return (op, _fixops((b'list',) + x[1:]))
+ elif op == b'subscript' and x[1][0] == b'relation':
# x#y[z] ternary
- return _fixops(('relsubscript', x[1][1], x[1][2], x[2]))
+ return _fixops((b'relsubscript', x[1][1], x[1][2], x[2]))
return (op,) + tuple(_fixops(y) for y in x[1:])
@@ -376,53 +378,53 @@
return x
op = x[0]
- if op == 'minus':
- return _analyze(_build('_ and not _', *x[1:]))
- elif op == 'only':
- return _analyze(_build('only(_, _)', *x[1:]))
- elif op == 'onlypost':
- return _analyze(_build('only(_)', x[1]))
- elif op == 'dagrangeall':
- raise error.ParseError(_("can't use '::' in this context"))
- elif op == 'dagrangepre':
- return _analyze(_build('ancestors(_)', x[1]))
- elif op == 'dagrangepost':
- return _analyze(_build('descendants(_)', x[1]))
- elif op == 'negate':
- s = getstring(x[1], _("can't negate that"))
- return _analyze(('string', '-' + s))
- elif op in ('string', 'symbol', 'smartset'):
+ if op == b'minus':
+ return _analyze(_build(b'_ and not _', *x[1:]))
+ elif op == b'only':
+ return _analyze(_build(b'only(_, _)', *x[1:]))
+ elif op == b'onlypost':
+ return _analyze(_build(b'only(_)', x[1]))
+ elif op == b'dagrangeall':
+ raise error.ParseError(_(b"can't use '::' in this context"))
+ elif op == b'dagrangepre':
+ return _analyze(_build(b'ancestors(_)', x[1]))
+ elif op == b'dagrangepost':
+ return _analyze(_build(b'descendants(_)', x[1]))
+ elif op == b'negate':
+ s = getstring(x[1], _(b"can't negate that"))
+ return _analyze((b'string', b'-' + s))
+ elif op in (b'string', b'symbol', b'smartset'):
return x
- elif op == 'rangeall':
+ elif op == b'rangeall':
return (op, None)
- elif op in {'or', 'not', 'rangepre', 'rangepost', 'parentpost'}:
+ elif op in {b'or', b'not', b'rangepre', b'rangepost', b'parentpost'}:
return (op, _analyze(x[1]))
- elif op == 'group':
+ elif op == b'group':
return _analyze(x[1])
elif op in {
- 'and',
- 'dagrange',
- 'range',
- 'parent',
- 'ancestor',
- 'relation',
- 'subscript',
+ b'and',
+ b'dagrange',
+ b'range',
+ b'parent',
+ b'ancestor',
+ b'relation',
+ b'subscript',
}:
ta = _analyze(x[1])
tb = _analyze(x[2])
return (op, ta, tb)
- elif op == 'relsubscript':
+ elif op == b'relsubscript':
ta = _analyze(x[1])
tb = _analyze(x[2])
tc = _analyze(x[3])
return (op, ta, tb, tc)
- elif op == 'list':
+ elif op == b'list':
return (op,) + tuple(_analyze(y) for y in x[1:])
- elif op == 'keyvalue':
+ elif op == b'keyvalue':
return (op, x[1], _analyze(x[2]))
- elif op == 'func':
+ elif op == b'func':
return (op, x[1], _analyze(x[2]))
- raise ValueError('invalid operator %r' % op)
+ raise ValueError(b'invalid operator %r' % op)
def analyze(x):
@@ -440,30 +442,30 @@
return 0, x
op = x[0]
- if op in ('string', 'symbol', 'smartset'):
+ if op in (b'string', b'symbol', b'smartset'):
return 0.5, x # single revisions are small
- elif op == 'and':
+ elif op == b'and':
wa, ta = _optimize(x[1])
wb, tb = _optimize(x[2])
w = min(wa, wb)
# (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])
+ m = _match(b'_() & ancestors(_)', (b'and', ta, tb))
+ if m and getsymbol(m[1]) in {b'draft', b'secret', b'_notpublic'}:
+ return w, _build(b'_phaseandancestors(_, _)', m[1], m[2])
# (::x and not ::y)/(not ::y and ::x) have a fast path
m = _matchonly(ta, tb) or _matchonly(tb, ta)
if m:
- return w, _build('only(_, _)', *m[1:])
+ return w, _build(b'only(_, _)', *m[1:])
- m = _match('not _', tb)
+ m = _match(b'not _', tb)
if m:
- return wa, ('difference', ta, m[1])
+ return wa, (b'difference', ta, m[1])
if wa > wb:
- op = 'andsmally'
+ op = b'andsmally'
return w, (op, ta, tb)
- elif op == 'or':
+ elif op == b'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 = [], [], []
@@ -474,8 +476,8 @@
if len(ss) == 1:
w, t = ss[0]
else:
- s = '\0'.join(t[1] for w, t in ss)
- y = _build('_list(_)', ('string', s))
+ s = b'\0'.join(t[1] for w, t in ss)
+ y = _build(b'_list(_)', (b'string', s))
w, t = _optimize(y)
ws.append(w)
ts.append(t)
@@ -483,7 +485,7 @@
for y in getlist(x[1]):
w, t = _optimize(y)
- if t is not None and (t[0] == 'string' or t[0] == 'symbol'):
+ if t is not None and (t[0] == b'string' or t[0] == b'symbol'):
ss.append((w, t))
continue
flushss()
@@ -492,48 +494,48 @@
flushss()
if len(ts) == 1:
return ws[0], ts[0] # 'or' operation is fully optimized out
- return max(ws), (op, ('list',) + tuple(ts))
- elif op == 'not':
+ return max(ws), (op, (b'list',) + tuple(ts))
+ elif op == b'not':
# Optimize not public() to _notpublic() because we have a fast version
- if _match('public()', x[1]):
- o = _optimize(_build('_notpublic()'))
+ if _match(b'public()', x[1]):
+ o = _optimize(_build(b'_notpublic()'))
return o[0], o[1]
else:
o = _optimize(x[1])
return o[0], (op, o[1])
- elif op == 'rangeall':
+ elif op == b'rangeall':
return 1, x
- elif op in ('rangepre', 'rangepost', 'parentpost'):
+ elif op in (b'rangepre', b'rangepost', b'parentpost'):
o = _optimize(x[1])
return o[0], (op, o[1])
- elif op in ('dagrange', 'range'):
+ elif op in (b'dagrange', b'range'):
wa, ta = _optimize(x[1])
wb, tb = _optimize(x[2])
return wa + wb, (op, ta, tb)
- elif op in ('parent', 'ancestor', 'relation', 'subscript'):
+ elif op in (b'parent', b'ancestor', b'relation', b'subscript'):
w, t = _optimize(x[1])
return w, (op, t, x[2])
- elif op == 'relsubscript':
+ elif op == b'relsubscript':
w, t = _optimize(x[1])
return w, (op, t, x[2], x[3])
- elif op == 'list':
+ elif op == b'list':
ws, ts = zip(*(_optimize(y) for y in x[1:]))
return sum(ws), (op,) + ts
- elif op == 'keyvalue':
+ elif op == b'keyvalue':
w, t = _optimize(x[2])
return w, (op, x[1], t)
- elif op == 'func':
+ elif op == b'func':
f = getsymbol(x[1])
wa, ta = _optimize(x[2])
w = getattr(symbols.get(f), '_weight', 1)
- m = _match('commonancestors(_)', ta)
+ m = _match(b'commonancestors(_)', ta)
# Optimize heads(commonancestors(_)) because we have a fast version
- if f == 'heads' and m:
- return w + wa, _build('_commonancestorheads(_)', m[1])
+ if f == b'heads' and m:
+ return w + wa, _build(b'_commonancestorheads(_)', m[1])
return w + wa, (op, x[1], ta)
- raise ValueError('invalid operator %r' % op)
+ raise ValueError(b'invalid operator %r' % op)
def optimize(tree):
@@ -547,7 +549,7 @@
# the set of valid characters for the initial letter of symbols in
# alias declarations and definitions
-_aliassyminitletters = _syminitletters | {'$'}
+_aliassyminitletters = _syminitletters | {b'$'}
def _parsewith(spec, lookup=None, syminitletters=None):
@@ -564,21 +566,21 @@
...
ParseError: ('invalid token', 4)
"""
- if lookup and spec.startswith('revset(') and spec.endswith(')'):
+ if lookup and spec.startswith(b'revset(') and spec.endswith(b')'):
lookup = None
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')))
+ raise error.ParseError(_(b'invalid token'), pos)
+ return _fixops(parser.simplifyinfixops(tree, (b'list', b'or')))
class _aliasrules(parser.basealiasrules):
"""Parsing and expansion rule set of revset aliases"""
- _section = _('revset alias')
+ _section = _(b'revset alias')
@staticmethod
def _parse(spec):
@@ -592,7 +594,7 @@
@staticmethod
def _trygetfunc(tree):
- if tree[0] == 'func' and tree[1][0] == 'symbol':
+ if tree[0] == b'func' and tree[1][0] == b'symbol':
return tree[1][1], getlist(tree[2])
@@ -604,7 +606,7 @@
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))
+ warn(_(b'warning: %s\n') % (alias.error))
alias.warned = True
return tree
@@ -613,24 +615,24 @@
"""Fold elements to be concatenated by `##`
"""
if not isinstance(tree, tuple) or tree[0] in (
- 'string',
- 'symbol',
- 'smartset',
+ b'string',
+ b'symbol',
+ b'smartset',
):
return tree
- if tree[0] == '_concat':
+ if tree[0] == b'_concat':
pending = [tree]
l = []
while pending:
e = pending.pop()
- if e[0] == '_concat':
+ if e[0] == b'_concat':
pending.extend(reversed(e[1:]))
- elif e[0] in ('string', 'symbol'):
+ elif e[0] in (b'string', b'symbol'):
l.append(e[1])
else:
- msg = _("\"##\" can't concatenate \"%s\" element") % (e[0])
+ msg = _(b"\"##\" can't concatenate \"%s\" element") % (e[0])
raise error.ParseError(msg)
- return ('string', ''.join(l))
+ return (b'string', b''.join(l))
else:
return tuple(foldconcat(t) for t in tree)
@@ -642,12 +644,12 @@
if len(inst.args) > 1: # has location
loc = inst.args[1]
# Remove newlines -- spaces are equivalent whitespace.
- spec = spec.replace('\n', ' ')
+ spec = spec.replace(b'\n', b' ')
# 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.
- inst.hint = spec + '\n' + ' ' * (loc + 1) + '^ ' + _('here')
+ inst.hint = spec + b'\n' + b' ' * (loc + 1) + b'^ ' + _(b'here')
raise
@@ -663,70 +665,70 @@
>>> _quote(1)
"'1'"
"""
- return "'%s'" % stringutil.escapestr(pycompat.bytestr(s))
+ return b"'%s'" % stringutil.escapestr(pycompat.bytestr(s))
def _formatargtype(c, arg):
- if c == 'd':
- return '_rev(%d)' % int(arg)
- elif c == 's':
+ if c == b'd':
+ return b'_rev(%d)' % int(arg)
+ elif c == b's':
return _quote(arg)
- elif c == 'r':
+ elif c == b'r':
if not isinstance(arg, bytes):
raise TypeError
parse(arg) # make sure syntax errors are confined
- return '(%s)' % arg
- elif c == 'n':
+ return b'(%s)' % arg
+ elif c == b'n':
return _quote(node.hex(arg))
- elif c == 'b':
+ elif c == b'b':
try:
return _quote(arg.branch())
except AttributeError:
raise TypeError
- raise error.ParseError(_('unexpected revspec format character %s') % c)
+ raise error.ParseError(_(b'unexpected revspec format character %s') % c)
def _formatlistexp(s, t):
l = len(s)
if l == 0:
- return "_list('')"
+ return b"_list('')"
elif l == 1:
return _formatargtype(t, s[0])
- elif t == 'd':
+ elif t == b'd':
return _formatintlist(s)
- 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':
+ elif t == b's':
+ return b"_list(%s)" % _quote(b"\0".join(s))
+ elif t == b'n':
+ return b"_hexlist('%s')" % b"\0".join(node.hex(a) for a in s)
+ elif t == b'b':
try:
- return "_list('%s')" % "\0".join(a.branch() for a in s)
+ return b"_list('%s')" % b"\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))
+ return b'(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t))
def _formatintlist(data):
try:
l = len(data)
if l == 0:
- return "_list('')"
+ return b"_list('')"
elif l == 1:
- return _formatargtype('d', data[0])
- return "_intlist('%s')" % "\0".join('%d' % int(a) for a in data)
+ return _formatargtype(b'd', data[0])
+ return b"_intlist('%s')" % b"\0".join(b'%d' % int(a) for a in data)
except (TypeError, ValueError):
- raise error.ParseError(_('invalid argument for revspec'))
+ raise error.ParseError(_(b'invalid argument for revspec'))
def _formatparamexp(args, t):
- return ', '.join(_formatargtype(t, a) for a in args)
+ return b', '.join(_formatargtype(t, a) for a in args)
_formatlistfuncs = {
- 'l': _formatlistexp,
- 'p': _formatparamexp,
+ b'l': _formatlistexp,
+ b'p': _formatparamexp,
}
@@ -772,12 +774,12 @@
for t, arg in parsed:
if t is None:
ret.append(arg)
- elif t == 'baseset':
+ elif t == b'baseset':
if isinstance(arg, set):
arg = sorted(arg)
ret.append(_formatintlist(list(arg)))
else:
- raise error.ProgrammingError("unknown revspec item type: %r" % t)
+ raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
return b''.join(ret)
@@ -789,15 +791,15 @@
for t, arg in parsed:
if t is None:
ret.append(arg)
- elif t == 'baseset':
- newtree = ('smartset', smartset.baseset(arg))
+ elif t == b'baseset':
+ newtree = (b'smartset', smartset.baseset(arg))
inputs.append(newtree)
- ret.append("$")
+ ret.append(b"$")
else:
- raise error.ProgrammingError("unknown revspec item type: %r" % t)
+ raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
expr = b''.join(ret)
tree = _parsewith(expr, syminitletters=_aliassyminitletters)
- tree = parser.buildtree(tree, ('symbol', '$'), *inputs)
+ tree = parser.buildtree(tree, (b'symbol', b'$'), *inputs)
tree = foldconcat(tree)
tree = analyze(tree)
tree = optimize(tree)
@@ -818,7 +820,7 @@
ret = []
pos = 0
while pos < len(expr):
- q = expr.find('%', pos)
+ q = expr.find(b'%', pos)
if q < 0:
ret.append((None, expr[pos:]))
break
@@ -827,8 +829,8 @@
try:
d = expr[pos]
except IndexError:
- raise error.ParseError(_('incomplete revspec format character'))
- if d == '%':
+ raise error.ParseError(_(b'incomplete revspec format character'))
+ if d == b'%':
ret.append((None, d))
pos += 1
continue
@@ -836,45 +838,47 @@
try:
arg = next(argiter)
except StopIteration:
- raise error.ParseError(_('missing argument for revspec'))
+ raise error.ParseError(_(b'missing argument for revspec'))
f = _formatlistfuncs.get(d)
if f:
# a list of some type, might be expensive, do not replace
pos += 1
- islist = d == 'l'
+ islist = d == b'l'
try:
d = expr[pos]
except IndexError:
- raise error.ParseError(_('incomplete revspec format character'))
- if islist and d == 'd' and arg:
+ raise error.ParseError(
+ _(b'incomplete revspec format character')
+ )
+ if islist and d == b'd' and arg:
# 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))
+ ret.append((b'baseset', arg))
pos += 1
continue
try:
ret.append((None, f(list(arg), d)))
except (TypeError, ValueError):
- raise error.ParseError(_('invalid argument for revspec'))
+ raise error.ParseError(_(b'invalid argument for revspec'))
else:
# a single entry, not expensive, replace
try:
ret.append((None, _formatargtype(d, arg)))
except (TypeError, ValueError):
- raise error.ParseError(_('invalid argument for revspec'))
+ raise error.ParseError(_(b'invalid argument for revspec'))
pos += 1
try:
next(argiter)
- raise error.ParseError(_('too many revspec arguments specified'))
+ raise error.ParseError(_(b'too many revspec arguments specified'))
except StopIteration:
pass
return ret
def prettyformat(tree):
- return parser.prettyformat(tree, ('string', 'symbol'))
+ return parser.prettyformat(tree, (b'string', b'symbol'))
def depth(tree):
@@ -885,18 +889,18 @@
def funcsused(tree):
- if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
+ if not isinstance(tree, tuple) or tree[0] in (b'string', b'symbol'):
return set()
else:
funcs = set()
for s in tree[1:]:
funcs |= funcsused(s)
- if tree[0] == 'func':
+ if tree[0] == b'func':
funcs.add(tree[1][1])
return funcs
-_hashre = util.re.compile('[0-9a-fA-F]{1,40}$')
+_hashre = util.re.compile(b'[0-9a-fA-F]{1,40}$')
def _ishashlikesymbol(symbol):
@@ -919,7 +923,7 @@
if not tree:
return []
- if tree[0] == "symbol":
+ if tree[0] == b"symbol":
if _ishashlikesymbol(tree[1]):
return [tree[1]]
elif len(tree) >= 3: