403Webshell
Server IP : 74.208.236.16  /  Your IP : 216.73.216.220
Web Server : Apache
System : Linux info 3.0 #1337 SMP Tue Jan 01 00:00:00 CEST 2000 all GNU/Linux
User : u102440577 ( 7172810)
PHP Version : 8.4.26
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /kunden/lib/python3/dist-packages/mercurial/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /kunden/lib/python3/dist-packages/mercurial/__pycache__/dirstate.cpython-313.pyc
�

6�hY���SSKJr SSKrSSKrSSKrSSKrSSKrSSKJrJ	r	J
r
JrJrJ
r
Jr SSKJr SSKJrJr SSKJr SSKJrJrJrJrJrJrJrJrJ r J!r!J"r" SS	K#J$r$ SS
K%J&r' \RP"S5r)\RT"SS
S9r+\+SLr,\"RZr-\ R\r.\R^r0\Rbr1"SS\.5r2"SS\.5r3Sr4Sr5Sr6Sr7Sr8Sr9Sr:"SS\'Rv5r&g)�)�annotationsN)�Any�Dict�Iterable�Iterator�List�Optional�Tuple�)�_)�MatcherT�TransactionT)�tracing)�dirstatemap�encoding�error�match�node�pathutil�policy�pycompat�scmutil�txnutil�util)�	timestamp)�dirstate�parsersrT)�pyo3c��\rSrSrSrSrSrg)�	repocache�Dzfilecache for files in .hg/c�8�URRU5$�N)�_opener�join��self�obj�fnames   �4/usr/lib/python3/dist-packages/mercurial/dirstate.pyr%�repocache.joinGs���{�{����&�&��N��__name__�
__module__�__qualname__�__firstlineno__�__doc__r%�__static_attributes__r-r,r*r r Ds
��%�'r,r c��\rSrSrSrSrSrg)�	rootcache�Kz*filecache for files in the repository rootc�$�URU5$r#)�_joinr&s   r*r%�rootcache.joinNs���y�y���r,r-Nr.r-r,r*r6r6Ks
��4� r,r6c�^�U4SjnU$)z�check that the func is called with a non-invalidated dirstate

The dirstate is in an "invalidated state" after an error occured during its
modification and remains so until we exited the top level scope that framed
such change.
c�>�UR(a'SnUTR-n[R"U5eT"U/UQ70UD6$)Nz/calling `%s` after the dirstate was invalidated)�_invalidated_contextr/r�ProgrammingError�r'�args�kwargs�msg�funcs    �r*�wrap�check_invalidated.<locals>.wrapZsE����$�$�C�C��4�=�=� �C��(�(��-�-��D�*�4�*�6�*�*r,r-�rCrDs` r*�check_invalidatedrGRs���+��Kr,c�&^�U4Sjn[U5$)Nc�>�UR(d'SnUTR-n[R"U5eT"U/UQ70UD6$)Nz2calling `%s` outside of a changing_parents context)�is_changing_parentsr/rr>r?s    �r*rD�'requires_changing_parents.<locals>.wrapesE����'�'�F�C��4�=�=� �C��(�(��-�-��D�*�4�*�6�*�*r,�rGrFs` r*�requires_changing_parentsrMd����+��T�"�"r,c�&^�U4Sjn[U5$)Nc�>�UR(d'SnUTR-n[R"U5eT"U/UQ70UD6$)Nz*calling `%s` outside of a `changing_files`)�is_changing_filesr/rr>r?s    �r*rD�%requires_changing_files.<locals>.wrappsE����%�%�>�C��4�=�=� �C��(�(��-�-��D�*�4�*�6�*�*r,rLrFs` r*�requires_changing_filesrSorNr,c�&^�U4Sjn[U5$)Nc�>�UR(d'SnUTR-n[R"U5eT"U/UQ70UD6$)Nz*calling `%s` outside of a changing context)�is_changing_anyr/rr>r?s    �r*rD�#requires_changing_any.<locals>.wrap{sE����#�#�>�C��4�=�=� �C��(�(��-�-��D�*�4�*�6�*�*r,rLrFs` r*�requires_changing_anyrXzrNr,c�&^�U4Sjn[U5$)Nc�>�UR(d7URS:�d'SnUTR-n[R"U5eT"U/UQ70UD6$)NrzBcalling `%s` outside of a changing_files or running_status context)rQ�_running_statusr/rr>r?s    �r*rD�/requires_changing_files_or_status.<locals>.wrap�sY����&�&�$�*>�*>��*B�,�
�
�4�=�=� �C��(�(��-�-��D�*�4�*�6�*�*r,rLrFs` r*�!requires_changing_files_or_statusr]�s���+��T�"�"r,�parents�filesc��\rSrSrSrSQSjrSrSr\R\
S55r\R\
S55r\RS5r
\RS	5rS
r\SRSj5r\SRSj5r\SRS
j5r\S5r\S5r\"S5S5r\S5rSSSjr\"S5STSj5r\S5r\SRSj5r\SRSj5r\S5r Sr!SUSjr"\S5r#SVSjr$SWSXSjjr%SYS jr&SZS!jr'S[S"jr(S\S#jr)\)r*S]S$jr+SVS%jr,SVS&jr-\S'5r.SVS(jr/\0SWS^S)jj5r1S_S*jr2S+r3S`S,jr4\5SaS-j5r6SbS.jr7ScS/jr8\9SQS0j5r:\9S15r;\<S25r=\<S35r>\0S45r?\0SdS5j5r@S6rASdS7jrBS8rCS9rDS:rESeS;jrFSeS<jrGSfSgS=jjrH\0S`S>j5rI\0SWShS?jj5rJS@rKSiSAjrLSBrMSjSCjrNSDrOSErPSFrQS]SGjrRSkSHjrSSIrTSlSmSJjjrUSKrVSnSLjrWSoSMjrXSNrYSWSpSOjjrZSPr[g)qr�r,c	��XplX�lX`lXlX@lX0lXPl[R"U5Ul	SUl
SUlX l0Ul
SUlSUlSUlSUlSUlSUlSUlSUR&-Ul0UlSUl[0R0UlUR4 g)z�Create a new dirstate object.

opener is an open()-like callable that can be used to open the
dirstate file; root is the root of the directory tracked by
the dirstate.
FrNsdirstatesdirstate-tracked-hints
%s.pending)�_use_dirstate_v2�_use_tracked_hint�_nodeconstantsr$�	_validate�_root�_sparsematchfnr�normasprefix�_rootdir�_dirty�_dirty_tracked_set�_ui�
_filecache�_changing_level�_change_typer[r=�_attached_to_a_transaction�	_filename�_filename_th�_pendingfilename�_plchangecallbacks�_origplr�_mapcls�_cwd)	r'�opener�ui�root�validate�
sparsematchfn�
nodeconstants�use_dirstate_v2�use_tracked_hints	         r*�__init__�dirstate.__init__�s���"!0��!1��+����!���
�+��!�-�-�d�3��
����"'�������� ��� ��� ���%*��!�*/��'�$���4��� -���� >���"$������"�.�.���	
�	�	r,c��UR(aSn[R"U5eS[U5;aU?S[U5;a1UR
R
5(aUR5 ggg)Nz1refreshing the dirstate in the middle of a change�_branch�_map)rVrr>�varsr�r��may_need_refresh�
invalidate�r'rBs  r*�refresh�dirstate.refresh�se�����E�C��(�(��-�-���T�
�"����T�$�Z��D�I�I�$>�$>�$@�$@��O�O��%A�r,c��UR g)zBmake sure the parents are loaded

Used to avoid a race condition.
N)�_pl�r's r*�prefetch_parents�dirstate.prefetch_parents�s��
	
��r,c#�# �UR5SLnURnUR5nUSLn[UR5nU=(d U=(d U(+nU(acUR
(aRUR5SLnU(d9URS:Xa)UR
(aSn[R"U5eU=(a U=(d U(+n	U=RS-
slSv� U=RS-slUR(aSn	UR5 U	(a'UR5ULdeURU5 gU(d@UR
(a.SnURRU5 UR5 ggg![a UR5 ef=f!U=RS-slUR(aSn	UR5 ff=f7f)u�Wrap a status operation

This context is not mutally exclusive with the `changing_*` context. It
also do not warrant for the `wlock` to be taken.

If the wlock is taken, this context will behave in a simple way, and
ensure the data are scheduled for write when leaving the top level
context.

If the lock is not taken, it will only warrant that the data are either
committed (written) and rolled back (invalidated) when exiting the top
level context. The write/invalidate action must be performed by the
wrapped code.


The expected  logic is:

A: read the dirstate
B: run status
   This might make the dirstate dirty by updating cache,
   especially in Rust.
C: do more "post status fixup if relevant
D: try to take the w-lock (this will invalidate the changes if they were raced)
E0: if dirstate changed on disk → discard change (done by dirstate internal)
E1: elif lock was acquired → write the changes
E2: else → discard the changes
Nrz8entering a status context, but dirstate is already dirtyrFs7dirstate dirty while exiting an isolated status context)�currentwlockrV�currenttransaction�boolr[rkrorr>�	Exceptionr�r=�writerz�	develwarn)
r'�repo�has_lock�is_changing�tr�has_tr�nested�first_and_alonerB�should_writes
          r*�running_status�dirstate.running_status�s����<�$�$�&�d�2���*�*��
�
$�
$�
&���4����d�*�*�+��*�>�f�>��?���t�{�{��,�,�.�d�:�F��d�2�2�a�7�D�K�K�P���,�,�S�1�1��?��)>�;�$?������!��		"��

� � �A�%� ��(�(�$�����!���*�*�,��2�2�2��J�J�r�N���{�{�P�����!�!�#�&����!�����	��O�O���	��
� � �A�%� ��(�(�$�����!�)�s+�C9H�<F/�B.H�/G�G�;H	�	Hc#�# �UR5cSn[R"U5eUR5SLnU(d>URS:Xa.UR
(aSnURRU5 URS:�deURcURS:XdeX lO8URU:wa(SnX2UR4-n[R"U5eSnU=RS-
slSv� URS:�deU=RS-slURS::aSUlURS:XdeUR(aUR5 OURS:*nUR5nXFSL:wa"U(aSnOSn[R"U5eU(aURU5 gg! UR5 e=f!URS:�deU=RS-slURS::aSUlURS:XdeUR(aUR5 fURS:*nf=f7f)	Ns7trying to change the dirstate without holding the wlockrs:entering a changing context, but dirstate is already dirtyzJtrying to open "%s" dirstate-changing context while a "%s" is already openFrz,transaction vanished while changing dirstatez,transaction appeared while changing dirstate)r�rr>r�rorkrzr�rpr�r=r�)r'r��change_typerBr�r�r��ms        r*�	_changing�dirstate._changing)sM�������&�L�C��(�(��-�-��(�(�*�$�6���$�.�.�!�3����O�C��G�G���c�"��#�#�q�(�(�(����$��'�'�1�,�,�,� +��
�
�
�+�
-� �
�
��!2�!2�3�3�C��(�(��-�-�������!��	9��
�'�'�!�+�+�+�� � �A�%� ��#�#�q�(�$(��!��+�+�q�0�0�0��(�(����!�#�3�3�q�8��
�
$�
$�
&����n�%��B��B���(�(��+�+���J�J�r�N���3	��O�O�����'�'�!�+�+�+�� � �A�%� ��#�#�q�(�$(��!��+�+�q�0�0�0��(�(����!�#�3�3�q�8��s,�DJ�G%�CJ�%G8�8G;�;BI>�>Jc#�t# �URU[5nUv� SSS5 g!,(df   g=f7f)a|Wrap a dirstate change related to a change of working copy parents

This context scopes a series of dirstate modifications that match an
update of the working copy parents (typically `hg update`, `hg merge`
etc).

The dirstate's methods that perform this kind of modifications require
this context to be present before being called.
Such methods are decorated with `@requires_changing_parents`.

The new dirstate contents will be written to disk when the top-most
`changing_parents` context exits successfully. If an exception is
raised during a `changing_parents` context of any level, all changes
are invalidated. If this context is open within an open transaction,
the dirstate writing is delayed until that transaction is successfully
committed (and the dirstate is invalidated on transaction abort).

The `changing_parents` operation is mutually exclusive with the
`changing_files` one.
N)r��CHANGE_TYPE_PARENTS�r'r��cs   r*�changing_parents�dirstate.changing_parentsas(���,�^�^�D�"5�
6�!��G�7�
6�
6���8�'�	8�
5�8c#�t# �URU[5nUv� SSS5 g!,(df   g=f7f)a�Wrap a dirstate change related to the set of tracked files

This context scopes a series of dirstate modifications that change the
set of tracked files. (typically `hg add`, `hg remove` etc) or some
dirstate stored information (like `hg rename --after`) but preserve
the working copy parents.

The dirstate's methods that perform this kind of modifications require
this context to be present before being called.
Such methods are decorated with `@requires_changing_files`.

The new dirstate contents will be written to disk when the top-most
`changing_files` context exits successfully. If an exception is raised
during a `changing_files` context of any level, all changes are
invalidated.  If this context is open within an open transaction, the
dirstate writing is delayed until that transaction is successfully
committed (and the dirstate is invalidated on transaction abort).

The `changing_files` operation is mutually exclusive with the
`changing_parents` one.
N)r��CHANGE_TYPE_FILESr�s   r*�changing_files�dirstate.changing_fileszs(���.�^�^�D�"3�
4���G�5�
4�
4�r�c�2�Sn[R"U5e)NzJMercurial 6.4 and later requires call to `dirstate.changing_parents(repo)`)rr>r�s  r*�parentchange�dirstate.parentchange�s��
0�	��$�$�S�)�)r,c� �URS:�$)znReturns true if the dirstate is in the middle of a set of changes.

This returns True for any kind of change.
r)ror�s r*rV�dirstate.is_changing_any�s���#�#�a�'�'r,c�J�URS::agUR[:H$)zcReturns true if the dirstate is in the middle of a set of changes
that modify the dirstate parent.
rF)rorpr�r�s r*rJ�dirstate.is_changing_parents�s'��
���1�$��� � �$7�7�7r,c�J�URS::agUR[:H$)zrReturns true if the dirstate is in the middle of a set of changes
that modify the files tracked or their sources.
rF)rorpr�r�s r*rQ�dirstate.is_changing_files�s'��
���1�$��� � �$5�5�5r,c��URURURURURUR
5$)zAReturn the dirstate contents (see documentation for dirstatemap).)rwrmr$rgrercr�s r*r��
dirstate._map�s<���|�|��H�H��L�L��J�J�����!�!�
�	
r,c�>�URcgUR5$)z�The matcher for the sparse checkout.

The working directory may not include every file from a manifest. The
matcher obtained by this property will match a path if it is to be
included in the working directory.

When sparse if disabled, return None.
N)rhr�s r*�_sparsematcher�dirstate._sparsematcher�s$�����&���"�"�$�$r,�branchc�0�SnSn[R"URURS5upUR	5R5nUbUR5 U(dgU$![a N)f=f!UbUR5 ff=f)Nr,r�sdefault)r�
trypendingrgr$�read�strip�FileNotFoundError�close)r'�f�data�modes    r*r��dirstate._branch�s�������	��(�(����T�\�\�9�M�G�A��6�6�8�>�>�#�D��}����	������!�	��	���}����	��s$�AA/�/
A<�9A?�;A<�<A?�?Bc�6�URR5$r#)r�r^r�s r*r��dirstate._pl�s���y�y� � �"�"r,c�8�URRU5$r#)r��
hastrackeddir)r'�ds  r*�hasdir�dirstate.hasdir�s���y�y�&�&�q�)�)r,�	.hgignorec��UR5nU(d[R"5$UVs/sHnSU-PM
 nn[R"URS/X0R
RS9$s snf)Ns
include:%sr,��warn)�_ignorefiles�matchmod�neverrrgrmr�)r'r_r��patss    r*�_ignore�dirstate._ignore�s_���!�!�#����>�>�#�#�+0�1�5�a�
��!�5��1��~�~�d�j�j�#�r�4�h�h�m�m�L�L��2s�A7c�n�URRSS5=(a [RS:g$)N�uisslash�/)rm�
configboolr�ossepr�s r*�_slash�dirstate._slash�s'���x�x�"�"�5�(�3�N����$�8N�Nr,c�B�[R"UR5$r#)r�	checklinkrgr�s r*�
_checklink�dirstate._checklink�s���~�~�d�j�j�)�)r,c�T�[[R"UR55$r#)r�r�	checkexecrgr�s r*�
_checkexec�dirstate._checkexec�s���D�N�N�4�:�:�.�/�/r,c�V�[R"URS55(+$)N�.hg)r�fscasesensitiver9r�s r*�
_checkcase�dirstate._checkcase�s���'�'��
�
�6�(:�;�;�;r,c� �URU-$r#)rj)r'r�s  r*r9�dirstate._joins���}�}�q� � r,c�$^^^�/mSUUU4SjjnU$)a+build a callable that returns flags associated with a filename

The information is extracted from three possible layers:
1. the file system if it supports the information
2. the "fallback" information stored in the dirstate if any
3. a more expensive mechanism inferring the flags from the parents.
c��>�SnSn[R"TRU55nTR(a[
R"U5(agOdTRU5nUR(aUR(agO/T(dTRT"55 TS"U5nSU;agTR(a[
R"U5(aggUcTRU5nUR(aUR(aggUc(T(dTRT"55 TS"U5nSU;agg![a gf=f)Nr,�lr�x)�os�lstatr9�OSErrorr�r�
statislink�	get_entry�has_fallback_symlink�fallback_symlink�appendr��
statisexec�has_fallback_exec�
fallback_exec)�x�entry�fallback_value�st�
buildfallback�
fallback_funcr's    ���r*�	get_flags�$dirstate.flagfunc.<locals>.get_flagssE����E�!�N�
��X�X�d�j�j��m�,������?�?�2�&�&��'����q�)���-�-��-�-�#�.�)�%�,�,�]�_�=�%2�1�%5�a�%8�N��~�-�#�����?�?�2�&�&��'���=� �N�N�1�-�E��*�*��*�*�#�+��
&�-�,�)�0�0���A�)6�q�)9�!�)<���~�-�#���E�
��
�s�%E�
E&�%E&)r�bytes�returnr	r-)r'rrrs`` @r*�flagfunc�dirstate.flagfuncs����
�'	�'	�R�r,c�v�URRSS5nU(aU$[R"5$)Nr�sforcecwd)rm�configr�getcwd)r'�forcecwds  r*rx�
dirstate._cwd@s-���8�8�?�?�5�+�6����O���� � r,c��URnXR:XagURn[R"U5(dU[R
-
nUR
U5(aU[U5S$U$)z�Return the path from which a canonical path is calculated.

This path should be used to resolve file patterns or to convert
canonical paths back to file paths for display. It shouldn't be
used to get real file paths. Use vfs functions instead.
r,N)rxrgr�endswithseprr��
startswith�len)r'�cwd�rootseps   r*r�dirstate.getcwdHsi���i�i���*�*����*�*������(�(��x�~�~�%�G��>�>�'�"�"��s�7�|�~�&�&��Jr,Nc��UcUR5n[R"URX!5nUR(a[R
"U5$U$r#)rr�pathtorgr��pconvert)r'r�r�paths    r*r�dirstate.pathto\sA���;��+�+�-�C��{�{�4�:�:�s�.���;�;��=�=��&�&��r,c�V�URRU5nUc
[5$U$)z-return a DirstateItem for the associated path)r��get�DirstateItem)r'rrs   r*r��dirstate.get_entryds&���	�	�
�
�d�#���=��>�!��r,c��XR;$r#)r�)r'�keys  r*�__contains__�dirstate.__contains__ks���i�i��r,c�>�[[UR55$r#)�iter�sortedr�r�s r*�__iter__�dirstate.__iter__ns���F�4�9�9�%�&�&r,c�6�URR5$r#)r��itemsr�s r*r,�dirstate.itemsqs���y�y��� � r,c�b�URVs/sHoRU5PM sn$s snfr#)r�rf)r'�ps  r*r^�dirstate.parentsvs%��+/�8�8�4�8�a���q�!�8�4�4��4s�,c�>�URURS5$)Nr�rfr�r�s r*�p1�dirstate.p1y����~�~�d�h�h�q�k�*�*r,c�>�URURS5$)Nrr2r�s r*�p2�dirstate.p2|r5r,c�N�URSURR:g$)zTrue if a merge is in progressr)r�re�nullidr�s r*�in_merge�dirstate.in_merges#���x�x��{�d�1�1�8�8�8�8r,c�B�[R"UR5$r#)r�tolocalr�r�s r*�branch�dirstate.branch�s��������-�-r,c�P�UcURRnURS:Xa[S5eSUlUR
SnURcUR
UlURRnX4:g=(a X$:HnURRXUS9$)z�Set dirstate parents to p1 and p2.

When moving from two parents to one, "merged" entries a
adjusted to normal and previous copy records discarded and
returned by the call.

See localrepo.setparents()
rzOcannot set dirstate parent outside of dirstate.changing_parents context managerTr)�fold_p2)	rer:ro�
ValueErrorrkr�rvr��
setparents)r'r3r7�oldp2r:rBs      r*rD�dirstate.setparents�s����:��$�$�+�+�B����1�$��<��
�
����������<�<���8�8�D�L��$�$�+�+���/�2�b�l���y�y�#�#�B�G�#�<�<r,c���URRRU[R"U55 Ub<URU5 UR
SUR-SURSSS9 gURnU"SSSSS9nURU5 URS	nU(aUR5 SSS5 g!,(df   g=f)
Nsdirstate-3-branch%s)r��plainT��location�
post_finalizer��w��
atomictemp�
checkambigs_branch)�	__class__r��setr�	fromlocal�_setup_tr_abort�addfilegenerator�_tr_key_suffix�
_write_branchr$rnr�)r'r?�transaction�vfsr��ces      r*�	setbranch�dirstate.setbranch�s���	
�����"�"�4��);�);�F�)C�D��"�� � ��-��(�(�&��)<�)<�<���"�"�!�"�
)�
�
��l�l��
��D�T�d�
C�q����q�!�����,�B���
�
��D�
C�
C�s�8C�
Cc�@�URURS-5 g)N�
)r�r�)r'�file_objs  r*rV�dirstate._write_branch�s�����t�|�|�e�+�,r,c��SHnXR;dM[X5 M! SUlSUl[	UR
S:�=(d UR=(d UR5UlSUl	g)z�Causes the next access to reread the dirstate.

This is different from localrepo.invalidatedirstate() because it always
rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
check whether the dirstate has changed before rereading it.)r�r�r�FrN)
�__dict__�delattrrkrlr�rorqr[r=rv)r'�as  r*r��dirstate.invalidate�sq��0�A��M�M�!��� �0����"'���$(�� � �1�$�
$��.�.�
$��#�#�%
��!�
��r,c���X:XagSUlUb*URU5 XRRU'gURRR	US5 g)z=Mark dest as a copy of source. Unmark dest if source is None.NT)rk�
_check_sparser��copymap�pop)r'�source�dests   r*�copy�
dirstate.copy�sS���>����������v�&�&,�I�I���d�#��I�I���!�!�$��-r,c�N�URRRUS5$r#)r�rgr)r'�files  r*�copied�dirstate.copied�s���y�y� � �$�$�T�4�0�0r,c�.�URR$r#)r�rgr�s r*�copies�dirstate.copies�s���y�y� � � r,c�@�SUlURRU5nUbUR(dUR	U5 URRU5nU(a&URRRUS5 U(aSUlU$)a-a "public" method for generic code to mark a file as tracked

This function is to be called outside of "update/merge" case. For
example by a command like `hg add X`.

if reset_copy is set, any existing copy information will be dropped.

return True the file was previously untracked, False otherwise.
TN)	rkr�r�tracked�_check_new_tracked_filename�set_trackedrgrhrl)r'�filename�
reset_copyr�pre_trackeds     r*rw�dirstate.set_tracked�sx������	�	�
�
�h�'���=��
�
��,�,�X�6��i�i�+�+�H�5����I�I���!�!�(�D�1��&*�D�#��r,c�f�URRU5nU(aSUlSUlU$)z�a "public" method for generic code to mark a file as untracked

This function is to be called outside of "update/merge" case. For
example by a command like `hg remove X`.

return True the file was previously tracked, False otherwise.
T)r��
set_untrackedrkrl)r'rx�rets   r*r}�dirstate.set_untracked�s/���i�i�%�%�h�/����D�K�&*�D�#��
r,c��SUlURUR(dURU5 Uup4nURR	XXE5 g)zFrecord that the current state of the file on disk is known to be cleanTN)rkr�rurv�	set_clean)r'rx�parentfiledatar��size�mtimes      r*r��dirstate.set_clean
sI������y�y��"�*�*��,�,�X�6�,���U��	�	���H�D�8r,c�H�SUlURRU5 g)z<record that the current state of the file on disk is unknownTN)rkr��set_possibly_dirty)r'rxs  r*r��dirstate.set_possibly_dirtys������	�	�$�$�X�.r,c���UR(aSn[R"U5eURR	U5nUcSnOUR
nU(dFU(d?URR	U5b"URR
U5 SUlO#U(dU(aUbUR(agURR
UUUSS9 g)aSet a file as tracked in the parent (or not)

This is to be called when adjust the dirstate to a new parent after an history
rewriting operation.

It should not be called during a merge (p2 != nullid) and only within
a `with dirstate.changing_parents(repo):` context.
z7update_file_reference should not be called when mergingNFT)�has_meaningful_mtime)	r;rr>r�rru�reset_staterk�added)r'rx�
p1_trackedrBr�
wc_trackeds      r*�update_file_p1�dirstate.update_file_p1s����=�=�K�C��(�(��-�-��	�	�
�
�h�'���=��J����J��j��y�y�}�}�X�&�2��	�	�%�%�h�/�"�����*�� �U�[�[���	�	������"'�
	�	
r,c	�,�URUUUUUUS9 g)a�update the information about a file in the dirstate

This is to be called when the direstates parent changes to keep track
of what is the file situation in regards to the working copy and its parent.

This function must be called within a `dirstate.changing_parents` context.

note: the API is at an early stage and we might need to adjust it
depending of what information ends up being relevant and useful to
other processing.
)rxr�r��p2_info�possibly_dirtyr�N)�_update_file)r'rxr�r�r�r�r�s       r*�update_file�dirstate.update_fileAs)��*	
����!�!��)�)�
	�	
r,c��URS:�d(URS:�dSn[R"U5eUR"U0UD6 g)a�NEVER USE THIS, YOU DO NOT NEED IT

This function is a variant of "update_file" to be called by a small set
of extensions, it also adjust the internal state of file, but can be
called outside an `changing_parents` context.

A very small number of extension meddle with the working copy content
in a way that requires to adjust the dirstate accordingly. At the time
this command is written they are :
- keyword,
- largefile,
PLEASE DO NOT GROW THIS LIST ANY FURTHER.

This function could probably be replaced by more semantic one (like
"adjust expected size" or "always revalidate file content", etc)
however at the time where this is writen, this is too much of a detour
to be considered.
rzrequires a changes contextN)ror[rr>r�)r'r@rArBs    r*�hacky_extension_update_file�$dirstate.hacky_extension_update_file_sN��&�$�$�q�(�D�,@�,@�1�,D�.�C��(�(��-�-����
�	
��	
r,c	���SUlURRU5nUcSnOURnX�:waSUlURRUUUUU(+US9 g)NTF)r�r�r�)rkr�rrurlr�)	r'rxr�r�r�r�r��	old_entry�prev_trackeds	         r*r��dirstate._update_filezsm������I�I�M�M�(�+�	��� �L�$�,�,�L��%�&*�D�#��	�	�������%3�!3�)�
	�	
r,c��[R"U5 URRU5(a:[	S5nU[
R"U5-n[R"U5e[R"U5H�nURRU5(a O�URRU5nUcMEUR(aMX[	S5nU[
R"U5[
R"U54-n[R"U5e URU5 g)Ns directory %r already in dirstates#file %r in dirstate clashes with %r)r�
checkfilenamer�r�rr�bytestrr�Abortr�finddirsr�removedrf)r'rxrBr�rs     r*rv�$dirstate._check_new_tracked_filename�s������h�'��9�9�"�"�8�,�,��7�8�C��8�#�#�H�-�-�C��+�+�c�"�"��"�"�8�,�A��y�y�&�&�q�)�)���I�I�M�M�!�$�E�� ������>�?����(�(��+�X�-=�-=�h�-G�H�H���k�k�#�&�&�-�	
���8�$r,c���URnUbQUR5(d;U"U5(d-[S5n[S5n[R"X1-US9eggg)z2Check that a filename is inside the sparse profileNs3cannot add '%s' - it is outside the sparse checkoutswinclude file with `hg debugsparse --include <pattern>` or use `hg add -s <file>` to include file directory while adding)�hint)r��alwaysrrr�)r'rx�sparsematchrBr�s     r*rf�dirstate._check_sparse�sj���)�)���"�;�+=�+=�+?�+?��x�(�(��N�O���Q����k�k�#�.�t�<�<�
)�,@�"r,c�2�UcG[RR[RRURU55nU(dDU(d8SU;a2URSS5upgUR
USUS5nUS-U-nU$UnU$SU;aWURSS5upgUR
USUS5nURS-U-n	US-[R"Xy5-nO [R"X R5nX�U'U$)Nr�rFT)	r�r�lexistsr%rg�rsplit�
_normalizer�fspath)
r'r�normed�
ignoremissing�exists�storemapr�r��folded�rs
          r*�
_discoverpath�dirstate._discoverpath�s����>��W�W�_�_�R�W�W�\�\�$�*�*�d�%C�D�F�� �T�T�\��{�{�4��+����O�O�A�u�m�T�B���T��A��� �
����
��v�~��}�}�T�1�-����O�O�A�u�m�T�B���J�J��%��)���T��D�K�K��$5�5�����V�Z�Z�8��%�V���
r,c���[R"U5nURRR	US5nUc2U(aUnU$URXX4URR5nU$r#)r�normcaser��filefoldmaprr��r'r�isknownr�r�r�r�s       r*�_normalizefile�dirstate._normalizefile�sj�����t�$�����&�&�*�*�6�4�8���>����
�
��+�+��-����9N�9N����
r,c�:�[R"U5nURRR	US5nUc&URR
R	US5nUc2U(aUnU$UR
XX4URR
5nU$r#)rr�r�r�r�
dirfoldmapr�r�s       r*r��dirstate._normalize�s������t�$�����&�&�*�*�6�4�8���>��Y�Y�)�)�-�-�f�d�;�F��>�����
��+�+��-����9M�9M����
r,c�L�UR(aURXU5$U$)a�
normalize the case of a pathname when on a casefolding filesystem

isknown specifies whether the filename came from walking the
disk, to avoid extra filesystem access.

If ignoremissing is True, missing path are returned
unchanged. Otherwise, we try harder to normalize possibly
existing path components.

The normalized case is determined based on the following precedence:

- version of name already stored in the dirstate
- version of name stored on disk
- version provided via command arguments
)r�r�)r'rr�r�s    r*�	normalize�dirstate.normalize�s!��(�?�?��?�?�4�-�@�@��r,c�F�URR5 SUlg)NT)r��clearrkr�s r*r��dirstate.clears���	�	������r,c���URnUb�UR5(d{UVs/sHoT"U5(dMUPM nnU(a UVs/sHoT"U5(dMUPM nnUb1UVs1sHoT"U5(aMUiM nnURU5nUcUn/nUR5 Oc[	U5S:a7/n/nUH,nXR;aURU5 MURU5 M. O[
U5n	U	[
U5-nX�-
nURcURUlURRXRR5 UHBnUR(aURU5 M'URRUSSS9 MD UHnURRU5 M  SUlgs snfs snfs snf)N�
T)r�r�)r�r��unionr�rr�rQrvr�r�rDrer:r;rwr�rk)
r'�parent�allfiles�changedfiles�matcherr��dirstatefilestoremove�	to_lookup�to_drop�changedfilessets
          r*�rebuild�dirstate.rebuilds����%�%����w�~�~�'7�'7�#+�:�8�a�w�q�z��8�H�:��+7�F�<�a�7�1�:��<��F��'�59�(K�D�q���
��D�%�(K�4�:�:�<�H���� �I��G��J�J�L�
��
��
#��I��G�!���=��$�$�Q�'��N�N�1�%�	"�"�,�/�O�'�#�h�-�7�I�%�1�G��<�<���8�8�D�L��	�	���V�%8�%8�%?�%?�@��A��}�}�� � ��#��	�	�%�%��#�#�&��	��A��I�I�!�!�!�$������];��F��
)Ls"�G�G�G!�$G!�3G&�G&c�X^�UcgU4SjnURSTR-U5 g)z3make sure we invalidate the current change on abortNc�4>�STlTR5 g�NF)rqr�)r�r's �r*�on_abort�*dirstate._setup_tr_abort.<locals>.on_abortKs���.3�D�+��O�O�r,sdirstate-invalidate%s)�addabortrU)r'r�r�s`  r*rS�dirstate._setup_tr_abortFs/���
�:��	�	���$�t�':�':�:��	
r,c�^^�TR(dgTR(aeTR=(a TRnT(a�TR	T5 STlUU4SjnTR
STR-TR4USSS9 U(a0TR
STR-TR4UU4SjSSS9 gU4SjnU"TR5nTRTU5 SSS5 U(a.U"TR5nTRTU5 SSS5 gg!,(df   ND=f!,(df   g=f)	NTc�:>�STlTRTU54 gr�)rq�_writedirstate�r�r'r�s ��r*�
on_success�"dirstate.write.<locals>.on_success`s���27��/��#�#�B��*�+r,sdirstate-1-main%srHrIsdirstate-2-key-post%sc�(>�TRTU5$r#)�_write_tracked_hintr�s ��r*�<lambda>� dirstate.write.<locals>.<lambda>ps���d�6�6�r�1�=r,c�(>�TRUSSSS9$)NrLTrM)r$)r�r's �r*r�r�vs������a��$�4��Pr,)rkr=rdrlrSrqrTrUrrrsr�r�)r'r��	write_keyr�rnr�s``    r*r��dirstate.writeTs4����{�{���,�,�,�,��*�*�F�t�/F�/F�	�
�� � ��$�.2�D�+�
,�

���$�t�':�':�:����!��!�"�
 �
���#�#�,�t�/B�/B�B��&�&�(�=�%�"&�$��
�P��
�$�.�.�
!�Q�����A�&�"���d�'�'�(�A��(�(��Q�/�)�(��"�
!��
)�(�s�(D9�E
�9
E�

Ec�\�URRUR5 SUlg)zGremove the tracked_hint file

To be used by format downgrades operationFN)r$�unlinkrsrdr�s r*�delete_tracked_hint�dirstate.delete_tracked_hints$��	
�����D�-�-�.�!&��r,c� �X RU'g)z�add a callback to be called when the wd parents are changed

Callback will be called with the following arguments:
    dirstate, (oldp1, oldp2), (newp1, newp2)

Category is a unique identifier to allow overwriting an old callback
with a newer callback.
N)ru)r'�category�callbacks   r*�addparentchangecallback� dirstate.addparentchangecallback�s��-5����)r,c�j�UR(aeURbjURUR:waP[URR55H"up4U"XRUR5 M$ SUlURRX5 SUlSUl	gr�)
r=rvr�r(rur,r�r�rkrl)r'r�rr�r�s     r*r��dirstate._writedirstate�s����,�,�,�,��<�<�#�������(@�%�d�&=�&=�&C�&C�&E�F�����|�|�T�X�X�6� G��D�L��	�	��������"'��r,c��[R"[R"5R5nURSU-5 g)Ns1
%s
)r�hex�uuid�uuid4r	r�)r'r�r�r#s    r*r��dirstate._write_tracked_hint�s-���h�h�t�z�z�|�)�)�*��	���
�S� �!r,c��URU5(ag[R"U5HnURU5(dM g g)NTF)r�rr�)r'r�r/s   r*�
_dirignore�dirstate._dirignore�s<���<�<��?�?���"�"�1�%�A��|�|�A����&�r,c	���/n[RRURS55(a UR	URS55 UR
R
S5Hpup#US:XdURS5(dM#UR	[RRUR[R"U555 Mr U$)Nr�r�signoresignore.)r�rr�r9r�rm�configitemsrr%rjr�
expandpath)r'r_�namers    r*r��dirstate._ignorefiles�s�����
�7�7�>�>�$�*�*�\�2�3�3��L�L����L�1�2��(�(�.�.�u�5�J�D��y� �D�O�O�J�$?�$?����R�W�W�\�\�$�-�-�����9N�O�P�	6�
�r,c	�.�[R"UR55n[5nU(a�UR	5n[
R"X@RRSS9nUH�upgn[
R"US5up�U	S:XaX�;aURU
5 M=[
R"URS/U/URRS9nU"U5(dM�XGU4s $ URU5 U(aM�g)NT)�
sourceinfosglobs
subincluder,r�)N���r,)�collections�dequer�rQ�popleftr��readpatternfilermr��	_patsplitr�rrg�add)r'r�r_�visited�i�patterns�pattern�lineno�line�kindr/r�s            r*�_ignorefileandline�dirstate._ignorefileandline�s����!�!�$�"3�"3�"5�6���%����
�
��A��/�/��8�8�=�=�T��H�*2�%���"�,�,�W�g�>����=�(��'����Q����N�N��J�J��R�'����������Q�4�4��t�,�,�*2�
�K�K��N�!�e�"r,c	�X�SnURnURn[Rn[R
n[Rn[Rn	[Rn
URn/nURn
/nURnUR5(dUR(a
URnOSn[UR55nUR!5 SunnU[#U5:a�U[#U5:a�UUS-nUUU:aUS-
nM6U[#U5:aFUUR%U5(a-UU	U[#U5:aUUR%U5(aM-US-
nU[#U5:aU[#U5:aM�U(aSU;aS/nSn[&R)U5nSUS'UH�nU(aU"USS	5nOUnUU;aMU"U"U55nU"UR*5nUU:XaUU;aSUU'U
"UU45 M]UU	:XdUU
:XaUUU'MpU"UU"U55 UU;aSUU'M�M� UR75(a2[9U5H#nUS:XdUU;aMU"U5(aM UU	M% UR5(a�UR(a�0nUR;5HUunnUcM[<R>"U5nURAU5nUc[C5nUUU'UREU5 MW UR;5HVunn[#U5S:�dMUH9n URGU US	SURRH5n!U U!:wdM4SUU 'M; MX UX�4$![,atnUU;aSUU'SnAGM�URR/U5(aU"U5 SnAGM!U"U[0R2"UR455 SnAGMOSnAff=f)
a�Get stat data about the files explicitly specified by match.

Return a triple (results, dirsfound, dirsnotfound).
- results is a mapping from filename to stat result. It also contains
  listings mapping subrepos and .hg to None.
- dirsfound is a list of files found to be directories.
- dirsnotfound is a list of files that the dirstate thinks are
  directories and that were not found.c��[S5n[R"U5(a[S5nO�[R"U5(a[S5nOt[R"U5(a[S5nOM[R
"U5(a[S5nO&[R"U5(a[S5n[S5U-$)Nsunknownscharacter devicesblock devicesfifossockets	directorys"unsupported file type (type is %s))r�stat�S_ISCHR�S_ISBLK�S_ISFIFO�S_ISSOCK�S_ISDIR)r�rs  r*�badtype�'dirstate._walkexplicit.<locals>.badtype�s����Z�=�D��|�|�D�!�!��,�-�����d�#�#���)�����t�$�$���z�����t�$�$���|�����d�#�#������:�;�d�B�Br,N)rrr�rr,r�FT)%�badr�r�r�r�S_IFMT�S_IFDIR�S_IFREG�S_IFLNKr9r��isexactr�r�r(r_�sortrr�dict�fromkeys�st_moder�r�r�
strtolocal�strerror�anypats�listr,rr�rrQrr�r�)"r'r�subreposr�badfn�dmapr��getkind�dirkind�regkind�lnkkindr%�	dirsfound�foundadd�dirsnotfound�notfoundaddr�r_r
�j�subpath�results�ff�nfrr�instr�r��nc�paths�normrr�s"                                  r*�
_walkexplicit�dirstate._walkexplicit�s���	C��	�	���y�y�������+�+���,�,���,�,���,�,���z�z���	��#�#����"�)�)���}�}���4�?�?����I��I��u�{�{�}�%���
�
�����1��#�e�*�n��S��]�!2��q�k�D�(�G��Q�x�'�!��Q�����c�%�j�.�U�1�X�%8�%8��%A�%A��!�H��c�%�j�.�U�1�X�%8�%8��%A�%A�
��F�A��#�e�*�n��S��]�!2���u���E�E��I��-�-��)�������B���r�5�$�/�����W�}��
F��4��8�_���r�z�z�*���7�?��T�z�&*�����b�"�X�&��W�_����"$�G�B�K��"�g�d�m�,��T�z�&*����"�)�F�=�=�?�?��'�]����;�!�x�-���Q�x�x���
�#��=�=�?�?�t����F� ������2��:���]�]�1�%���
�
�2����=��E�E�!&�F�2�J��	�	�!��)� &�|�|�~���e��u�:��>� %��!%�!3�!3� �$��d�D�I�I�4H�4H�"�� �6�>�,0�G�D�M�!&� .��	�/�/��e�
F���:�"&�G�B�K�K��y�y�'�'��+�+�#�B����b�(�"5�"5�d�m�m�"D�E�E��
F�s0�5;N+�2N+�N+�+
P)�5P$�(P$�6'P$�$P)c�L^^^^^^^^^ ^!^"^#^$^%^&�U(a![Rm[RnO@U(aTRmTRnO [Rm[RnTR
b][R"TR55n[R"TRU/5n[R"TU5mTRm!TR	5m TRm"TRmm[ R"n	[$R&m[$R(m%[$R*mTR,mS=p�TR/5(aSn
[RnOTR15(aSnU
(d,TR2(aTR4m#TR6m$SnOTR4m#Sm$TR9TU5um&p�T"(a%UHnT""US5 M U
HnT""U5 M
 U=(a U=(d U
(+nUVs/sHo�"US5(aMUPM nnUUUUUUUU U!U"U#U$U%U&U4SjnUH#unnT#(+=(d UU:HnU"U/U5 M% UHnT&U	M T&S	U(Gd4U
(Gd,T&(dT (aTVs/sHnUPM nnO)TVs/sHnUT&;dMT!"U5(dMUPM nnUR;5 U(a~[<R>"TR@SS9n[CU5HNnT$(aT$"USS5T&;aST&U'MUREU5(aU	"T"U55T&U'MIST&U'MP T&$[CU5n[RH"UVs/sHnT"U5PM
 sn5HnUT&[KU5'M T&$s snfs snfs snf![Fa	 ST&U'M�f=fs snf)a
Walk recursively through the directory tree, finding all files
matched by match.

If full is False, maybe skip some known-clean files.

Return a dict mapping filename to stat-like object (either
mercurial.osutil.stat instance or return value of os.stat()).

NFTrc��>�URnU(Ga�[R"S[U55 UR	5nTRU5nU(dMRUS:XdUS:XaSnSnUS:waSn[R"SU5 T"T"U5SUS9nSSS5 WGHDup�n
U(aX�;aMT(a#T"U=(a US	-U-=(d USS5nOU=(a US	-U-=(d UnUT;dMaU	T:XaIT"U5(dT(aT"U5 U"U5 UT
;aT(d
T"U5(aSTU'M�M�M�U	T:XdU	T:XacUT
;aT(d
T"U5(aU
TU'M�M�T(d
T"U5(a)T"U5(dU(d
T"US
S5nU
TU'GMGMGMUT
;dGM(T(dT"U5(dGM?STU'GMG U(aGM�gg!,(df   GNf=f![[4aKnTRTRU5[R"UR55 SnAGMXSnAff=f)Nzdirstate.walk worksthissallr,r�z!dirstate.walk.traverse listdir %sT)r�skipr�F)r�r�counterrrh�visitchildrenset�log�PermissionErrorr�rrrr&r')�work�
alreadynormed�wadd�nd�visitentriesrB�entriesr:r�rrr9r.r,�ignorer%�listdirr0r�matchalways�matchfn�	matchtdirr��
normalizefiler/r7r's            ���������������r*�traverse�dirstate.walk.<locals>.traverse�s����;�;�D����� 4�c�$�i�@��X�X�Z��$�5�5�b�9��#���7�*�l�f�.D�#'�L�����9�!�D�� ���%H�"�M�")�$�r�(��D�"I��N�$+�K�A�R�$��(=� �$�+��2�B��I��M�7�a��t��� �3�R�$�Y��]�8�q����(��7�?�#)�"�:�:�#,�$-�b�M� $�R��!�T�z�{�g�b�k�k�.2����?J�z�!�W�_����!�T�z�#.�'�"�+�+�24�G�B�K�3>�"-�����f� "�G�G�(5�)2�2�u�d�)C�B�.0����
G�� �4�Z�[�G�B�K�K�*.�G�B�K�Q$+�'�$�N�M��'�):�;���I�I����B���)<�)<�T�]�]�)K����	�s6�9H�G>�H�>
H
�H�
H�I+� ?I&�&I+r�)�cached)&rr�r�r�r�rhr��exactr_�unionmatcherr��intersectmatchersrP�traversedirr�rNr�r�rrrr r9r!�prefixr�r�r�r>r"r�pathauditorrgr'�checkr��	statfiles�next)'r'rr*�unknown�ignored�full�	dirignore�em�smr�rV�	skipstep3rGr3r�rSrJrH�sr��visit�
audit_pathr9�ivr
rr.r,rMr%rNr0rOrPrQr�rRr/r7s'``                        @@@@@@@@@@@@@r*�walk�
dirstate.walkTsb����,��Z�Z�F��
�
�I�
��\�\�F����I��[�[�F����I����*�������
�.�B��&�&��(;�(;�R�'@�A�B��.�.�u�b�9�E��-�-���l�l�n���%�%�	��y�y���,�,�������,�,���,�,���,�,���z�z��!�!���=�=�?�?��E����I�
�\�\�^�^��I��������I� �/�/�M��I����I� �M�'+�&8�&8���&I�#�������!�A�$���!���!��"��<�t�';�|�"<�	��7�4�a�y��1����4��7�=	/�=	/�=	/�~�E�B��!*�M�4�R�1�W�M��a�S�-�(�	��A���
���F�O����{�$(�)�D�q��D��)��$(�L�D�q�A�W�,<������D��L��J�J�L��
&�1�1�$�*�*�T�J�
��u�+�B�&�)�"�d�D�9�W�D�&*����$�)�)�"�-�-�/�*/��R��/�G�B�K�'+����-&�:���%�[���.�.�5�)A�5�a�$�q�'�5�)A�B�B�(*�G�D��H�%�C����w8��d*��L��4 '�/�*.�G�B�K�/��*Bs<�O<�*O<� P�3
P�P�P�P�P!�P�Pc
��URb\[R"UR55n[R"UR
U/5n[R"X5nURRSS5nUb#[RRSSU-5 URRSSS5nU(dS[RS'[RURRUUR UR#5UR$['U5['U5['U5['UR(55	un	n
nnn
nnnnnnnU=R*U-slUR((aUHnUR)U5 M URR,(a�UH�n[/U[05(a2Uunn[3S5UU4-nURR-U5 MJ[3S	5nURR-U[4R6"UR UR U5S
4-5 M� [9U5H,unnUR;U[R<"U55 M. [>R"U
UUU
UUUS9nU	U4$)NsworkersnumcpussRAYON_NUM_THREADSs%dsenabledT�1s!%s: ignoring invalid syntax '%s'
s*skipping unreadable pattern file '%s': %s
sNo such file or directory)�modifiedr�r��deletedr_r`�clean) rhr�rVr_rWr�rXrm�	configintr�environ�
setdefaultr��rustmod�statusr�rjr�r�r�rYrkr��
isinstance�tuplerr�	canonpathr(rr&r)r'r��
list_clean�list_ignored�list_unknownrcrd�numcpus�workers_enabled�lookuprnr�r�rorpr`r_�warningsr�	traversed�dirty�dir�item�	file_path�syntaxrB�fn�messagerus                             r*�_rust_status�dirstate._rust_statussm�����*�����
�
��0�B��&�&��(;�(;�R�'@�A�B��0�0��=�G��(�(�$�$�Y�
�;�������'�'�(<�e�g�o�N��(�(�-�-�i��T�J���59�H���1�2�
�N�N��I�I�N�N���M�M������O�O������������$�$�%�

�
	
�������������	
���u������ ���#�#�C�(�!��8�8�=�=� ���d�E�*�*�(,�%�I�v��A�B�!��F��C��H�H�M�M�#�&��J�K�C��H�H�M�M��$�.�.� $�
�
�t�}�}�d��9�	���!�("�#�;�K�B���K�K��H�/�/��8�9�'�����������
�����r,c	�	�UR(dSn[R"U5eX4Up�n/////4up�p�n///pNn
URnUR	5 Sn[
cSnOUR(aSnO	U(aSn[R"UR5nU(aURXXy5nUU4-$SnURnURnU
RnURnURnU	(aUROUnU(aUROUnU
RnURnU(aUROUnUR nUR"nUR$n UR&n!URR(n"U=(d UR*SLn#UR-XX�U#S9R/5GH_un$n%U"U$5(d;U(d
U"U$5(aU"U$5(aU(aU"U$5 OU"U$5 MOU"U$5n&U&R0n'U&R2n(U%(dU&R4(a
U"U$5 M�U&R6(a
U"U$5 M�U&R8(a
U"U$5 M�U&R:(a
U"U$5 M�U&R4(dM�U!(dU&R<(aU"U$5 GMU (dU&R>(aU"U$5 GM;U(S:�aEU(U%R@:waU(U%R@[B-:wd$U'U%RD-S-(aU (dU$U";aK[FRH"U%RD5(aU(U%R@:waU"U$5 GM�U"U$5 GM�Sn)Ub[RJ"U%U5n)O5U&RM[RN"U%55(aU"U$5 GM)U)bU&RMU)5(dU"U$5 GMMU(dGMWU"U$5 GMb [PRR"X�X�XSU5n*U
U*U4$![a SnGN�f=f![
Ra GN�f=f)	aDetermine the status of the working copy relative to the
dirstate and return a pair of (unsure, status), where status is of type
scmutil.status and:

  unsure:
    files that might have been modified since the dirstate was
    written, but need to be read to be sure (size is the same
    but mtime differs)
  status.modified:
    files that have definitely been modified since the dirstate
    was written (different size or mode)
  status.clean:
    files that have definitely not been modified since the
    dirstate was written
z3Calling `status` outside a `running_status` contextTNFc��gr#r-)r�s r*�noop�dirstate.status.<locals>.noop�s��r,)rar�@)*r[rr>r��preloadrtr�r�
get_fs_nowr$r�r��
FallbackErrorr$�__getitem__r�rVr�r�r�rgrYrjr,r�r�rur�r�r�r�r��st_size�
_rangemaskr%r�S_ISLNK�reliable_mtime_of�mtime_likely_equal_to�mtime_ofrru)+r'rr*r`rpr_rB�listignored�	listclean�listunknownr~rnr�r�ror,�use_rust�mtime_boundary�resr��	dcontains�dget�ladd�madd�aadd�uadd�iadd�radd�dadd�cadd�mexactrbr�r�rgrar�r�tr�r��reliablerus+                                           r*ru�dirstate.statusls���.�#�#�G�C��(�(��-�-�.5�g���46��B��B�4F�1��%�'�"$�b�"�%���y�y���������?��H�
�_�_��H�
��H�	"�&�1�1�$�,�,�?�N�
�
��'�'��k����n�.�.�.�	��%�%�	������}�}�������|�|��!,�w�~�~�$��!,�w�~�~�$���~�~���~�~��(�u�|�|�d�������O�O�	��O�O�	��O�O�	��)�)�#�#���9�E�-�-�T�9���i�i��[�D� �
�
�%�'��F�B���R�=�=��6�"�:�:�9�R�=�=�"��R�����H���R��A��6�6�D��6�6�D��!�)�)��R������R������R������R������ �Q�%;�%;���H�"�q�':�':���H��A�I�����+���
�
�Z�8O�0O�!�B�J�J�.�%�7�I��W�}��|�|�B�J�J�/�/�D�B�J�J�4F��R���R��#�H�%�1�#,�#>�#>���$���0�0��1C�1C�B�1G�H�H��R�� ��'�q�/F�/F� �0�0��R��"���R��K�L����W�w��
�����/�/��]�	"�!�N�	"���(�(�
��
�s$� Q�,Q+�Q(�'Q(�+R�Rc��^�URm[bURRmUR5(aTR5$UR	5nUR5(aUVs/sHo3T;dM
UPM sn$UR
5(a%[U4SjU55(a[U5$TVs/sHo1"U5(dMUPM sn$s snfs snf)zD
return files in the dirstate (in whatever state) filtered by match
c3�,># �UH	oT;v� M g7fr#r-)�.0r�r,s  �r*�	<genexpr>�#dirstate.matches.<locals>.<genexpr>s����!=�u���*�u�s�)	r�rtr��keysr_r!rZ�allr))r'rr_r�r,s    @r*�matches�dirstate.matchess�����y�y�����9�9�>�>�D��<�<�>�>��9�9�;�����
���=�=�?�?� %�2�u�!�T�	�A�u�2�2��<�<�>�>�c�!=�u�!=�=�=���;���,�4�a�5��8��4�,�,��3��
-s�9	C*�C*�
C/�!C/c�0�S/nURRUR5(a_URUR5 UR(a3URUR
RR55 [U5$)z{list all filename currently used by this dirstate

This is only used to do `hg rollback` related backup in the transaction
r�)	r$r�rrr�rcr��docket�
data_filenamerw)r'r_s  r*�all_file_names�dirstate.all_file_names sf��
����<�<���t�~�~�.�.��L�L����(��$�$����T�Y�Y�-�-�;�;�=�>��U�|�r,c#�4# �[S5n[S5n[S5n[S5nUR5Hyup�U
R(aCU
R(aX�;aX�;aXy-v� O!X�;aXY[R
"U54-v� U
R(dMlX�;dMsXi-v� M{ UHUn	UbU"U	5(dMURU	5n
U
R(aM9X�[R
"U54-v� MW g7f)zJ
check the dirstate contents against the parent manifest and yield errors
s5%s marked as tracked in p1 (%s) but not in manifest1
s*%s marked as added, but also in manifest1
s2%s marked as modified, but not in either manifest
s6%s in manifest1, but not marked as tracked in p1 (%s)
N)rr,r�rnr�shortr�r�)r'�m1�m2r3�narrow_matcher�missing_from_p1�unexpected_in_p1�missing_from_ps�missing_from_dsr�rs           r*�verify�dirstate.verify,s�����E�
���K�L���B�
���F�
���
�
��H�A�����>�>�a�k�a�k�)�-�-��[�)��
�
�2��,?�?�?��{�{�{�q�w�&�*�*�%��A��)�.��2C�2C���N�N�1�%�E��#�#�#�%�D�J�J�r�N�(;�;�;��s�B%D�+D�2AD�7!D)rqrprorkrlrnrrrsr=rwrer$rvrtrurgrjr[rhrmrcrdrf)F)r
r�)r�r	r
r�)r
r
)rzintdirstate.FlagFuncFallbackTr
zintdirstate.FlagFuncReturnT)r
r	r#)r�r	r�Optional[bytes]r
r	)rr	r
zintdirstate.DirstateItemT)r#rr
r�)r
�Iterator[bytes])r
z1Iterator[Tuple[bytes, intdirstate.DirstateItemT]])r
zList[bytes])r3r	r7r�)r?r	rW�Optional[TransactionT]r
�None)r
r�)rir�rjr	r
r�)rnr	r
r�)r
zDict[bytes, bytes])FFN)FN)FF)rr	r�r�r�r�r
r	)r�r	r��Iterable[bytes]r�zOptional[Iterable[bytes]]r
r�)r�r�r
r�)r�r	r�z$intdirstate.AddParentChangeCallbackTr
r�)r�r	r
zintdirstate.IgnoreFileAndLineT)T)rr
r*rr_r�r`r�rar�r
zintdirstate.WalkReturnT)rr
r*r�r`r�rpr�r_r�r
zintdirstate.StatusReturnT)rr
r
r�)r3r	r�z
Optional[Any]r
r�)\r/r0r1r2rUr�r�r��
contextlib�contextmanagerrGr�r�r�r�r��propertyrVrJrQ�
propertycacher�r�r r�r�r�r6r�r�r�r�r�r9rrxrrr�r$r)r,�	iteritemsr^r3r7r;r?rMrDrZrVr�rXrkrorrrSrwr}r]r�r�r�r�r�r�rvrfr�r�r�r�r�r�rSr�r�r�r�r�r�r�rr>rjr�rur�r�r�r4r-r,r*rr�s����N��5�n
������@"���@"�D����4���4�l������0������4*��(��(��8��8��6��6��
��
��%��%� �y��
��
��#��#�*��|��M��M��O��O��*��*��0��0��<��<�!�
7�:�7�	$�7�r�!��!��(�� �'�!��I�5�+�+��9��9�.��=��=�4���*@��	
��6-��&�	.��	.�1�!�����*����'�9�'�9�'�/�'�/�
�%
��%
�N����
��
�:
�@���
�>%�"
=��4
��"IN����$(��AE��	��6�����
37�	7��7�"�7�0�	7�

�7��7�r
�)0�V'�5��5�)M�5�	
�5�
(�"��	��,F0�\�
D��D��D��	D�
�D��
D�
!�D�LP �d]0��]0��]0��	]0�
�]0��
]0�
#�]0�~-�*
�BF�<��<�1>�<�	�<�<r,)<�
__future__rrr�r�rr��typingrrrrrr	r
�i18nr�interfaces.typesr
r�hgdemandimportr�rrrrr�rrrrrrr�
dirstateutilsr�
interfacesr�intdirstate�	importmodr�
importrustrt�HAS_FAST_DIRSTATE_V2r��	filecache�	rangemaskr�r r r6rGrMrSrXr]r�r��	idirstater-r,r*�<module>r�s��#���	��������
#��������
�
�9�
%��
�
�
�J�T�
2���d�*���"�"�
����	�
�
"�
"�
��'�'��'�	�'� �	� ��$#�#�#�#� ����r<�{�$�$�r<r,

Youez - 2016 - github.com/yon3zu
LinuXploit