�
�Xc@@s�
dd
lm
Z

ddlZddlZddlZddlZddlZddlmZ
ddl	m
Z
mZmZm
Z
mZ
ddlmZmZmZmZmZmZmZmZmZ
ejZejZd�Zdef
d	��YZd
�Z e!d�
Z"d�Z#d
�Z$d�Z%e!d�
Z&e!d�
Z'd�Z(d�Z)e!e*d�Z+d�Z,d�Z-e!d�
Z.d�Z/e!e*e!e!e*d�Z0e*d�
Z1dS(i(
tabsolute_importNi
(
t
_(tbinthextnullhextnullidtnullrev(	tcopiestdestutilterrort	filemergetobsoletetscmutiltsubrepotutiltworkerc
C@s.|jd
�
}
|
d |
d}
d
j
|
�
S(Ns
i����i����(tsplittjoin(tdatatbits((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt
_droponode's

t
mergestatecB@s�
eZ
dZd
ZdZed*d*d*d��
Zed��
Zd�Z	d*d*d*d�Z
d�Zd�Zd	�Z
d
�Zd�Zejd��
Zejd
��
Zejd��
Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d �Z&d!�Z'd"�Z(d#�Z)d$�Z*d%�Z+d&�Z,d'�Z-d(�Z.d)�Z/RS(+sXtrack 3-way merge state of individual files

    The merge state is stored on disk when needed. Two files are used: one with
    an old format (version 1), and one with a new format (version 2). Version 2
    stores a superset of the data in version 1, including new kinds of records
    in the future. For more about the new format, see the documentation for
    `_readrecordsv2`.

    Each record can contain arbitrary content, and has an associated type. This
    `type` should be a letter. If `type` is uppercase, the record is mandatory:
    versions of Mercurial that don't support it should abort. If `type` is
    lowercase, the record can be safely ignored.

    Currently known records:

    L: the node of the "local" part of the merge (hexified version)
    O: the node of the "other" part of the merge (hexified version)
    F: a file to be merged entry
    C: a change/delete or delete/change conflict
    D: a file that the external merge driver will merge internally
       (experimental)
    m: the external merge driver defined for this merge plus its run state
       (experimental)
    f: a (filename, dictonary) tuple of optional values for a given file
    X: unsupported mandatory record type (used in tests)
    x: unsupported advisory record type (used in tests)
    l: the labels for the parts of the merge.

    Merge driver run states (experimental):
    u: driver-resolved files unmarked -- needs to be run next time we're about
       to resolve or commit
    m: driver-resolved files marked -- only needs to be run before commit
    s: success/skipped -- does not need to be run any more

    smerge/statesmerge/state2cC@s#t|�
}|j
|
||�
|S(
sPInitialize a brand new merge state, removing any existing state on
        disk.(Rtreset(trepotnodetothertlabelstms((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytcleanTs

c
C@st|�
}
|
j
�
|
S(
s1Initialize the merge state, reading it from disk.(Rt_read(RR((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytread\s


cC@s|
|_t
|_d
|_d
S(s^Initialize the merge state.

        Do not use this directly! Instead call read() or clean().N(t_repotFalset_dirtytNonet_labels(tselfR((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt__init__cs	
	
cC@s�i|_i|_
d|_d|_||_x0dD](}|t|�
kr4t||�
q4q4W|
r{|
|_||_nd|_|j	r�d|_
n	d|_
tj|j
jd�
t�
i|_t|_dS(Ntlocalctxtotherctxt
st
utmerge(R&R'(t_statet_stateextrasR"t_localt_otherR#tvarstdelattrt_readmergedrivertmergedrivert_mdstatetshutiltrmtreeRRtTruet_resultsR R!(R$RRRtvar((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRks$
	
	
	
	
	





	

	
	
	

	
c
C@s�i|_i|_
d|_d|_x0dD](}
|
t|�
kr+t||
�
q+q+Wd|_d|_t	�}|j
�}x�
|D]�
\}}|dkr�t|�
|_q�|dkr�t|�
|_q�|dkr5
|jdd�}|d}t
|�
dks
|d	kr
d
}n|d|_||_q�|dkrh
|jd�
}|d|j|d<q�|d
kr�
|jdd�\}}	|	jd�
}
i}d}x6|t
|
�
kr�
|
|d||
|<|d7}q�
W||j
|<q�|dkr?|jdd�}
g|
D]}t
|�
dkr|^q|_q�|j�s�|j|�

q�q�Wi|_t|_|r�tj|�
�
ndS(s�Analyse each record content to restore a serialized state from disk

        This function process "record" entry produced by the de-serialization
        of on disk file.
        R&R'R(t
Lt
Ot
ms
i
tumsR)itFDCt
fit
lN(R&R'(R+R,R"R-R.R/R0R1R3tsett_readrecordsRRtlenR#tislowertaddR7R R!R	tUnsupportedMergeRecords(R$R8tunsupportedtrecordstrtypetrecordRtmdstatetfilenamet	rawextrast
extrapartstextrast
iRR?((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�sX	
	
	
	




	
	
	










	















1


	
	
c
C@s�|j�}
|j
�}|j|
|�r.|S|jd	j�d
}|
jd|j�f�

xmt|
�
D]_\}}|ddkrk|dj	d�
}|j
dd�
|ddj|�
f|
|<qkqkW|
Sd	S(
s�Read merge state from disk and return a list of record (TYPE, data)

        We read data from both v1 and v2 files and decide which one to use.

        V1 has been used by version prior to 2.9.1 and contains less data than
        v2. We read both versions and check if no data in v2 contradicts
        v1. If there is not contradiction we can safely assume that both v1
        and v2 were written at the same time and use the extract data in v2. If
        there is contradiction we ignore v2 content as we assume an old version
        of Mercurial has overwritten the mergestate file and left an old v2
        file around.

        returns list of record [(TYPE, data), ...]i����R:it
Fi
s
i����tN(t_readrecordsv1t_readrecordsv2t
_v1v2matchRR"tparentstappendRt	enumerateRtinsertR(R$t	v1recordst	v2recordstmctxtidxt
rR((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRA�s







$
cC@s�t�}x^|D]V}|d
dkr6|j
|�

q|d
dkr|j
dt|d�
f�

qqWx"|
D]}||krqtSqqWtSdS(NiR9RPi
(R@RDRR R6(R$RYRZtoldv2trec((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRT�s
	




$



c
C@s�g}
y}|jj
|j�
}xWt|�
D]I\}}|d
kr]|
jd|d f�

q+|
jd|d f�

q+W|j�
Wn+tk
r�
}
|jtjkr��q�n
X|
S(s�read on disk merge state for version 1 file

        returns list of record [(TYPE, data), ...]

        Note: the "F" data from this file are one entry short
              (no "other file node" entry)
        iR9i����RP(	Rtvfststatepathv1RWRVtclosetIOErrorterrnotENOENT(R$RGR>ROR?terr((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRR�s










c

C@s
g}
y�|jj
|j�
}|j�}d
}t|�
}x�||kr�||}|d7}td|||d!�d
}|d7}||||!}||7}|dkr�|d
|d}}n|
j||f�

q?W|j�
Wn+tk
r

}	
|	j	t	j
kr
�q
n
X|
S(sread on disk merge state for version 2 file

        This format is a list of arbitrary records of the form:

          [type][length][content]

        `type` is a single character, `length` is a 4 byte integer, and
        `content` is an arbitrary byte sequence of length `length`.

        Mercurial versions prior to 3.7 have a bug where if there are
        unsupported mandatory merge records, attempting to clear out the merge
        state with hg update --clean or similar aborts. The 't' record type
        works around that by writing out what those versions treat as an
        advisory record, but later versions interpret as special: the first
        character is the 'real' record type and everything onwards is the data.

        Returns list of records [(TYPE, data), ...].ii
s>Iit
t(RR`tstatepathv2RRBt_unpackRVRbRcRdRe(
R$RGR>RtofftendRHtlengthRIRf((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRS�s*
























c
C@s^|jj
jd
d�}
|jdk	rZ|j|
krZtjtd�
dtd�
�

�
n|
S(NtexperimentalR2s(merge driver changed since merge startedthints)revert merge driver change or abort merge(RtuitconfigR1R"R	tConfigErrorR
(R$tconfigmergedriver((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR2%
s





c

C@s,|jdkrtd
�
�
n|j|jS(Ns+localctx accessed but self._local isn't set(R-R"tRuntimeErrorR(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR&8
s

c

C@s,|jdkrtd
�
�
n|j|jS(Ns+otherctx accessed but self._other isn't set(R.R"RsR(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR'>
s

c

C@sLt|j
�
pKt|j�
pK|jjj|j�
pK|jjj|j�
S(
s�Whether mergestate is active.

        Returns True if there appears to be mergestate. This is a rough proxy
        for "is a merge in progress."
        (tboolR-R+RR`texistsRaRh(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytactiveD
s

c
C@s2|jr.|j
�}
|j|
�

t|_nd
S(s*Write current state on disk (if necessary)N(R!t_makerecordst
_writerecordsR (R$RG((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytcommitP
s	



c
C@s�
g}
|
jd
t
|j�
f�

|
jdt
|j�
f�

|jrr|
jddj|j|jg�
f�

nx�|jj�D]�\}}|ddkr�|
jddj|g
|�
f�

q�|dt	ks�|d	t	kr

|
jd
dj|g
|�
f�

q�|
jddj|g
|�
f�

q�Wx_t
|jj��
D]H\}}djd�|j�D�
�
}|
jd
d||ff�

qG
W|jdk	r�
dj|j�
}|
jd|f�

n|
S(NR9R:R;s
it
dt
Di
it
CRPc
s@s%|]\}
}d|
|fV
qd
S(s%s%sN((t.0t
kt
v((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>h
sR>s%s%sR?(RVRR-R.R2RR3R+t	iteritemsRtsortedR,R#R"(R$RGRzRRKRNRLR((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRwW
s(



	




& 
&'
"


!



cC@s|j|
�

|j
|
�

d
S(s,Write current state on disk (both v1 and v2)N(t_writerecordsv1t_writerecordsv2(R$RG((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRxp
s

cC@s�|jj
|jd
�}t|
�
}t|�
}|ddksFt�
|jt|j�
d�

x:|D]2\}}|dkrg|jdt	|�
�

qgqgW|j
�
dS(s/Write current state on disk in a version 1 filet
wiR9s

RPs%s
N(RR`RatitertnexttAssertionErrortwriteRR-RRb(R$RGR>tirecordstlrecordsRHR((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�u
s







cC@s�d
}|jj
|jd�}x�|
D]|\}}t|�
dksIt�
||krodd||f}}ndt|�
}|jt||t|�
|��

q%W|j�
dS(sqWrite current state on disk in a version 2 file

        See the docstring for _readrecordsv2 for why we use 't'.tLOFR�i
Rgs%s%ss>sI%isN(RR`RhRBR�R�t_packRb(R$RGt	whitelistR>tkeyRtformat((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR��
s






&
cC@s�|
j�rt
}n;tj|
j��
j�}|jjjd
||
j	��
d||
j�|j�t
|j��
|j�t
|j��
|
j�g|j
|<i
t
|j��
d6|j|<t|_dS(s/
add a new (potentially?) conflicting file the merge state
        fcl: file context for local,
        fco: file context for remote,
        fca: file context for ancestors,
        fd:  file path of the resulting merge.

        note: also write the local version to the `.hg/merge` directory.
        smerge/R)tancestorlinknodeN(tisabsentRthashlibtsha1tpatht	hexdigestRR`R�RRtfilenodetflagsR+RR,R6R!(R$tfcltfcotfcatfdthash((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRD�
s	
	
 




 
cC@s
|
|jkS(
N(
R+(R$tdfile((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt__contains__�
s
cC@s|j|
d
S(Ni(
R+(R$R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt__getitem__�
s
c

C@stt
|j�
�
S(
N(R�R�R+(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt__iter__�
s
c


C@s
|jj
�S(
N(R+tkeys(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytfiles�
s
cC@s||j|
d
<t
|_dS(Ni(R+R6R!(R$R�tstate((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytmark�
s

c


C@s|jS(
N(
R3(
R$((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRJ�
s
c
c@s<x5|jj
�D]$\}
}|d
dkr|
V
qqWdS(s%Obtain the paths of unresolved files.iR)N(R+titems(R$R>tentry((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt
unresolved�
s

c
c@s<x5|jj
�D]$\}
}|d
dkr|
V
qqWdS(s*Obtain the paths of driver-resolved files.iRzN(R+R�(R$R>R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytdriverresolved�
s

cC@s|jj
|
i�S(
N(R,t
setdefault(R$RK((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyRN�
s
c	C@s/||d
krtdfS|j
|}|\}}}}}	}
}}|j|j}
|j|�
}|jd�
}|r�|j|}nd}|j|||�}|j||
|
�}|jj|d|	d|�
}|j	�}|j	�}d|||krv
d|||krv
|j
�tkr^
||kr^
|
rs
|jjj
td�
|�

qs
qv
||krv
|}qv
n|
r|tkr�
|jjd	|�
}|jj||j�|�
|j�
n|jjj|d
t�


tj|j|j||||d|j�
\}}}n6tj|j|j||||d|j�
\}}}|dkr�|j
|=|jj|d�
t|_n|s�|j|d�
n|r%d}|r�|j�r�d
}qd}nB|j�r�d}n-|j�r||jkrd}qd}n||f|j |<n||fS(s)rerun merge process for file path `dfile`trdiR�tfileidtchangeidt
xR?sQwarning: cannot merge flags for %s without common ancestor - keeping local flags
smerge/t
ignoremissingRR]R>t
gtamt
aN(!R6R+RR.RNtgetR"t_filectxorabsenttfilectxR�RRRotwarnR
RR`twwriteRRbtwvfst
unlinkpathR
tpremergeR-R#R,tpopR!R�R�R&R7(R$t
preresolveR�twctxt
stateentryR�R�tlfiletafiletanodetofiletonodeR�toctxRNt
anccommitnodetactxtfcdR�R�tflotflaR>tcompleteR]tdeletedtaction((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_resolve�
sn













(



	




















		
	


		cC@s(|
tkrt
j||�S||SdS(
N(RR
t
absentfilectx(R$thexnodetctxR>((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�s

cC@s|jt
|
|�S(
sarun premerge process for dfile

        Returns whether the merge is complete, and the exit code.(R�R6(R$R�R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�scC@s|jt
|
|�d
S(sdrun merge process (assuming premerge was run) for dfile

        Returns the exit code of the merge.i
(R�R (R$R�R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytresolve sc
C@s�d\}
}}xh|jj
�D]W\}}|dkrD|
d7}
q|d
kr|dkri|d7}qv|d7}qqW|
||fS(sKreturn counts for updated, merged and removed files in this
        sessionii
R](iiiN(R7t
itervaluesR"(R$tupdatedtmergedtremovedR]R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytcounts&s








c
C@s<tg|j
j�D]"\}
}|d
dkrt^q�
S(s0get unresolved count for this merge (persistent)iR)(RBR+R�R6(R$R>R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytunresolvedcount4s
c
C@s|igd
6gd6gd6gd6gd6}
xL|jj
�D];\}\}}|dk	r9|
|j|ddf�

q9q9W|
S(s2return lists of actions to perform on the dirstateR]R>R�R�R�smerge resultN(R7R�R"RV(R$tactionsR>R]R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�9s
)
"

!
c
C@s5|jj
j�tk}
t|j|j�|
�
d
S(s-record remove/add/get actions in the dirstateN(Rtdirstatetp2Rt
recordupdatesR�(R$tbranchmerge((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt
recordactionsAs
cC@sd|j|
<dS(s]queues a file to be removed from the dirstate

        Meant for use by custom merge drivers.iR]N(iR](
R7(R$R>((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytqueueremoveFscC@sd|j|
<dS(sYqueues a file to be added to the dirstate

        Meant for use by custom merge drivers.iR�N(iR�(
R7(R$R>((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytqueueaddLscC@sd|j|
<dS(scqueues a file to be marked modified in the dirstate

        Meant for use by custom merge drivers.iR�N(iR�(
R7(R$R>((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytqueuegetRsN(0t__name__t
__module__t__doc__RaRhtstaticmethodR"RRR%RRRARTRRRSRt
propertycacheR2R&R'RvRyRwRxR�R�RDR�R�R�R�R�RJR�R�RNR�R�R�R�R�R�R�R�R�R�R�(((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR-sV#


		7	"			(																	K									cC@s�|jj
|
|d
d�
}dddg}||kr�djg|D]}d|d^qC�
}tjtd�
|
|||f�
�
n|S(NtdefaulttaborttignoreR�s, t
's$%s.%s not valid ('%s' is none of %s)(RoRpRR	RqR
(RtsectiontnameRptvalidRtvalidstr((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_getcheckunknownconfigXs



*

cC@sl|dkr|}n|j
jj|�
ok|j
j|�
ok|jj|�
|jkok||j|
|�
S(
N(R"R�taudittchecktisfileorlinkR�t	normalizetcmp(RR�R[R>tf2((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_checkunknownfilebs

	



c@sLt�}t��
t��t
|d
d�}t
|d
d�}|sD
��
fd�}	x�|j�D]�\}
\}}}
|dkr�t||
||
�r�|j|
�

q�qd|dkrdt||
||
|d�r�|j|
�

q�qdqdWtg|D]}|jj|�
r�|^q��
}||}|	||�
|	||�
n!
x
|j�D]
\}
\}}}
|d	krQ
|\}}t||
||
�}|jj|
�
r�
|}n|}|s�
d
|tfdf||
<qa|s�
|dkr
d
|
|
dt|fdf||
<qa|dkr)�j|
�

qa|dkrE�
j|
�

nd
|t	fdf||
<qQ
qQ
Wx.t
��
D] }
|jjt
d�
|
�

qrW�r�tjt
d�
�
�
nx.t
�
�
D] }
|jjt
d�
|
�

q�Wx`|j�D]R\}
\}}}
|
|k}|dkr�|\
}d
||f|
f||
<q�q�WdS(s�
    Considers any actions that care about the presence of conflicting unknown
    files. For some actions, the result is to abort; for others, it is to
    choose a different action.
    R*tcheckunknowntcheckignoredc@s<|
d
kr�j|�

n|
dkr8�
j|�

ndS(NR�R�(
tupdate(t	conflictsRp(tabortconflictst
warnconflicts(s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytcollectconflictsvs



t
ctdctdgitcmR�sremote createdR�R;s#remote differs from untracked localR�s%s: untracked file differs
sLuntracked files in working directory differ from files in requested revisions%s: replacing untracked file
N(R�R�(R@R�R�R�RDR�t_ignoreR R"R6R�RoR�R
R	tAbort(RR�R[tforceR�t
mergeforceR�t
unknownconfigt
ignoredconfigR�R>R;targstmsgR�tignoredconflictstunknownconflictstfl2tanct	differentRptbackupR�((R�R�s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_checkunknownfilesjs^	
	
	



"






!




"




	







 



"


	
cC@s�i}d
}|rd}nx6|j�D](}||
kr(|ddf||<q(q(W|s�x0|j�D]}||
krgd||<qgqgWn|S(s�

    Forget removed files

    If we're jumping between revisions (as opposed to merging), and if
    neither the working directory nor the target rev has the file,
    then we need to remove it from the dirstate, to prevent the
    dirstate from listing the file when it is no longer in the
    manifest.

    If we're merging, and the other revision has removed a file
    that is not present in the working directory, we need to mark it
    as removed.
    R>R]sforget deletedsforget removedN(R>Nsforget removed(R�R"R�(R�R[R�R�R;R>((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_forgetremoved�s


	





cC@s9t|
�
}|rA
x9dD]1}x(||D]\}}}|j
|�

q*WqWx(|dD]\}}}|j|�

qYWxA|dD]5\}}}|\}}	|j|�

|j
|�

q�Wx(|d	D]\}}}|j
|�

q�WxV|d
D]G\}}}|\}
}}}}
|r-
|j|
�

n|j
|�

q�Wni}x_t|�
D]Q}tj|�
}||kr�
tjtd�
|||f�
�
n|||<qT
Wd}}}x{t|j	��
D]g\}}|j
|�
r|j
|�
rtjtd
�
||f�
�
n|d}|d}|}q�
WdS(NR�R�R>R�tcdR�R]tdmR�R;s(case-folding collision between %s and %sRQs5case-folding collision between %s and directory of %st
/(R�R�R>R�R
R�(R@RDtdiscardR�RtnormcaseR	R

R
R�t
startswith(RtwmfR�tpmmfR;R>R
R
R�R�tf1tfatmoveR
tfoldmaptfoldt
foldprefixtunfoldprefixtlastfull((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_checkcollision�sB






























c
C@stS(
svrun the preprocess step of the merge driver, if any

    This is currently not implemented -- it's an extension point.(
R6(RRR�R((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytdriverpreprocesssc
C@stS(
strun the conclude step of the merge driver, if any

    This is currently not implemented -- it's an extension point.(
R6(RRR�R((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytdriverconclude	sc	@s�|d-k	r!|j
�r!d-}niiiif\}	}
}}gt�j�||gd
d��

D]}
|
j�^qe
|r�tj|�||�}|\}	}
}}n|jjt	d�
�

|jj
dt|�
t|�
t|�
f�

|jj
d|�|f�

�j�|j�|j�}}}t|	j
��
}|j|
j
��

d|kr�
t�f
d��jD�
�
r�
|dcd7<q�
n|d-k	r�
|j|�
}|j|�
}n|j|�
}i}x
|j�D]�\}\\}}\}}|r�|r�||kr�|	j|d-�}|d-k	rnd	|||t|j�fd
|f||<q�d	||d-t|j�fdf||<q�||}|j|�
}d|||k}||kr�||kr�d
d.df||<q�||krM||krM||kr1d|f
df||<q�d|tfdf||<q�|rx||krxd|f
df||<q�|r�||kr�d|tfdf||<q�d	|||t|j�fdf||<q�
|r||kr�q�||
krS|
|}||kr3d	||d-t|j�fdf||<qd||fd|f||<q�||	kr�|	|}d	|||t|j�fd|f||<q�||kr�|||kr�|r�d/||<qd|d-|t|j�fdf||<q|ddkrd0||<qd1||<q�q�
|r�
||kr4q�||
kr�|
|}||kr�d	||d-t|j�fd!f||<q�d"||fd#|f||<q�||	kr!|	|}||kr�d	|||t|j�fd$|f||<q�d	|||t|j�fd%|f||<q�||kr�|sLd&|f
d'f||<q�|skd&|f
d'f||<q�d(||j�fd)f||<q�|||kr�|r�d&|f
d*f||<q�d+d-||t|j�fd,f||<q�q�
q�
W|||fS(2s�
    Merge wctx and p2 with ancestor pa and generate merge action list

    branchmerge and force are as passed in to update
    matcher = matcher to filter file lists
    acceptremote = accept the incoming changes without prompting
    R�c


S@s
|j�S(
N(
trev(
R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt<lambda>ssresolving manifests
s) branchmerge: %s, force: %s, partial: %s
s% ancestor: %s, local: %s, remote: %s
s.hgsubstatec
3@s$|]}
�j|
�
j
�V
qdS(
N(tsubtdirty(R}R((
R�(s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>0st
+R;sboth renamed from sboth createdR?R~sremote unchangedt
esupdate permissionsR�sremote is newersversions differs%remote directory rename, both createdR
s$remote directory rename - move from slocal copied/moved from R]s
remote deleteR
sprompt changed/deletediR�R>sremote deleteds
other deleteds$local directory rename, both createdR�s"local directory rename - get from sremote copied from sremote moved from R�sremote createdR�sremote created, get or mergesremote recreatingR�sprompt deleted/changedN((R]Ns
remote delete(R>Nsremote deleted(R]Ns
other deleted(R"talwaysR�RUtmanifestRtmergecopiesRotnoteR
tdebugRtR@tvaluesR�tanytsubstatetmatchestdiffR�R�R RR�R6(RR�R�tpaR�R
tmatchertacceptremotetfollowcopiestcopytmovewithdirtdivergetrenamedeleteR�trettm1tm2tmatcopiedR2
R�R>tn1tfl1tn2R

R
R�R�tnolR�((
R�s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt
manifestmerges�	
	
9



#
&






+




































































c	C@s�x�|j�D]�\}\}}}|d
kr_||kr_|
|j
||�
r_d||<q
|dkr
||kr
||j
||�
r
||=q
q
WdS(s[Resolves false conflicts where the nodeid changed but the content
       remained the same.R
R]sprompt sameR�N(R]Nsprompt same(R�R�R"(	RR�R[tancestorR�R>R;R
R
((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt_resolvetrivial�s
"
0

0c
@s�t|�
d
kr_t
||
||d|||||�	\}
}}t||
|||
|	�
n�|jjtd�
|
|td�
jd�|D�
�
f�

i}
d\}}xq
|D]i
}|jjtd�
|�

t
||
|||||||�	\}
}}t||
|||
|	�
|dks>
t|�
t|�
krG
|}n|dksk
t|�
t|�
krt
|}nx�t|
j	��
D]�\}}|\}}}|jj
d|||f�

||
kr|
|}||kr�
||j|�

q|g
||<q�
i
|g
|6|
|<q�
Wq�W|jjtd�
�

i}
xt|
j��
D]�
\}}t|�
d
kr�|j�d\}�
t
�
f
d	��
d
D�
�
r�|jjtd
�
||f�

�
d|
|<qPq�nd|kr|jjtd�
|�

|dd|
|<qPnd
|kr�|d
d�t
�f
d�|d
d
D�
�
r�|jjtd�
|�

�|
|<qPq�n|jjtd�
|�

xTt|j��
D]@\}�
x1�
D])\}}}|jjd||f�

q�Wq�W|j�d\}�
|jjtd�
||f�

�
d|
|<qPqPW|jjtd�
�

t||
||d|
�
|
j�dkr�t|
||�}|
j|�

n|
||fS(sDCalculate the actions needed to merge mctx into wctx using ancestorsi
is5note: merging %s and %s using bids from ancestors %s
s and c
s@s|]}
t|
�
V
qdS(
N(
tstr(R}R
((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>�ss"
calculating bids for ancestor %s
s %s: %s -> %s
s 
auction for merging merge bids
c
3@s|]}
|
�dkV
qd
S(iN((R}R�(
R?(s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>�ss %s: consensus for %s
R~s %s: picking 'keep' action
R�c
3@s|]}
|
�kV
qdS(
N((R}R�(
tga0(s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>�ss %s: picking 'get' action
s% %s: multiple bids for merge action:
s  %s -> %s
s( %s: ambiguous merge - picked %s action
send of auction

N(NN(RBRD
R
RoR,
R
RR"R�R�R-
RVR�tallR�RF
R#
R
R�(RR�R[t	ancestorsR�R
R5
R6
R4
R
R�R9
R:
tfbidsRE
tdiverge1t
renamedelete1R>R�R;R
R
Rztbidst_ft	fractions((RH
R?s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytcalculateupdates�s~



	
	
*







$
	
$
	










 
 

	




$



	


"






c
c@s�
|jj
}tj}|j}|jj}ytj�}Wn1t	k
rm
}
|j
t
jkrd�nd	}n
Xd
}x�|
D]�\}	}
}|jj
d|	|f�

|r�|jjtd�
|	�

n||	�

y|||	�
dt�


Wn6t	k
r#

}
|jjtd�
|	|jf�

n
X|dkrD
||	fV
d
}n|d7}q{W|d
krl
||	fV
n|r�
ytj�
Wq�
t	k
r�

}
|j
t
jkr�
�n|jjtd�
|j�

q�
Xnd	S(
sSapply removes to the working directory

    yields tuples for progress updates
    is
 %s: %s -> r
sremoving %s
R�s update failed to remove %s: %s!
idi
sCcurrent directory was removed
(consider changing to repo root: %s)
N(RotverboseRR�twjoinR�R�tostgetcwdtOSErrorRdReR"R-
R,
R
R6R�tstrerrortroot(
RR�RR
tunlinkRS
R�tcwdRfROR>R
R
tinst((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytbatchremovesF
	
	






















	







cc@s�
|jj
}|
j}|j}|j}d
}|jj|dt|�
�

�j

xb
|D]Z
\}\}	}
}|jjd||f�

|r�|jjt	d�
|�

n|
r)
|j
|�
}tj|||�}
y)|jj
|�
r�tj||
�
nWq)
tk
r%

}
|jtjkr&
�q&
q)
Xn|jj|�
ra
|jj|�
ra
|jj|�

n||||�
j�|	dt�

|dkr�
||fV
d
}n|d7}qSWWdQX|d
kr�
||fV
ndS(	suapply gets to the working directory

    mctx is the context to get from

    yields tuples for progress updates
    it
expectedcounts
 %s: %s -> g
sgetting %s
tbackgroundcloseidi
N(RoRR
R�R�R�tbackgroundclosingRBR-
R,
R
RS
RtorigpathR�RtrenameRV
RdRetisdirtislinkt
removedirsRR6(RR[R�RR
tfctxR�RoROR>R�R

R
tabsftorigR(
((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytbatchget5s8
	
	
	














%

"


	


c5
C@sd+\}}}tj
||j�j�|j�|�}	g}
x$|
j�D]\}}|j�
qLWt|
d�
}
|
jt|
d�
�

|
j|
d�

x
|
D]
\}}}|\}}}}}|dkr�q�n|d,kr�t	j
||�}n$|jjd||f�

||}|d,krA
t	j
||�}n
||}||}||krn
||}n|j
|dt�

}|	j||||�
||kr�|r�|
j|�

q�q�W|jj}td�
}td	�
}|jj}x`|
D]X}tjj|j|�
�
r�
|jjd
|�

||�

tj|j|�
�

q�
q�
Wtd�|
j�D�
�
}g|
dD]}|d
dkry|^qyr�tj||||||�
nd
} tj|jd
t|f
|
d�}!x=|!D]5\}"}#| |"7} ||| d|#d|d|�
q�Wt |
d�
}tj|jd
t!||f|
d�}!x=|!D]5\}"}#| |"7} ||| d|#d|d|�
qdWt |
d�
}g|
dD]}|d
dkr�|^q�r�tj||||||�
nx^|
dD]R\}}}|jjd||f�

| d7} ||| d|d|d|�
qWx^|
dD]R\}}}|jjd||f�

| d7} ||| d|d|d|�
qeWx^|
dD]R\}}}|jjd||f�

| d7} ||| d|d|d|�
q�Wx5|
dD])\}}}|jjd||f�

q'Wx�|
dD]�\}}}|jjd||f�

| d7} ||| d|d|d|�
|\}$}%|jj"td�
|$|f�

||�

|j#||j
|$�
j$�|%�
tj|j|$�
�

|d7}q_Wx�|
dD]�\}}}|jjd||f�

| d7} ||| d|d|d|�
|\}$}%|jj"td �
|$|f�

|j#||j
|$�
j$�|%�
|d7}q8Wx�|
d!D]�\}}}|jjd"||f�

| d7} ||| d|d|d|�
|\
}%||�

tj%|j|�
d#|%kd$|%k�
|d7}q�W|o�|
o�|	j&}&|&rO|	j'�
t(||	|d%|�
}'t)|	j*��
}(|'s
|||t+t |(�
d�fSg})x<|
D]4\}}}||(kr|)j|||f�

qqW|)}
ng}*x�|
D]�\}}}|jjd&||f�

| d7} ||| d|d|d|�
|dkr�tj||||j,|�
||�
q\n||�

|	j-||�\}+},|+s\|d7}|*j|||f�

q\q\Wxj|*D]b\}}}|jjd'||f�

| d7} ||| d|d|d|�
|	j.||�
q;	W|	j'�
|	j/�}-|&r
|-r
|	j0�d(kr
t1||	|d%|�
s
t+|-d�}-n|	j'�
n|	j2�\}.}/}0||.7}||/7}||07}|	j3�}1|1r�
t)d)�|
dD�
�
}2xB|1j4�D]4\}3}4|
|3j|4�

|2j5d*�|4D�
�

qy
Wg|
dD]}|d
|2kr�
|^q�
|
d<n||d,d|d|�
||||-fS(-s
apply the merge action list to the working directory

    wctx is the working copy context
    mctx is the context to be merged into the working copy

    Return a tuple of counts (updated, merged, removed, unresolved) that
    describes how many files were affected by the update.
    iR
R�R;s.hgsubstates! preserving %s for resolve of %s
R�tupdatingR�sremoving %s
c
s@s-|]#\}
}|
dkrt|�
V
qd
S(R~N(
RB(R}R;R?((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>�sR]g����MbP?titemttotaltunitR�R>s
 %s: %s -> f
i
R�s
 %s: %s -> a
R�s %s: %s -> am
R~s
 %s: %s -> k
R
s %s: %s -> dm
smoving %s to %s
R�s %s: %s -> dg
sgetting %s to %s
R(
s
 %s: %s -> e
R?R�Rs %s: %s -> m (premerge)
s %s: %s -> m (merge)
R(c
s@s|]}
|
dV
qd
S(iN((R}R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>sc
s@s|]}
|
dV
qd
S(iN((R}R�((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>1s(iiiN(6RRtp1RR�tsortR�textendR"R
R�RoR-
R�RRDRVR�R�R
tprogressRT
R�tlexistsRS
RR�tsumR
tsubmergeRR\
RBRh
R,
R�RtsetflagsR2RyR!
R@R�tmaxRE
R�R�R�RJR"
R�R�R�tdifference_update(5RR�R�R[t	overwriteRR�R�R�RtmovesR;R?tmergeactionsR>R
R
R
R�R
R
R
R�R�R�R�R�t	_updatingt_filesRp
t
numupdatesR�t
ztprogRORj
tf0R�tusemergedrivertproceedtunresolvedft
newactionst
tocompleteR�R]R�t	msupdatedtmsmergedt	msremovedtextraactionstmfilesR~tacts((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytapplyupdates[s


*
































-

%



#
(



#
-




#



#



#






 


"







 
"





	


(









	


































4c
C@s�xL|
jd
g�D]8\}}}|r;|j
j|�

q|j
j|�

qWx3|
jdg�D]\}}}|j
j|�

qbWx3|
jdg�D]\}}}|j
j|�

q�WxL|
jdg�D]8\}}}|r�|j
j|�

q�|j
j|�

q�Wx3|
jdg�D]\}}}|j
j|�

q
Wx#|
jdg�D]\}}}qS
WxL|
jdg�D]8\}}}|r�
|j
j|�

qy
|j
j|�

qy
Wx�|
jdg�D]�\}}}|\}}}}	}
|rb|j
j|�

||kr�|	r'|j
j|�

n||krI|j
j	||�
q_|j
j	||�
q�q�
||kr�|j
j|�

n|	r�
|j
j|�

q�
q�
Wx�|
jd	g�D]w\}}}|\}}|r|j
j|�

|j
j|�

|j
j	||�
q�|j
j|�

|j
j|�

q�Wxk|
jd
g�D]W\}}}|\}}|r�|j
j|�

|j
j	||�
q?|j
j|�

q?WdS(s$record merge actions to the dirstateR]R>R�R�R(
R~R�R;R
R�N(
R�R�tremovetdropRDtnormallookuptotherparenttnormalR*R7
(
RR�R�R>R
R
R
R�R
R
R
R
tflag((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR�9s`"

"
"
"

"
"
"

"









"





"



c	1C@s	|
}	|d5ks|j
�r't}
nt}
|j���
|d5}|j�}|d
}
d5g
}|d5k	r||g
}n|
d5kr�|jjdd�
tj	|�
\}}}||j
�}
n|o�|}||
}|d
d5kr
|jjdddg
�dg
krd
|jj
|
j
�|j
��}gt|�
pJ
tg
D]}||^qK
}q
|
j|d|�

g
}n|
j
�|j
�t|
�
t|�
f\}}}}|s!t|�
dkr�
tjtd	�
�
�
ntj|�
}t|j��
r!tjtd
�
�
�
q!n|r||g
krNtjtd�
�
�
nU||
g
kr�|r�|
j�|j�kr�tjtd�
d
td�
�

�
q�n|r�|j�s�|j�r�tjtd�
d
td�
�

�
nx�
t|j�
D]}|j|�
j�
q�Wn]
|ss|
|krj|j ddtd|dd�

|j dd|dddd
�

d7S||
g
|g
fkrs|j!dt�
}|s�|	d5krdt"j#||
j
�g
�}||
j
�|kr�|
g
}qm|r4td�
}|	d5krtd�
}ntd�
}tj|d
|�

�
qmtd�
}td�
}tj|d
|�

�
qp|
g
}qsn|jj$ddt�} |r�|g
}t} n.||g
kr�|
g
}n|d
s�t} n|r�|j!dt�
r�t} nt%|||||||| d|d|�\}!}"}#d |!krEd }$|!|$\}%}&}t&j'|�
}'|$|'d!<|%d"kr�|jj(td#�
|'d
�r�d8|!|$<qB|$|
kr�d9|!|$<qBd:|!|$<qE|%d)krE|&\}(})}*}+}||)j)�},|jj(td*�
|'d
�d
kr8d+|,tfd,f|!|$<qB|!|$=qEnt*d-�d.j+�D�
�
}-xV|!j,�D]H\}$\}%}&}|%|-kr�g|-|%<n|-|%j-|$|&|f�

qnWt.j/|j0�
s$|r|s�|j!dtd/t�rt1||j2�d5�
q$t1||j2�|-�
nx_t|"j,��
D]K\}$}.|jj3td0�
|$�

x"|.D]}/|jj3d1|/�

qdWq7Wx_t|#j,��
D]K\}$}.|jj3td2�
|$�

x"|.D]}/|jj3d1|/�

q�Wq�W|s|t|df\}}}}n|
sP|j ddtd|d|�

|j4j5d3|j6��
nt7||-|||d4|�
}0|
s�|j8j9�
|j:||�
t;||-|�
t.j<|j=d3�
�

|s�|j8j>|j��

n|j8j?�
nWd5QX|
s	|j dd|d|d|0d6�

n|0S(;sq
    Perform a merge between the working directory and the given node

    node = the node to update to, or None if unspecified
    branchmerge = whether to merge between branches
    force = whether to force branch merging or file overwriting
    matcher = a matcher to filter file lists (dirstate not updated)
    mergeancestor = whether it is merging with an ancestor. If true,
      we should accept the incoming changes for any prompts that occur.
      If false, merging with an ancestor (fast-forward) is only allowed
      between different named branches. This flag is used by rebase extension
      as a temporary fix and should be avoided in general.
    labels = labels to use for base, local and other
    mergeforce = whether the merge was run with 'merge --force' (deprecated): if
      this is True, then 'force' should be True as well.

    The table below shows all the behaviors of the update command
    given the -c and -C or no options, whether the working directory
    is dirty, whether a revision is specified, and the relationship of
    the parent rev to the target rev (linear, on the same named
    branch, or on another named branch).

    This logic is tested by test-update-branches.t.

    -c  -C  dirty  rev  |  linear      same    cross
     n   n    n     n   |    ok        (1)       x
     n   n    n     y   |    ok        ok       ok
     n   n    y     n   |   merge      (2)      (2)
     n   n    y     y   |   merge      (3)      (3)
     n   y    *     *   |   discard   discard   discard
     y   n    y     *   |    (4)       (4)      (4)
     y   n    n     *   |    ok        ok       ok
     y   y    *     *   |    (5)       (5)      (5)

    x = can't happen
    * = don't-care
    1 = abort: not a linear update (merge or update --check to force update)
    2 = abort: uncommitted changes (commit and merge, or update --clean to
                 discard changes)
    3 = abort: uncommitted changes (commit or update --clean to discard changes)
    4 = abort: uncommitted changes (checked in commands.py)
    5 = incompatible options (checked in commands.py)

    Return the same tuple as applyupdates().
    isupdate with no targets3.9R*tpreferancestort
*R�i
soutstanding uncommitted mergesoutstanding merge conflictss7merging with a working directory ancestor has no effectsnothing to mergeRns#use 'hg update' or check 'hg heads'suncommitted changessuse 'hg status' to list changest	preupdatetthrowtparent1tparent2RQR�R	tmissings6commit and merge, or update --clean to discard changess+commit or update --clean to discard changessnot a linear updates'merge or update --check to force updateR6
R4
R
s.hgsubstateR>R
sjlocal%(l)s changed %(f)s which other%(o)s deleted
use (c)hanged version or (d)elete?$$ &Changed $$ &DeleteR]s
prompt deleteR�sprompt keepR�R�srother%(o)s changed %(f)s which local%(l)s deleted
use (c)hanged version or leave (d)eleted?$$ &Changed $$ &DeletedR�sprompt recreatingc
s@s|]}
|
gfV
qdS(
N((R}R;((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pys	<genexpr>Dssa am f g cd dc r dm dg m e ktbranchs<note: possible conflict - %s was renamed multiple times to:
s %s
s9note: possible conflict - %s was deleted and renamed to:
tupdatestateRNi(iiii(R]Ns
prompt delete(R�Nsprompt keep(R�Nsprompt keep(@R"R)
R R6twlockRURot
deprecwarnRt
destupdateRt
configlistt	changelogtcommonancestorsheadsR�RRE
RG
RBR	R

R
RRtlistR�R�
R�R�R0
R%
t
bailifchangedthookR&
Rt
foregroundt
configboolRQ
R
t
partextrastpromptchoiceR�tdictRR�RVRtfscasesensitiveR�R 
R*
R�R`R�RR�
R�tbeginparentchanget
setparentsR�RY
Rt	setbranchtendparentchange(1RRR�R
RE
t
mergeancestorRR4
R
R�tpartialtwctplRm
tpasR#
t_markt_actRw
R�tcahsR
tfp1tfp2txp1txp2RR(R&
R�
R
RnR6
tactionbyfileR9
R:
R>R;R
tpromptsR
R�R
R
R�R�tfltnftstats((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyR��s

0
	







	








$
!
/6




























	
	




	

	








	
	










	
	


"
















!








&
c	
C@s
|jj
|d
j�|
j��}t||
j�tt|j�d|d|�}t}|
j�}|r�t|�
dkr�||kr�|j|�

|dj�}n|j	j
�
|j|d
j�|�
|j	j|j
��

tj||
j�|j��
|j	j�
|S(s�
Do a graft-like merge.

    This is a merge where the merge ancestor is chosen such that one
    or more changesets are grafted onto the current changeset. In
    addition to the merge, this fixes up the dirstate to include only
    a single parent (if keepparent is False) and tries to duplicate any
    renames/copies appropriately.

    ctx - changeset to rebase
    pctx - merge base, usually ctx.p1()
    labels - merge labels eg ['local', 'graft']
    keepparent - keep second parent if any

    t
.R�
Rii(R�
t
isancestorRR�R6RRURBR�
R�R�
R�
R�tcurrenttransactionRtduplicatecopiesR#
R�
(	RR�tpctxRt
keepparentR�
R�
tpotherRU((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pytgraftys%!


$








(2t
__future__RRdR�RT
R4tstructti18nR
RRRRRRRQRRR	R
RRR
RRtpackR�tunpackRiRtobjectRR�R"R�R
R
R 
R!
R"
RD
RF
R RQ
R\
Rh
R�
R�R�R�
(((s3/usr/lib/python2.7/dist-packages/mercurial/merge.pyt<module>s@




(@	
		��-	
	P		+	�	

X	-	&�	T
�