6hfSSKJr SSKJr SSKJrJr SSKJr "SS5r Sr S r S r S r S rS rSrSrSrSSjrSr"SS5r"SS5rg)) annotations)_)errorutil) stringutilcV\rSrSrS SjrSrSrSrS SjrSSjr S r S r S r S r g)parserNc*XlX lSUlgN) _elements_methodscurrent)selfelementsmethodss 2/usr/lib/python3/dist-packages/mercurial/parser.py__init__parser.__init__s!  cTURn[URS5UlU$)zadvance the tokenizerN)rnext_iter)rts r_advanceparser._advance#s" LLDJJ- rcR[URURSSS5$)z%True if next token may start new termrr)anyrr)rs r _hasnewtermparser._hasnewterm)s%4>>$,,q/21Q788rcURSU:wa=[R"[S5URS-URS5eUR 5 g)z0make sure the tokenizer matches an end conditionrsunexpected token: %sN)rr ParseErrorrr)rms r_match parser._match-sP <<?a "")*T\\!_?D""1%8#9E#A3G G^^DLLO4Q77 $  E# NN51!"5MEu)9)9););~a$(:(:E!"I(FG&&q)<'='EsKK^^DLLO4Q77 rcrXlUR5 UR5nURup4nX%4$)z!generate a parse tree from tokens)rrr*r)r tokeniterresr0r1r2s rparse parser.parseWs0  kkm LLcxrc[U[5(dU$URUS"USSVs/sHo RU5PM sn6$s snf)z4recursively evaluate a parse tree using node methodsrrN) isinstancetuplereval)rtreers rr@ parser.eval_sJ$&&K}}T!W%d12h'Gh ! h'GHH'GsAclURU5nUR(aURU5$U$)z>> splitargspec(b'') ([], None, [], None) >>> splitargspec(b'foo bar') ([], None, ['foo', 'bar'], None) >>> splitargspec(b'foo *bar baz **qux') (['foo'], 'bar', ['baz'], 'qux') >>> splitargspec(b'*foo') ([], 'foo', [], None) >>> splitargspec(b'**foo') ([], None, [], 'foo') Ns**sno **optkey name providedrs!excessive **optkey names providedr*sno *varkey name provided) partitionsplitrProgrammingErrorlen)specoptkeypreseppostpostspress r splitargspecrYmsF^^E*NCd  (()EF F u:>(()MN Nq]]4(NCd 99;D JJLE (()DE E1XuQRy&00 tT !!rc^UupVpx[U4Sj[U55[U55n U [U5:a.[R"[ S5U[U5S.-5eU(dUU [U5[U5-:a:[R"[ S5U[U5[U5-S.-5e[ R"5n [XPSU 5H upXU 'M U(aU[U 5U X'O$[Xp[U 5U 5H upXU 'M U(a[ R"5X'X SHn U (aU ST:wd U SSU:wa$[R"[ S5S U0-5eU SSn X;aU n O/U(d$[R"[ S 5XS .-5eXn X;a$[R"[ S 5XS .-5eU S X'M U $)ayBuild dict from list containing positional and keyword arguments Arguments are specified by a tuple of ``(poskeys, varkey, keys, optkey)`` where - ``poskeys``: list of names of positional arguments - ``varkey``: optional argument name that takes up remainder - ``keys``: list of names that can be either positional or keyword arguments - ``optkey``: optional argument name that takes up excess keyword arguments If ``varkey`` specified, all ``keys`` must be given as keyword arguments. Invalid keywords, too few positional arguments, or too many positional arguments are rejected, but missing keyword arguments are just omitted. c3T># UHupU(dMUST:XdMUv M g7frNrK).0ix keyvaluenodes r buildargsdict..s&F'tq111E's (( (s6%(func)s takes at least %(nargs)d positional arguments)funcsnargss5%(func)s takes at most %(nargs)d positional argumentsNrrs %(func)s got an invalid argumentrcs5%(func)s got an unexpected keyword argument '%(key)s')rcskeys;%(func)s got multiple values for keyword argument '%(key)s'r$) r enumeraterQrr%rrsortdictzip)treesfuncnameargspecr`keynodeposkeysvarkeykeysrSkwstartargskr_ds ` r buildargsdictrrs %,!GTFy'F E GW G H CL9 :   gG s4y 88 F G CL3t9,DE F   ==?DG8G_-Q. SY1 CI89DAG:}} 8_AaDL(AaDGw,>""56'89LL  aDG 9A""JK$01   A 6""*%0 1 t/0 Krc[R"U5$![a=n[R"[R "U5R 55eSnAff=fr )r unescapestr ValueErrorrr% forcebytestrlower)ses rrtrtsRC%%a(( C z66q9??ABB Cs A8AAc[U[5(d(URU[R"U545 gUSU;aH[ [RUSS5nURUSUSSR U54-45 gURUSUS-45 USSHn[XQUS-U5 M USSUSSS-4/USS&g)Nrrs(%s %s) s(%s))r>r?appendrpprintmapjoin _prettyformat)rA leafnodeslevellinesrsrxs rrrs dE " " eZ..t456 aI  ""DH - eZ47DIIbM*BBCD eVd1g-./abA ! 5 9Ry|U2Yq\D%89:bc rcT/n[XSU5 SRSU55nU$)Nr c36# UHupSU-U-v M g7f)s NrK)r]lrxs rraprettyformat..s:EDAQEs)rr)rArroutputs r prettyformatrs, E$1e, ZZ:E: :F Mrcx^[U[5(dU$USnUT;aU4[U4SjUSS55-$/nUnUSU:Xa/USSupVUR[UT55 UnUSU:XaM/UR[UT55 URU5 [[ U55$)a{Flatten chained infix operations to reduce usage of Python stack >>> from . import pycompat >>> def f(tree): ... s = prettyformat(simplifyinfixops(tree, (b'or',)), (b'symbol',)) ... print(pycompat.sysstr(s)) >>> f((b'or', ... (b'or', ... (b'symbol', b'1'), ... (b'symbol', b'2')), ... (b'symbol', b'3'))) (or (symbol '1') (symbol '2') (symbol '3')) >>> f((b'func', ... (b'symbol', b'p1'), ... (b'or', ... (b'or', ... (b'func', ... (b'symbol', b'sort'), ... (b'list', ... (b'or', ... (b'or', ... (b'symbol', b'1'), ... (b'symbol', b'2')), ... (b'symbol', b'3')), ... (b'negate', ... (b'symbol', b'rev')))), ... (b'and', ... (b'symbol', b'4'), ... (b'group', ... (b'or', ... (b'or', ... (b'symbol', b'5'), ... (b'symbol', b'6')), ... (b'symbol', b'7'))))), ... (b'symbol', b'8')))) (func (symbol 'p1') (or (func (symbol 'sort') (list (or (symbol '1') (symbol '2') (symbol '3')) (negate (symbol 'rev')))) (and (symbol '4') (group (or (symbol '5') (symbol '6') (symbol '7')))) (symbol '8'))) rc3<># UHn[UT5v M g7fr )simplifyinfixops)r]r_ targetnodess rra#simplifyinfixops..5sPx!-a==xsrN)r>r?r~rreversed)rArop simplifiedr_rrs ` rrrsx dE " " aB uuPtABxPPPP J A A$"*u*1k:;  A$"*&q+67b *% &&rc^^UT:XaTR5$[U[5(dU$[UU4SjU55$)Nc3>># UHn[UTT5v M g7fr ) _buildtree)r]r_ placeholder replstacks rra_buildtree..JsI1A{I66s)popr>r?)templaterrs ``rrrEs:;}} h & & II IIrc[U[5(d[R"S5e[ [ U55n[ XU5nU(a[R"S5eU$)aCreate new tree by substituting placeholders by replacements >>> _ = (b'symbol', b'_') >>> def f(template, *repls): ... return buildtree(template, _, *repls) >>> f((b'func', (b'symbol', b'only'), (b'list', _, _)), ... ('symbol', '1'), ('symbol', '2')) ('func', ('symbol', 'only'), ('list', ('symbol', '1'), ('symbol', '2'))) >>> f((b'and', _, (b'not', _)), (b'symbol', b'1'), (b'symbol', b'2')) ('and', ('symbol', '1'), ('not', ('symbol', '2'))) placeholder must be a node tuplestoo many replacements)r>r?rrPlistrr)rrreplsrrs r buildtreerMsW k5 ) )$$%HIIXe_%I8)4A$$%=>> Hrc^^^X:Xag[U[5(a[U[5(dgUT:XaUST;aTRU5 g[U5[U5:wag[ UUU4Sj[ X555$)NTFrc3D># UHup[XTTT5v M g7fr ) _matchtree)r]pr_incompletenodesmatchesrs rra_matchtree..ls(&DA 1ow??&s )r>r?r~rQallrfpatternrArrrs ```rrrbs{ gu % %Ze-D-D+$q'"@t 7|s4y  & rNcUb+[U[5(d[R"S5eU/n[ XX#U5(aU$g)aIf a tree matches the pattern, return a list of the tree and nodes matched with the placeholder; Otherwise None >>> def f(pattern, tree): ... m = matchtree(pattern, tree, _, {b'keyvalue', b'list'}) ... if m: ... return m[1:] >>> _ = (b'symbol', b'_') >>> f((b'func', (b'symbol', b'ancestors'), _), ... (b'func', (b'symbol', b'ancestors'), (b'symbol', b'1'))) [('symbol', '1')] >>> f((b'func', (b'symbol', b'ancestors'), _), ... (b'func', (b'symbol', b'ancestors'), None)) >>> f((b'range', (b'dagrange', _, _), _), ... (b'range', ... (b'dagrange', (b'symbol', b'1'), (b'symbol', b'2')), ... (b'symbol', b'3'))) [('symbol', '1'), ('symbol', '2'), ('symbol', '3')] The placeholder does not match the specified incomplete nodes because an incomplete node (e.g. argument list) cannot construct an expression. >>> f((b'func', (b'symbol', b'ancestors'), _), ... (b'func', (b'symbol', b'ancestors'), ... (b'list', (b'symbol', b'1'), (b'symbol', b'2')))) The placeholder may be omitted, but which shouldn't match a None node. >>> _ = None >>> f((b'func', (b'symbol', b'ancestors'), None), ... (b'func', (b'symbol', b'ancestors'), (b'symbol', b'0'))) Nr)r>r?rrPrrs r matchtreerrsJDz+u'E'E$$%HIIfG'wGGHrc|URb$[S5URUR4-$UR$)z6Compose error message from specified ParseError objects at %d: %s)locationrmessage)insts rparseerrordetailrs2 }} $--!>>>||rc\rSrSrSrSrSrg)aliasizParsed result of aliascBXlX lX0lX@lSUlg)NF)nameror replacementwarned)rrroerrrs rralias.__init__s    & r)rorrrrN)rFrGrHrI__doc__rrJrKrrrrs  rrc\rSrSrSrSrSrSr\S5r \S5r \ S5r \ S 5r \ S 5r\ S 5r\ S 5r\ S 5r\ S5r\ S5r\ S5rSrg)basealiasrulesia[Parsing and expansion rule set of aliases This is a helper for fileset/revset/template aliases. A concrete rule set should be made by sub-classing this and implementing class/static methods. It supports alias expansion of symbol and function-call styles:: # decl = defn h = heads(default) b($1) = ancestors($1) - ancestors(default) Nssymbolc2[SUR-5e)Ns'%s' is not instantiatable) TypeErrorrF)clss r__new__basealiasrules.__new__s5 DEErc[e)z-Parse an alias name, arguments and definitionNotImplementedError)rRs rr*basealiasrules._parse "!rc[e)z9Return (name, args) if tree is a function; otherwise Noner)rAs r _trygetfuncbasealiasrules._trygetfuncrrc^TRU5nUSTR:Xa1USnUR S5(aUS[ S5U-4$USS4$TRU5nU(aUupFUR S5(aUS[ S5U-4$[U4SjU55(aUS[ S54$[U5[[U55:waUS[ S 54$XFVs/sHowSPM snS4$US[ S 54$![RanUS[U54sSnA$SnAff=fs snf) aI Parse an alias declaration into ``(name, args, errorstr)`` This function analyzes the parsed tree. The parsing rule is provided by ``_parse()``. - ``name``: of declared alias (may be ``decl`` itself at error) - ``args``: list of argument names (or None for symbol declaration) - ``errorstr``: detail about detected error (or None) >>> sym = lambda x: (b'symbol', x) >>> symlist = lambda *xs: (b'list',) + tuple(sym(x) for x in xs) >>> func = lambda n, a: (b'func', sym(n), a) >>> parsemap = { ... b'foo': sym(b'foo'), ... b'$foo': sym(b'$foo'), ... b'foo::bar': (b'dagrange', sym(b'foo'), sym(b'bar')), ... b'foo()': func(b'foo', None), ... b'$foo()': func(b'$foo', None), ... b'foo($1, $2)': func(b'foo', symlist(b'$1', b'$2')), ... b'foo(bar_bar, baz.baz)': ... func(b'foo', symlist(b'bar_bar', b'baz.baz')), ... b'foo(bar($1, $2))': ... func(b'foo', func(b'bar', symlist(b'$1', b'$2'))), ... b'foo($1, $2, nested($1, $2))': ... func(b'foo', (symlist(b'$1', b'$2') + ... (func(b'nested', symlist(b'$1', b'$2')),))), ... b'foo("bar")': func(b'foo', (b'string', b'bar')), ... b'foo($1, $2': error.ParseError(b'unexpected token: end', 10), ... b'foo("bar': error.ParseError(b'unterminated string', 5), ... b'foo($1, $2, $1)': func(b'foo', symlist(b'$1', b'$2', b'$1')), ... } >>> def parse(expr): ... x = parsemap[expr] ... if isinstance(x, Exception): ... raise x ... return x >>> def trygetfunc(tree): ... if not tree or tree[0] != b'func' or tree[1][0] != b'symbol': ... return None ... if not tree[2]: ... return tree[1][1], [] ... if tree[2][0] == b'list': ... return tree[1][1], list(tree[2][1:]) ... return tree[1][1], [tree[2]] >>> class aliasrules(basealiasrules): ... _parse = staticmethod(parse) ... _trygetfunc = staticmethod(trygetfunc) >>> builddecl = aliasrules._builddecl >>> builddecl(b'foo') ('foo', None, None) >>> builddecl(b'$foo') ('$foo', None, "invalid symbol '$foo'") >>> builddecl(b'foo::bar') ('foo::bar', None, 'invalid format') >>> builddecl(b'foo()') ('foo', [], None) >>> builddecl(b'$foo()') ('$foo()', None, "invalid function '$foo'") >>> builddecl(b'foo($1, $2)') ('foo', ['$1', '$2'], None) >>> builddecl(b'foo(bar_bar, baz.baz)') ('foo', ['bar_bar', 'baz.baz'], None) >>> builddecl(b'foo($1, $2, nested($1, $2))') ('foo($1, $2, nested($1, $2))', None, 'invalid argument list') >>> builddecl(b'foo(bar($1, $2))') ('foo(bar($1, $2))', None, 'invalid argument list') >>> builddecl(b'foo("bar")') ('foo("bar")', None, 'invalid argument list') >>> builddecl(b'foo($1, $2') ('foo($1, $2', None, 'at 10: unexpected token: end') >>> builddecl(b'foo("bar') ('foo("bar', None, 'at 5: unterminated string') >>> builddecl(b'foo($1, $2, $1)') ('foo', None, 'argument names collide with each other') Nrr$invalid symbol '%s'sinvalid function '%s'c3F># UHoSTR:gv M g7fr\) _symbolnode)r]rrs rra,basealiasrules._builddecl../s9DqQ43??*Ds!sinvalid argument lists&argument names collide with each othersinvalid format) r*rr%rr startswithrrr rQset)rdeclrArrfuncrors` r _builddeclbasealiasrules._builddeclsXZ 8::d#D 7coo %7Dt$$dA&<$=$DEE$% %t$ JDt$$dA&>$?$$FGG9D999dA&>$?@@4yCD N*?@ .AQ4.5 5dA/0115 8$ 0 67 7 80/s#D6EE+ D>8E>EcP^^[U[5(dU$USnUTR:waU4[UU4SjUSS55-$[U5S:XdeUSnUT;aSnX44$UR S5(a"[ R "[S5U-5eX44$) z%Mark alias arguments as ``_aliasarg``rc3H># UHnTRUT5v M g7fr ) _relabelargs)r]r_rors rra.basealiasrules._relabelargs..Bs! MHq!1!1!T!:!:H"rNr$ _aliasargrr)r>r?rrQrrr%r)rrArorsyms` ` rrbasealiasrules._relabelargs;s$&&K !W  55 MDH MMM M4yA~~1g $;By^^D ! !""1%;#>> from . import pycompat >>> parsemap = { ... b'$1 or foo': (b'or', (b'symbol', b'$1'), (b'symbol', b'foo')), ... b'$1 or $bar': ... (b'or', (b'symbol', b'$1'), (b'symbol', b'$bar')), ... b'$10 or baz': ... (b'or', (b'symbol', b'$10'), (b'symbol', b'baz')), ... b'"$1" or "foo"': ... (b'or', (b'string', b'$1'), (b'string', b'foo')), ... } >>> class aliasrules(basealiasrules): ... _parse = staticmethod(parsemap.__getitem__) ... _trygetfunc = staticmethod(lambda x: None) >>> builddefn = aliasrules._builddefn >>> def pprint(tree): ... s = prettyformat(tree, (b'_aliasarg', b'string', b'symbol')) ... print(pycompat.sysstr(s)) >>> args = [b'$1', b'$2', b'foo'] >>> pprint(builddefn(b'$1 or foo', args)) (or (_aliasarg '$1') (_aliasarg 'foo')) >>> try: ... builddefn(b'$1 or $bar', args) ... except error.ParseError as inst: ... print(pycompat.sysstr(parseerrordetail(inst))) invalid symbol '$bar' >>> args = [b'$1', b'$10', b'foo'] >>> pprint(builddefn(b'$10 or baz', args)) (or (_aliasarg '$10') (symbol 'baz')) >>> pprint(builddefn(b'"$1" or "foo"', args)) (or (string '$1') (string 'foo')) )r*rr)rdefnrorAs r _builddefnbasealiasrules._builddefnLs7^zz$ t9D5D++rc4S=p4URU5upVnU(a [S5nOURX&5nU(aUUR UUS.-n[XVXs5$![Ra n[ U5n[S5nSnANUSnAff=f)z>Parse an alias declaration and definition into an alias objectNs4bad declaration of %(section)s "%(name)s": %(error)ss3bad definition of %(section)s "%(name)s": %(error)s)sectionnameserror)rrrrr%r_sectionr) rrrreplefmtrrorrs rbuildbasealiasrules.builds...C LMD Q~~d1 LLC T++## Q&t,OP QsA##B7BBc^0nUH$up4URX45nXRUR'M& U$)zLParse a list of alias (name, replacement) pairs into a dict of alias objects)rr)ritemsaliasesrras rbuildmapbasealiasrules.buildmaps5JD $%AAFFO rc:[U[5(dgUSUR:Xa.USnURU5nU(aURcUS4$UR U5nU(a,Uup6URU5nU(aURbXF4$g)zbIf tree looks like an unexpanded alias, return (alias, pattern-args) pair. Return None otherwise. Nrr)r>r?rgetror)rrrArrrros r _getaliasbasealiasrules._getaliass $&& 7coo %7D D!AQVV^$wt$ JD D!AQVV'wrc^^[U[5(dU$USS:Xa USnTU$[UU4SjU55$)z_Replace _aliasarg instances with the substitution value of the same name in args, recursively. rrrc3H># UHnTRUT5v M g7fr ) _expandargs)r]rrors rra-basealiasrules._expandargs..sr?)rrArors` ` rrbasealiasrules._expandargssG $&&K 7l "q'C9 # UHnTRTUTT5v M g7fr _expand)r]rrcacher expandings rra)basealiasrules._expand..s&CGa GQ 5994s!$s5infinite expansion of %(section)s "%(name)s" detected)rrsinvalid number of arguments: %d)r>r?rrAbortr%rrrr~rrrrorQrdictrf) rrrArrrrrresultrs `` `` rrbasealiasrules._expands$&&K MM'4 ( 9CG  77++agg& & >""JK"||aff=>   66 KK 5E!&&Mqvv  66>M q6S[ ""45A> :; ;AS[[!R / ;vtCN';<< rsy&#MM`"DCLC ;M'`J *  &R  y2y2r