�
�c*@s[dZd
dk
lZ
d
dkZd
dkZd
dkZd
dkZd
dkZd
dkZd
dk	Z	d
dk
Z
d
dkZd
dkZd
dk
Z
d
dkZd
dkZd
dkZd
dkZd
dkZd�ad�ad
dkZeidjZd�Zd�Zd	�ZdqZedrZd&�Zd'�Zd(ef
d)��YZ d*�Z!d+�Z"he"d,<e!d-<Z#d.�Z$d/�Z%d0d1d2�Z&ei'Z'd3�Z(d4�Z)d5�Z*d6�Z+da-d7�Z.d8�Z/d9�Z0hdddd:�Z1d;�Z2d<�Z3d=�Z4d>�Z5d?�Z6dd@�Z7dAef
dB��YZ8dC�Z9e:edD�o

ei;Z<n

dE�Z<dddF�Z=eidGjo
d
dHk>Tn
d
dHk?TdI�Z@dJ�ZAdK�ZBdL�ZChZDdM�ZEdN�ZFdO�ZGdP�ZHdQ�ZIdR�ZJdS�ZKeLddT�ZMdUef
dV��YZNddW�ZOdXef
dY��YZPdZef
d[��YZQd1dd\�ZRd]�ZSdd^d_�ZTdd`�ZUgda�ZVdddb�ZWdc�ZXdd�ZYde�ZZdfdg�Z[eLdeLdh�Z\da]di�Z^dj�Z_dk�Z`dl�Zadm�Zbdn�Zcddo�Zddp�ZedS(ss�Mercurial utility functions and platform specfic implementations.

This contains helper routines that are independent of the SCM core and
hide platform-specific details from the core.
i�(
t
_Nc

Cs
t|�S(
N(
t	_fastsha1(
t
s((s./mercurial/util.pytsha1s
c
CsNyd
dkl
}

Wn#tj
o



d
dkl}

n
X|
aa
|
|�S(Ni�(
R(
tsha(thashlibRtImportErrorRR
(Rt_sha1((s./mercurial/util.pyR
s




tposixc
CsCti
|d
tdddtdtidti�}
|
i|
ifS(Ntshelltbufsizei�t	close_fdststdintstdout(t
subprocesstPopentTruetclosefdstPIPERR
(tcmdt
p((s./mercurial/util.pytpopen2)s


c
CsRti
|d
tdddtdtidtidti�}
|
i|
i|
ifS(NR	R
i�RRR
tstderr(RRRRRRR
R(RR((s./mercurial/util.pytpopen31s





c
Cs5yd
dk}|i
SWntj
o



dSn
XdS(s(Return version information if available.i�Ntunknown(t__version__tversionR(
R((s./mercurial/util.pyR8s




s%Y-%m-%d %H:%M:%Ss%Y-%m-%d %I:%M:%S%ps%Y-%m-%d %H:%Ms%Y-%m-%d %I:%M%ps%Y-%m-%ds%m-%ds%m/%ds%m/%d/%ys%m/%d/%Ys%a %b %d %H:%M:%S %Ys%a %b %d %I:%M:%S%p %Ys%a, %d %b %Y %H:%M:%Ss%b %d %H:%M:%S %Ys%b %d %I:%M:%S%p %Ys%b %d %H:%M:%Ss%b %d %I:%M:%S%ps%b %d %H:%Ms
%b %d %I:%M%ps%b %d %Ys%b %ds%H:%M:%Ss	%I:%M:%SPs%H:%Ms%I:%M%ps%Ys%Y-%ms%bs%b %Yc
sEh��ii
d
jo
��fd�}
n
��fd�}
|
S(s"cache the result of function callsi
c

s)|�jo
�|��|<n

�|S(
N((
targ(tcachetfunc(s./mercurial/util.pyt
fjs



c
s)|�jo
�|��|<n

�|S(
N((
targs(RR(s./mercurial/util.pyRos



(t	func_codetco_argcount(RR((RRs./mercurial/util.pyt	cachefunccs

c
sQh�g��ii
d
jo
���fd�}
n
���fd�}
|
S(s+cache most recent results of function callsi
c

sj|�jo;
t��d
jo
��i
d�=n

�|��|<n
�i|�
�i|�
�|S(Nii(tlentpoptremovetappend(
R(RRtorder(s./mercurial/util.pyR{s








c
sj|�jo;
t��d
jo
��i
d�=n

�|��|<n
�i|�
�i|�
�|S(Nii(R#R$R%R&(
R(RRR'(s./mercurial/util.pyR�s








(R R!(RR((RR'Rs./mercurial/util.pytlrucachefuncvs




t
propertycachecBseZ
d�Zdd
�ZRS(cCs|
|_|
i
|_dS(
N(Rt__name__tname(tselfR((s./mercurial/util.pyt__init__�s
	
cCs&|i|
�}t
|
|i|�
|S(
N(RtsetattrR+(R,tobjttypetresult((s./mercurial/util.pyt__get__�s


N(R*t
__module__R-tNoneR2(((s./mercurial/util.pyR)�s
	c
CsFti
|
d
tdtdtidti�}|i|�\}}|S(s9filter string S through command CMD, returning its outputR	RRR
(RRRRRtcommunicate(RRRtpouttperr((s./mercurial/util.pyt
pipefilter�s


cCsb
d
\}}z
t
id
d�
\}}ti|d�}|i|�
|i�
t
id
d�
\}}ti|�
|
id|�}
|
id|�}
ti|
�}t	i
djo
|d@o

d	}n

|o&
ttd
�|
t
|�f��n

t|d�i�SWdy|o
ti|�
n

Wn


n
Xy|o
ti|�
n

Wn


n
XXdS(s�filter string S through a pair of temporary files with CMD.
    CMD is used as a template to create the real command to be run,
    with the strings INFILE and OUTFILE replaced by the real names of
    the temporary files generated.tprefixs
hg-filter-in-twbshg-filter-out-tINFILEtOUTFILEtOpenVMSi
iscommand '%s' failed: %strbN(NN(R4ttempfiletmkstemptostfdopentwritetclosetreplacetsystemtsystplatformtAbortRtexplain_exittopentreadtunlink(RRtinnametoutnametinfdtfptoutfdtcode((s./mercurial/util.pyt
tempfilter�s,























s	tempfile:spipe:cCs[xKti
�D]=\}}|
i|�o!
|||
t|�i��Sq

q
Wt||
�S(
sIfilter a string through a command that transforms its input to its output(tfiltertablet	iteritemst
startswithR#tlstripR8(RRR+tfn((s./mercurial/util.pytfilter�s



%
c

Cst|o

d
|j�S(s&return true if a string is binary datat
(
tbool(
R((s./mercurial/util.pytbinary�sii
ccs�d
�}g}d}x�|D]�}|i|�
|t
|�7}||
jow
|
|joL
|
d>}
d||�>}||
jo

|}
n

|
|jo

|}
q�
n

di|�V
d}g}q
qW|o
di|�V
n

dS(srreturn no less than min bytes per chunk while data remains,
    doubling min after each chunk until it reaches maxc
Ss@|p
d
Sn

d
}
x |o
|dL}|
d7}
q
W|
dS(Nii
((t
xt
i((s./mercurial/util.pytlog2�s








ii
tN(R&R#tjoin(tsourcetmintmaxR`tbuftblentchunktnmin((s./mercurial/util.pytincreasingchunks�s(		























c


CstS(
N(
R(
RY((s./mercurial/util.pytalways�sc


CstS(
N(
tFalse(
RY((s./mercurial/util.pytnever�scCs2
|
p
t|�Sn

t
ii|
�oi
t
ii|�d
t
ii|
�d
jo
t
ii|t|��Sn

dit|�|f�}n

t|
�|id�}}|i	�
|i	�
x<|o4
|o-
|d|djo
|i
�
|i
�
q�
W|i	�
t
iidg
t|�|�p
dS(sa
return the relative path from one place to another.
    root should use os.sep to separate directories
    n1 should use os.sep to separate directories
    n2 should use "/" to separate directories
    returns an os.sep-separated path.

    If n1 is a relative path, it's assumed it's
    relative to root.
    n2 should always be relative to root.
    it
/i�s..t
.(
t	localpathRAtpathtisabst
splitdriveRbtpconvertt	splitpathtsplittreverseR$tsepR#(troottn1tn2t
at
b((s./mercurial/util.pytpathto�s

-







&





cCs�|ti
jo

ti
}n%
t|�o

|}n
|ti
}|}tii|�p
tii||
|�}n

tii|�}t|�}||jo8
|i|�o(
|t	|�}||�
t
|�Sn

||jo
d
Sn�ti|�}g}x�to�
yti|�}Wnt
j
o



Pn
Xt||�oC
|p
d
Sn

|i�
tii|�}||�
t
|�Sn

tii|�\}	}
|i|
�
|	|jo
Pn

|	}q

Wtd|��dS(s7return the canonical path of myname, given cwd and rootRas%s not under rootN(RARxtendswithsepRqRrRbtnormpathtpath_auditorRWR#RttstatRtOSErrortsamestatRwRvR&RI(RytcwdtmynametrootsepR+t
audit_pathtroot_sttreltname_sttdirnametbasename((s./mercurial/util.pyt	canonpath
sH









































cCs-tt
d
�p
tt
d�p

tid�S(s�return True if we are a frozen executable.

    The code supports py2exe (most common, Windows only) and tools/freeze
    (portable, not much used).
    tfrozent	importerst__main__(thasattrRGtimpt	is_frozen(((s./mercurial/util.pytmain_is_frozen>
s

c
Csntdjo]
tiid
�}|o
t|�
qj
t�o
tti�
qj
tt	d�p
d�
n

tS(s]return location of the 'hg' executable.

    Defaults to $HG or 'hg' in the search path.
    tHGthgN(
t
_hgexecutableR4RAtenvirontgettset_hgexecutableR�RGt
executabletfind_exe(
R�((s./mercurial/util.pythgexecutableH
s







c


Cs
|ad
S(s#set location of the 'hg' executableN(
R�(
Rq((s./mercurial/util.pyR�W
sc
Cs0d
�}h}x$|
D]}ti
i|�||<qW|dj	o
ti�}n

|}	tidjo
d|}n

zA
x-|
i�D]\}}
||
�ti
|<q�Wt�ti
d<|dj	o
||jo
ti|�
n

ti	|�}t
idjo
|d@o

d}n

|o�
|o�
dtii
|	idd�d�t|�df}|o
d	||f}n

y|i|d
�
Wq�tj
o



||��q�
Xn

|SWdxB|i�D]4\}}
|
djo
ti
|=q�
|
ti
|<q�W|dj	o
||jo
ti|�
n

XdS(s�enhanced shell command execution.
    run with environment maybe modified, maybe in different dir.

    if command fails and onerr is None, return status.  if ui object,
    print error message and return status, else raise onerr object as
    exception.c

SsA|djp

|t
jo
d
Sn

|tjo
dSn

t|�S(s9convert python object into string that is useful to shellt
0t
1N(R4RlRtstr(
tval((s./mercurial/util.pytpy2shellc
s





tnts"%s"R�R=i
is%s %ss%s: %ss

N(RAR�R�R4tgetcwdR+RVR�tchdirRFRGRHRqR�RvRJtwarntAttributeError(
RR�R�tonerrt	errprefixR�toldenvt
ktoldcwdtorigcmdt
vtrcterrmsg((s./mercurial/util.pyRF\
sJ	




















"













c
s�f
d
�}
|
S(s5wrap a function with code to check for calling errorscsay�||
�SWnItj
o=



t
titi�d
��djo

ti�n

�n
XdS(Nii
(t	TypeErrorR#t	tracebackt
extract_tbRGtexc_infoterrortSignatureError(Rtkwargs(
R(s./mercurial/util.pytcheck�s



&


((RR�((
Rs./mercurial/util.pytchecksignature�sc

Cs#yti
|�
Wn


tSn
XtS(
sCtest whether a file with this name exists. does not follow symlinks(RAtlstatRlR(
tfilename((s./mercurial/util.pytlexists�s




cCsryti
||
�
WnWtj
oK

}
d
�}||
�}ti
|
|�
ti|�
ti
||
�
n
XdS(sforcibly rename a filec
SsdxKtd
�D]=}
d|t
idd�f}tii|�p
|Sq

q
Wttidf�dS(Ni
s%s-%08xil�s"No usable temporary filename found(	txrangetrandomtrandintRARqtexiststIOErrorterrnotEEXIST(R9ttriesttemp((s./mercurial/util.pyttempname�s





N(RAtrenameR�RM(tsrctdstterrR�R�((s./mercurial/util.pyR��s

	



c

CsDti
|�
ytitii|��
Wntj
o



n
Xd
S(s.unlink and remove the directory if it is emptyN(RARMt
removedirsRqR�R�(
R((s./mercurial/util.pyRM�s




cCs�ti
i|�o8
yti|
�
Wn


n
Xtiti|�|
�
nR
y$ti||
�
ti||
�
Wn*ti	j
o

}
t
t|���n
Xd
S(s,copy a file, preserving mode and atime/mtimeN(RARqtislinkRMtsymlinktreadlinktshutiltcopyfiletcopystattErrorRIR�(R�tdesttinst((s./mercurial/util.pyR��s








cCs!
|d
jo4
t
i|�it
it
ii|
��ij}n

t
ii|�ok
t
i|
�
x�ti	|�D]F\}}t
ii
||�}t
ii
|
|�}t|||�
qqWn_
|oG
yt||
�
Wq
t
tfj
o



t}ti||
�
q

Xn
ti||
�
d
S(s1Copy a directory tree using hardlinks if possibleN(R4RAR�tst_devRqR�tisdirtmkdirtosutiltlistdirRbt	copyfilestos_linkR�R�RlR�tcopy(R�R�thardlinkR+tkindtsrcnametdstname((s./mercurial/util.pyR��s"


%










R�c
Bs eZ
dZd
�Zd�ZRS(s
ensure that a filesystem path contains no banned components.
    the following properties of a path are checked:

    - under top-level .hg
    - starts at the root of a windows drive
    - contains ".."
    - traverses a symlink (e.g. a/symlink_here/b)
    - inside a nested repositorycCs%t�|_
t�|_|
|_dS(
N(tsettauditedt
auditeddirRy(R,Ry((s./mercurial/util.pyR-�s


c	s���ijo
dSn

t
ii��}t|�}t
ii��d
p'
|d
i�d	jp
t
i|jo
tt	d����n

d�i�jo�
g}|D]}||i�q�~}xhd
D]\}||djoE
|i
|�}t
ii|| �}tt	d��|f��q�
q�Wn

��fd�}	|i�
g}
xT|oL
t
i
i|�}|�ijo
Pn

|	|�
|
i|�
|i�
qX

W�ii��
�ii|
�
dS(Nis.hgs.hg.Ras#path contains illegal component: %si
spath %r is inside repo %rc
s�ti
i�i|�}
yti|
�}Wn>tj
o2

}
|itititi	fjo
�q��
Xt
i|i�o 
t
td
��|f��nV
t
i|i�oB
ti
iti
i|
d��o 
t
td��|f��n

dS(Ns"path %r traverses symbolic link %rs.hgspath %r is inside repo %r(RARqRbRyR�R�R�tENOENTtENOTDIRtEINVALR�tS_ISLNKtst_modeRIRtS_ISDIRR�(R9tcurpathtstR�(R,Rq(s./mercurial/util.pyR�s



"




"

(s.hgs.hg.Ra(s.hgs.hg.(R�RARqtnormcaseRuRstlowertpardirRIRtindexRbR$RxR�R&taddtupdate(R,RqR�tpartst_[1]RtlpartstpostbaseR�tprefixesR9((R,Rqs./mercurial/util.pyt__call__s8









'




(












(R*R3t__doc__R-R�(((s./mercurial/util.pyR��s	c

Csti
|�iS(
s.Return number of hardlinks for the given file.(RAR�tst_nlink(
tpathname((s./mercurial/util.pytnlinks0stlinkcCstd
t
d���dS(NisHardlinks not supported(R�R(R�R�((s./mercurial/util.pyR�7s
c
CsdS(
N(
R4(tkeyR+tscope((s./mercurial/util.pyt
lookup_reg:s
R�(
t
*cCs�yti
||
�SWnAtj
o#

}
|itijo
�qX
n
tj
o



n
Xti|
titiBti	B�}ti
||�
ti|�
dS(
N(RAR�R�R�R�R�RKtO_CREATtO_WRONLYtO_EXCLRCRD(tinfoR�twhytld((s./mercurial/util.pytmakelockBs






#

c
Csnyti
|�SWnJtj
o,

}

|
ititifjo
�q^
n
tj
o



n
Xt|�i�S(
N(	RAR�R�R�R�tENOSYSR�t	posixfileRL(R�R
((s./mercurial/util.pytreadlockOs







c

CsAyti
|i��SWn#tj
o



ti|i�Sn
Xd
S(s1stat file object that may not have fileno method.N(RAtfstattfilenoR�R�R+(
RQ((s./mercurial/util.pyR

Ys


c
Cs�ti
|�}
tii|�\}}tii||i��}||jo
tii||i��}n

y,ti
|�}||
jo
tSn

tSWn


tSn
Xd
S(s�
    Check whether the given path is on a case-sensitive filesystem

    Requires a path (like /foo/.hg) ending with a foldable final
    directory component.
    N(	RAR�RqRvRbtupperR�RlR(Rqts1t
dR}tp2ts2((s./mercurial/util.pyt	checkcasebs












cCs�|i�i
|
i��oP
t|
�}||tijp
||tijo
|d
}n

||}n

tiitii|
|��p
dSn

ti}tio
|ti}n

|i
dd�
tid||f�}tii
tii|
��}g}x�|i|�D]�\}}|o
|i|�
q
n

|tjo
ti|�t|<n

t|}	|i�}
x@|	D]+}|i�|
jo
|i|�
Pq

q
W|i|�
tii||
�}q
Wdi|�S(s
Get name in the case stored in the filesystem

    The name is either relative to root, or it is an absolute path starting
    with root. Note that this function is unnecessary, and should not be
    called, for case-sensitive filesystems (simply because it's expensive).
    i
s
\s\\s([^%s]+)|([%s]+)RaN(R�RWR#RARxtaltsepRqR�RbR4REtretcompileR�R�tfindallR&t_fspathcacheR�(R+Ryt
ltsepstpatterntdirR1tpartRxtcontentstlpartt
n((s./mercurial/util.pytfspathws>

(

"
	



















	

c

Cs�y�ti
tiBtiB}
tid
d
|�\}}zati|�
ti|�id@}||
@}ti	|||
A�
ti|�id@|j}Wdti
|�
XWnttfj
o



t
Sn
X|p
|S(s}
    Check whether the given path is on a filesystem with UNIX-like exec flags

    Requires a directory (like /foo/.hg)
    Rai�N(R�tS_IXUSRtS_IXGRPtS_IXOTHR?R@RARDR�tchmodRMR�R�Rl(Rqt	EXECFLAGStfhRYt
mtnew_file_has_exectexec_flags_cannot_flip((s./mercurial/util.pyt	checkexec�s









 
	
c
Cs[ti
d
|�
}
y%tid|
�
ti|
�
tSWnttfj
o



tSn
XdS(s?check whether the given path is on a symlink-capable filesystemR
RoN(	R?tmktempRAR�RMRR�R�Rl(RqR+((s./mercurial/util.pyt	checklink�s






cCs
ti
d
jS(sCreturn True if patches should be applied in binary mode by default.R�(RAR+(((s./mercurial/util.pytneedbinarypatch�sc

Cs-|it
i�p
t
io
|it
i�S(
s)Check path ends with os.sep or os.altsep.(tendswithRARxR
(
Rq((s./mercurial/util.pyR�sc

Cs|it
i�S(
s�Split path by os.sep.
    Note that this function does not use os.altsep because this is
    an alternative of simple "xxx.split(os.sep)".
    It is recommended to use os.path.normpath() before using this
    function if need.(RvRARx(
Rq((s./mercurial/util.pyRu�scCs0ti
d
jp 
ti
djp
tiid�S(sAre we running in a GUI?R�tmactDISPLAY(RAR+R�R�(((s./mercurial/util.pytgui�scCs�ti
i|�\}}tid
d|d|�\}}ti|�
yti|�id@}WnWtj
oK

}
|i	t	i
jo
�n

|}|d	jo
t}n

|dM}n
Xti
||�
|
o
|Sn

y�yt|d�}	WnStj
oG

}
|i	t	i
jo
|Sn

t|dd	�p

||_n

�n
Xt|d�}
x!t|	�D]}|
i|�
qb
W|	i�
|
i�
Wn%


yti|�
Wn


n
X�n
X|S(
s
Create a temporary file with the same contents from name

    The permission bits are copied from the original file.

    If the temporary file is going to be truncated immediately, you
    can use emptyok=True as an optimization.

    Returns the name of the temporary file.
    R9s.%s-R
i�i�R>R�R:N(RARqRvR?R@RDR�R�R�R�R�R4tumaskR&
R
R�tgetattrR�t
filechunkiterRCRM(R+temptyokt
createmodeR
RYtfdR�R�R�tifptofpRh((s./mercurial/util.pyt
mktempcopy�sF

"



































tatomictempfilec
Bs2eZ
dZd
�Zd�Zd�Zd�ZRS(s�file-like object that atomically updates a file

    All writes will be redirected to a temporary copy of the original
    file.  When rename is called, the copy is renamed to the original
    name, making the changes visible.
    cCsL|
|_d|_t|
d
d|jd|�|_t|i|�|_dS(NR7
t
wR8
(t_atomictempfile__nameR4t_fpR<
R�R
(R,R+tmodeR8
((s./mercurial/util.pyR-s

	
	


cCst|i
|
�S(
N(R5
R@
(R,R+((s./mercurial/util.pyt__getattr__s
c

Cs;|ii
p*
|ii�
t|it|i��
n

dS(
N(R@
tclosedRDR�R�RpR?
(
R,((s./mercurial/util.pyR�!s




c

CsR|ip
dSn

|ii
p/
yti|i�
Wn


n
X|ii�
n

dS(
N(R@
RC
RARMR�RD(
R,((s./mercurial/util.pyt__del__&s








(R*R3R�R-RB
R�RD
(((s./mercurial/util.pyR=
s

			cCs�y6ti
|�
|
d
j	o
ti||
�
n

d
SWnJtj
o>

}
|itijo
d
Sn

|itijo
�q�
n
Xtii	tii
|��}t||
�
t||
�
d
S(s9recursive directory creation with parent mode inheritanceN(RAR�R4R&
R�R�R�R�RqtabspathR�tmakedirs(R+RA
R�tparent((s./mercurial/util.pyRF
/s














topenercBsMeZ
dZed
�Zed��Zd�Zdeed�Z	d�Z
RS(s�Open files relative to a base directory

    This class is used to hide the details of COW semantics and
    remote file access from higher level code.
    cCs9|
|_|o
t
|
�|_n

t|_d|_dS(
N(R�R�R�RkR4R8
(R,R�taudit((s./mercurial/util.pyR-Es

	

	
c

Cs
t|i
�S(
N(R.
R�(
R,((s./mercurial/util.pyt_can_symlinkMscCs3|idjo
dSn

ti|
|id
@�
dS(Ni�(R8
R4RAR&
(R,R+((s./mercurial/util.pyt_fixfilemodeQs


t
rc	Cs7
|i|
�
t
ii|i|
�}|o
d
|jo
|d
7}n

d}|djo�
yt|�}WnRtj
oF



d}t
ii|�}t
ii|�p
t	||i
�
q�
n
X|o
t|||i
�Sn

|djo
tt
|�|�
q

n

t||�}|djo
|i|�
n

|S(NR}i�RL
R>ii
(RL
srb(R�RARqRbR�R�R�R�R�RF
R8
R=
R�R<
R
RK
(	R,RqRA
ttextt
atomictempRtnlinkR
RQ((s./mercurial/util.pyR�Vs*






















c	Cs
|i|�
t
ii|i|�}yt
i|�
Wntj
o



n
Xt
ii|�}t
ii|�p
t	||i
�
n

|ioX
yt
i|
|�
Wq
tj
o1

}
t|i
td
�|
|if|��q

Xn4
||d�}|i|
�
|i�
|i|�
dS(Nscould not symlink to %r: %sR>
(R�RARqRbR�RMR�R�R�RF
R8
RJ
R�R�RtstrerrorRCRDRK
(R,R�R�tlinknameR�R�R((s./mercurial/util.pyR�os&



















(R*R3R�RR-R)RJ
RK
RlR�R�(((s./mercurial/util.pyRH
?s
	tchunkbufferc
Bs eZ
dZd
�Zd�ZRS(soAllow arbitrary sized chunks of data to be efficiently read from an
    iterator over chunks of arbitrary size.cCs%t|
�|_d
|_
d|_dS(szin_iter is the iterator that's iterating over the input chunks.
        targetsize is how big a buffer to try to maintain.RaiiNi
(titerRft
targetsize(R,tin_iter((s./mercurial/util.pyR-�s
	
cCs'
|
t|i
�jo�
|io�
t|
|i�}ti�}|i|i
�
t|i
�}x@|iD]5}|i|�
|t|�7}||jo
Pqg
qgW||jo

t|_n

|i	�|_
n

t|i
�|
jo
t
|i
�d
}|_
n$
|i
|
 t|i
|
�}|_
|S(suRead L bytes of data from the iterator of chunks of data.
        Returns less than L bytes if the iterator runs dry.Ra(R#RfRS
ReRT
t	cStringIOtStringIORCRltgetvalueR�tbuffer(R,R
RT
t	collectort	collectedRhR((s./mercurial/util.pyRL�s$ 










	






#
(R*R3R�R-RL(((s./mercurial/util.pyRR
�s	ccs�|
d
jp
t�
|djp
|d
jp
t�
xttol
|djo

|
}n
t||
�}|o

|i|�}|p
Pn

|o
|t|�8}n

|V
q8
WdS(sX
Create a generator that produces the data in the file size
    (default 65536) bytes at a time, up to optional limit (default is
    to read all data).  Chunks may be less than size bytes if the
    chunk is the last chunk in the file, or the file is a socket or
    some other type of file that sometimes reads less data than is
    requested.iN(tAssertionErrorR4RRdRLR#(RtsizetlimittnbytesR((s./mercurial/util.pyR6
�s
!







cCsPti
�}|d
djo
tio

ti}
n

ti}
ti|�|
fS(Nii
(ttimet	localtimetdaylighttaltzonettimezonetmktime(tltttz((s./mercurial/util.pytmakedate�s




	
s%a %b %d %H:%M:%S %Y %1%2cCs�|p
t�\}}d
|
jp

d|
joh
|djo
dp
d}t
|�d}|
id
d||df�}
|
idd|d�}
n

ti|
tit|�|��}|S(	s�represent a (unixtime, offset) tuple as a localized time.
    unixtime is seconds since the epoch, and offset is the time zone's
    number of seconds away from UTC. if timezone is false, do not
    append time zone to string.s%1s%2it
-t
+i<s%c%02ds%02d(Rh
tabsRER`
tstrftimetgmtimetfloat(tdatetformatt
tRg
tsigntminutesR((s./mercurial/util.pytdatestr�s



 

%
c

Cst|d
d�
S(s1turn (timestamp, tzoff) tuple into iso 8631 date.Rp
s%Y-%m-%d(
Rt
(
Ro
((s./mercurial/util.pyt	shortdate�sc
Cs'
d
�}||�|}}|djo
di
|i�d �}n

xs|D]k}g}|D]"}d||
jo
|tq^
q^~}	|	p(
|d||7}|
d|d7}
qM
qMWti||
�}
tti|
��}|djo#
tti	|
��}||}n
||}||fS(	s~parse a localized time string and return a (unixtime, offset) tuple.
    if the string cannot be parsed, ValueError is raised.c
Ss�|i�d
}
|
ddjo�
t
|
�djon
|
di�o]
|
ddjo
dp
d
}t|
dd!�}t|
dd!�}||d|dSn

|
d	jp

|
d
jo
dSn

dS(Ni�is+-ii
Rj
ii<tGMTtUTC(RvR#tisdigittintR4(tstringRg
Rr
thoursRs
((s./mercurial/util.pyRd
�s

5






t
 i�t
%t
@s@%iN(
R4RbRvRR`
tstrptimeRy
tcalendarttimegmRe
(
Rz
Rp
tdefaultsRd
toffsetRo
R
R�Rtfoundt	timetuplet
localunixtimetunixtime((s./mercurial/util.pytstrdate�s"	



6








c
Cs�|p
dSn

t|t
�o
t|�djo
|Sn

|
p

t}
n

|i�}y"tt|id��\}}Wn�tj
o�


|p

h}n

t	�}x_di�D]Q}||jo>
|d
djo
d||<q

t
|d|d
�||<q�
q�Wxb|
D]?}yt|||�\}}Wnttfj
o



q


XPq

Wt
td�|��n
Xt|�d	jo
t
td
�|��n

|djp

|djo
t
td
�|��n

||fS(s�parse a localized date/time string and return a (unixtime, offset) tuple.

    The date may be a "unixtime offset" string or in one of the specified
    formats. If the date already is a (unixtime, offset) tuple, it is returned.
    iiR|
sd mb yY HI M StHMSt00R}
sinvalid date: %r i�sdate exceeds 32 bits: %di ;��simpossible time zone offset: %d(ii(t
isinstancettupleR#tdefaultdateformatststriptmapRy
Rvt
ValueErrorRh
Rt
R�t
OverflowErrorRIRRk
(Ro
tformatsR�twhenR�tnowR
Rp
((s./mercurial/util.pyt	parsedate�s@

#






"



	





#







c
s}
d
�}
d�}|i�}|ddjo!
||d���f
d�Sn*

|ddjo!
|
|d���f
d�Sn�dd	jon
yt
|d�}Wn-tj
o!



ttd
�|d��n
Xt�d|dd��f
d
�Sny
d|joB
|id�\}}|
|�||�����fd�Sn*
|
|�||�����fd�SdS(s�Return a function that matches a given date match specifier

    Formats include:

    '{date}' match a given date to the accuracy provided

    '<{date}' on or before a given date

    '>{date}' on or after a given date

    c
Ss)td
ddd�}
t
|t|
�dS(NtmbR�R
i(tdictR�textendeddateformats(Ro
R
((s./mercurial/util.pyR�3s

c
	Ss�td
ddddddd�}
x@di
�D]2}y"||
d	<t|t|
�d
SWq.


q.Xq.Wd|
d	<t|t|
�d
S(NR�t12tHIt23t
Mt59t
Ss31 30 29R
it28(R�RvR�R�(Ro
R
tdays((s./mercurial/util.pyR
7s
!










it
<i
c

s
|�j
S(((
R^(
R�(s./mercurial/util.pyt<lambda>Est
>c

s
|�jS(((
R^(
R�(s./mercurial/util.pyR�HsRi
sinvalid day spec: %siic

s
|�jS(((
R^(
R�(s./mercurial/util.pyR�Oss to c

s|�jo

|�j
S(((
R^(tstoptstart(s./mercurial/util.pyR�Ssc

s|�jo

|�j
S(((
R^(R�R�(s./mercurial/util.pyR�VsN(R�Ry
R�RIRRh
Rv(Ro
R�R
R�R|R}((R�R�R�s./mercurial/util.pyt	matchdate&s,
		


















c
Cs�|id
�}
|
djo
||
 }n

|id�}
|
djo
||
d}n

|id�}
|
djo
||
 }n

|id�}
|
djo
||
 }n

|S(s>Return a short representation of a user name or email address.R~
iR�i
R|
Ro(
tfind(tuserR((s./mercurial/util.pyt	shortuserXs















c
Cs>|id
�}
|
djo

d}
n

||id�d|
!S(sget email of author.R�i�R�i
N(R�R4(tauthorRL
((s./mercurial/util.pytemailhs

i�cCs/t|�|
j
o
|Sn
d
||
d SdS(s;Trim string to at most maxlength (default: 400) characters.s%s...iN(
R#(RM
t	maxlength((s./mercurial/util.pytellipsisns
c#s��f
d
�}|
o 
tt
id�o

d�}n
t}
|djo
|
o
g}||��
n

x<
t
i�dtd|�D]
\}}}d|jok
|V
t
ii|dd�}	t
iit
ii|	d��o	
|	V
n

|o
|i	d�
q�
g|(q�
|
o�
g}
x}|D]u}t
ii||�}|||�oJ
t
ii
|�o&
x0t|t|�D]}
|
V
qo
Wq�
|
i|�
q

q
W|
|(q�
q�WdS(	s2yield every hg repository under path, recursively.c

s|i�jo

|�n

dS(
N(
R�(
R�(
Rq(s./mercurial/util.pyt
errhandlerws

R�cSsjt}t
ii}t
i|
�}x)|D]!}|||�o
t}Pq(
q(W|p
|i|�
n

|S(
N(RlRARqR�R�RR&(tdirlstR�tmatchR�tdirstatt
lstdirstat((s./mercurial/util.pyt_add_dir_if_not_there{s






	


ttopdowntonerrors.hgtpatchesN(
R�RARqRlR4twalkRRbR�R%R�t	walkreposR&(Rqt	followsymt	seen_dirstrecurseR�R�RytdirstfilestqroottnewdirsR
tfnamethgname((
Rqs./mercurial/util.pyR�us:









"
	










cCsJt�}|i
t��
g}
|D]}|
tii|�q$~
}|S(
s+return default os-specific hgrc search path(t
system_rcpathtextendtuser_rcpathRARqR�(RqR�R((s./mercurial/util.pyt	os_rcpath�s	

-
cCs�tdjo�
d
tijo�
gax�tid
iti�D]�}|p
q=n

tii|�oT
x^ti	|�D]<\}
}|
i
d�o 
titii||
��
qt
qtWq=
ti|�
q=Wq�
t
�an

tS(s
return hgrc search path. if env var HGRCPATH is set, use it.
    for each item in path, if directory, use files ending in .rc,
    else use item.
    make HGRCPATH empty to only look in .hg/hgrc of current repo.
    if no HGRCPATH, use default os-specific path.tHGRCPATHs.rcN(t_rcpathR4RAR�RvtpathsepRqR�R�R�R0
R&RbR�(RRR�((s./mercurial/util.pytrcpath�s








(

c

Cs
d
dtd�fddtd�fddtd�fd
dtd	�fddtd
�fddtd�fd
dtd�fddtd
�fddtd�fddtd�ff
}
x>|
D]6\}}}|||jo
||t
|�Sq�
q�W|
dd|S(s:return byte count formatted as readable string, with unitsidi
is%.0f GBi
s%.1f GBs%.2f GBis%.0f MBs%.1f MBs%.2f MBs%.0f KBs%.1f KBs%.2f KBs
%.0f bytesi�ii@i@i@iiiiii(RRn
(R_
tunitst
multipliertdivisorRp
((s./mercurial/util.pyt	bytecount�s











cCsP|d
}|
i|�o2
|
t
|�}
|
id�o
|
d}
qL
n

|
S(Nt
:s//i(RWR#(tschemeRqtsc((s./mercurial/util.pytdrop_scheme�s






c

Cst|�i
d
d�S(Ns\\s
\(treprRE(
R((s./mercurial/util.pytuirepr�scCs$
d
ti
jo/
ytti
d
�SWq?tj
o



q?
Xn

y�ddk}ddk}
ddk}x�titi	fD]�}ypy|i
�}Wntj
o




wyn
Xti|�p
wyn

|i
||id�}|
id|�dSWqytj
o



qy
XqyWWntj
o



n
XdS(	NtCOLUMNSi�R[it
hi
iPt(RAR�Ry
R�ttermiostarraytfcntlRGR
RR
R�tisattytioctlt
TIOCGWINSZR(R�R�R�tdevR9
tarri((s./mercurial/util.pyt	termwidth�s.




	

$















cCsL|djo
t
�d
}n

dd|
}|iti|d||
�
�S(Nis

R|
twidth(R4R�Rbttextwraptwrap(tlinet
hangindentR�tpadding((s./mercurial/util.pyR��s




c
cs1x*|D]"}
x|
i�D]}|V
qWqWdS(
N(
t
splitlines(titeratorRhR�((s./mercurial/util.pyt	iterlines
s




(s%Y-%m-%d %H:%M:%Ss%Y-%m-%d %I:%M:%S%ps%Y-%m-%d %H:%Ms%Y-%m-%d %I:%M%ps%Y-%m-%ds%m-%ds%m/%ds%m/%d/%ys%m/%d/%Ys%a %b %d %H:%M:%S %Ys%a %b %d %I:%M:%S%p %Ys%a, %d %b %Y %H:%M:%Ss%b %d %H:%M:%S %Ys%b %d %I:%M:%S%p %Ys%b %d %H:%M:%Ss%b %d %I:%M:%S%ps%b %d %H:%Ms
%b %d %I:%M%ps%b %d %Ys%b %ds%H:%M:%Ss	%I:%M:%SPs%H:%Ms%I:%M%p(s%Ys%Y-%ms%bs%b %Y(fR�ti18nRR�R�RV
R�R
R�RGR?R�RAR�R`
R�R�R�R�RR
RR+RRRRR�R�R"R(tobjectR)R8RTRURZR]RjRIRkRmR~R�R4R�R�R�R�RFR�R�R�RMR�R�R�R�R�R�R�R

twindowsRR	
R
R

R
R
R"
R,
R.
R/
RRuR3
RlR<
R=
RF
RH
RR
R6
Rh
Rt
Ru
R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�(((s./mercurial/util.pys<module>s�

T
H
		

			



























					
	
				
			1	
		2	
					?	

	

	
	
			
	.						0H"	$.	2		.