Mercurial > public > mercurial-scm > hg

comparison mercurial/revsetlang.py @ 43077:687b865b95ad

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
formatting: byteify all mercurial/ and hgext/ string literals Done with python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py') black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**') # skip-blame mass-reformatting only Differential Revision: https://phab.mercurial-scm.org/D6972
author Augie Fackler <augie@google.com>
date Sun, 06 Oct 2019 09:48:39 -0400
parents 2372284d9457
children c59eb1560c44
comparison
equal deleted inserted replaced
43076:2372284d9457 43077:687b865b95ad
20 ) 20 )
21 from .utils import stringutil 21 from .utils import stringutil
22 22
23 elements = { 23 elements = {
24 # token-type: binding-strength, primary, prefix, infix, suffix 24 # token-type: binding-strength, primary, prefix, infix, suffix
25 "(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None), 25 b"(": (21, None, (b"group", 1, b")"), (b"func", 1, b")"), None),
26 "[": (21, None, None, ("subscript", 1, "]"), None), 26 b"[": (21, None, None, (b"subscript", 1, b"]"), None),
27 "#": (21, None, None, ("relation", 21), None), 27 b"#": (21, None, None, (b"relation", 21), None),
28 "##": (20, None, None, ("_concat", 20), None), 28 b"##": (20, None, None, (b"_concat", 20), None),
29 "~": (18, None, None, ("ancestor", 18), None), 29 b"~": (18, None, None, (b"ancestor", 18), None),
30 "^": (18, None, None, ("parent", 18), "parentpost"), 30 b"^": (18, None, None, (b"parent", 18), b"parentpost"),
31 "-": (5, None, ("negate", 19), ("minus", 5), None), 31 b"-": (5, None, (b"negate", 19), (b"minus", 5), None),
32 "::": ( 32 b"::": (
33 17, 33 17,
34 "dagrangeall", 34 b"dagrangeall",
35 ("dagrangepre", 17), 35 (b"dagrangepre", 17),
36 ("dagrange", 17), 36 (b"dagrange", 17),
37 "dagrangepost", 37 b"dagrangepost",
38 ), 38 ),
39 "..": ( 39 b"..": (
40 17, 40 17,
41 "dagrangeall", 41 b"dagrangeall",
42 ("dagrangepre", 17), 42 (b"dagrangepre", 17),
43 ("dagrange", 17), 43 (b"dagrange", 17),
44 "dagrangepost", 44 b"dagrangepost",
45 ), 45 ),
46 ":": (15, "rangeall", ("rangepre", 15), ("range", 15), "rangepost"), 46 b":": (15, b"rangeall", (b"rangepre", 15), (b"range", 15), b"rangepost"),
47 "not": (10, None, ("not", 10), None, None), 47 b"not": (10, None, (b"not", 10), None, None),
48 "!": (10, None, ("not", 10), None, None), 48 b"!": (10, None, (b"not", 10), None, None),
49 "and": (5, None, None, ("and", 5), None), 49 b"and": (5, None, None, (b"and", 5), None),
50 "&": (5, None, None, ("and", 5), None), 50 b"&": (5, None, None, (b"and", 5), None),
51 "%": (5, None, None, ("only", 5), "onlypost"), 51 b"%": (5, None, None, (b"only", 5), b"onlypost"),
52 "or": (4, None, None, ("or", 4), None), 52 b"or": (4, None, None, (b"or", 4), None),
53 "|": (4, None, None, ("or", 4), None), 53 b"|": (4, None, None, (b"or", 4), None),
54 "+": (4, None, None, ("or", 4), None), 54 b"+": (4, None, None, (b"or", 4), None),
55 "=": (3, None, None, ("keyvalue", 3), None), 55 b"=": (3, None, None, (b"keyvalue", 3), None),
56 ",": (2, None, None, ("list", 2), None), 56 b",": (2, None, None, (b"list", 2), None),
57 ")": (0, None, None, None, None), 57 b")": (0, None, None, None, None),
58 "]": (0, None, None, None, None), 58 b"]": (0, None, None, None, None),
59 "symbol": (0, "symbol", None, None, None), 59 b"symbol": (0, b"symbol", None, None, None),
60 "string": (0, "string", None, None, None), 60 b"string": (0, b"string", None, None, None),
61 "end": (0, None, None, None, None), 61 b"end": (0, None, None, None, None),
62 } 62 }
63 63
64 keywords = {'and', 'or', 'not'} 64 keywords = {b'and', b'or', b'not'}
65 65
66 symbols = {} 66 symbols = {}
67 67
68 _quoteletters = {'"', "'"} 68 _quoteletters = {b'"', b"'"}
69 _simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%")) 69 _simpleopletters = set(pycompat.iterbytestr(b"()[]#:=,-|&+!~^%"))
70 70
71 # default set of valid characters for the initial letter of symbols 71 # default set of valid characters for the initial letter of symbols
72 _syminitletters = set( 72 _syminitletters = set(
73 pycompat.iterbytestr( 73 pycompat.iterbytestr(
74 pycompat.sysbytes(string.ascii_letters) 74 pycompat.sysbytes(string.ascii_letters)
75 + pycompat.sysbytes(string.digits) 75 + pycompat.sysbytes(string.digits)
76 + '._@' 76 + b'._@'
77 ) 77 )
78 ) | set(map(pycompat.bytechr, pycompat.xrange(128, 256))) 78 ) | set(map(pycompat.bytechr, pycompat.xrange(128, 256)))
79 79
80 # default set of valid characters for non-initial letters of symbols 80 # default set of valid characters for non-initial letters of symbols
81 _symletters = _syminitletters | set(pycompat.iterbytestr('-/')) 81 _symletters = _syminitletters | set(pycompat.iterbytestr(b'-/'))
82 82
83 83
84 def tokenize(program, lookup=None, syminitletters=None, symletters=None): 84 def tokenize(program, lookup=None, syminitletters=None, symletters=None):
85 ''' 85 '''
86 Parse a revset statement into a stream of tokens 86 Parse a revset statement into a stream of tokens
102 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)] 102 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
103 103
104 ''' 104 '''
105 if not isinstance(program, bytes): 105 if not isinstance(program, bytes):
106 raise error.ProgrammingError( 106 raise error.ProgrammingError(
107 'revset statement must be bytes, got %r' % program 107 b'revset statement must be bytes, got %r' % program
108 ) 108 )
109 program = pycompat.bytestr(program) 109 program = pycompat.bytestr(program)
110 if syminitletters is None: 110 if syminitletters is None:
111 syminitletters = _syminitletters 111 syminitletters = _syminitletters
112 if symletters is None: 112 if symletters is None:
113 symletters = _symletters 113 symletters = _symletters
114 114
115 if program and lookup: 115 if program and lookup:
116 # attempt to parse old-style ranges first to deal with 116 # attempt to parse old-style ranges first to deal with
117 # things like old-tag which contain query metacharacters 117 # things like old-tag which contain query metacharacters
118 parts = program.split(':', 1) 118 parts = program.split(b':', 1)
119 if all(lookup(sym) for sym in parts if sym): 119 if all(lookup(sym) for sym in parts if sym):
120 if parts[0]: 120 if parts[0]:
121 yield ('symbol', parts[0], 0) 121 yield (b'symbol', parts[0], 0)
122 if len(parts) > 1: 122 if len(parts) > 1:
123 s = len(parts[0]) 123 s = len(parts[0])
124 yield (':', None, s) 124 yield (b':', None, s)
125 if parts[1]: 125 if parts[1]:
126 yield ('symbol', parts[1], s + 1) 126 yield (b'symbol', parts[1], s + 1)
127 yield ('end', None, len(program)) 127 yield (b'end', None, len(program))
128 return 128 return
129 129
130 pos, l = 0, len(program) 130 pos, l = 0, len(program)
131 while pos < l: 131 while pos < l:
132 c = program[pos] 132 c = program[pos]
133 if c.isspace(): # skip inter-token whitespace 133 if c.isspace(): # skip inter-token whitespace
134 pass 134 pass
135 elif ( 135 elif (
136 c == ':' and program[pos : pos + 2] == '::' 136 c == b':' and program[pos : pos + 2] == b'::'
137 ): # look ahead carefully 137 ): # look ahead carefully
138 yield ('::', None, pos) 138 yield (b'::', None, pos)
139 pos += 1 # skip ahead 139 pos += 1 # skip ahead
140 elif ( 140 elif (
141 c == '.' and program[pos : pos + 2] == '..' 141 c == b'.' and program[pos : pos + 2] == b'..'
142 ): # look ahead carefully 142 ): # look ahead carefully
143 yield ('..', None, pos) 143 yield (b'..', None, pos)
144 pos += 1 # skip ahead 144 pos += 1 # skip ahead
145 elif ( 145 elif (
146 c == '#' and program[pos : pos + 2] == '##' 146 c == b'#' and program[pos : pos + 2] == b'##'
147 ): # look ahead carefully 147 ): # look ahead carefully
148 yield ('##', None, pos) 148 yield (b'##', None, pos)
149 pos += 1 # skip ahead 149 pos += 1 # skip ahead
150 elif c in _simpleopletters: # handle simple operators 150 elif c in _simpleopletters: # handle simple operators
151 yield (c, None, pos) 151 yield (c, None, pos)
152 elif ( 152 elif (
153 c in _quoteletters 153 c in _quoteletters
154 or c == 'r' 154 or c == b'r'
155 and program[pos : pos + 2] in ("r'", 'r"') 155 and program[pos : pos + 2] in (b"r'", b'r"')
156 ): # handle quoted strings 156 ): # handle quoted strings
157 if c == 'r': 157 if c == b'r':
158 pos += 1 158 pos += 1
159 c = program[pos] 159 c = program[pos]
160 decode = lambda x: x 160 decode = lambda x: x
161 else: 161 else:
162 decode = parser.unescapestr 162 decode = parser.unescapestr
163 pos += 1 163 pos += 1
164 s = pos 164 s = pos
165 while pos < l: # find closing quote 165 while pos < l: # find closing quote
166 d = program[pos] 166 d = program[pos]
167 if d == '\\': # skip over escaped characters 167 if d == b'\\': # skip over escaped characters
168 pos += 2 168 pos += 2
169 continue 169 continue
170 if d == c: 170 if d == c:
171 yield ('string', decode(program[s:pos]), s) 171 yield (b'string', decode(program[s:pos]), s)
172 break 172 break
173 pos += 1 173 pos += 1
174 else: 174 else:
175 raise error.ParseError(_("unterminated string"), s) 175 raise error.ParseError(_(b"unterminated string"), s)
176 # gather up a symbol/keyword 176 # gather up a symbol/keyword
177 elif c in syminitletters: 177 elif c in syminitletters:
178 s = pos 178 s = pos
179 pos += 1 179 pos += 1
180 while pos < l: # find end of symbol 180 while pos < l: # find end of symbol
181 d = program[pos] 181 d = program[pos]
182 if d not in symletters: 182 if d not in symletters:
183 break 183 break
184 if d == '.' and program[pos - 1] == '.': # special case for .. 184 if (
185 d == b'.' and program[pos - 1] == b'.'
186 ): # special case for ..
185 pos -= 1 187 pos -= 1
186 break 188 break
187 pos += 1 189 pos += 1
188 sym = program[s:pos] 190 sym = program[s:pos]
189 if sym in keywords: # operator keywords 191 if sym in keywords: # operator keywords
190 yield (sym, None, s) 192 yield (sym, None, s)
191 elif '-' in sym: 193 elif b'-' in sym:
192 # some jerk gave us foo-bar-baz, try to check if it's a symbol 194 # some jerk gave us foo-bar-baz, try to check if it's a symbol
193 if lookup and lookup(sym): 195 if lookup and lookup(sym):
194 # looks like a real symbol 196 # looks like a real symbol
195 yield ('symbol', sym, s) 197 yield (b'symbol', sym, s)
196 else: 198 else:
197 # looks like an expression 199 # looks like an expression
198 parts = sym.split('-') 200 parts = sym.split(b'-')
199 for p in parts[:-1]: 201 for p in parts[:-1]:
200 if p: # possible consecutive - 202 if p: # possible consecutive -
201 yield ('symbol', p, s) 203 yield (b'symbol', p, s)
202 s += len(p) 204 s += len(p)
203 yield ('-', None, s) 205 yield (b'-', None, s)
204 s += 1 206 s += 1
205 if parts[-1]: # possible trailing - 207 if parts[-1]: # possible trailing -
206 yield ('symbol', parts[-1], s) 208 yield (b'symbol', parts[-1], s)
207 else: 209 else:
208 yield ('symbol', sym, s) 210 yield (b'symbol', sym, s)
209 pos -= 1 211 pos -= 1
210 else: 212 else:
211 raise error.ParseError( 213 raise error.ParseError(
212 _("syntax error in revset '%s'") % program, pos 214 _(b"syntax error in revset '%s'") % program, pos
213 ) 215 )
214 pos += 1 216 pos += 1
215 yield ('end', None, pos) 217 yield (b'end', None, pos)
216 218
217 219
218 # helpers 220 # helpers
219 221
220 _notset = object() 222 _notset = object()
221 223
222 224
223 def getsymbol(x): 225 def getsymbol(x):
224 if x and x[0] == 'symbol': 226 if x and x[0] == b'symbol':
225 return x[1] 227 return x[1]
226 raise error.ParseError(_('not a symbol')) 228 raise error.ParseError(_(b'not a symbol'))
227 229
228 230
229 def getstring(x, err): 231 def getstring(x, err):
230 if x and (x[0] == 'string' or x[0] == 'symbol'): 232 if x and (x[0] == b'string' or x[0] == b'symbol'):
231 return x[1] 233 return x[1]
232 raise error.ParseError(err) 234 raise error.ParseError(err)
233 235
234 236
235 def getinteger(x, err, default=_notset): 237 def getinteger(x, err, default=_notset):
249 251
250 252
251 def getlist(x): 253 def getlist(x):
252 if not x: 254 if not x:
253 return [] 255 return []
254 if x[0] == 'list': 256 if x[0] == b'list':
255 return list(x[1:]) 257 return list(x[1:])
256 return [x] 258 return [x]
257 259
258 260
259 def getrange(x, err): 261 def getrange(x, err):
260 if not x: 262 if not x:
261 raise error.ParseError(err) 263 raise error.ParseError(err)
262 op = x[0] 264 op = x[0]
263 if op == 'range': 265 if op == b'range':
264 return x[1], x[2] 266 return x[1], x[2]
265 elif op == 'rangepre': 267 elif op == b'rangepre':
266 return None, x[1] 268 return None, x[1]
267 elif op == 'rangepost': 269 elif op == b'rangepost':
268 return x[1], None 270 return x[1], None
269 elif op == 'rangeall': 271 elif op == b'rangeall':
270 return None, None 272 return None, None
271 raise error.ParseError(err) 273 raise error.ParseError(err)
272 274
273 275
274 def getintrange(x, err1, err2, deffirst=_notset, deflast=_notset): 276 def getintrange(x, err1, err2, deffirst=_notset, deflast=_notset):
275 """Get [first, last] integer range (both inclusive) from a parsed tree 277 """Get [first, last] integer range (both inclusive) from a parsed tree
276 278
277 If any of the sides omitted, and if no default provided, ParseError will 279 If any of the sides omitted, and if no default provided, ParseError will
278 be raised. 280 be raised.
279 """ 281 """
280 if x and (x[0] == 'string' or x[0] == 'symbol'): 282 if x and (x[0] == b'string' or x[0] == b'symbol'):
281 n = getinteger(x, err1) 283 n = getinteger(x, err1)
282 return n, n 284 return n, n
283 a, b = getrange(x, err1) 285 a, b = getrange(x, err1)
284 return getinteger(a, err2, deffirst), getinteger(b, err2, deflast) 286 return getinteger(a, err2, deffirst), getinteger(b, err2, deflast)
285 287
294 def getargsdict(x, funcname, keys): 296 def getargsdict(x, funcname, keys):
295 return parser.buildargsdict( 297 return parser.buildargsdict(
296 getlist(x), 298 getlist(x),
297 funcname, 299 funcname,
298 parser.splitargspec(keys), 300 parser.splitargspec(keys),
299 keyvaluenode='keyvalue', 301 keyvaluenode=b'keyvalue',
300 keynode='symbol', 302 keynode=b'symbol',
301 ) 303 )
302 304
303 305
304 # cache of {spec: raw parsed tree} built internally 306 # cache of {spec: raw parsed tree} built internally
305 _treecache = {} 307 _treecache = {}
318 320
319 >>> _build(b'f(_) and _', (b'string', b'1'), (b'symbol', b'2')) 321 >>> _build(b'f(_) and _', (b'string', b'1'), (b'symbol', b'2'))
320 ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2')) 322 ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2'))
321 """ 323 """
322 template = _cachedtree(tmplspec) 324 template = _cachedtree(tmplspec)
323 return parser.buildtree(template, ('symbol', '_'), *repls) 325 return parser.buildtree(template, (b'symbol', b'_'), *repls)
324 326
325 327
326 def _match(patspec, tree): 328 def _match(patspec, tree):
327 """Test if a tree matches the given pattern statement; return the matches 329 """Test if a tree matches the given pattern statement; return the matches
328 330
331 [('func', ('symbol', 'f'), ('symbol', '1')), ('symbol', '1')] 333 [('func', ('symbol', 'f'), ('symbol', '1')), ('symbol', '1')]
332 >>> _match(b'f(_)', parse(b'f(1, 2)')) 334 >>> _match(b'f(_)', parse(b'f(1, 2)'))
333 """ 335 """
334 pattern = _cachedtree(patspec) 336 pattern = _cachedtree(patspec)
335 return parser.matchtree( 337 return parser.matchtree(
336 pattern, tree, ('symbol', '_'), {'keyvalue', 'list'} 338 pattern, tree, (b'symbol', b'_'), {b'keyvalue', b'list'}
337 ) 339 )
338 340
339 341
340 def _matchonly(revs, bases): 342 def _matchonly(revs, bases):
341 return _match('ancestors(_) and not ancestors(_)', ('and', revs, bases)) 343 return _match(b'ancestors(_) and not ancestors(_)', (b'and', revs, bases))
342 344
343 345
344 def _fixops(x): 346 def _fixops(x):
345 """Rewrite raw parsed tree to resolve ambiguous syntax which cannot be 347 """Rewrite raw parsed tree to resolve ambiguous syntax which cannot be
346 handled well by our simple top-down parser""" 348 handled well by our simple top-down parser"""
347 if not isinstance(x, tuple): 349 if not isinstance(x, tuple):
348 return x 350 return x
349 351
350 op = x[0] 352 op = x[0]
351 if op == 'parent': 353 if op == b'parent':
352 # x^:y means (x^) : y, not x ^ (:y) 354 # x^:y means (x^) : y, not x ^ (:y)
353 # x^: means (x^) :, not x ^ (:) 355 # x^: means (x^) :, not x ^ (:)
354 post = ('parentpost', x[1]) 356 post = (b'parentpost', x[1])
355 if x[2][0] == 'dagrangepre': 357 if x[2][0] == b'dagrangepre':
356 return _fixops(('dagrange', post, x[2][1])) 358 return _fixops((b'dagrange', post, x[2][1]))
357 elif x[2][0] == 'dagrangeall': 359 elif x[2][0] == b'dagrangeall':
358 return _fixops(('dagrangepost', post)) 360 return _fixops((b'dagrangepost', post))
359 elif x[2][0] == 'rangepre': 361 elif x[2][0] == b'rangepre':
360 return _fixops(('range', post, x[2][1])) 362 return _fixops((b'range', post, x[2][1]))
361 elif x[2][0] == 'rangeall': 363 elif x[2][0] == b'rangeall':
362 return _fixops(('rangepost', post)) 364 return _fixops((b'rangepost', post))
363 elif op == 'or': 365 elif op == b'or':
364 # make number of arguments deterministic: 366 # make number of arguments deterministic:
365 # x + y + z -> (or x y z) -> (or (list x y z)) 367 # x + y + z -> (or x y z) -> (or (list x y z))
366 return (op, _fixops(('list',) + x[1:])) 368 return (op, _fixops((b'list',) + x[1:]))
367 elif op == 'subscript' and x[1][0] == 'relation': 369 elif op == b'subscript' and x[1][0] == b'relation':
368 # x#y[z] ternary 370 # x#y[z] ternary
369 return _fixops(('relsubscript', x[1][1], x[1][2], x[2])) 371 return _fixops((b'relsubscript', x[1][1], x[1][2], x[2]))
370 372
371 return (op,) + tuple(_fixops(y) for y in x[1:]) 373 return (op,) + tuple(_fixops(y) for y in x[1:])
372 374
373 375
374 def _analyze(x): 376 def _analyze(x):
375 if x is None: 377 if x is None:
376 return x 378 return x
377 379
378 op = x[0] 380 op = x[0]
379 if op == 'minus': 381 if op == b'minus':
380 return _analyze(_build('_ and not _', *x[1:])) 382 return _analyze(_build(b'_ and not _', *x[1:]))
381 elif op == 'only': 383 elif op == b'only':
382 return _analyze(_build('only(_, _)', *x[1:])) 384 return _analyze(_build(b'only(_, _)', *x[1:]))
383 elif op == 'onlypost': 385 elif op == b'onlypost':
384 return _analyze(_build('only(_)', x[1])) 386 return _analyze(_build(b'only(_)', x[1]))
385 elif op == 'dagrangeall': 387 elif op == b'dagrangeall':
386 raise error.ParseError(_("can't use '::' in this context")) 388 raise error.ParseError(_(b"can't use '::' in this context"))
387 elif op == 'dagrangepre': 389 elif op == b'dagrangepre':
388 return _analyze(_build('ancestors(_)', x[1])) 390 return _analyze(_build(b'ancestors(_)', x[1]))
389 elif op == 'dagrangepost': 391 elif op == b'dagrangepost':
390 return _analyze(_build('descendants(_)', x[1])) 392 return _analyze(_build(b'descendants(_)', x[1]))
391 elif op == 'negate': 393 elif op == b'negate':
392 s = getstring(x[1], _("can't negate that")) 394 s = getstring(x[1], _(b"can't negate that"))
393 return _analyze(('string', '-' + s)) 395 return _analyze((b'string', b'-' + s))
394 elif op in ('string', 'symbol', 'smartset'): 396 elif op in (b'string', b'symbol', b'smartset'):
395 return x 397 return x
396 elif op == 'rangeall': 398 elif op == b'rangeall':
397 return (op, None) 399 return (op, None)
398 elif op in {'or', 'not', 'rangepre', 'rangepost', 'parentpost'}: 400 elif op in {b'or', b'not', b'rangepre', b'rangepost', b'parentpost'}:
399 return (op, _analyze(x[1])) 401 return (op, _analyze(x[1]))
400 elif op == 'group': 402 elif op == b'group':
401 return _analyze(x[1]) 403 return _analyze(x[1])
402 elif op in { 404 elif op in {
403 'and', 405 b'and',
404 'dagrange', 406 b'dagrange',
405 'range', 407 b'range',
406 'parent', 408 b'parent',
407 'ancestor', 409 b'ancestor',
408 'relation', 410 b'relation',
409 'subscript', 411 b'subscript',
410 }: 412 }:
411 ta = _analyze(x[1]) 413 ta = _analyze(x[1])
412 tb = _analyze(x[2]) 414 tb = _analyze(x[2])
413 return (op, ta, tb) 415 return (op, ta, tb)
414 elif op == 'relsubscript': 416 elif op == b'relsubscript':
415 ta = _analyze(x[1]) 417 ta = _analyze(x[1])
416 tb = _analyze(x[2]) 418 tb = _analyze(x[2])
417 tc = _analyze(x[3]) 419 tc = _analyze(x[3])
418 return (op, ta, tb, tc) 420 return (op, ta, tb, tc)
419 elif op == 'list': 421 elif op == b'list':
420 return (op,) + tuple(_analyze(y) for y in x[1:]) 422 return (op,) + tuple(_analyze(y) for y in x[1:])
421 elif op == 'keyvalue': 423 elif op == b'keyvalue':
422 return (op, x[1], _analyze(x[2])) 424 return (op, x[1], _analyze(x[2]))
423 elif op == 'func': 425 elif op == b'func':
424 return (op, x[1], _analyze(x[2])) 426 return (op, x[1], _analyze(x[2]))
425 raise ValueError('invalid operator %r' % op) 427 raise ValueError(b'invalid operator %r' % op)
426 428
427 429
428 def analyze(x): 430 def analyze(x):
429 """Transform raw parsed tree to evaluatable tree which can be fed to 431 """Transform raw parsed tree to evaluatable tree which can be fed to
430 optimize() or getset() 432 optimize() or getset()
438 def _optimize(x): 440 def _optimize(x):
439 if x is None: 441 if x is None:
440 return 0, x 442 return 0, x
441 443
442 op = x[0] 444 op = x[0]
443 if op in ('string', 'symbol', 'smartset'): 445 if op in (b'string', b'symbol', b'smartset'):
444 return 0.5, x # single revisions are small 446 return 0.5, x # single revisions are small
445 elif op == 'and': 447 elif op == b'and':
446 wa, ta = _optimize(x[1]) 448 wa, ta = _optimize(x[1])
447 wb, tb = _optimize(x[2]) 449 wb, tb = _optimize(x[2])
448 w = min(wa, wb) 450 w = min(wa, wb)
449 451
450 # (draft/secret/_notpublic() & ::x) have a fast path 452 # (draft/secret/_notpublic() & ::x) have a fast path
451 m = _match('_() & ancestors(_)', ('and', ta, tb)) 453 m = _match(b'_() & ancestors(_)', (b'and', ta, tb))
452 if m and getsymbol(m[1]) in {'draft', 'secret', '_notpublic'}: 454 if m and getsymbol(m[1]) in {b'draft', b'secret', b'_notpublic'}:
453 return w, _build('_phaseandancestors(_, _)', m[1], m[2]) 455 return w, _build(b'_phaseandancestors(_, _)', m[1], m[2])
454 456
455 # (::x and not ::y)/(not ::y and ::x) have a fast path 457 # (::x and not ::y)/(not ::y and ::x) have a fast path
456 m = _matchonly(ta, tb) or _matchonly(tb, ta) 458 m = _matchonly(ta, tb) or _matchonly(tb, ta)
457 if m: 459 if m:
458 return w, _build('only(_, _)', *m[1:]) 460 return w, _build(b'only(_, _)', *m[1:])
459 461
460 m = _match('not _', tb) 462 m = _match(b'not _', tb)
461 if m: 463 if m:
462 return wa, ('difference', ta, m[1]) 464 return wa, (b'difference', ta, m[1])
463 if wa > wb: 465 if wa > wb:
464 op = 'andsmally' 466 op = b'andsmally'
465 return w, (op, ta, tb) 467 return w, (op, ta, tb)
466 elif op == 'or': 468 elif op == b'or':
467 # fast path for machine-generated expression, that is likely to have 469 # fast path for machine-generated expression, that is likely to have
468 # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()' 470 # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()'
469 ws, ts, ss = [], [], [] 471 ws, ts, ss = [], [], []
470 472
471 def flushss(): 473 def flushss():
472 if not ss: 474 if not ss:
473 return 475 return
474 if len(ss) == 1: 476 if len(ss) == 1:
475 w, t = ss[0] 477 w, t = ss[0]
476 else: 478 else:
477 s = '\0'.join(t[1] for w, t in ss) 479 s = b'\0'.join(t[1] for w, t in ss)
478 y = _build('_list(_)', ('string', s)) 480 y = _build(b'_list(_)', (b'string', s))
479 w, t = _optimize(y) 481 w, t = _optimize(y)
480 ws.append(w) 482 ws.append(w)
481 ts.append(t) 483 ts.append(t)
482 del ss[:] 484 del ss[:]
483 485
484 for y in getlist(x[1]): 486 for y in getlist(x[1]):
485 w, t = _optimize(y) 487 w, t = _optimize(y)
486 if t is not None and (t[0] == 'string' or t[0] == 'symbol'): 488 if t is not None and (t[0] == b'string' or t[0] == b'symbol'):
487 ss.append((w, t)) 489 ss.append((w, t))
488 continue 490 continue
489 flushss() 491 flushss()
490 ws.append(w) 492 ws.append(w)
491 ts.append(t) 493 ts.append(t)
492 flushss() 494 flushss()
493 if len(ts) == 1: 495 if len(ts) == 1:
494 return ws[0], ts[0] # 'or' operation is fully optimized out 496 return ws[0], ts[0] # 'or' operation is fully optimized out
495 return max(ws), (op, ('list',) + tuple(ts)) 497 return max(ws), (op, (b'list',) + tuple(ts))
496 elif op == 'not': 498 elif op == b'not':
497 # Optimize not public() to _notpublic() because we have a fast version 499 # Optimize not public() to _notpublic() because we have a fast version
498 if _match('public()', x[1]): 500 if _match(b'public()', x[1]):
499 o = _optimize(_build('_notpublic()')) 501 o = _optimize(_build(b'_notpublic()'))
500 return o[0], o[1] 502 return o[0], o[1]
501 else: 503 else:
502 o = _optimize(x[1]) 504 o = _optimize(x[1])
503 return o[0], (op, o[1]) 505 return o[0], (op, o[1])
504 elif op == 'rangeall': 506 elif op == b'rangeall':
505 return 1, x 507 return 1, x
506 elif op in ('rangepre', 'rangepost', 'parentpost'): 508 elif op in (b'rangepre', b'rangepost', b'parentpost'):
507 o = _optimize(x[1]) 509 o = _optimize(x[1])
508 return o[0], (op, o[1]) 510 return o[0], (op, o[1])
509 elif op in ('dagrange', 'range'): 511 elif op in (b'dagrange', b'range'):
510 wa, ta = _optimize(x[1]) 512 wa, ta = _optimize(x[1])
511 wb, tb = _optimize(x[2]) 513 wb, tb = _optimize(x[2])
512 return wa + wb, (op, ta, tb) 514 return wa + wb, (op, ta, tb)
513 elif op in ('parent', 'ancestor', 'relation', 'subscript'): 515 elif op in (b'parent', b'ancestor', b'relation', b'subscript'):
514 w, t = _optimize(x[1]) 516 w, t = _optimize(x[1])
515 return w, (op, t, x[2]) 517 return w, (op, t, x[2])
516 elif op == 'relsubscript': 518 elif op == b'relsubscript':
517 w, t = _optimize(x[1]) 519 w, t = _optimize(x[1])
518 return w, (op, t, x[2], x[3]) 520 return w, (op, t, x[2], x[3])
519 elif op == 'list': 521 elif op == b'list':
520 ws, ts = zip(*(_optimize(y) for y in x[1:])) 522 ws, ts = zip(*(_optimize(y) for y in x[1:]))
521 return sum(ws), (op,) + ts 523 return sum(ws), (op,) + ts
522 elif op == 'keyvalue': 524 elif op == b'keyvalue':
523 w, t = _optimize(x[2]) 525 w, t = _optimize(x[2])
524 return w, (op, x[1], t) 526 return w, (op, x[1], t)
525 elif op == 'func': 527 elif op == b'func':
526 f = getsymbol(x[1]) 528 f = getsymbol(x[1])
527 wa, ta = _optimize(x[2]) 529 wa, ta = _optimize(x[2])
528 w = getattr(symbols.get(f), '_weight', 1) 530 w = getattr(symbols.get(f), '_weight', 1)
529 m = _match('commonancestors(_)', ta) 531 m = _match(b'commonancestors(_)', ta)
530 532
531 # Optimize heads(commonancestors(_)) because we have a fast version 533 # Optimize heads(commonancestors(_)) because we have a fast version
532 if f == 'heads' and m: 534 if f == b'heads' and m:
533 return w + wa, _build('_commonancestorheads(_)', m[1]) 535 return w + wa, _build(b'_commonancestorheads(_)', m[1])
534 536
535 return w + wa, (op, x[1], ta) 537 return w + wa, (op, x[1], ta)
536 raise ValueError('invalid operator %r' % op) 538 raise ValueError(b'invalid operator %r' % op)
537 539
538 540
539 def optimize(tree): 541 def optimize(tree):
540 """Optimize evaluatable tree 542 """Optimize evaluatable tree
541 543
545 return newtree 547 return newtree
546 548
547 549
548 # the set of valid characters for the initial letter of symbols in 550 # the set of valid characters for the initial letter of symbols in
549 # alias declarations and definitions 551 # alias declarations and definitions
550 _aliassyminitletters = _syminitletters | {'$'} 552 _aliassyminitletters = _syminitletters | {b'$'}
551 553
552 554
553 def _parsewith(spec, lookup=None, syminitletters=None): 555 def _parsewith(spec, lookup=None, syminitletters=None):
554 """Generate a parse tree of given spec with given tokenizing options 556 """Generate a parse tree of given spec with given tokenizing options
555 557
562 >>> _parsewith(b'foo bar') 564 >>> _parsewith(b'foo bar')
563 Traceback (most recent call last): 565 Traceback (most recent call last):
564 ... 566 ...
565 ParseError: ('invalid token', 4) 567 ParseError: ('invalid token', 4)
566 """ 568 """
567 if lookup and spec.startswith('revset(') and spec.endswith(')'): 569 if lookup and spec.startswith(b'revset(') and spec.endswith(b')'):
568 lookup = None 570 lookup = None
569 p = parser.parser(elements) 571 p = parser.parser(elements)
570 tree, pos = p.parse( 572 tree, pos = p.parse(
571 tokenize(spec, lookup=lookup, syminitletters=syminitletters) 573 tokenize(spec, lookup=lookup, syminitletters=syminitletters)
572 ) 574 )
573 if pos != len(spec): 575 if pos != len(spec):
574 raise error.ParseError(_('invalid token'), pos) 576 raise error.ParseError(_(b'invalid token'), pos)
575 return _fixops(parser.simplifyinfixops(tree, ('list', 'or'))) 577 return _fixops(parser.simplifyinfixops(tree, (b'list', b'or')))
576 578
577 579
578 class _aliasrules(parser.basealiasrules): 580 class _aliasrules(parser.basealiasrules):
579 """Parsing and expansion rule set of revset aliases""" 581 """Parsing and expansion rule set of revset aliases"""
580 582
581 _section = _('revset alias') 583 _section = _(b'revset alias')
582 584
583 @staticmethod 585 @staticmethod
584 def _parse(spec): 586 def _parse(spec):
585 """Parse alias declaration/definition ``spec`` 587 """Parse alias declaration/definition ``spec``
586 588
590 """ 592 """
591 return _parsewith(spec, syminitletters=_aliassyminitletters) 593 return _parsewith(spec, syminitletters=_aliassyminitletters)
592 594
593 @staticmethod 595 @staticmethod
594 def _trygetfunc(tree): 596 def _trygetfunc(tree):
595 if tree[0] == 'func' and tree[1][0] == 'symbol': 597 if tree[0] == b'func' and tree[1][0] == b'symbol':
596 return tree[1][1], getlist(tree[2]) 598 return tree[1][1], getlist(tree[2])
597 599
598 600
599 def expandaliases(tree, aliases, warn=None): 601 def expandaliases(tree, aliases, warn=None):
600 """Expand aliases in a tree, aliases is a list of (name, value) tuples""" 602 """Expand aliases in a tree, aliases is a list of (name, value) tuples"""
602 tree = _aliasrules.expand(aliases, tree) 604 tree = _aliasrules.expand(aliases, tree)
603 # warn about problematic (but not referred) aliases 605 # warn about problematic (but not referred) aliases
604 if warn is not None: 606 if warn is not None:
605 for name, alias in sorted(aliases.iteritems()): 607 for name, alias in sorted(aliases.iteritems()):
606 if alias.error and not alias.warned: 608 if alias.error and not alias.warned:
607 warn(_('warning: %s\n') % (alias.error)) 609 warn(_(b'warning: %s\n') % (alias.error))
608 alias.warned = True 610 alias.warned = True
609 return tree 611 return tree
610 612
611 613
612 def foldconcat(tree): 614 def foldconcat(tree):
613 """Fold elements to be concatenated by `##` 615 """Fold elements to be concatenated by `##`
614 """ 616 """
615 if not isinstance(tree, tuple) or tree[0] in ( 617 if not isinstance(tree, tuple) or tree[0] in (
616 'string', 618 b'string',
617 'symbol', 619 b'symbol',
618 'smartset', 620 b'smartset',
619 ): 621 ):
620 return tree 622 return tree
621 if tree[0] == '_concat': 623 if tree[0] == b'_concat':
622 pending = [tree] 624 pending = [tree]
623 l = [] 625 l = []
624 while pending: 626 while pending:
625 e = pending.pop() 627 e = pending.pop()
626 if e[0] == '_concat': 628 if e[0] == b'_concat':
627 pending.extend(reversed(e[1:])) 629 pending.extend(reversed(e[1:]))
628 elif e[0] in ('string', 'symbol'): 630 elif e[0] in (b'string', b'symbol'):
629 l.append(e[1]) 631 l.append(e[1])
630 else: 632 else:
631 msg = _("\"##\" can't concatenate \"%s\" element") % (e[0]) 633 msg = _(b"\"##\" can't concatenate \"%s\" element") % (e[0])
632 raise error.ParseError(msg) 634 raise error.ParseError(msg)
633 return ('string', ''.join(l)) 635 return (b'string', b''.join(l))
634 else: 636 else:
635 return tuple(foldconcat(t) for t in tree) 637 return tuple(foldconcat(t) for t in tree)
636 638
637 639
638 def parse(spec, lookup=None): 640 def parse(spec, lookup=None):
640 return _parsewith(spec, lookup=lookup) 642 return _parsewith(spec, lookup=lookup)
641 except error.ParseError as inst: 643 except error.ParseError as inst:
642 if len(inst.args) > 1: # has location 644 if len(inst.args) > 1: # has location
643 loc = inst.args[1] 645 loc = inst.args[1]
644 # Remove newlines -- spaces are equivalent whitespace. 646 # Remove newlines -- spaces are equivalent whitespace.
645 spec = spec.replace('\n', ' ') 647 spec = spec.replace(b'\n', b' ')
646 # We want the caret to point to the place in the template that 648 # We want the caret to point to the place in the template that
647 # failed to parse, but in a hint we get a open paren at the 649 # failed to parse, but in a hint we get a open paren at the
648 # start. Therefore, we print "loc + 1" spaces (instead of "loc") 650 # start. Therefore, we print "loc + 1" spaces (instead of "loc")
649 # to line up the caret with the location of the error. 651 # to line up the caret with the location of the error.
650 inst.hint = spec + '\n' + ' ' * (loc + 1) + '^ ' + _('here') 652 inst.hint = spec + b'\n' + b' ' * (loc + 1) + b'^ ' + _(b'here')
651 raise 653 raise
652 654
653 655
654 def _quote(s): 656 def _quote(s):
655 r"""Quote a value in order to make it safe for the revset engine. 657 r"""Quote a value in order to make it safe for the revset engine.
661 >>> _quote(b'asdf\'') 663 >>> _quote(b'asdf\'')
662 "'asdf\\''" 664 "'asdf\\''"
663 >>> _quote(1) 665 >>> _quote(1)
664 "'1'" 666 "'1'"
665 """ 667 """
666 return "'%s'" % stringutil.escapestr(pycompat.bytestr(s)) 668 return b"'%s'" % stringutil.escapestr(pycompat.bytestr(s))
667 669
668 670
669 def _formatargtype(c, arg): 671 def _formatargtype(c, arg):
670 if c == 'd': 672 if c == b'd':
671 return '_rev(%d)' % int(arg) 673 return b'_rev(%d)' % int(arg)
672 elif c == 's': 674 elif c == b's':
673 return _quote(arg) 675 return _quote(arg)
674 elif c == 'r': 676 elif c == b'r':
675 if not isinstance(arg, bytes): 677 if not isinstance(arg, bytes):
676 raise TypeError 678 raise TypeError
677 parse(arg) # make sure syntax errors are confined 679 parse(arg) # make sure syntax errors are confined
678 return '(%s)' % arg 680 return b'(%s)' % arg
679 elif c == 'n': 681 elif c == b'n':
680 return _quote(node.hex(arg)) 682 return _quote(node.hex(arg))
681 elif c == 'b': 683 elif c == b'b':
682 try: 684 try:
683 return _quote(arg.branch()) 685 return _quote(arg.branch())
684 except AttributeError: 686 except AttributeError:
685 raise TypeError 687 raise TypeError
686 raise error.ParseError(_('unexpected revspec format character %s') % c) 688 raise error.ParseError(_(b'unexpected revspec format character %s') % c)
687 689
688 690
689 def _formatlistexp(s, t): 691 def _formatlistexp(s, t):
690 l = len(s) 692 l = len(s)
691 if l == 0: 693 if l == 0:
692 return "_list('')" 694 return b"_list('')"
693 elif l == 1: 695 elif l == 1:
694 return _formatargtype(t, s[0]) 696 return _formatargtype(t, s[0])
695 elif t == 'd': 697 elif t == b'd':
696 return _formatintlist(s) 698 return _formatintlist(s)
697 elif t == 's': 699 elif t == b's':
698 return "_list(%s)" % _quote("\0".join(s)) 700 return b"_list(%s)" % _quote(b"\0".join(s))
699 elif t == 'n': 701 elif t == b'n':
700 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s) 702 return b"_hexlist('%s')" % b"\0".join(node.hex(a) for a in s)
701 elif t == 'b': 703 elif t == b'b':
702 try: 704 try:
703 return "_list('%s')" % "\0".join(a.branch() for a in s) 705 return b"_list('%s')" % b"\0".join(a.branch() for a in s)
704 except AttributeError: 706 except AttributeError:
705 raise TypeError 707 raise TypeError
706 708
707 m = l // 2 709 m = l // 2
708 return '(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t)) 710 return b'(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t))
709 711
710 712
711 def _formatintlist(data): 713 def _formatintlist(data):
712 try: 714 try:
713 l = len(data) 715 l = len(data)
714 if l == 0: 716 if l == 0:
715 return "_list('')" 717 return b"_list('')"
716 elif l == 1: 718 elif l == 1:
717 return _formatargtype('d', data[0]) 719 return _formatargtype(b'd', data[0])
718 return "_intlist('%s')" % "\0".join('%d' % int(a) for a in data) 720 return b"_intlist('%s')" % b"\0".join(b'%d' % int(a) for a in data)
719 except (TypeError, ValueError): 721 except (TypeError, ValueError):
720 raise error.ParseError(_('invalid argument for revspec')) 722 raise error.ParseError(_(b'invalid argument for revspec'))
721 723
722 724
723 def _formatparamexp(args, t): 725 def _formatparamexp(args, t):
724 return ', '.join(_formatargtype(t, a) for a in args) 726 return b', '.join(_formatargtype(t, a) for a in args)
725 727
726 728
727 _formatlistfuncs = { 729 _formatlistfuncs = {
728 'l': _formatlistexp, 730 b'l': _formatlistexp,
729 'p': _formatparamexp, 731 b'p': _formatparamexp,
730 } 732 }
731 733
732 734
733 def formatspec(expr, *args): 735 def formatspec(expr, *args):
734 ''' 736 '''
770 parsed = _parseargs(expr, args) 772 parsed = _parseargs(expr, args)
771 ret = [] 773 ret = []
772 for t, arg in parsed: 774 for t, arg in parsed:
773 if t is None: 775 if t is None:
774 ret.append(arg) 776 ret.append(arg)
775 elif t == 'baseset': 777 elif t == b'baseset':
776 if isinstance(arg, set): 778 if isinstance(arg, set):
777 arg = sorted(arg) 779 arg = sorted(arg)
778 ret.append(_formatintlist(list(arg))) 780 ret.append(_formatintlist(list(arg)))
779 else: 781 else:
780 raise error.ProgrammingError("unknown revspec item type: %r" % t) 782 raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
781 return b''.join(ret) 783 return b''.join(ret)
782 784
783 785
784 def spectree(expr, *args): 786 def spectree(expr, *args):
785 """similar to formatspec but return a parsed and optimized tree""" 787 """similar to formatspec but return a parsed and optimized tree"""
787 ret = [] 789 ret = []
788 inputs = [] 790 inputs = []
789 for t, arg in parsed: 791 for t, arg in parsed:
790 if t is None: 792 if t is None:
791 ret.append(arg) 793 ret.append(arg)
792 elif t == 'baseset': 794 elif t == b'baseset':
793 newtree = ('smartset', smartset.baseset(arg)) 795 newtree = (b'smartset', smartset.baseset(arg))
794 inputs.append(newtree) 796 inputs.append(newtree)
795 ret.append("$") 797 ret.append(b"$")
796 else: 798 else:
797 raise error.ProgrammingError("unknown revspec item type: %r" % t) 799 raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
798 expr = b''.join(ret) 800 expr = b''.join(ret)
799 tree = _parsewith(expr, syminitletters=_aliassyminitletters) 801 tree = _parsewith(expr, syminitletters=_aliassyminitletters)
800 tree = parser.buildtree(tree, ('symbol', '$'), *inputs) 802 tree = parser.buildtree(tree, (b'symbol', b'$'), *inputs)
801 tree = foldconcat(tree) 803 tree = foldconcat(tree)
802 tree = analyze(tree) 804 tree = analyze(tree)
803 tree = optimize(tree) 805 tree = optimize(tree)
804 return tree 806 return tree
805 807
816 expr = pycompat.bytestr(expr) 818 expr = pycompat.bytestr(expr)
817 argiter = iter(args) 819 argiter = iter(args)
818 ret = [] 820 ret = []
819 pos = 0 821 pos = 0
820 while pos < len(expr): 822 while pos < len(expr):
821 q = expr.find('%', pos) 823 q = expr.find(b'%', pos)
822 if q < 0: 824 if q < 0:
823 ret.append((None, expr[pos:])) 825 ret.append((None, expr[pos:]))
824 break 826 break
825 ret.append((None, expr[pos:q])) 827 ret.append((None, expr[pos:q]))
826 pos = q + 1 828 pos = q + 1
827 try: 829 try:
828 d = expr[pos] 830 d = expr[pos]
829 except IndexError: 831 except IndexError:
830 raise error.ParseError(_('incomplete revspec format character')) 832 raise error.ParseError(_(b'incomplete revspec format character'))
831 if d == '%': 833 if d == b'%':
832 ret.append((None, d)) 834 ret.append((None, d))
833 pos += 1 835 pos += 1
834 continue 836 continue
835 837
836 try: 838 try:
837 arg = next(argiter) 839 arg = next(argiter)
838 except StopIteration: 840 except StopIteration:
839 raise error.ParseError(_('missing argument for revspec')) 841 raise error.ParseError(_(b'missing argument for revspec'))
840 f = _formatlistfuncs.get(d) 842 f = _formatlistfuncs.get(d)
841 if f: 843 if f:
842 # a list of some type, might be expensive, do not replace 844 # a list of some type, might be expensive, do not replace
843 pos += 1 845 pos += 1
844 islist = d == 'l' 846 islist = d == b'l'
845 try: 847 try:
846 d = expr[pos] 848 d = expr[pos]
847 except IndexError: 849 except IndexError:
848 raise error.ParseError(_('incomplete revspec format character')) 850 raise error.ParseError(
849 if islist and d == 'd' and arg: 851 _(b'incomplete revspec format character')
852 )
853 if islist and d == b'd' and arg:
850 # we don't create a baseset yet, because it come with an 854 # we don't create a baseset yet, because it come with an
851 # extra cost. If we are going to serialize it we better 855 # extra cost. If we are going to serialize it we better
852 # skip it. 856 # skip it.
853 ret.append(('baseset', arg)) 857 ret.append((b'baseset', arg))
854 pos += 1 858 pos += 1
855 continue 859 continue
856 try: 860 try:
857 ret.append((None, f(list(arg), d))) 861 ret.append((None, f(list(arg), d)))
858 except (TypeError, ValueError): 862 except (TypeError, ValueError):
859 raise error.ParseError(_('invalid argument for revspec')) 863 raise error.ParseError(_(b'invalid argument for revspec'))
860 else: 864 else:
861 # a single entry, not expensive, replace 865 # a single entry, not expensive, replace
862 try: 866 try:
863 ret.append((None, _formatargtype(d, arg))) 867 ret.append((None, _formatargtype(d, arg)))
864 except (TypeError, ValueError): 868 except (TypeError, ValueError):
865 raise error.ParseError(_('invalid argument for revspec')) 869 raise error.ParseError(_(b'invalid argument for revspec'))
866 pos += 1 870 pos += 1
867 871
868 try: 872 try:
869 next(argiter) 873 next(argiter)
870 raise error.ParseError(_('too many revspec arguments specified')) 874 raise error.ParseError(_(b'too many revspec arguments specified'))
871 except StopIteration: 875 except StopIteration:
872 pass 876 pass
873 return ret 877 return ret
874 878
875 879
876 def prettyformat(tree): 880 def prettyformat(tree):
877 return parser.prettyformat(tree, ('string', 'symbol')) 881 return parser.prettyformat(tree, (b'string', b'symbol'))
878 882
879 883
880 def depth(tree): 884 def depth(tree):
881 if isinstance(tree, tuple): 885 if isinstance(tree, tuple):
882 return max(map(depth, tree)) + 1 886 return max(map(depth, tree)) + 1
883 else: 887 else:
884 return 0 888 return 0
885 889
886 890
887 def funcsused(tree): 891 def funcsused(tree):
888 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'): 892 if not isinstance(tree, tuple) or tree[0] in (b'string', b'symbol'):
889 return set() 893 return set()
890 else: 894 else:
891 funcs = set() 895 funcs = set()
892 for s in tree[1:]: 896 for s in tree[1:]:
893 funcs |= funcsused(s) 897 funcs |= funcsused(s)
894 if tree[0] == 'func': 898 if tree[0] == b'func':
895 funcs.add(tree[1][1]) 899 funcs.add(tree[1][1])
896 return funcs 900 return funcs
897 901
898 902
899 _hashre = util.re.compile('[0-9a-fA-F]{1,40}$') 903 _hashre = util.re.compile(b'[0-9a-fA-F]{1,40}$')
900 904
901 905
902 def _ishashlikesymbol(symbol): 906 def _ishashlikesymbol(symbol):
903 """returns true if the symbol looks like a hash""" 907 """returns true if the symbol looks like a hash"""
904 return _hashre.match(symbol) 908 return _hashre.match(symbol)
917 [] 921 []
918 """ 922 """
919 if not tree: 923 if not tree:
920 return [] 924 return []
921 925
922 if tree[0] == "symbol": 926 if tree[0] == b"symbol":
923 if _ishashlikesymbol(tree[1]): 927 if _ishashlikesymbol(tree[1]):
924 return [tree[1]] 928 return [tree[1]]
925 elif len(tree) >= 3: 929 elif len(tree) >= 3:
926 results = [] 930 results = []
927 for subtree in tree[1:]: 931 for subtree in tree[1:]: