ROOTPLOIT
Server: Apache
System: Linux info 3.0 #1337 SMP Tue Jan 01 00:00:00 CEST 2000 all GNU/Linux
User: ws67150586 (67150586)
PHP: 8.3.36
Disabled: NONE
Upload Files
File: //kunden/kunden/kunden/lib/python3/dist-packages/mercurial/__pycache__/revsetlang.cpython-313.pyc
�

6�ht�
��SSKJr SSKrSSKJr SSKJr SSKJrJ	r	J
r
JrJ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;SOr<SPr=SQr>SRr?\=\?SS.r@STrASUrBSVrCSWrDSXrESYrF\R�R�SZ5rIS[rJS\rKg)`�)�annotationsN�)�_��hex)�error�parser�pycompat�smartset�util)�
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.�	rangepost�not)�
N)r3r4NN�!�and)r"NN)r6r"N�&�%)r"NN)�onlyr"�onlypost�or)�NN)r;r<N�|)�NN)�keyvaluer>N)�NN)�listr@N)rNNNN)r�symbolNNN)r�stringNNN)�+�=�,rrrBrC�end>r;r6r3�"�'s()[]#:=,-|&+!~^%s._@��s-/c#�^# �[U[5(d[R"SU-5e[R
"U5nUc[nUc[nU(a�T(a�URSS5n[U4SjU55(a`US(a
SUSS4v� [U5S:�a,[US5nSSU4v� US(a
SUSUS-4v� SS[U54v� gS[U5pvXg:Ga2XnUR5(aGO
US:XaXUS	-S
:XaS
SU4v� US-
nGO�US:XaXUS	-S:XaSSU4v� US-
nGO�US
:XaXUS	-S:XaSSU4v� US-
nGO�U[;a	USU4v� GO�U[;dUS:Xa�XUS	-S;a�US:Xa
US-
nXnSn	O[Rn	US-
nUnXg:a3Xn
U
S:XaUS	-
nMX�:XaSU	"XU5U4v� GO)US-
nXg:aM3[R "[#S5U5eX�;a�UnUS-
nXg:a-Xn
X�;aO#U
S:XaXS-
S:XaUS-nOUS-
nXg:aM-XUnU[$;aUSU4v� O�SU;atT(aT"U5(aSX�4v� O_URS5nUSSH*nU(aSX�4v� U[U5-
nSSU4v� US-
nM, US(a
SUSU4v� OSX�4v� 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-rc3�D># �UHo(dMT"U5v� M g7f�N�)�.0�sym�lookups  ��6/usr/lib/python3/dist-packages/mercurial/revsetlang.py�	<genexpr>�tokenize.<locals>.<genexpr>ws����3�e�s�s�{�v�c�{�{�e�s�
 � rrBrGr@r&�.r,rr�r)sr'sr"c��U$rNrO��xs rS�<lambda>�tokenize.<locals>.<lambda>�s��1��\rCsunterminated stringr!���ssyntax error in revset '%s')�
isinstance�bytesr�ProgrammingErrorr
�bytestr�_syminitletters�_symletters�split�all�len�isspace�_simpleopletters�
_quotelettersr	�unescapestr�
ParseErrorr�keywords)
�programrR�syminitletters�
symletters�parts�s�pos�l�c�decode�drQ�ps
 `           rS�tokenizerzTs�����*�g�u�%�%��$�$�5��?�
�	
����w�'�G���(���� �
��6��
�
�d�A�&���3�e�3�3�3��Q�x� �%��(�A�.�.��5�z�A�~���a��M���T�1�o�%���8�$�e�A�h��A��6�6��4��W��.�.��
��G���

�'��L���9�9�;�;��
��I�'��a��0�E�9��$��$�$��1�H�C�
��I�'��a��0�E�9��$��$�$��1�H�C�
��I�'��a��0�E�9��$��$�$��1�H�C�
�"�
"��d�C�.� �
����D�y��c�A�g�&�.�8��D�y��q����L��$���+�+���1�H�C��A��'��L����:��1�H�C���6�$�f�W�s�^�&<�a�@�@���q����'��&�&�q�)?�'@�!�D�D�
�
 ��A��1�H�C��'��L���&����I�'��'�"2�d�":��1�H�C���q����'��C�.�C��h���D�!�n�$�����f�S�k�k�$�c�-�-� �I�I�d�O�E�"�3�B�Z���#,�a�"3�3��S��V���#�T�1�o�-��Q���(��R�y�(�%��)�Q�7�7�� �#�)�)��1�H�C��"�"��0�1�G�;�S��
�	�q���k�'�l�4��
��s�H	M�AM�,C	M�8Mc�j�U(aUSS:XaUS$[R"[S55e)NrrBrsnot a symbol)rrmrrYs rS�	getsymbolr|�s/���Q�q�T�Y�
���t��
�
�
�1�_�-�
.�.r]c�j�U(aUSS:Xd	USS:XaUS$[R"U5e)NrrCrBr�rrm)rZ�errs  rS�	getstringr��s5���a��d�i��1�Q�4�9�#4���t��
�
�
�3�
�r]c��U(dU[LaU$[[X55$![a [R
"U5ef=frN)�_notset�intr��
ValueErrorrrm)rZr�defaults   rS�
getintegerr��sF�����'���$��9�Q�$�%�%���$����s�#�#�$�s	�(�!A	c�v�[R"[U55nUbU$[R"U5erN)r
�	parseboolr|rrm)rZr�values   rS�
getbooleanr��s2��� � ��1��.�E�����
�
�
�3�
�r]c�H�U(d/$USS:Xa[USS5$U/$)NrrAr)�listrYs rS�getlistr��s,����	���t�w���A�a�b�E�{��
�3�Jr]c���U(d[R"U5eUSnUS:Xa
USUS4$US:XaSUS4$US:XaUSS4$US:Xag[R"U5e)	Nrr1rr@r0r2r/�NNr~)rZr�ops   rS�getranger�s�������s�#�#�	
�1��B�	�X�~���t�Q�q�T�z��	�{�	��Q�q�T�z��	�|�	���t�T�z��	�{�	��
�
�
�3�
�r]c��U(a USS:Xd	USS:Xa[X5nXU4$[X5upg[XbU5[XrU54$)z�Get [first, last] integer range (both inclusive) from a parsed tree

If any of the sides omitted, and if no default provided, ParseError will
be raised.
rrCrB)r�r�)rZ�err1�err2�deffirst�deflast�n�a�bs        rS�getintranger�sS��	�a��d�i��1�Q�4�9�#4��q����t���A��D�A��a�x�(�*�Q�g�*F�F�Fr]c��[U5n[U5U:dUS:�a%[U5U:�a[R"U5eU$)Nr)r�rhrrm)rZ�min�maxrrus     rS�getargsr�!s<����
�A�
�1�v��|��q��S��V�c�\����s�#�#��Hr]c�l�[R"[U5U[R"U5SSS9$)Nr?rB)�keyvaluenode�keynode)r	�
buildargsdictr��splitargspec)rZ�funcname�keyss   rS�getargsdictr�(s3�������
�����D�!� ���r]c�^�[RU5nUc[U5=[U'nU$rN)�
_treecache�get�parse)�spec�trees  rS�_cachedtreer�6s-���>�>�$��D��|�"'��+�-�
�4��4��Kr]c�H�[U5n[R"US/UQ76$)z�Create 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�_)r�r	�	buildtree)�tmplspec�repls�templates   rS�_buildr�>s'���8�$�H����H�&7�@�%�@�@r]c�L�[U5n[R"X!SSS15$)z�Test 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)'))
r�r?rA)r�r	�	matchtree)�patspecr��patterns   rS�_matchr�Hs.���'�"�G�����(�;��*@��r]c��[SSX45$)Ns!ancestors(_) and not ancestors(_)r6)r�)�revs�basess  rS�
_matchonlyr�Vs���6���8M�N�Nr]c��[U[5(dU$USnUS:XaxSUS4nUSSS:Xa[SX SS45$USSS:Xa
[S	U45$USSS
:Xa[SX 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�relsubscriptc3�8# �UHn[U5v� M g7frN)�_fixops�rP�ys  rSrT�_fixops.<locals>.<genexpr>us���3�U������U���)r`�tupler�)rZr��posts   rSr�r�ZsL���a������	
�1��B�	�Y���q��t�$���Q�4��7�n�$��K���t�A�w�7�8�8�
�q�T�!�W��
&��O�T�2�3�3�
�q�T�!�W��
#��H�d�a�D��G�4�5�5�
�q�T�!�W��
#��L�$�/�0�0�$�	�u���G�J��1�2��.�/�0�0�	�|�	��!��Q��;� 6����1��a��!�A�$�q�'�1�Q�4�@�A�A��5�5�3�Q�q�r�U�3�3�3�3r]c���UcU$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!�rCrB�smartset�nodesetr/>r;r3r0r2r r>r6r1rrr*rrr@r�r>rAc3�8# �UHn[U5v� M g7frN��_analyzer�s  rSrT�_analyze.<locals>.<genexpr>�s���8�%�Q�X�a�[�[�%�r�r?r�invalid operator %r)r�r�rrmrr�r�r�)rZr�rs�ta�tb�tcs      rSr�r�xs5���y���	
�1��B�	�X�~���~�6��!�"��6�7�7�	�w����}�5�q���u�5�6�6�	�{�	���z�1�Q�4�0�1�1�	�~�	����q�!B�C�D�D�	�~�	�����!��5�6�6�	��	���0�!�A�$�7�8�8�	�y���a��d�A�2�3�4����D�1�H�-�.�.�	�>�	>���	�{�	��D�z��	�H�	H��H�Q�q�T�N�#�#�	�x����!��~��	��
��a��d�^��
�a��d�^����|��	��	�
�a��d�^��
�a��d�^��
�a��d�^������	�w���u�u�8�!�A�B�%�8�8�8�8�	�{�	��a�D�(�1�Q�4�.�)�)�	�w���a�D�(�1�Q�4�.�)�)�
�+�b�0�
1�1r]c��[U5$)z�Transform raw parsed tree to evaluatable tree which can be fed to
optimize() or getset()

All pseudo operations should be mapped to real operations or functions
defined in methods or symbols table respectively.
r�rYs rS�analyzer��s���A�;�r]c��^
^^�UcSU4$USnUS;aSU4$US:Xa�[US5up#[US5upE[X$5n[SSX545nU(a'[US5S;aU[	S	USUS54$[X55=(d [XS5nU(aU[	S
/USSQ764$[SU5nU(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[[	S55nUSUS4$[US5nUSXS44$US:XaSU4$US;a[US5nUSXS44$US;a([US5up#[US5upEX$-XU44$US;a[US5upjXaX�S44$US:Xa[US5upjXaX�SUS44$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)%Nrr�g�?r6rr@s_() & ancestors(_)>�draft�secret�
_notpublics_phaseandancestors(_, _)r�snot _s
differences	andsmallyr;c�>�T(dg[T5S:XaTSupO3SRST55n[SSU45n[U5upTR	U5 TR	U5 TSS2	g)Nrr�c3�0# �UHupUSv� M g7f)rNrO)rP�w�ts   rSrT�-_optimize.<locals>.flushss.<locals>.<genexpr>�s���3����q��t��s�s_list(_)rC)rh�joinr��	_optimize�append)r�r�rsr��ss�ts�wss    ���rS�flushss�_optimize.<locals>.flushss�sm������2�w�!�|��!�u���1��J�J�3��3�3���;��A��7�� ��|����I�I�a�L��I�I�a�L��1�r]rCrBr�r3spublic()s_notpublic()r/)r0r2r )r*r1)rrrrr�r>rAc3�8# �UHn[U5v� M g7frN�r�r�s  rSrT�_optimize.<locals>.<genexpr>s���3�U��y��|�|�U�r�r?r�_weightscommonancestors(_)sheadss_commonancestorheads(_)r�)r�r�r�r|r�r�r�r�rhr�r��zip�sum�getattr�symbolsr�r�)rZr��war��wbr�r��mr�r�r��o�fr�r�r�s             @@@rSr�r��s�����y��!�t��	
�1��B�	�
<�<��A�v�
�	�v���1�Q�4�����1�Q�4������K��
�(�6�2�*:�;����1�Q�4��$H�H��f�8�!�A�$��!��E�E�E�
�r��4�*�R�"4����f�]�3�Q�q�r�U�3�3�3��8�R� ����
�r�Q�4�0�0�0�
�7��B��r�,���	�u����R�
��B��	���1���A��Q�<�D�A��}�!�A�$�)�"3�q��t�y�7H��	�	�1�&�!���I��I�I�a�L��I�I�a�L��	�	��r�7�a�<��a�5�"�Q�%�<���2�w��Z�%��)�3�4�4�4�	�v���+�q��t�$�$��&��1�2�A��Q�4��1��:���!�A�$��A��Q�4�"��d��#�#�	�{�	��!�t��	�9�	9��a��d�O����t�b�A�$�Z���	�&�	&��1�Q�4�����1�Q�4�����w����$�$�	�B�	B���1������q�A�$�-���	��	���1������q�A�$��!��%�%�%�	�w���3�Q�q�r�U�3�4���B��2�w����
�"�"�	�{�	���1������q��t�Q�-���	�w���a��d�O���1�Q�4�����G�K�K��N�I�q�1���(�"�-��
��=�Q��6�6�"<�a��d�C�C�C��v��a�D�"�~�%�%�
�+�b�0�
1�1r]c� �[U5upU$)zSOptimize evaluatable tree

All pseudo operations should be transformed beforehand.
r�)r�r��newtrees   rS�optimizer�s��
!����G��Nr]�$c�t�U(a.URS5(aURS5(aSn[R"[5nUR	[XUS95upEU[
U5:wa [R"[S5U5e[[R"US55$)aGenerate a parse tree of given spec with given tokenizing options

>>> _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;)�
startswith�endswithr	�elementsr�rzrhrrmrr��simplifyinfixops)r�rRrpryr�rts      rS�
_parsewithr,s���,�$�/�/�*�-�-�$�-�-��2E�2E����
�
�h��A������^�D��I�D��c�$�i�����q�!1�2�C�8�8��6�*�*�4�1A�B�C�Cr]c�H�\rSrSrSr\"S5r\S5r\S5r	Sr
g)�_aliasrulesiMz0Parsing and expansion rule set of revset aliasessrevset aliasc��[U[S9$)z�Parse alias declaration/definition ``spec``

This allows symbol names to use also ``$`` as an initial letter
(for backward compatibility), and callers of this function should
examine whether ``$`` is used also for unexpected symbols or not.
�rp)r�_aliassyminitletters)r�s rS�_parse�_aliasrules._parseRs���$�/C�D�Dr]c�\�USS:Xa#USSS:XaUSS[US54$gg)NrrrrBr@)r��r�s rS�_trygetfunc�_aliasrules._trygetfunc\sA����7�g��$�q�'�!�*�	�"9���7�1�:�w�t�A�w�/�/�/�#:�r]rON)�__name__�
__module__�__qualname__�__firstlineno__�__doc__r�_section�staticmethodrr�__static_attributes__rOr]rSrrMs7��:���!�H��E��E��0��0r]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)r�buildmap�expand�sorted�itemsr�warnedr)r��aliases�warn�name�aliass     rS�
expandaliasesrbsu���"�"�7�+�G����g�,�D���!�'�-�-�/�2�K�D��{�{�{�5�<�<�<��Q�'�(�E�K�K�8�9�#���3��Kr]c��[U[5(a	USS;aU$USS:Xa�U/n/nU(a�UR5nUSS:XaUR[	USS55 OEUSS;aURUS5 O'[
S5US-n[R"U5eU(aM�SS	RU54$[S
U55$)z(Fold elements to be concatenated by `##`r)rCrBr�rrN�rCrBs#"##" can't concatenate "%s" elementrCr]c3�8# �UHn[U5v� M g7frN)�
foldconcat)rPr�s  rSrT�foldconcat.<locals>.<genexpr>�s���1�D�q�Z��]�]�D�r�)
r`r��pop�extend�reversedr�rrrmr�)r��pendingru�e�msgs     rSr#r#os����d�E�"�"�d�1�g�2�'�
���A�w�*���&��������
�A���t�z�!����x��!�"���/��1��/�/�����1����B�C�q��t�L���&�&�s�+�+��g��3�8�8�A�;�'�'��1�D�1�1�1r]c���[XS9$![RaSnURb@URnUR	SS5nUS-SUS---S-[S5-UleSnAff=f)N)rR�
� rs^ shere)rrrm�location�replacer�hint)r�rR�inst�locs    rSr�r��sw����$�.�.�����
��=�=�$��-�-�C��<�<��t�,�D�
�u��t�s�Q�w�'7�7�%�?�!�G�*�L�D�I�
��
�s��A2�AA-�-A2c�\�S[R"[R"U55-$)z�Quote 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�_quoter5�s%���Z�)�)�(�*:�*:�1�*=�>�>�>r]c��US: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)	N�ds_rev(%d)�srWs(%s)�n�bs&unexpected revspec format character %s)r�r5r`ra�	TypeErrorr�r�branch�AttributeErrorrrmr)rv�args  rS�_formatargtyper?�s����D�y��S��X�%�%�	
�d���c�{��	
�d���#�u�%�%��O�
�c�
���}��	
�d���c�#�h���	
�d��	��#�*�*�,�'�'��
�
�1�F�G�!�K�
L�L���	��O�	�s�8B3�3Cc��[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)r�r9s_hexlist('%s')c3�8# �UHn[U5v� M g7frNr�rPr�s  rSrT�!_formatlistexp.<locals>.<genexpr>�s���-@�a��c�!�f�f�a�r�r:s_list('%s')c3�@# �UHoR5v� M g7frN)r<rCs  rSrTrD�s���.E�1�a�x�x�z�z�1�s�r@s
(%s or %s))rhr?�_formatintlistr5r�r=r;�_formatlistexp)rsr�rur�s    rSrGrG�s����A��A��A�v��	
�a���a�1��&�&�	
�d���a� � �	
�d���f�U�Z�Z��]�3�3�3�	
�d�� �5�:�:�-@�a�-@�#@�@�@�	
�d��	�!�E�J�J�.E�1�.E�$E�E�E�	
�Q��A��N�1�R�a�5�!�4�n�Q�r�U�A�6N�O�O�O��	�	��O�	�s�C�Cc���[U5nUS:XagUS:Xa[SUS5$SSRSU55-$![[4a  [
R"[S55ef=f)	NrrArr7s_intlist('%s')r�c3�># �UHnS[U5-v� M g7f)s%dN)r�rCs  rSrT�!_formatintlist.<locals>.<genexpr>�s���-K�d��e�c�!�f�n�d�s��invalid argument for revspec)rhr?r�r;r�rrmr)�datarus  rSrFrF�sz��C���I����6��
�!�V�!�$��Q��0�0� �5�:�:�-K�d�-K�#K�K�K���z�"�C����q�!@�A�B�B�C�s�A�A�A�0A4c�:^�SRU4SjU55$)Ns, c3�<># �UHn[TU5v� M g7frN)r?)rPr�r�s  �rSrT�"_formatparamexp.<locals>.<genexpr>�s����9�D�q�n�Q��*�*�D�s�)r�)�argsr�s `rS�_formatparamexprQ�s����:�:�9�D�9�9�9r])�l�pc��[X5n/nUH�upEUcURU5 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\\'')"
�basesetr�r9�unknown revspec item type: %rr])�
_parseargsr�r`�setrrFr�rGrrbr�)�exprrP�parsed�retr�r>s      rS�
formatspecr\�s���J��
#�F�
�C�����9��J�J�s�O�
�*�_��#�s�#�#��S�k���J�J�~�d�3�i�0�1�
�*�_��J�J�~�d�3�i��6�7��(�(�)I�A�)M�N�N���8�8�C�=�r]c�$�[X5n/n/nUH�upVUcURU5 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$)	z<similar to formatspec but return a parsed and optimized treerUr�r�r�rVr]r)rBr�)rWr�r�basesetrrbr�rrr	r�r#r�r�)	rYrPrZr[�inputsr�r>r�r�s	         rS�spectreer`s���
��
#�F�
�C�
�F�����9��J�J�s�O�
�*�_�"�H�$4�$4�S�$9�:�G��M�M�'�"��J�J�t��
�*�_�!�3�'�G��M�M�'�"��J�J�t���(�(�)I�A�)M�N�N���8�8�C�=�D��d�+?�@�D����D�"3�=�f�=�D��d��D��4�=�D��D�>�D��Kr]c�t�[R"U5n[U5n/nSnU[U5:Ga[UR	SU5nUS:aURSXS45 GO,URSXU45 US-nXnUS:XaURSU45 US-
nM~[U5n[RU5nU(a�US-
nUS:Hn	XnU	(a'US:Xa!U(aURS	U45 US-
nM�U	(a(US
:Xa"U(aURSU45 US-
nGMURSU"[U5U545 OURS[#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)z�parse 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 revspecrRr7rUr9r�rKs$too many revspec arguments specified)r
rc�iterrh�findr��
IndexErrorrrmr�next�
StopIteration�_formatlistfuncsr�r�r;r�r?)
rYrP�argiterr[rt�qrxr>r��islists
          rSrWrW7s������D�!�D��4�j�G�
�C�
�C�

��D�	�/��I�I�d�C� ���q�5��J�J��d�4�j�)�*���
�
�D�$�1�+�&�'��!�e��	N��	�A�
��9��J�J��a�y�!��1�H�C��	G��w�-�C�
� � ��#����1�H�C��$�Y�F�
��I��
�!�t�)���
�
�J��,�-��q�����A��I�#��
�
�J��,�-��q����
K��
�
�D�!�D��I�q�/�2�3�

K��
�
�D�.��"8�9�:�	�q���m��D�	�/�p
��W�
����q�!H�I�J�J��c�	N��"�"�1�%K�#L�M�M�	N���	G��"�"�1�%D�#E�F�F�	G���
��&�&��<�=���
��&�z�*�
K��&�&�q�)H�'I�J�J�
K���z�*�
K��&�&�q�)H�'I�J�J�
K���
���J�
�sN�F<�%G)�H�9#I�I6�*J)�<*G&�)*H�*I�0I3�60J&�)
J7�6J7c�0�[R"US5$)Nr!)r	�prettyformatr
s rSrlrl�s�����t�%;�<�<r]c�f�[U[5(a[[[U55S-$g)Nrr)r`r�r��map�depthr
s rSroro�s)���$�����3�u�d�#�$�q�(�(�r]c���[U[5(a	USS;a
[5$[5nUSSHnU[U5-nM USS:XaUR	USS5 U$)Nrr!rr)r`r�rX�	funcsused�add)r��funcsrss   rSrqrq�sl���d�E�"�"�d�1�g�1G�&G��u������a�b��A��Y�q�\�!�E����7�g���I�I�d�1�g�a�j�!��r]s[0-9a-fA-F]{1,40}$c�,�[RU5$)z,returns true if the symbol looks like a hash)�_hashre�match)�symbols rS�_ishashlikesymbolrx�s���=�=�� � r]c��U(d/$USS:Xa[US5(aUS/$/$[U5S:�a/nUSSHnU[U5-
nM U$/$)areturns the list of symbols of the tree that look like hashes

>>> gethashlikesymbols(parse(b'3::abe3ff'))
['3', 'abe3ff']
>>> gethashlikesymbols(parse(b'precursors(.)'))
[]
>>> gethashlikesymbols(parse(b'precursors(34)'))
['34']
>>> gethashlikesymbols(parse(b'abe3ffZ'))
[]
rrBrr>N)rxrh�gethashlikesymbols)r��results�subtrees   rSrzrz�s{����	��A�w�)���T�!�W�%�%���G�9��&��I�

�T��a�����A�B�x�G��)�'�2�2�G� ���
�Ir])NNNr�rN)L�
__future__r�string�i18nr�noder�rr	r
rr�utilsr
r�rnr�rkrX�iterbytestrrj�sysbytes�
ascii_letters�digitsrn�bytechr�rangerdrerz�objectr�r|r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�basealiasrulesrrr#r�r5r?rGrFrQrgr\r`rWrlrorq�re�compilerurxrzrOr]rS�<module>r�s��#�
������'��
C�'�	�
9�'�	�
3�	'�

�3�'�	�
3�
'�	�
:�'�	�
9�'�
��'� 
��!'�.	�
L�/'�0�0�1'�2	�
.�3'�4�.�5'�6	�
,�7'�8	�
4�9'�:
�,�;'�<	�
+�='�>,�
1�
-�
%�
%�/�/�'�M'��R#��
���t��
��x�+�+�,?�@�A���������&�.�.�/�
�
�
�F�M�M�
*�	+�
�	�����H���e�C��o�.�/�
0����H�$8�$8��$?� @�@��E�T�(��/� � '�$� �� �)0��
G�
���
��A��O�4�<32�l�c2�L�'�$��/��D�B0�&�'�'�0�*
�2�2
� ?�M�(P�,	C�:�
�
���2�j�6J�Z=��	��'�'�/�/�/�
0��!�
r]