�
�Xc@@s�
dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZddl	m
Z
mZmZm
Z

ddlmZ
ddlmZmZmZmZmZmZ
ejZejZejZejZd
ZdZ dZ!dZ"e!Z#e Z$e$e#BZ%e!e"BZ&dZ'd
Z(e'Z)dZ*dZ+ej,Z,ej-Z-ej.Z.d
�Z/d�Z0d�Z1ej2e�
Z3d�Z4d�ZdZ5de6f
d��YZ7dZ8dZ9dZ:de6f
d��YZ;de6f
d��YZ<dS(s�Storage back-end for Mercurial.

This provides efficient delta storage with O(1) retrieve and append
and O(changes) merge between branches.
i(
tabsolute_importNi
(tbinthextnullidtnullrev(
t
_(tancestorterrortmdifftparsersttemplatefilterstutiliiiiic

C@st|d
?�
S(Ni(
tint(
t
q((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	getoffsetDs
c

C@st|d
@�
S(Ni��(
R(
R
((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytgettypeGs
cC@stt|�
d
>|
B�
S(Ni(
tlong(toffsetttype((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytoffset_typeJs
cC@sy|tkr(t
j�}|j|
�

n:|
|g}|j�
tj|d
�
}|j|d�

|j|�

|j�S(s�generate a hash from the given text and its parent hashes

    This hash combines both the current file contents and its history
    in a manner that makes it easy to distinguish nodes with the same
    content in the revision graph.
    ii
(Rt	_nullhashtcopytupdatetsortthashlibtsha1tdigest(ttexttp1tp2t
st
l((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pythashOs







c
C@s�|s
|S|d
}
|
dkr$|S|
dkrvyt|�
SWqvt
jk
rr
}
ttd�
t|�
�
�
qvXn|
dkr�tj|d�Sttd�
|
�
�
dS(	s decompress the given input is
t
xsrevlog decompress error: %st
ui
sunknown compression type %rN(t_decompresstzlibRtRevlogErrorRtstrRtbuffer(R
t
tt
e((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
decompressds









#


s>4l20s20s20strevlogoldioc
B@s#eZ
d�Zd
�Zd�ZRS(c

C@stj
t�
|_dS(
N(tstructtcalcsizet
indexformatv0tsize(
tself((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt__init__s
c	C@s%
|j}g}i
t
t6}d
}}t|
�
}x�|||k
r�|
|||!}	||7}tt|	�}
t|
d
d
�|
dd|
d|
d|j|
dt
�|j|
dt
�|
df}|j|�

|||
d<|d7}q5W|jd
d
d
ddddtf�

||dfS(	Nii
i����iiiii(
R/RRtlent_unpackR.RtgettappendtNone(R0tdatatinlineRtindextnodemapt
ntoffRtcurR)te2((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
parseindex�s 
	










(
3



%cC@s{t|
d
�
r%t
td�
�
�
nt|
d
�
|
d|
d|
d||
d�
||
d�
|
df}tt|�
S(	Nisindex entry flags need RevlogNGi
iiiii(RR%RRt_packR.(R0tentrytnodetversiontrevR>((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	packentry�s



"
'
(t__name__t
__module__R1R?RE(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR+~s
		s>Qiiiiii20s12xs>Ii���trevlogioc
B@s#eZ
d�Zd
�Zd�ZRS(c

C@stj
t�
|_dS(
N(R,R-t
indexformatngR/(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR1�s
cC@s1tj
|
|�\}}|t|d
d�|fS(NR:(R	tparse_index2tgetattrR6(R0R7R8R9tcache((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR?�s
cC@s9tt
|
�
}|d
kr5tt|�|d}n|S(Nii(R@RIt
versionformat(R0RARBRCRDt
p((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRE�s



(RFRGR1R?RE(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRH�s
		trevlogcB@s�eZ
dZed
�
Zd�Zd�Zd�Zd�ZddGd�Z
ejd��
Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZdGd�
Zd�Zd�ZeZded�Zd�Z dGdGd�Z!dGd�
Z"dGdGd�Z#dGdGd�Z$dGdGd�Z%d �Z&d!�Z'd"�Z(dGdGd#�Z)d$�Z*d%�Z+d&�Z,d'�Z-d(�Z.d)�Z/d*�Z0d+�Z1d,�Z2d-�Z3dGd.�
Z4dGd/�
Z5dGd0�
Z6dGd1�
Z7dGd2�
Z8d3�Z9d4�Z:d5�Z;dGd6�
Z<d7�Z=d8�Z>dGd9�
Z?dGd:�
Z@dGdGd;�ZAd<�ZBd=�ZCed>�
ZDd?�ZEdGd@�
ZFdA�ZGdB�ZHdC�ZIdD�ZJdE�ZKdF�ZLRS(Hs�
    the underlying revision storage object

    A revlog consists of two parts, an index and the revision data.

    The index is a file with a fixed record size containing
    information on each revision, including its nodeid (hash), the
    nodeids of its parents, the position and offset of its data within
    the data file, and the revision it's based on. Finally, each entry
    contains a linkrev entry that can serve as a pointer to external
    data.

    The revision data itself is a linear collection of data chunks.
    Each chunk represents a revision and is usually represented as a
    delta against the previous chunk. To bound lookup time, runs of
    deltas are limited to about 2 times the length of the original
    version data. This makes retrieval of a version proportional to
    its size, or O(1) relative to the number of revisions.

    Both pieces of the revlog are written to in an append-only
    fashion, which means we never need to rewrite a file to insert or
    remove data, and can use some simple techniques to avoid the need
    for locking while reading.

    If checkambig, indexfile is opened with checkambig=True at
    writing, to avoid file stat ambiguity.
    c
C@s	||_|d
 d|_
|
|_||_d|_tjd�
|_d|_	d|_
d|_t|_
g|_i|_i
tt6|_d|_t}t|
dd�}|dk	rZ
d|kr�d	|kr�|tO}q�nd}d
|kr
|d
|_
nd|kr 
|d|_nd|kr<
|d|_
nt|jd
t��
|_n|j
dk
r�
ttd�
|j
�
�
n0|j
|j
d@r�
ttd�
|j
�
�
nd}t|_yd|j|j�
}|j�}|j�
t |�
dkr't!j"t#|d �d}t|_nWn+t$k
rU
}
|j%t%j&krV�qVn
X||_'|t(@|_)|t@|_*|d@}	|d@}
|
t+kr�|	r�ttd�
|j|	d?f�
�
nk|
t,kr|	t-@rttd�
|j|	d?f�
�
n.|
t,kr0ttd�
|j|
f�
�
nt|_.t/�|_0|j't+krct1�|_0ny|j0j2||j)�}Wn0t3t4fk
r�


ttd�
|j�
�
n
X|\|_}|_	|dk	r�||_5|_n|j	s�|j6�
ni|_7dS(s�
        create a revlog object

        opener is a function that abstracts the file opening operation
        and can be used to implement COW semantics or the like.
        i����s.diditi
toptionstrevlogv1tgeneraldeltatchunkcachesizetmaxchainlentaggressivemergedeltast
lazydeltabases0revlog chunk cache size %r is not greater than 0i
s.revlog chunk cache size %r is not a power of 2ii��s*index %s unknown flags %#04x for format v0is)index %s unknown flags %#04x for revlogngsindex %s unknown format %dsindex %s is corruptedN(iRPi��(8t	indexfiletdatafiletopenert_checkambigR6t_cacheRtlrucachedictt_chainbasecachet_chunkcachet_chunkcachesizet_maxchainlentFalset_aggressivemergedeltasR9t_pcacheRRt
_nodecachet_nodepostREVLOG_DEFAULT_VERSIONRKtREVLOGGENERALDELTAtboolR4t_lazydeltabaseR%RtTruet
_initemptytreadtcloseR2R,tunpackRMtIOErrorterrnotENOENTRCtREVLOGNGINLINEDATAt_inlinet
_generaldeltatREVLOGV0tREVLOGNGtREVLOGNG_FLAGStstoredeltachainsRHt_ioR+R?t
ValueErrort
IndexErrorR:t_chunkcleart_chaininfocache(
R0RZRXt
checkambigt
vtoptst	indexdatat
ftinsttflagstfmtt
dR:((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR1�s�	

					
	
	
		
	

















	











	
















	









	

c

C@s|jt
|j�
d
�
S(Ni(RBR2R9(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyttip=
s
cC@sd
|
k
ot|�
kS
S(Ni(
R2(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt__contains__?
s
c

C@st|j
�
d
S(Ni
(R2R9(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt__len__A
s
c

C@stt
t|�
�
�
S(
N(titertxrangeR2(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt__iter__C
s
icC@sPd
}|dk	r4|
|kr'd}n||7}nt
|�
}t|
||�S(s8iterate over all rev in this revlog (from start to stop)i
i����N(R6R2R�(R0tstarttstoptstep((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytrevsE
s


	


c

C@s|j|j
d
�
�

|jS(Ni(RDRBRe(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR:P
s
cC@s.y|j|
�

t
SWntk
r)


tSXdS(
N(RDRktKeyErrorRb(R0RB((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pythasnodeU
s







c

C@sjd|_
|jj�
d|_i|_y|jj�
Wn*tk
re


i
t	t
6|_d|_n
XdS(NiRP(iRP(R6R\R^tclearR_RdRetclearcachestAttributeErrorRRRf(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�\
s
	


	
	




cC@s
y|j|
SWn�t
k
r%


�n�tk
rP


t|
|jtd
�
��
n�tk
r



|j}|j}|j}|dkr�t
|�
d}nxOt|dd�D];}||d}|||<||
kr�|d|_|Sq�Wt|
|jtd
�
��
n
XdS(Nsno nodeii����ii
(Ret	TypeErrorR%tLookupErrorRXRR�R9RfR6R2R�(R0RBR;t
iRNt
rR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRDh
s&








	
	
	










cC@s|j|
d
S(Ni(
R9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRB
s
cC@s|j|
d
S(Ni(
R9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytlinkrev�
s
cC@s>|j}||j
|
�
}||d
d||ddfS(Niii(R9RD(R0RBR�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytparents�
s
	

cC@s|j|
d
d!S(Nii(
R9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
parentrevs�
s
cC@st|j
|
d
d?�
S(Nii(RR9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR��
s
cC@s|j|
�
|j
|
�
S(
N(R�tlength(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytend�
s
cC@s|j|
d
S(Ni
(
R9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR��
s
cC@sq|jj
|
�
}|dk	r"|S|j}||
d
}x$||
kr_|}
||
d
}q<W||j|
<|S(Ni(R^R4R6R9(R0RDtbaseR9((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	chainbase�
s


	





cC@s|j|
�
d
S(Ni(
t
_chaininfo(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytchainlen�
s
cC@s�|j}|
|kr||
S|j
}|j}|
}||}d
}d
}x�||dkr�|d7}||d7}|r�|d}n
|d8}||kr�||}	||	d
7}||	d7}Pn||}qNW||d7}||f}
|
||
<|
S(Niii
(R~R9Ru(R0RDtchaininfocacheR9RStiterrevR)tclentcompresseddeltalenR(R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR��
s2
	


	
	























c	C@s�g}|j}|j
}|
}||}xT||d
kr~||kr~|j|�

|rg|d
}n
|d8}||}q+W||kr�t}n|j|�

t}|j�
||fS(sW
Obtain the delta chain for a revision.

        ``stoprev`` specifies a revision to stop at. If not specified, we
        stop at the base of the chain.

        Returns a 2-tuple of (chain, stopped) where ``chain`` is a list of
        revs in ascending order and ``stopped`` is a bool indicating whether
        ``stoprev`` was hit.
        ii
(R9RuR5RkRbtreverse(	R0RDtstoprevtchainR9RSR�R)tstopped((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt_deltachain�
s"
	
	










	



cC@s|j|
d
d@S(Nii��(
R9(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR��
s
cC@sC|j|
d
}|dkr!|S|j
|j|
�
�
}t|�
S(s?return the length of the uncompressed text for a given revisionii(R9trevisionRBR2(R0RDRR(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytrawsize�
s



cC@stj
|j|
d
|d|�S(s�Generate the ancestors of 'revs' in reverse topological order.
        Does not generate revs lower than stoprev.

        See the documentation for ancestor.lazyancestors for more details.R�t	inclusive(Rt
lazyancestorsR�(R0R�R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	ancestors�
s
cc@s�t|
�
}|t
kr2x|D]}|V
qWd
St|
�
}xf|jd|d�
D]N}xE|j|�
D]4}|t
krk||krk|j|�

|V
PqkqkWqUWd
S(s$
Generate the descendants of 'revs' in revision order.

        Yield a sequence of revision numbers starting with a child of
        some rev in revs, i.e., each revision is *not* considered a
        descendant of itself.  Results are ordered by revision number (a
        topological sort).NR�i
(tminRtsetR�R�tadd(R0R�tfirstR�tseenR!((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytdescendants�
s



	







c	@s�
|
dkrt
g
}
n|dkr3|j�}ng|
D]}|j|�
^q:}
g|D]}|j|�
^q\}d
tf
d��Y}||j|
�
�
��jt�

�j|
�

t	�}t
j�f
d�|D�
�
}xk|rQ
|j�}||kr
q�q�|j|�

x3|j
|�
D]"}|�kr(
|j|�

q(
q(
Wq�Wt|�
}|j�
�g|D]}|j|�
^qr
fS(s�
Return a tuple of the ancestors of common and the ancestors of heads
        that are not ancestors of common. In revset terminology, we return the
        tuple:

          ::common, (::heads) - (::common)

        The list is sorted by revision number, meaning it is
        topologically sorted.

        'heads' and 'common' are both lists of node IDs.  If heads is
        not supplied, uses all of the revlog's heads.  If common is not
        supplied, uses nullid.tlazysetc
B@s5eZ
d�Zd
�Zd�Zd�Zd�ZRS(cS@st�|_
|
|_dS(
N(R�taddedvaluest
lazyvalues(R0R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR1"s

cS@s|
|jkp|
|j
kS(
N(R�R�(R0tvalue((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�&s
c
s@sK|j}
x|
D]}|V
qWx%|j
D]}||
kr)|V
q)q)WdS(
N(R�R�(R0taddedR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�)s
	


	


cS@s|jj
|
�

dS(
N(R�R�(R0R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�1s
cS@s|jj
|
�

dS(
N(R�R(R0tvalues((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR4s
(RFRGR1R�R�R�R(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�!s

				c
3@s!|]}
|
�kr|
V
qdS(
N((t.0R�(
thas(s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pys	<genexpr>=sN(R6RtheadsRDtobjectR�R�RRR�tcollectionstdequetpopleftR�R5tlistRRB(	R0tcommonR�R;R�tmissingtvisitR�RN((
R�s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytfindcommonmissings.



"
"



	

	










cC@s+|
d
krt
g
}
ntj|j|
�S(sO
Return an object that can be used to incrementally compute the
        revision numbers of the ancestors of arbitrary sets that are not
        ancestors of common. This is an ancestor.incrementalmissingancestors
        object.

        'common' is a list of revision numbers. If common is not supplied, uses
        nullrev.
        N(R6RRtincrementalmissingancestorsR�(R0R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytincrementalmissingrevsKs	
cC@sR|
dkrt
g
}
n|dkr3|j�}n|jd
|
�
}|j|�
S(sxReturn the revision numbers of the ancestors of heads that
        are not ancestors of common.

        More specifically, return a list of revision numbers corresponding to
        nodes N such that every N satisfies the following constraints:

          1. N is an ancestor of some node in 'heads'
          2. N is not an ancestor of any node in 'common'

        The list is sorted by revision number, meaning it is
        topologically sorted.

        'heads' and 'common' are both lists of revision numbers.  If heads is
        not supplied, uses all of the revlog's heads.  If common is not
        supplied, uses nullid.R�N(R6RtheadrevsR�tmissingancestors(R0R�R�tinc((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytfindmissingrevsYs



cC@s�|
dkrt
g
}
n|dkr3|j�}ng|
D]}|j|�
^q:}
g|D]}|j|�
^q\}|jd
|
�
}g|j|�
D]}|j|�
^q�S(s.Return the ancestors of heads that are not ancestors of common.

        More specifically, return a list of nodes N such that every N
        satisfies the following constraints:

          1. N is an ancestor of some node in 'heads'
          2. N is not an ancestor of any node in 'common'

        The list is sorted by revision number, meaning it is
        topologically sorted.

        'heads' and 'common' are both lists of node IDs.  If heads is
        not supplied, uses all of the revlog's heads.  If common is not
        supplied, uses nullid.R�N(R6RR�RDR�R�RB(R0R�R�R;R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytfindmissingqs


"
"
cC@s�gggf}|
dk	r\t
|
�
}
|
s1|Stg|
D]}|j|�
^q;�
}ntg
}
t}|tkr�|dkr�g|D]}|j|�
^q�tg
t
|j��
fS|dkr�t|�
d
}d}i}n�
t
|�
}|s�|St	�}t
j|t�}t	|�
}	t
g|	D]}|j|�
^q-
�
}x�|	r|	j�}|tkrr
qN
n|j|�
}||krN
||kr�
|j|�

|	jg|j|�
D]}
|
tkr�
|
^q�
�

q�
||kr�
|j|�

q�
qN
qN
W|s|S|tkrtg|
D]}||kr|^q}
|
rmtg|
D]}|j|�
^qL�
}q�|Snt}tg
}
t	|
�
}|j�}
g}x�
|jdt
|d�d|d
�D]z
}|j|�
}t}
|tkr�t}
n�||kr`t}
||
kr�t|j|�
�
}
|
d|ksJ|
d
|kr]|
j|�

q]q�nKt|j|�
�
}
|
d|ks�|
d
|kr�|j|�

t}
n|
r�|dks�||kr�|j|�

|dk	r�||kr�t||<qA|dkrAt||<x*|j|�
D]}
|j|
d�
q!WqAq�q�Wg|j�D]\}}|rR|^qR}t
|
�
}
|s�t�
|
s�t�
|s�t�
||
|fS(s�Return a topological path from 'roots' to 'heads'.

        Return a tuple (nodes, outroots, outheads) where 'nodes' is a
        topologically sorted list of all nodes N that satisfy both of
        these constraints:

          1. N is a descendant of some node in 'roots'
          2. N is an ancestor of some node in 'heads'

        Every node is considered to be both a descendant and an ancestor
        of itself, so every reachable node in 'roots' and 'heads' will be
        included in 'nodes'.

        'outroots' is the list of reachable nodes in 'roots', i.e., the
        subset of 'roots' that is returned in 'nodes'.  Likewise,
        'outheads' is the subset of 'heads' that is also in 'nodes'.

        'roots' and 'heads' are both lists of node IDs.  If 'roots' is
        unspecified, uses nullid as the only root.  If 'heads' is
        unspecified, uses list of all of the revlog's heads.i
R�iR�N(R6R�R�RDRRRBR�R2R�tdicttfromkeysRbtmaxtpopR�RR�RR�RkttupletremoveR5t	iteritemstAssertionError(R0trootsR�tnonodesR;t	lowestrevR�t
highestrevR�t
nodestotagRNR�t
orderedouttisdescendanttflag((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytnodesbetween�s�




+	

8
	


	(
	







%
+
	,



	
 
 


	







+




c

C@s0y|jj
�SWntk
r+


|j�SXdS(
N(R9R�R�t	_headrevs(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�&s




cC@s|jj
|
�
S(
N(R9tcomputephasesmapsets(R0R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
computephases,s
c
C@s�t|�
}
|
st
g
Sd
g
|
d}|j}x<|D]4}d||<||}d
||d<||d<q:Wgt|�
D]\}}|r|^qS(Nii
ii(R2RR9t	enumerate(R0tcounttisheadR9R�R)tval((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�/s



	







cC@s�
|
dkrQ|dkrQt
|�
s+tg
Sg|j�D]}|j|�
^q8S|
dkrft}
n|dkr{g}ntg|D]}|j|�
^q��
}|j|
�
}t|f
�
}t|f
�
}|j}	x�|jd
|d�
D]}}xt|	|�
D]f}
|
|krA
||kr1
|j	|�

n|j	|�

n|
|kr
|
|kr
|j
|
�

q
q
Wq�Wg|D]}|j|�
^qx
S(s
return the list of all nodes that have no children

        if start is specified, only heads that are descendants of
        start will be returned
        if stop is specified, it will consider all the revs from stop
        as if they had no children
        R�i
N(R6R2RR�RBR�RDR�R�R�R�(R0R�R�R�R;tstoprevststartrevt	reachableR�R�RN((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�<s,


&
	

	
(


	







cC@s�g}|j|
�
}x�|j
d
|d�
D]�}g|j|�
D]}|tkrB|^qB}|r�x[|D]+}||krm|j|j|�
�

qmqmWq,|tkr,|j|j|�
�

q,q,W|S(s!find the children of a given nodeR�i
(RDR�R�RR5RB(R0RBt
cRNR�tprtprevs((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytchildren^s


.




 


cC@sQ|
tkrt
Sx:|j|
g
�
D]&}||kr9t
S||kr#Pq#q#WtS(
N(RRkR�Rb(R0R�R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
descendantls







cC@sz|j|
�
|j|�
}
}y|j
j|
|�}Wn/ttfk
ri


tj|j|
|�}n
Xt|j|�S(
s@calculate all the heads of the common ancestors of nodes a and b(	RDR9tcommonancestorsheadsR�t
OverflowErrorRR�tmapRB(R0t
at
btancs((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�vs




cC@s|
|j|
|�kS(
s�return True if node a is an ancestor of node b

        The implementation of this is trivial but the use of
        commonancestorsheads is not.(
R�(R0R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
isancestorscC@s�|j|
�
|j|�
}
}y|j
j|
|�}Wn/ttfk
ri


tj|j|
|�}n
X|r�tt|j	|��
St
S(
s5calculate the "best" common ancestor of nodes a and b(RDR9R�R�R�RR�R�R�RBR(R0R�R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR�s





cC@sL
t|
t
�r|j|
�
St|
�
d
kr`y|
}|j|�

|SWq`tk
r\


q`Xny~t
|
�
}t|�
|
kr�t�
n|dkr�t|�
|}n|dks�|t|�
kr�t�
n|j|�
SWnttfk
r�


n
Xt|
�
dkrH
y!t	|
�
}|j|�

|SWqH
t
tfk
rD



qH
XndS(Niii((t
isinstanceRRBR2RDR�R&R{R�R
R�(R0tidRBRD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt_match�s6












	



	









cC@s�
y3|jj
|
�
}|r.|j|�
r.|SdSWnWtk
rv


t|d
d�s�t|
|jtd�
��
q�nt	t
fk
r�


n
X|
|jkr�|j|
St|
�
dkr�
y�t|
�
d}t
|
|d �
}g|jD]#}|dj|�
r�|d^q�}g|D]0}t|�
j|
�
r
|j|�
r
|^q
}t|�
dkr�
t|�
dkr�
|d|j|
<|dSt|
|jtd�
��
ndSWq�
tk
r�



q�
XndS(Ntfilteredrevssambiguous identifieri(iiii
(R9tpartialmatchR�R6R%RKR�RXRR�R{RdR2R
t
startswithRR�(R0R�R;RtprefixR)tnl((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
_partialmatch�s:












3
"










cC@sW|j|
�
}|dk	r|S|j|
�
}|r8|St|
|jtd
�
��
dS(s�locate a node based on:
            - revision number or str(revision number)
            - nodeid or subset of hex nodeid
        sno match foundN(R�R6R
R�RXR(R0R�R;((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytlookup�s




cC@s+|j|
�
\}}t
|||�|
kS(
spcompare text with a given file revision

        returns True if text is different than what is stored.
        (R�R (R0RBRRR((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytcmp�s
cC@sj|j\}}|t
|�
|
krWt
|�
t
|�
tkrW|||f|_n|
|f|_d
S(svAdd a segment to the revlog cache.

        Accepts an absolute offset and the data that is at that location.
        N(R_R2t
_chunksize(R0RR7t
oR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	_addchunk�s2
c	C@s�|dk	rt
}n6|jr3|j|j�
}n|j|j�
}t}|j}|
|d
@}|
|||d
@|}|j|�

|j	|�
}|r�|j
�
n|j||�
|
|ks�||kr�tj
||
||�S|S(sU
Load a segment of raw data from the revlog.

        Accepts an absolute offset, length to read, and an optional existing
        file handle to read from.

        If an existing file handle is passed, it will be seeked and the
        original seek position will NOT be restored.

        Returns a str or buffer of raw byte data.
        i
N(R6RbRtRZRXRYRkR`tseekRmRnR
RR'(	R0RR�tdftclosehandlet	cachesizet
realoffsett
reallengthR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
_loadchunk�s$
		

	












c	C@s�|j\}}t
|�
}|
|}||}|d
krz||k
rz|d
krc||krc|Stj||||�S|j|
|d|�
S(s�
Obtain a segment of raw data from the revlog.

        Accepts an absolute offset, length of bytes to obtain, and an
        optional file handle to the already-opened revlog. If the file
        handle is used, it's original seek position will not be preserved.

        Requests for data may be returned from a cache.

        Returns a str or a buffer instance of raw byte data.
        iR
(R_R2RR'R
(	R0RR�R
R
R�Rt
cachestarttcacheend((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	_getchunk!s







cC@s�|j|
�
}|j
|�
}|jrZ||
d
|jj7}||d
|jj7}n||}||j||d|�
fS(s�Obtain a segment of raw data corresponding to a range of revisions.

        Accepts the start and end revisions and an optional already-open
        file handle to be used for reading. If the file handle is read, its
        seek position will not be preserved.

        Requests for data may be satisfied by a cache.

        Returns a 2-tuple of (offset, data) for the requested range of
        revisions. Offset is the integer offset from the beginning of the
        revlog and data is a str or buffer of the raw byte data.

        Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
        to determine where each revision's data begins and ends.
        i
R
(R�R�RtRzR/R
(R0R�tendrevR
R�R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	_chunkraw9s

	



cC@s t|j
|
|
d
|�
d�
S(s<
Obtain a single decompressed chunk for a revision.

        Accepts an integer revision and an optional already-open file handle
        to be used for reading. If used, the seek position of the file will not
        be preserved.

        Returns a str holding uncompressed data for the requested revision.
        R
i
(R*R
(R0RDR
((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt_chunkRs	cC@s
|
s
gS|j}|j
}|j}|jj}tj}g}|j}	y*|j|
d
|
dd|�
\}
}Wn4t	k
r�


g|
D]}|j
|d|�

^q�SXxa|
D]Y}||�
}
|r�|
|d|7}
n||�
}|	t|||
|
|��
�

q�W|S(s�
Obtain decompressed chunks for the specified revisions.

        Accepts an iterable of numeric revisions that are assumed to be in
        ascending order. Also accepts an optional already-open file handle
        to be used for reading. If used, the seek position of the file will
        not be preserved.

        This function is similar to calling ``self._chunk()`` multiple times,
        but is faster.

        Returns a list with decompressed data for each requested revision.
        ii����R
i
(R�R�RtRzR/RR'R5R
R�R
R*(R0R�R
R�R�R8tiosizeR'RtladdRR7RDt
chunkstarttchunklength((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt_chunks]s(


	
	
	

	
	
*

'





$c

C@s
d|_dS(sClear the raw chunk cache.iRPN(iRP(
R_(
R0((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR}�scC@s:|j|
d
}||
kr!t
S|jr.|S|
dSdS(s(return deltaparent of the given revisionii
N(R9RRu(R0RDR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytdeltaparent�s


	
cC@sV|
tkr4|j
|�
|
kr4t|j|�
�
Stj|j|
�
|j|�
�S(
s1return or calculate a delta between two revisions(RR
R&R
RttextdiffR�(R0trev1trev2((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytrevdiff�s!

c
C@s�
t|
t
�r'|
}|j|�
}n|
}d}d}|tkrId
S|jr�|jd|krp|jdS|jd}nd}|dkr�|j|�
}n|j|�
t@r�t	t
d�
|j|�
t@�
�
n|j|d|�

\}}|r
|jd}nd|_|j|d|�

}	|dkrW
t
|	d�
}|	d}	ntj||	�}|j|||�}|||f|_|S(	s�return an uncompressed revision of a given node or revision
        number.

        _df is an existing file handle to read from. It is meant to only be
        used internally.
        RPiii
sincompatible revision flag %xR�R
N(R�RRBR6RR\RDR�tREVIDX_KNOWN_FLAGSR%RR�R
R&Rtpatchest
_checkhash(
R0t	nodeorrevt_dfRDRBt	cachedrevRR�R�tbins((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR��s<





	








	




cC@st|
||�S(
syCompute a node hash.

        Available as a function so that subclasses can replace the hash
        as needed.
        (
R (R0RRR((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR �scC@s2|j|�
\}}|j
|
||||�
|
S(
N(R�t	checkhash(R0RRBRDRR((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR
�s


cC@sk||j|
||�krg|}|dkrEtjt|�
�
}nttd
�
|j|f�
�
ndS(Nsintegrity check failed on %s:%s(R R6R
tshortRR%RRX(R0RRRRBRDt	revornode((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR$
�s





c
C@s�
|js,|j
d
�
|jd
�
tkr0dS|
j|j�
}|dkrjttd�
|j�
�
n|d}|dk	r�|j
|�
}nt	|�
d}|j
d
�
}|
j|j|�
|r�|j
�
|j�
n|j|jd�}z2x+|D]#}|j|j||�d�

q
WWd|j�
X|j|jddtd|j�}|jtM_t|_xC|D];}|jj|j||j|j|�}	|j|	�

qz
W|j�
|
j|j||jj�
|j�
dS(	s
Check if the revlog is too big for inline and convert if so.

        This should be called after revisions are added to the revlog. If the
        revlog has grown too large to be an inline revlog, it will convert it
        to use multiple index and data files.
        i����Ns%s not found in the transactionii
t
wt
atomictempR(RtR�R�t
_maxinlinetfindRXR6R%RR2R�R�RYtflushRnRZtwriteR
RkR[RCRsRbRzRER9RBtreplaceR/R}(
R0ttrtfpttrinfottrindextdataoffR
R�R�R)((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytcheckinlinesize�s<,















%


	


(


c
C@s&
|tkr(t
td
�
|j�
�
nt|
�
tkrbt
td�
|jt|
�
f�
�
n|pz|j|
||�}||jkr�|Sd}|j	s�|j
|jd�}n|j
|jdd|j�
}	z,|j
||
||||t||	|�
SWd|r
|j�
n|	j�
XdS(sadd a revision to the log

        text - the revision data to add
        transaction - the transaction object used for rollback
        link - the linkrev data to add
        p1, p2 - the parent nodeids of the revision
        cachedelta - an optional precomputed delta
        node - nodeid of revision; typically node is not specified, and it is
            computed by default as hash(text, p1, p2), however subclasses might
            use different hashing method (and override checkhash() in such case)
        s!attempted to add linkrev -1 to %ss;%s: size of %d bytes exceeds maximum revlog storage of 2GiBsa+RN(RR%RRXR2t
_maxentrysizeR R:R6RtRZRYR[t_addrevisiontREVIDX_DEFAULT_FLAGSRn(
R0RttransactiontlinkRRt
cachedeltaRBtdfhtifh((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytaddrevisions(




	



	







cC@s0
|
sd
|
fSt|
�
}d	}|dkr1n�|dkr�tj�}g}d}x=||kr�|d
}|j|j|
||!�
�

|}qXW|j|j��

ttt|��
|kr�d
j	|�
}q�nt
|
�
}|d	ks
t|�
|kr&
|
ddkr
d
|
fSd|
fSd
|fS(s7 generate a possibly-compressed representation of text RPi,i@Biiis
R"Ni(R2R6R$tcompressobjR5tcompressR+
tsumR�tjoint	_compress(R0RRR
t
zRNtpostpos2((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR>
<s.
























c
C@sw|
dkrt
S|
\}}}}}}}	||d
kso||kso|	|dkso|jrs||jkrst
StS(s�Returns True if the given delta is good. Good means that it is within
        the disk span, disk size, and chain length bounds that we know to be
        performant.iiN(R6RbRaRk(
R0R�ttextlentdistRR7R�R�R�R�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt_isgooddeltaYs




c"	@s�|g
���������	�
f	d
��
�
�����
fd�}t�
�
}
|
d}�
j
|�
�d}�
j��
�
j�	�
}}|dkr�tj�
j�d�
�d�}nt|�
}|tkrq�
jrqt	�}�rK
�
j
rK
�
jrK
|�d�
}|j�d�

�
j
||�rK
|}qK
n|dkr,�
j
r,g||fD]$}|tkrm
||krm
|^qm
}|r�
�
jr�
t|�
g
}n|j|�

g}x<|D]4}||�
}�
j
||�r�
|j|�

q�
q�
W|r,t|dd��

}q,n|dkrq||krq||�
}�
j
||�rn|}qnqqn|dk	r�|\}}}}}}}n@�
�}�
j|�
}t|d�
t|d�
}|
}}t���||||||�f} �
jjd| �
|
�
j�<�
jj| �
j�
j|
�}!�
j|��|!||��
|r�|dkr��
�}nt|�
tkr��|
|f�
_n|�
j |
<�S(	s
internal function to add revisions to the log

        see addrevision for argument descriptions.
        invariants:
        - text is optional (can be None); if not set, cachedelta must be set.
          if both are set, they must correspond to each other.
        c@s4
�d
dk	r�d
S�
d
}�
d}
t
jd�
}|
| tj�j|�
t|
�
|�kr{|
|�d
<nL�jr��}n�}�j�j	|�
d|�

}tj
||
��d
<yA�j�d
����
�t@r
t
td�
��
�
nWn!tk
r+



�t@s,
�q,
n
X�d
S(Nii
s>lllR!
snode %s is not censored(R6R,R-RtreplacediffheaderR�R2RtR�RBtpatchR$
tREVIDX_ISCENSOREDR%RtCensoredNodeError(tbaserevtdeltathlentfhtbasetext(	tbtextR9
R:
R�R;
RBRRR0(s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	buildtextvs*








	
	












c

@sb
�
r#�
d
|kr#�
d}
n���}�j|�
rit
j�j|�
t|�
�}||}
nH�jr{�}n�}�j�j|�
d|�

}t
j||�}
�j	|
�
\}}t|�
t|�
}�j
|�
}|��j|�
}	�jr
|}
n|}
�j
|�
\}}|d7}||7}|	|||f|
|||fS(Nii
R!
(t
iscensoredRRH
R�R2RtR�RBR
R>
R�R�RuR�(
RDRM
R(theaderRO
tptextR7tdeltalenR�RF
R�R�R�(RR
R9
R:
R;
RR0(s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
builddelta�s.

	
!

	
	






	
	






i
itkeyc

S@s|d
S(Ni
((
R!((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt<lambda>�si����N(!R2R�R6RDRtpatchedsizeR�RRyR�RuRjR�RG
RcR�RR5R�R>
RR9tinsertR:RzRERBRCt_writeentryRR&R\R^("R0RBRR7
R8
RRR�R9
R;
R:
talwayscacheRW
tcurrtprevRM
tp1rtp2rRE
ttestedtcandidatedeltaRNR�tpdeltastpdRF
RR7R�R�R�R�R)RA((RQ
RR
R9
R:
R�R;
RBRRRR0s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR5
lsl		
' 







	




$















	







!





c	C@s$
|jd
t
j�
|r/|jd
t
j�
nt|�
d}|js�|
j|j|�
|
j|j|t|�
�
|d
r�|j|d
�

n|j|d�

|j|�

ni|||j	j
7}|
j|j||�
|j|�

|j|d
�

|j|d�

|j|
|�
dS(Nii
(R
tostSEEK_ENDR2RtR�RYRXR,
RzR/R3
(	R0R7
R;
R:
RAR7R8
RR^
((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR\
�s"


	












c@s�g}d}t
|�
}d
}|r:|j|d�
}n|j|jdd|j�
�||jj}	|jr�|j	|j||	|�
d�n>|j	|j|	|�
|j	|j
|�
|j|j
d����fd�}
z�d�
xxt��
fd�i�D][}|d}|d}|d	}
|d
}|d}|d}|d
pX
t}|j
|�

||�
}||jkr�
|�
q	
nxA||
fD]3}||jkr�
t||jtd�
��
q�
q�
W||jkrt||jtd�
��
n|j|�
}|tkr�|j|�
r�tjd�
}|j|�
}t
|�
|}|| tj||�kr�tj|j|j|�
��
q�n|r�|j|||
�r�|tO}n|j|d||||
|||f��dt|�
�

�
|r||�
�
n�r	
|jr	
�j �
|j|j
d��|j|jdd|j�
�q	
q	
WWd�r�j �
n�j �
X|S(s\

        add a delta group

        given a set of deltas, add them to the revision log. the
        first delta is against its parent, which should be in our
        log, the rest are against the previous delta.

        If ``addrevisioncb`` is defined, it will be called with arguments of
        this revlog and the node that was added.
        ii
sa+Rc
@s!�r�j�
n�
j�
dS(
N(
R+
((R:
R;
(s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyR+
9s



c@s
�j�
�
S(
N(
t
deltachunk((tcgR�(s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRY
@sRBRRtcst	deltabaseRM
R�sunknown parentsunknown delta bases>lllR]
N(!R6R2R�RZRXR[RzR/RtR�RYR�R6
R5R:R�RRDRRS
R,R-R�RRH
RtCensoredBaseErrorRBt_peek_iscensoredRJ
R5
RiRn(R0Ri
t
linkmapperR7
t
addrevisioncbtcontentRBR�R�tisizeR+
t	chunkdataRRRj
Rk
RM
R�R8
RNRL
RN
toldlentnewlen((Ri
R�R:
R;
s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytaddgroups|







	

	



"





























	








c
C@stS(
s%Check if a file revision is censored.(
Rb(R0RD((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRS
�sc
C@stS(
s6Quickly check if a delta produces a censored revision.(
Rb(R0RL
RM
R+
((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRm
�scC@s'
t�}t
|�
}i}t�}xI|j�D];}|j|�
}|||<||
kr1|j|�

q1q1Wx�|r
|d
8}|j|�
}||
kr�|j|�

n
|j|�

x[|j|�
D]J}	|	tkr�|j|	�
}
|
||	<|
|
kr
|j|
�

q
q�q�WqsW||fS(s�find the minimum rev that must be stripped to strip the linkrev

        Returns a tuple containing the minimum rev and a set of all revs that
        have linkrevs that will be broken by this strip.
        i
(	R�R2R�R�R�R�R�R�R(R0tminlinkt
brokenrevst
strippointR�tfuturelargelinkrevstheadtheadlinkrevR�RNtplinkrev((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt
getstrippoint�s,	

	





	










cC@s
t|�
d
krdS|j
|
�
\}}|t|�
krAdS|j|�
}|js|j|j|�
||jj}n|||jj7}|j|j|�
d|_
i|_|j�
x0t
|t|�
�D]}|j|j|�
=q�W|j|d5dS(s7truncate the revlog on the first revision with a linkrev >= minlink

        This function is called when we're stripping revision minlink and
        its descendants from the repository.

        We have to remove all revisions with linkrev >= minlink, because
        the equivalent changelog revisions will be renumbered after the
        strip.

        So we truncate the revlog on the first of these revisions, and
        trust that the caller has saved the revisions that shouldn't be
        removed and that it'll re-add them after this truncation.
        iNi����(R2R}
R�RtR�RYRzR/RXR6R\R~R}R�R:RBR9(R0Rv
R7
RDRR�R!((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytstrip�s"



	

	
	



c
C@s�
d
}
t|�
r7t
d
|jt|�
d�
�}
nyF|j|j�
}|jd
d�
|j�}|j�
||
}Wn1tk
r�
}
|j	t	j
kr��nd
}n
Xy�|j|j�
}|jd
d�
|j�}|j�
|jj
}t
d
||�}|||}|jrv
d
}	x*|D]"}
|	t
d
|j|
�
�7}	q/
Wd
}|t|�
||	}nWn1tk
r�

}
|j	t	j
kr�
�nd
}n
X||fS(Nii
i(R2R�R�RZRYR
ttellRnRpRqRrRXRzR/RtR�(R0texpectedR�tactualtddR�RR�tdit	databytesR�((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt	checksize�s@


%



















	



 






c
C@s,|jg
}
|j
s(|
j|j�

n|
S(
N(RXRtR5RY(R0tres((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pytfiless

	

N(MRFRGt__doc__RbR1R�R�R�R�R6R�Rt
propertycacheR:R�R�RDRBR�R�R�R�R�R�R�R�R�R�R�R�R/R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�RR�R
R

R
R
R
R
R
R
R
R}R
R
R�R R
R$
R3
R<
R>
RG
R5
R\
Ru
RS
Rm
R}
R~
R�
R�
(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyRO�s�
b															
		#				@�			
"		
				
	"	&			$(		
	3		3
%		�	g			(	(	%i
ii�(=R�
t
__future__RR�RqRRf
R,R$RBR
RRRti18nRRPRRRR	R
RtpackR@RoR3R>
RA
R*R#RvRwRsRhtREVLOG_DEFAULT_FLAGStREVLOG_DEFAULT_FORMATRgRxRJ
R6
R
R)
R
R%R�RK
RRRRRR R.R�R+RIRMR4
RHRO(((s4/usr/lib/python2.7/dist-packages/mercurial/revlog.pyt<module>sV




"
.		
	
	
	











	
	
						+