�
�c@s�dZd
dk
lZlZlZlZlZ
d
dklZ
d
dk	Z	d
dk
Z
d
dkZd
dkZd
dk
Z
d
dkZd
dkZd
dkZd
dkZeiZeiZeiZeiZeiZdZdZd ZeZeZ e eBZ!dZ"e
i#Z#e
i$Z$d	�Z%d
�Z&d�Z'ee�Z(d�Z)d
�Zd�Zde*f
d��YZ+de*f
d��YZ,de*f
d��YZ-dZ.dZ/de*f
d��YZ0dZ1dZ2dZ3de*f
d��YZ4de*f
d��YZ5dS(!s�Storage back-end for Mercurial.

This provides efficient delta storage with O(1) retrieve and append
and O(changes) merge between branches.
i�(tbinthextnullidtnullrevtshort(
t
_Nii
iic

Cst|d
?�S(Ni(
tint(
t
q((s#/sys/lib/python/mercurial/revlog.pyt	getoffset's
c

Cst|d
@�S(Ni�(
R(
R((s#/sys/lib/python/mercurial/revlog.pytgettype*s
cCstt|�d
>|
B�S(Ni(
tlong(toffsetttype((s#/sys/lib/python/mercurial/revlog.pytoffset_type-s
cCsx|tjo
t
i�}|i|
�
n8
|
|g}|i�
t|d
�}|i|d�
|i|�
|i�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
(Rtnullhashtcopytupdatetsortt_shatdigest(ttexttp1tp2t
st
l((s#/sys/lib/python/mercurial/revlog.pythash2s








c
CsH
|p
d
|fSn

t|�}
d	}|
djo
n�
|
djo�
ti�}g}d}x?||
jo1
|d
}|i|i|||!��
|}q`
W|i|i��
ttt|��|
jo
d
i	|�}q�

t
|�}|d	jp
t|�|
jo-
|ddjo
d
|fSn

d|fSn

d
|fS(s7 generate a possibly-compressed representation of text ti,i@Biiit
t
uNi(tlentNonetzlibtcompressobjtappendtcompresstflushtsumtmaptjoint	_compress(RRRt
zt
ptpostpos2((s#/sys/lib/python/mercurial/revlog.pyR"Gs.


















 



c
Cs||p
|Sn

|d
}
|
djo
|Sn

|
djo
t|�Sn

|
djo
|dSn

t
td�|
��dS(s decompress the given input iRt
xRi
sunknown compression type %rN(t_decompresstRevlogErrorR(Rt
t((s#/sys/lib/python/mercurial/revlog.pyt
decompressds












t
lazyparsercBsDeZ
dZd
�Zd�Zdd�Zd�Zddd�ZRS(sK
    this class avoids the need to parse the entirety of large indices
    cCs�yti
|
�i}Wntj
o




d
}n
X|
|_tit�|_||_	||i|_
dg
|i
|_ht
t<|_d
|_d
|_d
|_dS(Ni(tutiltfstattst_sizetAttributeErrortdataftstructtcalcsizet
indexformatngRtdatasizeRRtindexRRR%tallmaptallt
mapfind_count(tselfR6tsize((s#/sys/lib/python/mercurial/revlog.pyt__init__zs




	

	



	
	
c
	Cs�|io
d
Sn

|i
}
d|_d}d}|id}|iid�
x�||
jo�
|ii|�}d}xftd�D]X}||t|td!}||i|<|d7}||i	jo
Pn

||i7}q�W||7}qP
Wd
S(s�
        during a commit, we need to make sure the rev being added is
        not a duplicate.  This requires loading the entire index,
        which is fairly slow.  loadmap can load up just the node map,
        which takes much less time.
        Ni
ii
i(
R<R:RR6tseektreadtxrangetngshaoffsetR%R(	R?tendtcurtcountt	blocksizetdatatoffR,t
n((s#/sys/lib/python/mercurial/revlog.pytloadmap�s(


	
	


















c
CsU
|io
dSn

|djoT
|ii|
�
|
||ijo
t|i|
d
�}n

|ii|�}n

t|�|i}|
|i}d
}|t|i	�|jo
t|i	�|}n

x�t
|�D]v}|i	||djoK
||||i!}||i	||<|ttd!}	|||i|	<n

||i7}q�WdS(Nii(
R=RR6RBR:tmaxRCRRR;RDRER%(
R?t
blockstartRIRJtlendt
iRKR,t
bRL((s#/sys/lib/python/mercurial/revlog.pyt	loadblock�s(




















cCs�|io
dSn

|id
jo*
|i�
|
|ijo
|
Sn

dSn

|id7_|id}xJ|i|djo5
|djo
d|_d|_dSn

|d8}qk
W|d|i}|id}x�djo�t	||d�}|i
i|�
|i
i||�}||}x�t
o�
|i|
d|�}|}|djod
||i}	|	|i}||t|td!}
|
|
jo 
|	||i|i|
<|
Sq�
q)

Pq)

W||8}q�
WdS(s;search backwards through the index file for a specific nodeii
ii
iN(R<RR>RMR%RR;R=RRNR6RBRCtTruetfindRE(R?tnodetlastRFRItstartRJtfindendRKRQRL((s#/sys/lib/python/mercurial/revlog.pytfindnode�sF













	
	


























cCs�|io
dSn

t
}|
djo-
d
}d|i|i}|i}t}nX
|o(
|
|i}||i}||}n)
|
d@|i}|id}||}x,||jo
|i||�
||7}q�
W|o

t|_n

dS(Nii
i�ii�R=tFalseRRR:RTRS(R?RQRFR=RORI((s#/sys/lib/python/mercurial/revlog.pyt	loadindex�s(








	















N(	t__name__t
__module__t__doc__RARMRRSRZR\(((s#/sys/lib/python/mercurial/revlog.pyR1qs			-t	lazyindexc
BsVeZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
RS(	s!a lazy version of the index arraycCs
|
|_dS(
N(
R)(R?tparser((s#/sys/lib/python/mercurial/revlog.pyRA
s
c

Cst|i
i�S(
N(RR)R;(
R?((s#/sys/lib/python/mercurial/revlog.pyt__len__
s
cCsE|
d
jo
|
t|i
i�7}
n

|i
i|
�
|i
i|
S(Ni(RR)R;R\(R?R*((s#/sys/lib/python/mercurial/revlog.pytload
s




cCs'tt
|ii|
p

|i|
��S(
N(t_unpackR9R)R;Rc(R?R*((s#/sys/lib/python/mercurial/revlog.pyt__getitem__

s
cCstt
|�|ii|
<dS(
N(t_packR9R)R;(R?R*titem((s#/sys/lib/python/mercurial/revlog.pyt__setitem__
s
cCs|ii
|
=dS(
N(R)R;(R?R*((s#/sys/lib/python/mercurial/revlog.pyt__delitem__
s
cCs#|ii
i|
tt|��
dS(
N(R)R;tinsertRfR9(R?R*t
e((s#/sys/lib/python/mercurial/revlog.pyRj
s
cCs |ii
itt|
��
dS(
N(R)R;R!RfR9(R?Rk((s#/sys/lib/python/mercurial/revlog.pyR!
s
(R]R^R_RARbRcReRhRiRjR!(((s#/sys/lib/python/mercurial/revlog.pyR`
s

							tlazymapc
BsMeZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	RS(sa lazy version of the node mapcCs
|
|_dS(
N(
R)(R?Ra((s#/sys/lib/python/mercurial/revlog.pyRA
s
cCs3|ii
|
�}|djo
t|
��n

dS(
N(R)RZRtKeyError(R?tkeyRL((s#/sys/lib/python/mercurial/revlog.pyRc
s



cCs8|
|ii
jo
tSn

|ii�
|
|ii
jS(
N(R)R%RTRM(R?Rn((s#/sys/lib/python/mercurial/revlog.pyt__contains__ 
s




c
cs�tV
x�t
|ii�D]m}
|ii|
}|p$
|ii|
�
|ii|
}n

t|t�o
tt	|�}n

|d
V
qWdS(Ni(
RRDR)RR;R\t
isinstancetstrRdR9(R?RQtret((s#/sys/lib/python/mercurial/revlog.pyt__iter__%
s








cCswy|ii
|
SWn^tj
oR



y|i|
�
|ii
|
SWqstj
o



td
t|
���qs
Xn
XdS(Nsnode (R)R%RmRcR
(R?Rn((s#/sys/lib/python/mercurial/revlog.pyRe/
s








cCs||ii
|
<dS(
N(R)R%(R?Rntval((s#/sys/lib/python/mercurial/revlog.pyRh8
s
cCs|ii
|
=dS(
N(R)R%(R?Rn((s#/sys/lib/python/mercurial/revlog.pyRi:
s
(
R]R^R_RARcRoRsReRhRi(((s#/sys/lib/python/mercurial/revlog.pyRl
s

				
			s>4l20s20s20si8trevlogoldioc
Bs#eZ
d�Zd
�Zd�ZRS(c

Csti
t�|_dS(
N(R7R8t
indexformatv0R@(
R?((s#/sys/lib/python/mercurial/revlog.pyRAA
s
c
Cs+
|i}g}ht
t<}d
}}t|�tjo
||
i�7}n

t|�}	x�|||	j
o�
||||!}
||7}tt|
�}t|d
d
�|dd|d|d|i	|dt
�|i	|dt
�|df}|i
|�
|||d<|d7}q^
W||dfS(	Nii
i�iiiii(R@RRRt_prereadsizeRCRdRvR
tgetR!R(
R?tfpRJtinlineRR;tnodemapRLRKRRGRkte2((s#/sys/lib/python/mercurial/revlog.pyt
parseindexD
s"
	











(
3



cCsVt|
d
�|
d|
d|
d||
d�||
d�|
df}t
t|�S(Nii
iiiii(RRfRv(R?tentryRVtversiontrevR|((s#/sys/lib/python/mercurial/revlog.pyt	packentryY
s
"
'
(R]R^RAR}R�(((s#/sys/lib/python/mercurial/revlog.pyRu@
s
		s>Qiiiiii20s12xi s>Itrevlogioc
Bs#eZ
d�Zd
�Zd�ZRS(c

Csti
t�|_dS(
N(R7R8R9R@(
R?((s#/sys/lib/python/mercurial/revlog.pyRAm
s
c
Cs�t|�t
jo�
ti�oz
|or
t|
�}t|�}t|�}t|d
�}t|d
�}t	d
|�|d
<||d
<||dfSq�
||
i�7}n

ti
||�\}}}	|||	fS(Ni(RRwR2t
openhardlinksR1R`RltlistR	R
RRCtparserstparse_index(
R?RyRJRzRaR;R{RkRtcache((s#/sys/lib/python/mercurial/revlog.pyR}p
s










cCs;tt
|
�}|d
jo
tt|�|d}n

|S(Nii(RfR9t
versionformat(R?R~RVRR�R)((s#/sys/lib/python/mercurial/revlog.pyR��s




(R]R^RAR}R�(((s#/sys/lib/python/mercurial/revlog.pyR�l
s
		trevlogcBs�eZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd.d�Zd�Zd�Zd.d.d�Zd.d.d�Zd.d.d�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d �Z#d!�Z$d"�Z%d#�Z&d$�Z'd.d%�Z(d.d&�Z)d'�Z*d(�Z+d.d)�Z,d*�Z-d+�Z.d,�Z/d-�Z0RS(/sM
    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.
    cCs||_|d
 d|_
|
|_d|_d|_htt<|_g|_	t
}t|
d�o&
|
i}|t
@o
|tO}q�
n

d}yV|i|i�}|it�}t|�djo
tit|d �d}n

Wn/tj
o#

}
|itijo
�q

n
X||_|t@|_|d@}|d@}|tjo.
|o'
ttd�|i|d	?f��nq
|t
jo3
|t@o'
ttd
�|i|d	?f��n1
|t
jo#
ttd�|i|f��n

t�|_|itjo
t�|_n

|o�
y|ii |||i�}	Wn4t!t"fj
o"

}

ttd�|i��n
X|	\|_	|_|_|ip
|i#�
q�
n

|i	gjp+
t$|i	t%�p
|i	d
dtjo,
|i	i&dddd
d
d
d
tf�
n

dS(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.diRt
defversionii�s*index %s unknown flags %#04x for format v0is)index %s unknown flags %#04x for revlogngsindex %s unknown format %dsindex %s is corruptedi�iN(iRi�t	indexfiletdatafiletopenerRt_cachet_chunkcacheRRR{R;tREVLOG_DEFAULT_VERSIONthasattrR�tREVLOGNGtREVLOGNGINLINEDATARCRwRR7tunpackR�tIOErrorterrnotENOENTRt_inlinetREVLOGV0R.RR�t_ioRuR}t
ValueErrort
IndexErrort_chunkclearRpR`R!(R?R�R�t
vRQt
ftinsttflagstfmtt
dRk((s#/sys/lib/python/mercurial/revlog.pyRA�s`	

	
	
	

	

	






"


	


























#

cCs1t|i
t�o
|i
ii|
|�
n

d
S(s8load a block of indexes all at once from the lazy parserN(RpR;R`R)R\(R?RXRF((s#/sys/lib/python/mercurial/revlog.pyt
_loadindex�s
c
Cs=t|i
t�o&
|i
i}
|
i�
|
i|_n

d
S(s5loads both the map and the index from the lazy parserN(RpR;R`R)R\R%R{(R?R)((s#/sys/lib/python/mercurial/revlog.pyt
_loadindexmap�s



c

Cs=t|i
t�o&
|i
ii�
|i
ii|_
n

d
S(s"loads the map from the lazy parserN(RpR{RlR)RMR%(
R?((s#/sys/lib/python/mercurial/revlog.pyt_loadmap�s

c

Cs|it
|i�d
�S(Ni(RVRR;(
R?((s#/sys/lib/python/mercurial/revlog.pyttip�s
c

Cst|i
�d
S(Ni
(RR;(
R?((s#/sys/lib/python/mercurial/revlog.pyRb�s
c
cs&xtt
|��D]}
|
V
qWdS(
N(RDR(R?RQ((s#/sys/lib/python/mercurial/revlog.pyRs�s

cCsDy|i|
SWn.t
j
o"



t|
|itd
���n
XdS(Nsno node(R{RmtLookupErrorR�R(R?RV((s#/sys/lib/python/mercurial/revlog.pyR��s



cCs|i|
d
S(Ni(
R;(R?R�((s#/sys/lib/python/mercurial/revlog.pyRV�s
cCs|i|
d
S(Ni(
R;(R?R�((s#/sys/lib/python/mercurial/revlog.pytlinkrevs
cCs>|i}||i
|
�}||d
d||ddfS(Niii(R;R�(R?RVRQR�((s#/sys/lib/python/mercurial/revlog.pytparentss
	

cCs|i|
d
d!S(Nii(
R;(R?R�((s#/sys/lib/python/mercurial/revlog.pyt
parentrevss
cCst|i
|
d
d?�S(Nii(RR;(R?R�((s#/sys/lib/python/mercurial/revlog.pyRXs
cCs|i|
�|i
|
�S(
N(RXtlength(R?R�((s#/sys/lib/python/mercurial/revlog.pyRF
s
cCs|i|
d
S(Ni
(
R;(R?R�((s#/sys/lib/python/mercurial/revlog.pyR�s
cCs|i|
d
S(Ni(
R;(R?R�((s#/sys/lib/python/mercurial/revlog.pytbases
cCsH|i|
d
}|djo
|Sn

|i
|i|
��}t|�S(s?return the length of the uncompressed text for a given revisionii(R;trevisionRVR(R?R�RR/((s#/sys/lib/python/mercurial/revlog.pyR@s




cCs�t|
f
�}|
g
}|o
|i
|�}n
d
}x�|o�
|id
�}||jo
q;n

|tjo
q;n

x_|i|�D]N}|i
|�|jo
q�n

||jo
|i|�
|i|�
q�
q�Wq;
W|S(sxreturn the set of all nodes ancestral to a given node, including
         the node itself, stopping when stop is matchedi(tsetR�tpopRR�taddR!(R?RVtstopt	reachabletvisittstopnRLR)((s#/sys/lib/python/mercurial/revlog.pyR�.s&
	



















c
gs�t|
�}t
tg
�}x_|oW
xP|i|id
��D]6}||jo#
|i|�
|i|�
|V
q>
q>Wq
WdS(s:Generate the ancestors of revs using a breadth-first visitiN(R�R�RR�R�R!R�(R?trevsR�tseentparent((s#/sys/lib/python/mercurial/revlog.pyt	ancestorsEs










c
gs�t|
�}xrt
t|
�d
t|��D]Q}xH|i|�D]7}|tjo$
||jo
|i|�
|V
PqB
qBWq,WdS(s5Generate the descendants of revs in topological orderi
N(R�RDtminRR�RR�(R?R�R�RQR,((s#/sys/lib/python/mercurial/revlog.pytdescendantsPs
 





c
Cs�|
djo

t
g
}
n

|djo
|i�}n

g}|
D]}||i|�qB~}
g}|D]}||i|�ql~}t|i|
��}|it�
|i|
�
t�}g}|D]}	|	|jo
||	q�
q�~}
xt|
ol
|
i	d
�}	|	|jo
q�
|i|	�
x5|i
|	�D]$}||jo
|
i|�
q?

q?
Wq�t|�}|i
�
g}|D]}	||i|	�q�~S(sR

        returns the topologically sorted list of nodes from the set:
        missing = (ancestors(heads) \ ancestors(common))

        where ancestors() is the set of ancestors from heads, heads included

        if heads is None, the heads of the revlog are used
        if common is None, nullid is assumed to be a common node
        iN(RRtheadsR�R�R�R�RRR�R�R!R�RRV(
R?tcommonR�t_[1]RLt_[2]thastmissingt_[3]t
rR�R)t_[4]((s#/sys/lib/python/mercurial/revlog.pytfindmissingZs.






*
*



	
2














cCs1gggf}|
dj	oO
t
|
�}
|
p
|Sn

tg}|
D]}||i|�qE~�}n
tg
}
t}|tjoQ
|djoD
g}|D]}||i|�q�~tg
t
|i��fSn

|djo 
t|�d
}	d}
h}n�t
|�}|p
|Sn

t	�}
t
i|d�}t	|�}tg}|D]}||i|�qU
~�}	x�|o�
|i
�}|tjo
qz
n

|i|�}||jo�
||
joS
|
i|�
|ig}
|i|�D]}|tjo
|
|q���
q?
||jo
|i
|�
q?
qz

qz

W|
p
|Sn

|tjou
g}|
D]}||
jo
||qk
qk~}
|
o4
tg}|
D]}||i|�q�~�}q�|Sn
t}tg
}
t	|
�}|i�}
g}x�tt|d�|	d
�D]�}|i|�}t}|tjo

t}n�
||joc
t}||
joL
t|i|��}|d|jp
|d
|jo
|
i|�
q�
q
nO
t|i|��}|d|jp
|d
|jo
|i|�
t}n

|o�
|
djp

||
jo~
|i|�
|
dj	o
||jo
d
||<q�
|
djo8
d
||<x+|i|�D]}|i
|d�
q�Wq�
q
qWg}|i�D]"}||djo
||q�
q�~}t
|
�}
|p
t�
|
p
t�
|p
t�
||
|fS(s
Return a tuple containing three elements. Elements 1 and 2 contain
        a final list bases and heads after all the unreachable ones have been
        pruned.  Element 0 contains a topologically sorted list of all

        nodes that satisfy these constraints:
        1. All nodes must be descended from a node in roots (the nodes on
           roots are considered descended from themselves).
        2. All nodes must also be ancestors of a node in heads (the nodes in
           heads are considered to be their own ancestors).

        If roots is unspecified, nullid is assumed as the only root.
        If heads is unspecified, it is taken to be the output of the
        heads method (i.e. a list of all nodes in the repository that
        have no children).i
iN(RR�R�R�RRRVR�RR�tdicttfromkeysRNR�R�RR�RRDR[RTttupletremoveR!titerkeystAssertionError(R?trootsR�tnonodesR�RLt	lowestrevR�R�t
highestrevR�t
nodestotagR�R�R)t_[5]t_[6]tdescendentst
orderedouttisdescendentt_[7]((s#/sys/lib/python/mercurial/revlog.pytnodesbetween�s�





4	

D





	0








 
&




2
4
	








"
"




!





 
<




c
Cs,|
djo�
|djo�
t
|�}|p
tg
Sn

d
g
|d
}|i}x8t|�D]*}||}d||d<||d<q_Wg}t|�D]%}||o
||i|�q�
q�~Sn

|
djo

t}
n

|djo

g}n

tg}	|D]}
|	|i|
�q

~	�}|i|
�}t|f
�}
t|f
�}|i}x�t|d
t
|��D]�}x{||�D]m}||
jo/
||jo
|
i	|�
n

|i	|�
n

||jo
||jo
|i
|�
q�
q�Wq|
Wg}|D]}||i|�q~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
        i
iiiN(RRRR;RDRVR�R�R�R�R�(R?RXR�RHtisheadR;R�RkR�R�RLtstoprevststartrevR�R�R�R)R�((s#/sys/lib/python/mercurial/revlog.pyR�s>




	





A







0


	










cCs�g}|i|
�}x�t
|d
t|��D]�}g}|i|�D]}|tjo
||qI
qI~}|o<
x`|D]-}||jo
|i|i|��
q~
q~Wq/
|tjo
|i|i|��
q/
q/W|S(s!find the children of a given nodei
(R�trangeRR�RR!RV(R?RVt
cR)R�R�tprtprevs((s#/sys/lib/python/mercurial/revlog.pytchildren>s


;




"



cCsh
t|
t
tf�o
|i|
�Sn

t|
�d
jo5
y|
}|i|�
|SWqotj
o



qo
Xn

y�t|
�}t|�|
jo

t�n

|djo
t|�|}n

|djp
|t|�jo

t�n

|i|�SWntt	fj
o



n
Xt|
�djoA
y!t
|
�}|i|�
|SWqd
ttfj
o



qd

Xn

dS(Niii((RpR
RRVRR�R�RqR�t
OverflowErrorRt	TypeError(R?tidRVR�((s#/sys/lib/python/mercurial/revlog.pyt_matchLs6







	







 











c
Cs"
t|
�d
jo

y�|
�d}t
|
|d �}g}|iD]"}|| |jo
||qH
qH~}g}|D]'}t|�i|
�o
||q~
q~~}t|�djo>
t|�djo
|dSn

t|
|itd���n

dSWq
t	j
o



q

Xn

dS(Ni(iii
sambiguous identifier(
RRR{R
t
startswithR�R�RRR�(R?R�Rtbin_idR�RLtnlR�((s#/sys/lib/python/mercurial/revlog.pyt
_partialmatchns



9
;







cCsa|i|
�}|dj	o
|Sn

|i|
�}|o
|Sn

t|
|itd
���dS(s�locate a node based on:
            - revision number or str(revision number)
            - nodeid or subset of hex nodeid
        sno match foundN(R�RR�R�R�R(R?R�RL((s#/sys/lib/python/mercurial/revlog.pytlookups





cCs+|i|
�\}}t
|||�|
jS(
s'compare text with a given file revision(R�R(R?RVRRR((s#/sys/lib/python/mercurial/revlog.pytcmp�s
cCsm|i\}}|t
|�|
jo4
t
|�t
|�tjo
|||f|_n
|
|f|_dS(
N(R�RRw(R?RRJt
oR�((s#/sys/lib/python/mercurial/revlog.pyt	_addchunk�s
4
cCs�|io
|i
|i�}n
|i
|i�}td
|�}|i|
�
|i|�}|i|
|�
||jo
|| Sn

|S(Ni
(R�R�R�R�RNRBRCR�(R?RR�tdft	readaheadR�((s#/sys/lib/python/mercurial/revlog.pyt
_loadchunk�s










cCs�|i\}}t
|�}|
|}||}|d
jo>
||j
o1
|d
jo
||jo
|Sn

|||!Sn

|i|
|�S(Ni(R�RR�(R?RR�R�R�Rt
cachestarttcacheend((s#/sys/lib/python/mercurial/revlog.pyt	_getchunk�s








cCsX|i|
�}|i
|�|}|io
||
d
|ii7}n

|i||�S(Ni
(RXRFR�R�R@R�(R?R�tendrevRXR�((s#/sys/lib/python/mercurial/revlog.pyt	_chunkraw�s






cCst|i
|
|
��S(
N(R0R�(R?R�((s#/sys/lib/python/mercurial/revlog.pyt_chunk�s
c

Cs
d|_dS(NiR(iR(
R�(
R?((s#/sys/lib/python/mercurial/revlog.pyR��s
cCsu|
d
|jo0
|i|
�|i|�jo
|i
|�Sn

ti|i|i|
��|i|i|���S(s1return or calculate a delta between two revisionsi
(R�R�tmdiffttextdiffR�RV(R?trev1trev2((s#/sys/lib/python/mercurial/revlog.pytrevdiff�s0

c
Cs�|
tjo
d
Sn

|i
o)
|i
d|
jo
t|i
d�Sn

d}|i|
�}|i|�}|i|dd@o)
ttd�|i|dd@��n

|i
oL
|i
d|jo8
|i
d|jo$
|i
d}t|i
d�}n

|i	||d�
|i
||�
|djo
|i|�}n

g}t|d|d�D]}||i|�qa
~}t
i||�}|i|
�\}}	|
t|||	�jo#
ttd�|i|f��n

|
||f|_
|S(	s/return an uncompressed revision of a given nodeRiii�sincompatible revision flag %xi
sintegrity check failed on %s:%dN(RR�RqRR�R�R;R.RR�R�R�RDR�tpatchesR�RR�(
R?RVRR�R�R�R�tbinsRR((s#/sys/lib/python/mercurial/revlog.pyR��s2







2






;





c
Cs�|ip#
|i
d
�|id
�djo
dSn

|
i|i�}|djo
ttd�|i��n

|d}|i
|�}|
i|i	|�
|o
|i
�
|i�
n

|i|i	d�}z.x'|D]}|i
|i||��
q�WWd|i�
X|i|iddt�
}|itM_t|_xC|D];}|ii|i||i|i|�}	|i
|	�
qI
W|i�
|
i|i||ii�
|i�
dS(Ni�is%s not found in the transactionit
wt
atomictemp(R�RXR�RUR�RR.RR�R�R#tcloseR�twriteR�RTRR�R[R�R�R;RVtrenametreplaceR@R�(
R?ttrRyttrinfottrindextdataoffR�R�RQRk((s#/sys/lib/python/mercurial/revlog.pytcheckinlinesize�s8
.












!

	

(


c	Cs�d}|i
p
|i|id
�}n

|i|id�}z&|i|
|||||||�SWd|o
|i�
n

|i�
XdS(s
add 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
        d - an optional precomputed delta
        t
asa+N(RR�R�R�R�t_addrevisionR�(	R?RttransactiontlinkRRR�tdfhtifh((s#/sys/lib/python/mercurial/revlog.pytaddrevisions	





&

c	Cs�t|
||�}	|	|i
jo
|	Sn

t|�}
|
d
}|i|�}|i|�}
|
oz
|p.
|i|i|��}ti||
�}n

t	|�}t|d
�t|d�}||
|i
|�}n

|
p
|t|
�djo4
t	|
�}t|d
�t|d�}|
}n

t|
d�|t|
�|||i|�|i|�|	f}|i
id|�
|
|i
|	<|ii||i|i|
�}|ip|
|i|i|
�
|i|i|
t|��
|do
|i|d�
n

|i|d
�
|i�
|i|�
nj
|
|
|ii7}
|i|i|
|
�
|i|�
|i|d�
|i|d
�
|i||�
|	|
|
f|_|	S(Ni
iii�(RR{RR�RFR�RVR�R�R"RXR
R�R;RjR�R�RR�R�R�R�R�R#R@R
R�(R?RR	
R

RRR�R
R
RVtcurrtprevR�RtptextRJRtdistRkR~((s#/sys/lib/python/mercurial/revlog.pyR
+sN

















'


!
















csX�f
d
�}ti�i
|
��i
|�|�}|djo
tSn

�i|�S(s4calculate the least common ancestor of nodes a and bc
s9g}
�i|�D]}|t
jo
|
|q
q~
S(
N(R�R(R�R�R)(
R?(s#/sys/lib/python/mercurial/revlog.pyR�`s
N(tancestorR�RRRV(R?R
RRR�R�((
R?s#/sys/lib/python/mercurial/revlog.pyR
]s
'


ccs�g}|
D]}||i|�q~}|p
t
i�V
d
Sn

|i|d�d}|id|�
xW
tt|�d�D]?
}||||d}	}
|i|
�}|d
j	o
||�
n

|i	|�}||d|d||�}|	djo,
|i
|�}|tit|��7}n
|i
|	|
�}t
it|�t|��V
|V
t|�djoA
d}
x=|
t|�jo 
|
d	}||
|!V
|}
q�
Wq�
|V
q�Wt
i�V
d
S(
sG
calculate a delta group

        Given a list of changeset revs, return a set of deltas and
        metadata corresponding to nodes. the first delta is
        parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
        have this parent as it has all history before these
        changesets. parent is parent[0]
        Nii
i�iiiii(R�tchangegroupt
closechunkR�RjRDRRVRR�R�R�ttrivialdiffheaderR�tchunkheader(R?tnodelistR�tinfocollectR�RLR�R)R�R
RRtnbtmetaR*R+((s#/sys/lib/python/mercurial/revlog.pytgroupis8
*







 












	cCs�t|�}|d
}d
}t}}d}	}
}|o
|i|�}
n

|i|id�}||ii}
|io$
|i	|i|
|
|�
d
}n?
|i	|i|
|�
|i	|i
|
�
|i|i
d�}z�}x�
D]�}tid|d �\}}}}||�}||i
jo

|}q�

t|d�}~xC||fD]5}||i
jo
t||itd���q_

q_
W|p9
|}||i
jo
t||itd���q�
n

||jo@
t|�}t|d�t|d
�}ti||�}n

||jp
|
|	||d	jo

|o
|i�
n

|i�
|i|�}t|�djo
t|d
�}n
ti||g
�}~|i|||||d
||�}|o9
|io.
|i|i
d�}|i|id�}n

||jo
ttd���n

t|�}n/

t|
d�|||||i|�|i|�|f}|iid|�
||i
|<|ii||i|i|�}|io{
|i |�
|i |d�
|i |d
�
|i!||�
|ip.
|i|i
d�}|i|id�}q}
n0
|i |d�
|i |d
�
|i |�
||d
||f\}}}}|i"|�}|i#|�}	|i|�}
q�Wd
|o
|i$�
n

|i$�
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.
        i
isa+R
t20s20s20s20siPsunknown parentsunknown baseiisconsistency error adding groupi�N(%RRRRFR�R�R�R@R�R�R�R7R�R{tbufferR�RR"R�tpatchedsizeR#R�R�R
R.R
R�R;RjR�RVRR�R
R�RXR�(R?R�t
linkmapperR	
R�R/RVR�R
RXRFttextlenR
tisizeR
tchaintchunkRRtcsR

tdeltaR)tcdeltat	cdeltalenRtchkRkR~((s#/sys/lib/python/mercurial/revlog.pytaddgroup�s�

















"







#

#



&














$



!













"




cCs,
t|�d
jo
dSn

t
|it�o
|i�
n

x/|D]#}|i|d|
jo
PqC
qCWdS|i|�}|ip'
|i|i|�
||i	i
}n
|||i	i
7}|i|i|�
d|_
|i�
x0t|t|��D]}|i|i|�=q�i|d5dS(s6truncate 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 readd them after this truncation.
        iNii�(RRpR;R`R�RXR�R�R�R�R@R�RR�R�RDR{RV(R?tminlinkR	
R�RFR,((s#/sys/lib/python/mercurial/revlog.pytstrip
s*



	



	



c
Cs�d
}
t|�o&
t
d
|it|�d��}
n

y<|i|i�}|id
d�
|i�}||
}Wn5tj
o)

}
|iti	jo
�n

d
}n
Xy�|i|i
�}|id
d�
|i�}|ii}t
d
||�}|||}|i
oU
d
}	x*|D]"}
|	t
d
|i|
��7}	q"
Wd
}|t|�||	}n

Wn5tj
o)

}
|iti	jo
�n

d
}n
X||fS(Nii
i(RRNRFR�R�RBttellR�R�R�R�R�R@R�R�(R?texpectedR�tactualtddR�RRQtdit	databytesR�((s#/sys/lib/python/mercurial/revlog.pyt	checksize9s>



&


















 

 



c
Cs.|ig
}
|i
p
|
i|i�
n

|
S(
N(R�R�R!R�(R?tres((s#/sys/lib/python/mercurial/revlog.pytfiles\s




N(1R]R^R_RAR�R�R�R�RbRsR�RVR�R�R�RXRFR�R�R@RR�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+
R2
R4
(((s#/sys/lib/python/mercurial/revlog.pyR��s\
	>																		
'�(		"											%'	2	1	s	,	#i
(6R_RVRR
RRRti18nRR
R
R�R�terrorR2R7RR�tpackRfR�RdR"R'R0R-tsha1RR�R�R�tREVLOG_DEFAULT_FLAGStREVLOG_DEFAULT_FORMATR�RwR.R�RR	R
RRtobjectR1R`RlRvtv0shaoffsetRuR9RER�R�R�(((s#/sys/lib/python/mercurial/revlog.pys<module>sH(

H
$	
	
	
	
	





	
							
�%
(