6ht SSKJr SSKrSSKJr SSKJr SSKJrJ r J r J r J r SSK Jr 0SS _S S _S S _SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_S S_S!S"_S#S$_S%S$_S$S&S'S(S(S)S*S(S+.Er1S,kr0rS-S.1r\"\ R("S/55r\"\ R("\ R,"\R.5\ R,"\R05-S0-55\"\"\ R4\"S1S2555-r\\"\ R("S355-rS]S4jr\"5r S5r!S6r"\ 4S7jr#S8r$S9r%S:r&\ \ 4S;jr'S<r(S=r)0r*S>r+S?r,S@r-SAr.SBr/SCr0SDr1SEr2SFr3\SG1-r4S^SHjr5"SISJ\ Rl5r7S_SKjr8SLr9S_SMjr:SNr;SOrSRr?\=\?SS.r@STrASUrBSVrCSWrDSXrESYrF\ RRSZ5rIS[rJS\rKg)`) annotationsN)_hex)errorparserpycompatsmartsetutil) stringutil()N)groupr))funcrrN[)rNN) subscriptr]N#)rNN)relationrN##)NN)_concatrN~)NN)ancestorrN^)rNN)parentr parentpost-)N)negate)minusr"N::) dagrangeall) dagrangeprer')dagranger' dagrangepost..:)rangeall)rangeprer.)ranger. rangepostnot) N)r3r4NN!and)r"NN)r6r"N&%)r"NN)onlyr"onlypostor)NN)r;r<N|)NN)keyvaluer>N)NN)listr@N)rNNNN)rsymbolNNN)rstringNNN)+=,rrrBrCend>r;r6r3"'s()[]#:=,-|&+!~^%s._@s-/c#^# [U[5(d[R"SU-5e[R "U5nUc[ nUc[nU(aT(aURSS5n[U4SjU55(a`US(a SUSS4v [U5S:a,[US5nSSU4v US(a SUSUS-4v SS[U54v gS[U5pvXg:Ga2XnUR5(aGO US:XaXUS -S :XaS SU4v US- nGOUS :XaXUS -S :XaS SU4v US- nGOUS :XaXUS -S:XaSSU4v US- nGOU[;a USU4v GOU[;dUS:XaXUS -S;aUS:Xa US- nXnSn O[Rn US- nUnXg:a3Xn U S:XaUS - nMX:XaSU "XU5U4v GO)US- nXg:aM3[R "[#S5U5eX;aUnUS- nXg:a-Xn X;aO#U S :XaXS- S :XaUS-nO US- nXg:aM-XUn U [$;aU SU4v OSU ;atT(aT"U 5(aSX4v O_U RS5nUSSH*n U (aSX4v U[U 5- nSSU4v US- nM, US(a SUSU4v OSX4v US-nO#[R "[#S5U-U5eUS- nXg:aGM2SSU4v g7f)a 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): >>> list(tokenize(b"@::")) [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)] s&revset statement must be bytes, got %rNr-rc3D># UHo(dM T"U5v M g7fN).0symlookups 6/usr/lib/python3/dist-packages/mercurial/revsetlang.py tokenize..ws3ess{vc{{es  rrBrGr@r&.r,rrr)sr'sr"cU$rNrOxs rStokenize..s1\rCsunterminated stringr!ssyntax error in revset '%s') isinstancebytesrProgrammingErrorr bytestr_syminitletters _symletterssplitalllenisspace_simpleopletters _quotelettersr unescapestr ParseErrorrkeywords) programrRsyminitletters symletterspartssposlcdecodedrQps ` rStokenizerzTs* gu % %$$ 5 ?  w'G( 6 dA& 3e3 3 3Qx %(A..5zA~aMT1o%8$eAhA664W. .  G  ' L 99;;  I'a0E9$$ $ 1HC I'a0E9$$ $ 1HC I'a0E9$$ $ 1HC " "dC.  DycAg&.8DyqL$++ 1HCA'L:1HC6$fWs^&>$ D |"'+- 44 Kr]cH[U5n[R"US/UQ76$)zCreate raw parsed tree from a template revset statement >>> _build(b'f(_) and _', (b'string', b'1'), (b'symbol', b'2')) ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2')) rB_)rr buildtree)tmplspecreplstemplates rS_buildr>s' 8$H   H&7 @% @@r]cL[U5n[R"X!SSS15$)zTest if a tree matches the given pattern statement; return the matches >>> _match(b'f(_)', parse(b'f()')) >>> _match(b'f(_)', parse(b'f(1)')) [('func', ('symbol', 'f'), ('symbol', '1')), ('symbol', '1')] >>> _match(b'f(_)', parse(b'f(1, 2)')) rr?rA)rr matchtree)patspecrpatterns rS_matchrHs.'"G   (;*@ r]c[SSX45$)Ns!ancestors(_) and not ancestors(_)r6)r)revsbasess rS _matchonlyrVs 68M NNr]c[U[5(dU$USnUS:XaxSUS4nUSSS:Xa[SX SS45$USSS:Xa [S U45$USSS :Xa[S X SS45$USSS :Xa [S U45$OIUS:XaU[SUSS-54$US:Xa*USSS:Xa[SUSSUSSUS45$U4[SUSS55-$)znRewrite raw parsed tree to resolve ambiguous syntax which cannot be handled well by our simple top-down parserrrr rr@r)r*r(r+r0r1r/r2r;rANrr relsubscriptc38# UHn[U5v M g7frN)_fixopsrPys rSrT_fixops..us3UU)r`tupler)rZrposts rSrrZsL a   1B Yqt$ Q47n $KtAw78 8 qT!W &OT23 3 qT!W #HdaDG45 5 qT!W #L$/0 0$ uGJ12./00 | !Q; 61a!A$q'1Q4@AA 553QqrU33 33r]cUcU$USnUS:Xa[[S/USSQ765$US:Xa[[S/USSQ765$US:Xa[[SUS55$US :Xa[R"[ S 55eUS :Xa[[S US55$US :Xa[[SUS55$US:Xa([ US[ S55n[SSU-45$US;aU$US:XaUS4$US;aU[US54$US:Xa[US5$US;a [US5n[US5nXU4$US:Xa.[US5n[US5n[US5nXXE4$US:XaU4[ SUSS55-$US:XaXS[US54$US:XaXS[US54$[SU-5e) Nrr%s _ and not _rr9 only(_, _)r:sonly(_)r(scan't use '::' in this contextr)s ancestors(_)r+sdescendants(_)r#scan't negate thatrCr!rCrBsmartsetnodesetr/>r;r3r0r2r r>r6r1rrr*rrr@rr>rAc38# UHn[U5v M g7frN_analyzers rSrT_analyze..s8%QXa[[%rr?rinvalid operator %r)rrrrmrrrr)rZrrstatbtcs rSrrxs5y 1B X~~6!"677 w}5qu566 { z1Q4011 ~ q!BCDD ~ !566  0!A$788 y adA23 4D1H-.. > > { Dz H HHQqTN## x!~  ad^ ad^|   ad^ ad^ ad^ wuu8!AB%8888 { aD(1Q4.)) waD(1Q4.)) +b0 11r]c[U5$)zTransform 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. rrYs rSanalyzers A;r]c^ ^^UcSU4$USnUS;aSU4$US:Xa[US5up#[US5upE[X$5n[SSX545nU(a'[US5S;aU[ S USUS54$[ X55=(d [ XS5nU(aU[ S /USSQ764$[S U5nU(a US X7S44$X$:aS nXaX544$US:Xa///smmm U UU4Sjn[ US5Hbn [U 5upjU b&U SS:Xd U SS:XaT RXj45 M9U"5 TRU5 TRU 5 Md U"5 [T5S:Xa TSTS4$[T5US[T5-44$US:XaK[SUS5(a[[ S55n U SU S4$[US5n U SXS44$US:XaSU4$US;a[US5n U SXS44$US;a([US5up#[US5upEX$-XU44$US;a[US5upjXaXS44$US:Xa[US5upjXaXSUS44$US:Xa&[SUSS56umm[T5U4T-4$US:Xa[US5upjXaUSU 44$US:Xau[US5n [US5up#[[RU 5S S5n[S!U5nU S":XaU(aXb-[ S#US54$Xb-XSU44$[!S$U-5e)%Nrrg?r6rr@s_() & ancestors(_)>draftsecret _notpublics_phaseandancestors(_, _)rsnot _s differences andsmallyr;c>T(dg[T5S:XaTSupO3SRST55n[SSU45n[U5upTR U5 TR U5 TSS2 g)Nrrc30# UH upUSv M g7f)rNrO)rPwts rSrT-_optimize..flushss..s3qtss_list(_)rC)rhjoinr _optimizeappend)rrrsrsstswss rSflushss_optimize..flushsssm2w!|!u1JJ333;A7 | IIaL IIaL1r]rCrBrr3spublic()s _notpublic()r/)r0r2r )r*r1)rrrrrr>rAc38# UHn[U5v M g7frNrrs rSrT_optimize.. s3Uy||Urr?r_weightscommonancestors(_)sheadss_commonancestorheads(_)r)rrrr|rrrrrhrrzipsumgetattrsymbolsrr)rZrwarwbrrmrrrofrrrs @@@rSrrsy!t 1B <<Av v1Q41Q4 K (62*: ; 1Q4$HHf8!A$!EE E r  4*R"4 f]3QqrU33 3 8R   rQ400 0 7Br, uR B 1AQ>> _parsewith(b'foo($1)', syminitletters=_aliassyminitletters) ('func', ('symbol', 'foo'), ('symbol', '$1')) >>> from . import error >>> from . import pycompat >>> try: ... _parsewith(b'$1') ... except error.ParseError as e: ... pycompat.sysstr(e.message) ... e.location "syntax error in revset '$1'" 0 >>> try: ... _parsewith(b'foo bar') ... except error.ParseError as e: ... pycompat.sysstr(e.message) ... e.location 'invalid token' 4 srevset(rN)rRrps invalid token)rAr;) startswithendswithr elementsrrzrhrrmrrsimplifyinfixops)rrRrpryrrts rS _parsewithr,s,$//*--$--2E2E hA^DID c$iq!12C88 6**41AB CCr]cH\rSrSrSr\"S5r\S5r\S5r Sr g) _aliasrulesiMz0Parsing and expansion rule set of revset aliasess revset aliasc[U[S9$)zParse 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. rp)r_aliassyminitletters)rs rS_parse_aliasrules._parseRs$/CDDr]c\USS:Xa#USSS:XaUSS[US54$gg)NrrrrBr@)rrs rS _trygetfunc_aliasrules._trygetfunc\sA 7g $q'!* "971:wtAw// /#: r]rON) __name__ __module__ __qualname____firstlineno____doc__r_section staticmethodrr __static_attributes__rOr]rSrrMs7:!HEE00r]rc:[RU5n[RX5nUbm[UR 55HPup4UR (dMUR (aM+U"[S5UR -5 SUlMR U$)zCExpand aliases in a tree, aliases is a list of (name, value) tupless warning: %s T)rbuildmapexpandsorteditemsrwarnedr)raliaseswarnnamealiass rS expandaliasesrbsu""7+G   g ,D !'--/2KD{{{5<<<Q'(EKK89# 3 Kr]c[U[5(a USS;aU$USS:XaU/n/nU(aUR5nUSS:XaUR[ USS55 OEUSS;aUR US5 O'[ S5US-n[R"U5eU(aMSS RU54$[S U55$) z(Fold elements to be concatenated by `##`r)rCrBrrrNrCrBs#"##" can't concatenate "%s" elementrCr]c38# UHn[U5v M g7frN) foldconcat)rPrs rSrTfoldconcat..s1DqZ]]Dr) r`rpopextendreversedrrrrmr)rpendingruemsgs rSr#r#os dE " "d1g2'   Aw*&  Atz!x!"/1//1BCqtL&&s++g388A;''1D111r]c[XS9$![RaSnURb@URnUR SS5nUS-SUS---S-[ S5-UleSnAff=f)N)rR  rs^ shere)rrrmlocationreplacerhint)rrRinstlocs rSrrsw $..     == $--C<<t,D u tsQw'77%?!G*LDI  s A2AA--A2c\S[R"[R"U55-$)zQuote a value in order to make it safe for the revset engine. >>> _quote(b'asdf') "'asdf'" >>> _quote(b"asdf'\"") '\'asdf\\\'"\'' >>> _quote(b'asdf\'') "'asdf\\''" >>> _quote(1) "'1'" s'%s')r escapestrr rc)rss rS_quoter5s% Z))(*:*:1*=> >>r]cUS:XaS[U5-$US:Xa [U5$US:Xa+[U[5(d[e[ U5 SU-$US:Xa[[ U55$US:Xa[UR55$[R"[S5U-5e![a [ef=f) Nds_rev(%d)srWs(%s)nbs&unexpected revspec format character %s) rr5r`ra TypeErrorrrbranchAttributeErrorrrmr)rvargs rS_formatargtyper?sDySX%% dc{ d#u%%O c } dc#h d #**,' '   1FG!K LL O s 8B33Cc[U5nUS:XagUS:Xa[XS5$US:Xa [U5$US:XaS[SR U55-$US:XaS SR S U55-$US :XaS SR S U55-$US-nS[USUU5[XSU54-$![ a [ ef=f)Nr _list('')rr7r8s _list(%s)rr9s_hexlist('%s')c38# UHn[U5v M g7frNrrPrs rSrT!_formatlistexp..s-@ac!ffarr:s _list('%s')c3@# UHoR5v M g7frN)r<rCs rSrTrDs.E1axxzz1sr@s (%s or %s))rhr?_formatintlistr5rr=r;_formatlistexp)rsrrurs rSrGrGs AAAv aa1&& da  dfUZZ]333 d 5::-@a-@#@@@ d !EJJ.E1.E$EE E QA N1Ra5!4nQrUA6NO OO  O s CCc[U5nUS:XagUS:Xa[SUS5$SSRSU55-$![[4a [ R "[S55ef=f) NrrArr7s_intlist('%s')rc3># UHnS[U5-v M g7f)s%dN)rrCs rSrT!_formatintlist..s-Kdec!fndsinvalid argument for revspec)rhr?rr;rrrmr)datarus rSrFrFszC I 6 !V!$Q0 0 5::-Kd-K#KKK z "Cq!@ABBCsAAA0A4c:^SRU4SjU55$)Ns, c3<># UHn[TU5v M g7frN)r?)rPrrs rSrT"_formatparamexp..s9DqnQ**Ds)r)argsrs `rS_formatparamexprQs ::9D9 99r])lpc[X5n/nUHupEUcURU5 MUS:XaE[U[5(a [ U5nUR[ [ U555 MfUS:Xa&UR[[ U5S55 M[R"SU-5e SRU5$)a 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 %d = rev(int(arg)), no quoting %s = string(arg), escaped and single-quoted %b = arg.branch(), escaped and single-quoted %n = hex(arg), single-quoted %% = a literal '%' Prefixing the type with 'l' specifies a parenthesized list of that type, and 'p' specifies a list of function parameters of that type. >>> formatspec(b'%r:: and %lr', b'10 or 11', (b"this()", b"that()")) '(10 or 11):: and ((this()) or (that()))' >>> formatspec(b'%d:: and not %d::', 10, 20) '_rev(10):: and not _rev(20)::' >>> formatspec(b'%ld or %ld', [], [1]) "_list('') or _rev(1)" >>> formatspec(b'keyword(%s)', b'foo\xe9') "keyword('foo\\xe9')" >>> b = lambda: b'default' >>> b.branch = b >>> formatspec(b'branch(%b)', b) "branch('default')" >>> formatspec(b'root(%ls)', [b'a', b'b', b'c', b'd']) "root(_list('a\\x00b\\x00c\\x00d'))" >>> formatspec(b'sort(%r, %ps)', b':', [b'desc', b'user']) "sort((:), 'desc', 'user')" >>> formatspec(b'%ls', [b'a', b"'"]) "_list('a\\x00\\'')" basesetrr9unknown revspec item type: %rr]) _parseargsrr`setrrFrrGrrbr)exprrPparsedretrr>s rS formatspecr\sJ #F C 9 JJsO *_#s##Sk JJ~d3i0 1 *_ JJ~d3i6 7(()IA)MN N 88C=r]c$[X5n/n/nUHupVUcURU5 MUS:Xa<S[R"U54nURU5 URS5 M]US:Xa(SU4nURU5 URS5 M[R "SU-5e SR U5n[U[S9n[R"US/UQ76n[U5n[U5n[U5nU$) zrrs rSspectreer`s  #F C F 9 JJsO *_"H$4$4S$9:G MM' " JJt  *_!3'G MM' " JJt (()IA)MN N 88C=D d+? @D   D"3 =f =D d D 4=D D>D Kr]ct[R"U5n[U5n/nSnU[U5:Ga[UR SU5nUS:aUR SXS45 GO,UR SXU45 US-nXnUS:XaUR SU45 US- nM~[U5n[RU5nU(aUS- nUS:Hn XnU (a'US:Xa!U(aUR S U45 US- nMU (a(US :Xa"U(aUR S U45 US- nGMUR SU"[U5U545 OUR S[#Xg545 US- nU[U5:aGM[[U5 [R"[S 55e![ a [R"[S55ef=f![a [R"[S55ef=f![ a [R"[S55ef=f![[ 4a [R"[S 55ef=f![[ 4a [R"[S 55ef=f![a U$f=f)zparse the expression and replace all inexpensive args return a list of tuple [(arg-type, arg-value)] Arg-type can be: * None: a string ready to be concatenated into a final spec * 'baseset': an iterable of revisions rr8Nrs#incomplete revspec format charactersmissing argument for revspecrRr7rUr9rrKs$too many revspec arguments specified)r rciterrhfindr IndexErrorrrmrnext StopIteration_formatlistfuncsrrr;rr?) rYrPargiterr[rtqrxr>rislists rSrWrW7s   D !D4jG C C D / IIdC  q5 JJd4j) *  D$1+&'!e N A 9 JJay ! 1HC  Gw-C   # 1HC$YF I !t) J,-qAI# J,-q K D!DIq/23  K D."89: qm D /p  W q!HIJJc N""1%K#LM M N G""1%D#EF F G &&<= &z* K&&q)H'IJJ K z* K&&q)H'IJJ K   J sNF<% G)H9#II6*J)<*G&)*H*I0I360J&) J76J7c0[R"US5$)Nr!)r prettyformatr s rSrlrls   t%; <>> gethashlikesymbols(parse(b'3::abe3ff')) ['3', 'abe3ff'] >>> gethashlikesymbols(parse(b'precursors(.)')) [] >>> gethashlikesymbols(parse(b'precursors(34)')) ['34'] >>> gethashlikesymbols(parse(b'abe3ffZ')) [] rrBrr>N)rxrhgethashlikesymbols)rresultssubtrees rSrzrzs{   Aw) T!W % %G9  & I TaABxG )'2 2G  Ir])NNNrrN)L __future__rstringi18nrnoderrr r r r utilsr rrnrrkrX iterbytestrrjsysbytes ascii_lettersdigitsrnbytechrrangerdrerzobjectrr|rrrrrrrrrrrrrrrrrrrrbasealiasrulesrrr#rr5r?rGrFrQrgr\r`rWrlrorqrecompilerurxrzrOr]rSrs# '  C'  9'  3 '   3 '   3 '  :'  9'   '    !' . L/' 0 01' 2 .3' 4 .5' 6 ,7' 8 49' : ,;' < +=' > , 1 - % %// 'M' R # t x++,?@A &../   FMM * +   H  eCo./ 0H$8$8$? @@ ET (/  '$   )0 G  A O4<32lc2L'$/DB0&''0* 22  ?M(P, C:   2j6JZ=  ''/// 0! r]