^cdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0dd l1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7m8Z8mZm9Z9m:Z:m;Z;dd ldd l9m?Z@mAZBmCZCmDZEmFZFmGZGmHZHmIZJdd lKmLZLmMZMe e!e#eeee%e&e'e"e$e/e+e.e,e*e-e0e8jNdZOe8jPdZQe8jPdZRe8jPdZSejTZUdZVdZWdZXdZYeWeXeYfZZdZ[eSdupe;j\eOdZ]e>j^e=j_e2j`dGddZae>j^e=jbe2j`dGddZcdZdd Zed!Zfe;j\eOd"rd#ZgndZgd$Zhd%Zied&Zjd'ZkGd(dZldS))zStorage back-end for Mercurial. This provides efficient delta storage with O(1) retrieve and append and O(changes) merge between branches. N)binhexnullrevsha1nodeconstantsshortwdirrev)_)getattr) ALL_KINDS CHANGELOGV2COMP_MODE_DEFAULTCOMP_MODE_INLINECOMP_MODE_PLAIN ENTRY_RANKFEATURES_BY_VERSIONFLAG_GENERALDELTAFLAG_INLINE_DATA INDEX_HEADERKIND_CHANGELOG RANK_UNKNOWNREVLOGV0REVLOGV1REVLOGV1_FLAGSREVLOGV2REVLOGV2_FLAGSREVLOG_DEFAULT_FLAGSREVLOG_DEFAULT_FORMATREVLOG_DEFAULT_VERSIONSUPPORTED_FLAGS)REVIDX_DEFAULT_FLAGSREVIDX_ELLIPSISREVIDX_EXTSTOREDREVIDX_FLAGS_ORDERREVIDX_HASCOPIESINFOREVIDX_ISCENSOREDREVIDX_RAWTEXT_CHANGING_FLAGS)attr) ancestordagoperrormdiffpolicypycompat revlogutilstemplatefiltersutil) repositoryr1)deltasdocketflagutilnodemaprandomaccessfilerevlogv0rewritesidedata) storageutil stringutilparsersr)r*revlogic |dfSNFrltexts 2/usr/lib/python3/dist-packages/mercurial/revlog.pyellipsisreadprocessorrF ;c |dfSr@rArBs rEellipsiswriteprocessorrJrGrHcdSr@rArBs rEellipsisrawprocessorrLs 5rHcn|r|d|dS||dS)z}Verify the integrity of the given revlog ``node`` while providing a hook point for extensions to influence the operation.skipreadN)addrevision)rC skipflagsstatenodes rE_verify_revisionrTsE kt$$$$$ DrHBaseIndexObjectT)slotsc\eZdZejZejZejZejZejZ ejZ ejZ ejZ ejZ ejZejdZdS)revlogrevisiondeltaNdefault)__name__ __module__ __qualname__r(ibrSp1nodep2nodebasenodeflagsbaserevisionsizerPdeltar:protocol_flagslinknoderArHrErXrXs 4799D TWYYF TWYYFtwyyH DGIIEtwyytwyyH DGIIEtwyyHTWYYNtwt$$$HHHrHrX)frozencteZdZejdZejdZejdZdS) revlogproblemNrY)r[r\r]r(r^warningr+rSrArHrEririsLdgd###G DGD ! ! !E 474 DDDrHricFt||\}}||fSN)r= parse_index2datainlineindexcaches rEparse_index_v1rss%''f55LE5 %<rHcTt||t\}}||fSN)format)r=rmrrns rEparse_index_v2rws*''fX'FFLE5 %<rHcTt||t\}}||fSru)r=rmr rns rEparse_index_cl_v2rys*''f['IILE5 %<rHparse_index_devel_nodemapcFt||\}}||fSrl)r=rzrns rEparse_index_v1_nodemapr|s%88vFF ue|rHc`t||\}}t||fSrl)rs rustrevlog MixedIndexrns rEparse_index_v1_mixedrs.!$//LE5   ' ' ..rHisNcannot read from revlog %s; expected %d bytes from offset %d, data size is %ds0123456789abcdefABCDEFceZdZdZejZ dxdZdZdydZ dydZ e j d Z e j d Zd Ze j d Ze j d ZdZdZdZdzdZejdZdZdZdZdZdZd{dZdZdZ dZ!dZ"dZ#d Z$d!Z%d"Z&d#Z'd$Z(d%Z)d&Z*d'Z+d(Z,d)Z-d*Z.e.Z/d+Z0d,Z1d-Z2d.Z3d/Z4dyd0Z5d|d1Z6d2Z7d}d3Z8dyd4Z9d}d5Z:d}d6Z;d}d7Zd:Z?d}d;Z@d<ZAd=ZBd>ZCd?ZDd@ZEd~dAZFdBZGdCZHdDZIdEZJddGZKdHZLdydIZMdydJZNd}dKZOdLZPdMZQdNZRdOZSdydPZTdydQZUddRZVdydSZWdTZXdydUZYdVZZddWZ[dXZ\dYZ]ejdZZ^ejd[Z_d\Z`ddeaddfd]Zb dd^Zcd_Zdd`Ze ddaZfdbZgdcZh dddZideZjdfZkdgZldhZmdiZndjZodddepjqdfdkZrdlZsdmZtdnZudoZvhdpZwdetddfdqZxdrZyddtZzduZ{ ddvZ|dwZ}dS)r>ak 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. If mmaplargeindex is True, and an mmapindexthreshold is set, the index will be mmapped rather than read if it is larger than the configured threshold. If censorable is True, the revlog can have censored revisions. If `upperboundcomp` is not None, this is the expected maximal gain from compression for the data content. `concurrencychecker` is an optional function that receives 3 arguments: a file handle, a filename, and an expected position. It should check whether the current position in the file handle is valid, and log/warn/fail (by raising). See mercurial/revlogutils/contants.py for details about the content of an index entry. NFTc ||_||_d|_d|_d|_d|_d|_||_| |_||_ | rtj ||_|dtvsJt|dksJ||_||_||_||_d|_t'jd|_d|_d|_d|_d|_d|_d|_d|_d|_i|_d |_i|_ d |_!d|_"d|_#d|_$d |_%d |_&tOtPj)|_*d|_+d|_,|-| |_.| |_/dS) aJ 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. `target`: a (KIND, ID) tuple that identify the content stored in this revlog. It help the rest of the code to understand what the revlog is about without having to resort to heuristic and index filename analysis. Note: that this must be reliably be set by normal code, but that test, debug, or performance measurement code might not set this to accurate value. Nrd)rrHiTFszlibg?i)0upperboundcompradix _docket_file _indexfile _datafile _sidedatafile _nodemap_filepostfix _trypendingopener nodemaputilget_nodemap_filer lentarget _checkambig_mmaplargeindex _censorable_revisioncacher1 lrucachedict_chainbasecache _chunkcache_chunkcachesize _maxchainlen_deltabothparents _debug_deltarq_docket_nodemap_docket_pcache _compengine_compengineopts_maxdeltachainspan_withsparseread _sparserevlog hassidedata_srdensitythreshold _srmingapsizedictr5flagprocessors_flagprocessors_writinghandles _adding_group _loadindex_concurrencycheckercanonical_parent_order) selfrrrr checkambigmmaplargeindex censorablerpersistentnodemapconcurrencychecker trypendingrs rE__init__zrevlog.__init__!s8-  !! %  D!,!=d!C!CD ayI%%%%6{{a &-%"#055#$ !%!  # "!"$$" #' # $H$;<< $! #5 '=###rHcd}|jj}d|vr|jtkrt}nKd|vrt }n?d|vrt tz}d|vr |tz}nd|jjvrt}nt}d|vr |d|_ d|vr |d|_ d |vr |d |_ t|d d |_d |_|jr(t|d d |_d|vr |d|_d|vr |d|_d|vr|d|jd<d|vr|d|jd<d|vr |d|_|jr d|vr|d}t|dd |_t|dd }|jp||_d|vr |d|_d|vr |d|_|drt6|jt:<|diD] \}}t?j |||j!|j dkr)tCj"tGd|j z|j |j dz zr)tCj"tGd|j z|dd }|||fS)aprocess options (from above/config) to setup associated default revlog mode These values might be affected when actually reading on disk information. The relevant values are returned for use in _loadindex(). * newversionflags: version header to use if we need to create a new revlog * mmapindexthreshold: minimal index size for start to use mmap * force_nodemap: force the usage of a "development" version of the nodemap code Ns changelogv2srevlogv2srevlogv1 generaldeltasrevlogv0schunkcachesizes maxchainlensdeltabothparentss lazydeltaTFs lazydeltabases debug-deltas compengines zlib.levels zstd.levelsmaxdeltachainspansmmapindexthresholds sparse-revlogswith-sparse-readssparse-read-density-thresholdssparse-read-min-gap-sizesenableellipsissflagprocessorsrs0revlog chunk cache size %r is not greater than 0rs.revlog chunk cache size %r is not a power of 2sdevel-force-nodemap)$roptions revlog_kindrr rrrrrrrrrboolget _lazydelta_lazydeltabaserrrrrrrrrellipsisprocessorrr"itemsr5insertflagprocessorr+ RevlogErrorr )rmmapindexthresholdopts new_headerwithsparsereadflag processor force_nodemaps rE _init_optszrevlog._init_optss] "{" T ! !d&6.&H&H$JJ D !JJ D !$44J$&&// DK/ / /!JJ/J  $ $#'(9#:D T ! ! $^ 4D  $ & &%)*=%>D "txx d;;<<# ? J"&txx0@%'H'H"I"ID  T ! ! $^ 4D  D #M2D  D 26}2ED  / D 26}2ED  / 4 ' '&*+?&@D #   =$9T$A$A!%&;!< !$((+;U"C"CDDdhh':EBBCC#1C^ +t 3 3'+,L'MD $ &$ . .!%&A!BD  88% & & F4ED  1 $xx(92>>DDFF P POD)  (y$:N O O O O  1 $ $#EFF&'  !T%9A%= > #CDD&' !7?? -}<|jr-|jd|jzr d|jz}n d|jz}|||_||_nd}d|_| ||}t|dkr*tj |ddd}d|_n|}|d z|_ |d z|_tj|j}|4t#d } | |j|jfz} t'j| |j |zr?t#d } |j d z } | | |j|jfz} t'j| t*|j} | d|j |_| d|j |_| d|_| ds ||_|} nJ||_|jrt5j|||_n!t5j|||j|_|j|j|_d} |jj} | dkrm| |j|| } t| | kr=t#d} | |jt| | fz} t'j| d|_d|_d|_|j=|j |_!|j"|_#n-|jd|jz|_!nd|j|jfz|_!tH|_%|j%j&|_&|jsd|_'d|_(|jo |otRdu}d}tT)|jd}n|jj+d}tX|_-|jt\krt^j0|_-nW|jtbkr td|_-n:|jtfkr th|_-n|r tR|_-n|r tj|_- |-| |j}|\}}|j o|jduotmj7|d}|rotqj9|}|Y|d}t|d|j:kr3|d|j:d|j;kr||_<|j=|n>#t|t~f$r*t'jt#d|jzwxYw||_@tjA|j|jr|jn|j!|jB||_CtjA|j|j#|jB|_DtmjEd|_Fi|_GdS)Ns%s.i.%ss%s.i.as%s.irHTrFis!unknown version (%d) in revlog %ss-unknown flags (%#04x) in version %d revlog %ssinlinerssidedatasdocket) use_pending)rs.too few index data for %s: got %d, expected %ds%s.ds%s.d.%ss rust.indexupdate_nodemap_datasindex %s is corrupted)Hrrrrrexistsrr _initemptyrrrunpack _format_flags_format_versionr rr display_idr+rr_inline _generaldeltarr docketutildefault_docket parse_docketindex_filepath index_endr data_filepathrsidedata_filepathrr nodeconstantsnullidr_storedeltachainsr|r~rrs _parse_indexrr8parse_index_v0rrwr ryrr1 safehasattrrpersisted_datatip_revtip_noderr ValueError IndexErrorrqr7r _segmentfile_segmentfile_sidedatar_chaininfocache_decompressors)rr4rrr entry_point entry_dataheadersupported_flagsmsg display_flagfeatures index_data index_size devel_nodemapuse_rust_indexdrq chunkcache use_nodemap nodemap_datas rErzrevlog._loadindexs!8<8I8I5 & < #$ DL'AAKK   /$+"4"4Y5K"L"L /#dj0KK!DJ.K  !DL +D  J"DO 5GHHJ:""%,Z^<>',,,#&66 -HII#1R7  d&:DOLL',,,*4+?@H.8I.t/ABBDL!:/!:4;M!N!ND ' 4D I& "-' $/!?#-#{555rHc#K|jr|jdVdS||j5}|VddddS#1swxYwYdS)z%file object suitable to read sidedatarN)rrr)rrs rE_sidedatareadfpzrevlog._sidedatareadfps   &q) ) ) ) ) )T/00 B                  sAA A c0t|jdz SNrrrqrs rEtiprevz revlog.tiprevs4:""rHcP||Srl)rSr@rs rEtipz revlog.tipsyy'''rHc<d|cxkot|kncSr)rrrevs rE __contains__zrevlog.__contains__s*C#####d))#####rHc*t|jSrlr?rs rE__len__zrevlog.__len__s4:rHcTttt|Srl)iterrangerrs rE__iter__zrevlog.__iter__sE#d))$$%%%rHrcJtjt|||S)z8iterate over all rev in this revlog (from start to stop)startstop)r;iterrevsr)rrOrPs rErevsz revlog.revss #CIIUFFFFrHcT ||dS#t$rYdSwxYw)NTF)rErrrSs rEhasnodezrevlog.hasnodes=  HHTNNN4   55 s  ''c~||tzs||tzrdSdS)z;whether two revisions (baserev, rev) can be delta-ed or notFT)rbr')rbaserevrEs rEcandeltazrevlog.candeltasB JJw  "? ?  JJsOO; ; 5trHcr|j/|tj|dStj||dSdSrl)rrupdate_persistent_nodemapsetup_persistent_nodemapr transactions rE update_cacheszrevlog.update_cachessI   )"5d;;;;;4[$GGGGG * )rHcd|_|j|j|ji|_d|_|j |j o"|j duotj |jd}|r4tj|}| |d|_|jj|dSdSdS)Nrr)rrclearr clear_cacherrrrq clearcachesrrr1rrrr)rrrs rErbzrevlog.clearcachess" ""$$$ %%''' "..000 #      D"$. D -BCC   >&5d;;L''3A$. . ====  > >''rHc |j|S#t$rtj$rS||jjks||jjvr tjtj ||j tdwxYw)Nno node) rqrE TypeErrorr+rrwdiridwdirfilenodeidsWdirUnsupported LookupErrorrr rTs rErEz revlog.revs J:>>$'' '      J J J*1114-===++#D$/1Z==II I Js A,BcHt|j|ddz S)Nrr)intrqrDs rErOz revlog.start/s 4:c?1%+,,,rHc|j|d}|dkr|Sd|kr5|j|}|ddkr|d|dzS|dz}d|k5dS)Nr rrq)rrE sd_cut_offes rEsidedata_cut_offzrevlog.sidedata_cut_off2sqZ_Q' ?? 3hh 3Atqyytad{" 1HC 3hh qrHc.|j|ddzS)NrrrorDs rErbz revlog.flagsCsz#q!F**rHc(|j|dSr>rorDs rElengthz revlog.lengthFz#q!!rHc:|jsdS|j|dS)Nrrn)rrqrDs rEsidedata_lengthzrevlog.sidedata_lengthIs# 1z#q!!rHc|j|d}|dkr|S||}t|S)z?return the length of the uncompressed text for a given revisionrr)rqrawdatar)rrElrs rErawsizezrevlog.rawsizeNs< JsOA  66H LL  1vv rHc||}|tjtz zdkr||St ||S)z=length of non-raw text (processed by a "read" flag processor)r)rbr5REVIDX_KNOWN_FLAGSr"r|rrP)rrErbs rErz revlog.sizeWsW 3 H//A Ba G G<<$$ $4==%%&&&rHc|j|t}|jtks |tkrdS|t krdS|S)aReturn the rank of a revision if already known, or None otherwise. The rank of a revision is the size of the sub-graph it defines as a head. Equivalently, the rank of a revision `r` is the size of the set `ancestors(r)`, `r` included. This method returns the rank retrieved from the revlog in constant time. It makes no attempt at computing unknown values for versions of the revlog which do not persist the rank. Nr)rqrrr rr)rrEranks rE fast_rankzrevlog.fast_rankasDz#z*  ; . .$,2F2F4 '>>1 rHc|j|}||S|j}|}||d}||kr|}||d}||k||j|<|S)N)rrrq)rrEbaserqiterrevs rE chainbasezrevlog.chainbasessx#'',,  K W~a gooG>!$Dgoo%)S! rHc(|j|dS)NrrorDs rElinkrevzrevlog.linkrevrvrHc |j|}n&#t$r|tkr tjwxYw|jr!|dt kr|d|dfS|d|dfS)N)rqrr r+rhrr)rrEentrys rE parentrevszrevlog.parentrevss JsOEE   g~~++    & &58w+>+>8U1X% %8U1X% %s #3cv |j|dS#t$r|tkr tjwxYw)Nr)rqrr r+rhrDs rErSz revlog.nodesH :c?1% %   g~~++  s#8cX||||zSrl)rOrurDs rEendz revlog.ends#zz#S!1!111rHc|j}|||}|jr9|d|jkr(||dd||ddfS||dd||ddfS)Nrrr)rqrErr)rrSir s rEparentszrevlog.parentss~ J dhhtnn   & *1Q44;+>+>QqT71:q1wqz) )QqT71:q1wqz) )rHc8||dSr) _chaininforDs rEchainlenzrevlog.chainlenss##A&&rHcR|j}||vr||S|j}|j}|}||}d}d}||dkrW|dz }||dz }|r |d}n|dz}||vr||} || dz }|| dz }n||}||dkW||dz }||f} | ||<| S)Nrrr)rrqr) rrEchaininfocacherq generaldeltarrqclencompresseddeltalenrrs rErzrevlog._chaininfos- . !#& & )  'N1oo AID !A$ &  A$1 .(("7+! "ad*"gA1oo !A$ &  % &srHc |j|||jS#t$rYnwxYwg}|j}|j}|}||}||dkrE||kr?|||r |d}n|dz}||}||dkr||k?||krd}n||d}|||fS)aWObtain 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. rrTF)rq deltachainrAttributeErrorappendreverse) rrEstoprevchainrqrrrqstoppeds rE _deltachainzrevlog._deltachains :((gt7IJJ J    D  )  'N1oo'W"4"4 LL ! ! ! A$1 gA 1oo'W"4"4 g  GG LL ! ! !G g~s # 00ct|}|j}|D] }||t |jjrtj}|j}nt j}|j}|||||S)zGenerate the ancestors of 'revs' in reverse revision order. Does not generate revs lower than stoprev. See the documentation for ancestor.lazyancestors for more details.N)r inclusive) listrS rustancestorrqrust_ext_compat LazyAncestorsr) lazyancestors_uncheckedparentrevs)rrRrrcheckrevrrargs rE ancestorszrevlog.ancestorssDzz9  A HQKKKK  # (B #(6M*CC$2M+C}S$9MMMMrHcBtj||j|jSrl)r*descendantrevsrRrrrRs rE descendantszrevlog.descendants s#D$)T_EEErHc|jg}|}fd|D}fd|D}Gdd}||t|t }tjfd|D}|ra| }||vr|| |D]}|vr| ||at|}| fd|DfS)aReturn 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.Nc:g|]}|SrArE.0nrs rE z,revlog.findcommonmissing.. #...!$((1++...rHc:g|]}|SrArrs rErz,revlog.findcommonmissing..!#,,,!,,,rHc,eZdZdZdZdZdZdZdS))revlog.findcommonmissing..lazysetc:t|_||_dSrl)set addedvalues lazyvalues)rrs rErz2revlog.findcommonmissing..lazyset.__init__%s#&55 ",rHc&||jvp||jvSrlrrrvalues rErFz6revlog.findcommonmissing..lazyset.__contains__)s 00LET_4LLrHc3NK|j}|D]}|V|jD] }||vr|V dSrlr)raddedrs rErLz2revlog.findcommonmissing..lazyset.__iter__,sV(AGGGG  A::  rHc:|j|dSrl)rrOrs rErOz-revlog.findcommonmissing..lazyset.add4s $$U+++++rHc:|j|dSrl)rupdate)rvaluess rErz0revlog.findcommonmissing..lazyset.update7s ''/////rHN)r[r\r]rrFrLrOrrArHrElazysetr$sb - - - M M M    , , , 0 0 0 0 0rHrc3$K|] }|v|V dSrlrA)rrhass rE z+revlog.findcommonmissing..@s'!C!Casll!llll!C!CrHc:g|]}|SrArS)rmissrs rErz,revlog.findcommonmissing..Ls#999TYYt__999rH)rheadsrrOrrr collectionsdequepopleftrrrsort) rcommonrrmissingvisitrprs ` @rEfindcommonmissingzrevlog.findcommonmissings >k]F =JJLLE....v...,,,,e,,, 0 0 0 0 0 0 0 0,gdnnV,,--  6%%!!C!C!C!CU!C!C!CCC ( AG|| A++((A|| Q (w-- 999999999rHc|tg}t,|jjr t|j|St j|j|S)aOReturn 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. )rrrqrMissingAncestorsr)incrementalmissingancestorsr)rrs rEincrementalmissingrevszrevlog.incrementalmissingrevsNsM >YF  # (B #00VDD D3DOVLLLrHc|tg}||}||}||S)axReturn 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.Nr)rheadrevsrmissingancestorsrrrincs rEfindmissingrevszrevlog.findmissingrevs^sL >YF =MMOOE)))88##E***rHc|jg}|}fd|D}fd|D}|}fd||DS)a.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.Nc:g|]}|SrArrs rErz&revlog.findmissing..rrHc:g|]}|SrArrs rErz&revlog.findmissing..rrHrc:g|]}|SrArrrrs rErz&revlog.findmissing..s#BBB ! BBBrH)rrrrrs` rE findmissingzrevlog.findmissingvs >k]F =JJLLE....v...,,,,e,,,)))88BBBBc&:&:5&A&ABBBBrHcf gggf}|/t|}|s|Stfd|D}njg}t}|tkr8|6fdDjgtfS|t dz }d i}nXt|}|s|St t|d}t |}tfd|D}|r| }|jkr" |}||krg| vrJ || fd|Dn||vr| || s|S|tkr. fd|D}|rtfd |D}n|St}jg}t |} | }g} t|d |dz D])}|}d} |tkrd } n|| vrRd } ||vrKt%|} | d | vs | d| vr||nMt%|} | d | vs | d| vr| |d } | r\ | vrV| | ||vrd ||< 3d ||<|D]} | | d+d |D}t|}| sJ|sJ|sJ| ||fS)aReturn 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.Nc:g|]}|SrArrs rErz'revlog.nodesbetween..s#888QTXXa[[888rHc:g|]}|SrArrs rErz'revlog.nodesbetween..s#,,,!1,,,rHrFc:g|]}|SrArrs rErz'revlog.nodesbetween..s#>>>adhhqkk>>>rHc*g|]}|jk |SrA)r)rrrs rErz'revlog.nodesbetween..s%LLL11 ;K;KQ;K;K;KrHcg|]}|v| SrArA)rrootrs rErz'revlog.nodesbetween..s#EEE$493D3D3D3D3DrHc:g|]}|SrAr)rrrs rErz'revlog.nodesbetween..s#$F$F$FTXXd^^$F$F$FrHrrNTcg|] \}}|| SrArA)rheadrs rErz'revlog.nodesbetween..)s!>>>*$>>>>rH)rrrrrrrrfromkeysmaxpoprErOrrcopyrRrStupleremoverr)rrootsrnonodes lowestrev highestrev nodestotagrrr orderedout isdescendantrrs` @rE nodesbetweenzrevlog.nodesbetweensn*r2,  KKE 8888%88899II[MEI  u}-,,,t,,, TZZ\\""  =TQJIEEKKE IMM%//EUJ>>>>:>>>??J %NN$$ ##HHQKK >> ))" a((("))LLLL QLLLe ! + %,  7"" FEEE%EEE# #$F$F$F$F$F$F$F G GII#N$  %jj   "" Y!2!2aHH' +' +A ! A LG### k!!# ::dll1oo..A! ++11D1D Q$,,q//**aDK''QqT[-@-@OOA&&&#'L +)"3i!!!$$$)U  $E!HH& $E!H!\\!__++ !T****>> >>>U   E5))rHc|> |jS#t$r|cYSwxYwt,|jjr t|j|St j||jSrl)rqrr _headrevs rustdagoprr*rrs rErzrevlog.headrevs0s < (z**,,,! ( ( (~~''''' (  TZ%? %%dj$77 7~dD$=>>>s >>c6|j|Srl)rqcomputephasesmapsets)rrs rE computephaseszrevlog.computephases:sz..u555rHct|}|stgSdg|dzz}|j}|D]%}d||<||}dx||d<||d<&dt|DS)Nrrrrcg|] \}}|| SrArA)rrvals rErz$revlog._headrevs..Hs!999faS9999rH)rrrq enumerate)rcountisheadrqrrqs rEr zrevlog._headrevs=sD  9  "  , ,AF1IaA*+ +F1Q4L6!A$<<99 & 1 19999rHc8|9|7tsjgSfdDS|t}n|}fd|pgD}t jjj||}fd|DS)areturn 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 Nc:g|]}|SrArrs rErz revlog.heads..Us#:::QDIIaLL:::rHc:h|]}|SrArrs rE zrevlog.heads..\s#444ADHHQKK444rH)startrevstoprevsc:g|]}|SrAr)rrErs rErz revlog.heads..bs#///3 #///rH) rrrrrEr*headrevssubsetrRr)rrOrPrrRs` rErz revlog.headsJs =T\t99 % }$::::$--//::: : =EEHHUOOE4444444# It   0///$////rHc|g}||}||dzD]}d||D}|r4|D]0}||kr(|||1W|t kr(||||S)z!find the children of a given noder)rOc(g|]}|tk |SrA)r)rprs rErz#revlog.children..isFFFBg R rH)rErRrrrSr)rrSr%rrprevsrs rEchildrenzrevlog.childrends  HHTNNQ'' ' 'AFF$//!"4"4FFFE '//BQww1.../g1&&&rHc||||}}|||}tj|j|S)z@calculate all the heads of the common ancestors of nodes a and b)rE_commonancestorsheadsr.maplistrSrabancss rEcommonancestorsheadszrevlog.commonancestorsheadsrsIxx{{DHHQKK1))!Q// 4000rHc |jj|}n.#ttf$rt j|jg|R}YnwxYw|S)z7calculate all the heads of the common ancestors of revs)rqr)r OverflowErrorr)r)rrRr(s rEr#zrevlog._commonancestorsheadsxsb I24:2D9DD . I I I0H4HHHDDD I s (==c||||}}|||S)zgreturn True if node a is an ancestor of node b A revision is considered an ancestor of itself.)rE isancestorrevrr&r's rE isancestorzrevlog.isancestors7xx{{DHHQKK1!!!Q'''rHc|tkrdS||krdS||krdSt|||g|gdS)zreturn True if revision a is an ancestor of revision b A revision is considered an ancestor of itself. The implementation of this is trivial but the use of reachableroots is not.TF) includepath)rrreachablerootsr.s rEr-zrevlog.isancestorrevsW <<4 !VV4 UU5D''A3'GGHHHrHc |j||||S#t$r tj|j||||cYSwxYw)zlreturn (heads(::( and ::))) If includepath is True, return (::).)rqreachableroots2rr*_reachablerootspurer)rminrootrrr1s rEr2zrevlog.reachablerootsss :--{    ,%     s'A A cJ||||}} |j||}n2#ttf$rt j|j||}YnwxYw|r"tt|j |S|j S)z5calculate the "best" common ancestor of nodes a and b) rErqrrr+r)rrmaprSrr%s rEr)zrevlog.ancestorsxx{{DHHQKK1 =:''1--DD . = = =%doq!<> !M*    D  r77a$,44 4 4 2ww NE$56     5 4s7 A""A43A48A+C$$C87C8%EE! E!cxjj}d} j}|r|r|rd}n|S|r t jdSn:#t j$rtddsd}Ynttf$rYnwxYw|r(t j j tdjvr jSt!dkr=t!dzdz} t!dzdkrdt"vrdSt%d|fd jD}fd |D}jjr|jt!|dkrUt!|d kr|s|dj<|dSt j j td|r t jdS#t,j$rYdSwxYwdS) NFT filteredrevssambiguous identifier(rrrcVg|]%}|d|d&S)r) startswith)rrqprefixs rErz(revlog._partialmatch..s2JJJq!A$//&2I2IJadJJJrHcg|];}t|$|9|.sTSVV%6%6r%:%:?C||ArHr)rwdirhexrCrq partialmatchrUr+rhrr rrAmbiguousPrefixLookupErrorrr rr hexdigitsrnullhexrrrr<)rr= maybewdir ambiguouspartialr{nlrDs`` @rE _partialmatchzrevlog._partialmatchs&.99"==   j--b11G 4<<00 # $II"N ++t  ! ! !466 !  +    D   2DOQ'>%?%?    <# # r77b==B1 q A r77Q;??rFi//#tRVKJJJDJJJJ!%-88<<+IIdk***r77Q;;2ww!||I|+-a5 R(!!u :DOQ/F-G-G0//t%>     =s57A/A//"B&B&%B&%H$:H$$H76H7c||}||S||}|r|Stj||jt d)z{locate a node based on: - revision number or str(revision number) - nodeid or subset of hex nodeid Nsno match found)r>rOr+rirr )rr=rs rElookupz revlog.lookups] KKOO =H   r " "  HDOQ7H5I5IJJJrHrcfd}dt}fd}tdds tj|}|||S#t j$r;jjkr(t j j tdYnt$rYnwxYwjjkr.isvalid#s "0088 3   uu(   tt "'doq}}MMM4s===cXtdtj|DS)Nc3"K|] }|dkV dS)fNrA)rr%s rErz5revlog.shortest..maybewdir..0s&GGQqDyGGGGGGrH)allr. iterbytestr)rDs rErKz"revlog.shortest..maybewdir/s*GG(*>v*F*FGGGGG GrHct|t|dzD]}|d|}|s|cSdS)zDisambiguate against wdirid.rN)rKr)hexnode minlengthrurDrKs rE disambiguatez%revlog.shortest..disambiguate4s_ 3w<g|]}|S)ro)rr)rrErirs rErz"revlog._chunks..s)EEEC CB //EEErHrrnrp)rOrurrqrfr1rrr deltautil slicechunkrlr+r$r&rrrr+r)rrRrirtrOrurpiosizerr{ladd slicedchunks revschunkfirstrevlastrevoffsetrodecomp def_decomprE chunkstart chunklength comp_moder%rs` ` rE_chunkszrevlog._chunkssE I & x#  7LL$/dzL&! 1! 1I |H$TTrT?  6'??a''E( F#66xR6PP   F F FFEEEE9EEEEEEEE F _F+J  1 1"U3ZZ 537f"44J$fSkk  JsOB/ F4f!4kBB//DGGGG"222DOOOO"333DA''''8C9$C+C000! 1$s B((CCc^|j|d}||krtS|jr|S|dz S)z(return deltaparent of the given revisionrr)rqrr)rrErs rE deltaparentzrevlog.deltaparents9z#q! 3;;N   K7NrHc|js||tkStj|jdr&|jj|_||S|tkrdS|j|}|d}||krdS|tkrdS|d}||dkr7||}||krn|}||dk7|d}||dkr7||}||krn|}||dk7||ks||krdS||S)ztells whether rev is a snapshots issnapshotTrrrrF)rrrr1rrq issnapshotru)rrErrrbr'rcs rErzrevlog.issnapshotsw! (##C((G3 3  dj- 8 8 ("j3DO??3'' ' '>>4 3Qx 3;;4 7??4 1Xkk"oo""  $$ABwwB kk"oo"" 1Xkk"oo""  $$ABwwB kk"oo"" 2::5t$$$rHc||stjdt||ddz S)z/number of snapshot in the chain before this onesrevision %d not a snapshotrr)rr+ProgrammingErrorrrrDs rE snapshotdepthzrevlog.snapshotdepthsOs## H()FGG G4##C((+,,q00rHc|tkr;|||kr"t||St j||||S)zreturn or calculate a delta between two revisions The delta calculated is in binary form and is intended to be written to revlog data directly. So this function needs raw revision data. )rrbytesrrr,textdiffrz)rrev1rev2s rErevdiffzrevlog.revdiffsi 7??t//55==T**++ +~dll400$,,t2D2DEEErHc.|||S)zreturn an uncompressed revision of a given node or revision number. _df - an existing file handle to read from. (internal-only)  _revisiondatar nodeorrev_dfs rErPzrevlog.revisions !!)S111rHct|tr|}n||}||S)za map of extra data related to the changeset but not part of the hash This function currently return a dictionary. However, more advanced mapping object will likely be used in the future for a more efficient/lazy code. )r:rkrE _sidedata)rrrrEs rEr:zrevlog.sidedatas@ i % % &CC((9%%C~~c"""rHct|tr|}||}n|}d}||jkrdS||||\}}}|r|r|S|||}||}|r |tkr|S|rtj |||} |} ntj |||} | \} } | r| | |||s |||f|_ | S)NrH)rr) r:rkrSr_rawtextrErbr!r5processflagsrawprocessflagsread checkhashr) rrrrawrErSrawtext validatedrb validatehashrDrs rErzrevlog._revisiondata(s8 i % % C99S>>DDDC 4;  3#'--cs-"C"CWi  9 N ;((4..C 3  "666N  ##3D'5IILDD)$??A!" D,  0 NN43N / / / 7#'g"6D  rHcd}d}|jr.|jd|kr||jddfS|jd}|||}|||\}}|r |jd}d|_d}|j|d} d| krd| z}||||} |t | d}| dd} t j|| } ~|| d fS) zjreturn the possibly unvalidated rawtext for a revision returns (rev, rawtext, validated) NrrTr)rr)rirtF)rrErrqrrr,patches) rrSrEr cachedrevbasetextrrrtr|binsrs rErzrevlog._rawtextTs     /"1%--T03T::+A.I ;((4..C))#y)AAw  .*1-H# *S/!$ <<WJ||Ecj|AA  T!W~~H8D-$// We$$rHcz|j|}|d}|d}|jr||jjd|zzz }|dkriS|jj||zkr9|j}|jj}|}|}t ||||fz} tj| |j ||} |j|d} | tkr| } n]| tkr| | } n<| tkr|| } nd} | | z} tj| t!j| }|S)z0Return the sidedata for a given revision number.rmrnrr rp)rqrrfr sidedata_endrFILE_TOO_SHORT_MSGr+rrrgrrr&rr$ sidedatautildeserialize_sidedata)rrE index_entrysidedata_offset sidedata_sizefilenamerr~rum comp_segmentcompsegmentrr:s rErzrevlog._sidedatas\jo %a.#A < A tz4C@ @O A  I < $'F F F)H,+C$F"F"h%DDA#A&& &1<< ]  z#r" ? " ""GG & & &((66GG % % %ool33GG0C 4KC#C(( (4W==rHc2|||dS)zreturn an uncompressed raw data of a given node or revision number. _df - an existing file handle to read from. (internal-only) T)rrrs rErzzrevlog.rawdatas !!)Sd!;;;rHc.tj|||S)zyCompute a node hash. Available as a function so that subclasses can replace the hash as needed. )r;ra)rrDrbrcs rEhashz revlog.hashs +D"b999rHc  ||||\}}|||||kr|jr|jd|krd|_|}|!tjt |}t jtd|j tj |fzdS#t j$r8|j r/tj|rt j|j ||wxYw)zCheck node hash integrity. Available as a function so that subclasses can extend hash mismatch behaviors as needed. Nrsintegrity check failed on %s:%s)rrrr0rrr+rr rr.bytestrrr;iscensoredtextCensoredNodeError)rrDrSrbrcrE revornodes rErzrevlog.checkhashs%  zbjd++Btyyr2....&/4+>q+AT+I+I*.D' $ / 5c$ii @ @I'899(8(C(CDE/."     KK$>t$D$D K-dotTJJJ  s B8B<4::g+>+>???# @ @ @ @ @ @ @ @ @ @ @ @ @ @ @, JJt$*2G(G H H H  0T : : : 0 A $!!D    ++--(+Wd';$3:!0 " #"w" #sW2NA8G > N GNGN-C K NKN K!BNN,cdS)z0called when trying to add a node already stored.NrA)rr]rSs rE_nodeduplicatecallbackzrevlog._nodeduplicatecallback1srHc#K|j5|j5dVdddn #1swxYwYddddS#1swxYwYdS)zCContext manager that keeps data and sidedata files open for readingN)rreadingrrs rErzrevlog.reading4s  & & ( (  +3355                                   s3AA AA AA AA#&A#c#tK|jr d}||jz}tj||jdVdSdx}x}} t |}d}|r||dz }d}|js |d}|j !| dtj n*| |j j tjn%#t$r|d}YnwxYw||j||j|J ||jd}| |j jtjn,#t$r||jd}YnwxYw||j|j j||jjz}|}|jr||j||zn||j||||f|_|jr|n||j_||j_dV|j ||d|_d|j_d|j_||||||dSdS#d|_d|j_d|j_||||||wwxYw)Ns)try to write in a `trypending` revlog: %srrr-r.r))rrr+rrrrrr:rr/r0r1data_endr2rrOrrrrrqrfrrrrr _write_docketr) rr]rrdfhsdfhrdsizeisizes rE_writingzrevlog._writing;sV   .>C 4? "C(-- -   + EEEEE# #C ##6 II, HHQUOOE| ;2"ll511</HHQ 4444HHT\%:BKHHH,222"ll5112OODNE:::%1???K#{{4+=E{JJ!:BKHHHH,KKK#{{4+=E{JJKOO*DL,E DJ11++--<<OODOUU]CCCCOODOU;;;(+S$'7$:>,3O33C!0<@*9<+&&{333'+$37!0<@*9?IIKKK#JJLLL?IIKKKKK#?(,$37!0<@*9?IIKKK#JJLLL?IIKKKK#sW4K3A'CKC=:K<C==)K'AE.-K.&FKFCKA$L7c:|j|dS)zwrite the current docket on disk Exist as a method to help changelog to implement transaction logic We could also imagine using the same transaction logic for all revlog since docket are cheap.N)rrr\s rErzrevlog._write_docket}s  ;'''''rHc |tkr)tjtd|jz| i} n*| r(|js!tjtd|r|p||||}tj |||\} } | |krd}t| tkr8tjtd|jt| fz|p|| ||}|j |} | | S| r|| ||||| |||||||| |  S)aadd 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) flags - the known flags to set on the revision deltacomputer - an optional deltacomputer instance shared between multiple calls s!attempted to add linkrev -1 to %sNs9trying to add sidedata to a revlog who don't support thems;%s: size of %d bytes exceeds maximum revlog storage of 2GiB)rbrc) cachedelta deltacomputerr:)rr+rr rrrrr5processflagswriter _maxentrysizerqget_revraddrawrevision)rrDr]linkrbrcrrSrbrr:rrrEs rE addrevisionzrevlog.addrevisions6 7??#677$/I   HH  d. (NOO   32499T2r22D ( :4u M M d??J w<<- ' '#R?CLL12 1tyy"b11j  && ?J  8 NN7DRBN 7 7 7""       !'#   rHc ||5|||||||||| |  cdddS#1swxYwYdS)zadd a raw revision with known flags, node and parents useful when reusing a revision not stored in this revlog (ex: received over wire, or read from an external bundle). rr:N)r _addrevision) rrr]rrbrcrSrbrrr:s rErzrevlog.addrawrevisions"]]; ' '  $$+!%                    sAA Acz|sd|fS|j|}|rd|fS|dddkrd|fSd|fS)z6Generate a possibly-compressed representation of data.rHrru)r!compress)rro compresseds rErzrevlog.compresssc 9 %..t44  # ? " !9  9 TzrHc~|s|S|dd}|dkr] t|S#tj$r;}tjt dt j|zd}~wwxYw|dkr|S|dkrtj|dS| |}| |S)zDecompress a revlog chunk. The chunk is expected to begin with a header identifying the format type so it can be routed to an appropriate decompressor. rrxsrevlog decompress error: %sNrr) _zlibdecompresszlibr+rr r< forcebytestrr1rrr$)rrorrqrs rEr$zrevlog.decompress s  K. 1I 99 &t,,,:   '455 -a001  %ZZK $YY;tQ'' '++A.. $$T***s%A/6A**A/c  ||jkr)tjtd|jz||jjks||jjvr)tjtd|jz|jd} tj | |j r|jd} n |jd} |g}t|}|dz }| |}|j r|j\}}}|j r-| ||j|||jjzznE| ||j||jjz| ||j|||||}}|;t'jt*||d|d}nt|}| &d}|jr|j}t3j||} t7j|||||||}| || }t<}|j&|jj }t3j!||}|\}}t<}| r|j"rtF}tIj%| }|jj&} |'|\}!}"|!dkr]|"ddd krOt|"t|kr/|!rJ|"dd|jj kr tP}|"}nt<}|"}nd }d} tR}#|j*tVkr||ftXtXfkrd}#n|tXkr$|tXkrd|-|z}#n|tXkr$|tXkrd|-|z}#nt\.|jj/r"t\0|j||}#n^tc||f\}$}%d|-|%z}#|#ted |3|%g|$gDz }#t7j4|||j5|||j6||||| t|||# }&|j7|&|j8|}'|dkr5|j.|j9|j*z}(|j:|(}(|(|'z}'|;||'|j<|||| |d}| r|| =|| }t}|t~kr |||f|_@|jA|jB|<|S) ainternal function to add revisions to the log see addrevision for argument descriptions. note: "addrevision" takes non-raw text, "_addrevision" takes raw text. if "deltacomputer" is not provided or None, a defaultdeltacomputer will be used. invariants: - rawtext is optional (can be None); if not set, cachedelta must be set. if both are set, they must correspond to each other. s %s: attempt to add null revisions %s: attempt to add wdir revisionN1adding revision outside `revlog._writing` contextrr write_debugrrrHc3K|]}dVdS)rNrA)rr s rErz&revlog._addrevision.. s"PPaPPPPPPrH)rb data_offsetdata_compressed_lengthdata_uncompressed_lengthdata_compression_modedata_delta_baselink_rev parent_rev_1 parent_rev_2node_idrsidedata_compressed_lengthsidedata_compression_moder)Crr+rr rrrfrgrrrr_get_data_offsetrrrqrfrrEr, patchedsizer>rr_reportrvrr/ revisioninfo finddeltainforrr#delta_compressionrrrserialize_sidedatarrrrrr rrr rrsortedsumrrdeltalenrrrrr _writeentryro buildtexttyperrrr))rrSrr]rrbrcrbr alwayscacherr:rfhbtextcurrprevr~rrrp1rp2rtextlenrrevinfo deltainforq default_comprrserialized_sidedatarh comp_sidedatarpminpmaxrqrrs) rErzrevlog._addrevision4 s6 4;  #566H  D&- - -t)999#566H    'FC(-- - < )%a(BB%a(B 4yyax&&t,,  # F!1NCd| F((&4$*:O3O*O (($1F*F((dnfEEE88B<<"S ?' D*Q-00*Q-GG'llG  K  2)1 %3+M*         "//<< + < #<BL+L)DDA*+ ' i$4!  ( (7 %"."A("K"K "l7O#}}-@AA A}T !!A#&%// &&-@)A)AAA !!A#&|>??1B-*7''0@-*7'"%  O  ; . .Szgw///C7NN4>>#...C7NN4>>#...(TZ-G($>>$*c3??DD!'c !3!3JD$t~~d333DCPP4+?+?+O+OPPPPPPD  #,#5%,"2%N+'*+>'?'?&?   " ! ''-- 199-'$*>>FZ++F33FUNE    N       (  ;7?#--gr::G ==E ! !#'w"7D %.%8T" rHcR|j||S|jjS)aReturns the current offset in the (in-transaction) data file. Versions < 2 of the revlog can get this 0(1), revlog v2 needs a docket file to store that information: since sidedata can be rewritten to the end of the data file within a transaction, you can have cases where, for example, rev `n` does not have sidedata while rev `n - 1` does, leading to `n - 1`'s sidedata being written after `n`'s data. TODO cache this in a docket file before getting out of experimental.)rrr)rrs rErzrevlog._get_data_offset s' < 88D>> !<( (rHcF|jd}tj||j\} } } |j!| dt jn*| |jjt j| rR|j!| dt jn*| |jj t j| r*| |jj t jt|dz } |j s| |j||jr| |j|| |j| t|z|dr| |d| |d|r| || |n|| |jjzz }| |j|| || |d| |d|rJ|||j|jd} |jd}|jd}| J|J|J| |j_||j_ ||j_ t-j||dS)Nrrrr)rr+rrr/r0r1rr2rrrrrOrrrrrqrfrrrr[)rr]rrorr~r:rrrrrrwh1wh2wh3s rErzrevlog._writeentry s   'FC(-- --S$ <  HHQ $ $ $ $ HHT\+R[ 9 9 9  =|#BK((((. <<<  > IIdl/ = = =4yy1}| 1 OODNF 3 3 3! E 2ODDD OODOTCJJ-> ? ? ?Aw # $q'""" IId1g    % 8$$$ IIe     dTZ22 2F OODOV 4 4 4 IIe    IId1g    IId1g        # #K 0 0 0 < #&q)C&q)C&q)C?????????%(XXZZDL "$'HHJJDL !(+ DL %,[$?????rHc.|jrtjdd|_d} ||5d}|jr|j}t j||} |D]} | \} } } }}}}}||}|pt}|j | }|'| |||r |||d}e| | fD]D}|j |s(tj ||jtdE|j |s(tj ||jtd||}|t$kr||rt)jd}||}t/||z }|d|t1j||kr-tj|j|||s |||r |t:z}|| d||| | |||f|| | }|r |||d} dddn #1swxYwYd|_n #d|_wxYw| S) a\ 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. scannot nest addgroup() callsTNrFsunknown parentsunknown delta bases>lll)rrr:)rr+rrrr rvrr!rqrrhas_noderirr rrEr iscensoredstructcalcsizer|rr,replacediffheaderCensoredBaseErrorrS_peek_iscensoredr&r)rr3 linkmapperr]r addrevisioncbduplicaterevisioncbemptyrrrorSrbrcrf deltabaserdrbr:rrErrWhlenoldlennewlens rEaddgroupzrevlog.addgroupH s(   J()HII I!W '{++T "T "" $6"-"5K ) 7 +!!! #K"K"D  ! %:h//D!9%9E*,,T22C33KEEE.;//c::: %  "X#z22155"'"3 !4:q1B/C/C##  :..y99#/%t:O8P8P#hhy11G'))doog.F.F) &w77!%g!6!6!$Ud!2 $<5+B"F,,#("9 $71C1C##!3T%:%:7E%J%J3!22++# %($/&3!),  C%1% dC000!EEWK"T "T "T "T "T "T "T "T "T "T "T "T "T "T "T "l"'D  D  & & & &ys/JH-I5) J5I99J<I9=J JcN|jsdS||tzS)z%Check if a file revision is censored.F)rrbr&rDs rEr,zrevlog.iscensored s( 5zz#!222rHcJ|jsdStj|||jS)z6Quickly check if a delta produces a censored revision.F)rr;deltaiscensoredr|)rrWrds rEr1zrevlog._peek_iscensored s) 5*5'4<HHHrHctj|t|dz ||j|jS)zfind 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. r)r;resolvestripinforrrr)rminlinks rE getstrippointzrevlog.getstrippoint s> +  IIM MMOO L O    rHc&t|dkrdS||\}}|t|krdS||}|js+||j|||jjz}n|||jjzz}|jr0| |}||j|||j ||j @||j _ ||j _ ||j _|j |dd|_t#jd|_|j|j|j|d=dS)a7truncate 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. rNT) strippingrr)rrArOrrOrrqrfrrrrrrrrrrr1rrrrar)rr@r]rEr rrrs rEstripz revlog.strip s t99>> F##G,,Q #d))   F::c??| ; OODNH 5 5 5 --CCcDJ$99:C   >0055L OOD. = = =--- < #&)DL "$,DL !(4DL % L  {d  ; ; ;##055 %%''' "..000 Js2v   rHcZd}t|r3td|t|dz } |5}|dt j|}dddn #1swxYwY||z }n#t$rd}YnwxYw | |j }|dt j|}| |j j }td||z}|||zz }|jrGd}|D](} |td|| z })d}|t||zz |z }n#t$rd}YnwxYw||fS)zCheck size of index and data files return a (dd, di) tuple. - dd: extra bytes for the "data" file - di: extra bytes for the "index" file A healthy revlog will return (0, 0). rrN)rrrr:r/ior1rrrrrrqrfrru) rexpectedr3actualddsrdi databytesrs rE checksizezrevlog.checksize s t99 71dhhs4yy1}5566H  "1q"+&&& " " " " " " " " " " " " " " "("BB    BBB   DO,,A FF1bk " " "VVXXF GGIII %AAv{##A1q5!B| 8 88AQ A!7!77IIc$ii!m+i7    BBB BxsIB,5B B,BB,"B#B,, B;:B;?CF F&%F&cH|jg}|j"|js||jn||j||jd|jjr||j||j d|jj r||j ||j d|S)NF) include_empty) rrrrrextendrold_index_filepathsrold_data_filepathsrrold_sidedata_filepaths)rress rEfilesz revlog.files1 s   $< + 4>*** JJt( ) ) ) JJt|77e7LL M M M|$ + 4>*** JJt|66U6KK L L L|( / 4-... JJt|:::OO P P P rHc|dvrtjd|z| |jsd}|js|tjkr tj}tj|||t|j |j |j |j |j|||| S)N)snodesstorageslinearNs"unhandled value for nodesorder: %srW) deltaparentfn candeltafn rawsizefn revdifffnflagsfn deltamode revisiondataassumehaveparentrevisionssidedata_helpers)r+rrrr2CG_DELTAMODE_PREVCG_DELTAMODE_FULLr; emitrevisionsrXrrXr|rrb)rnodes nodesorderr^r_r]r`s rErczrevlog.emitrevisionsA s D D D(5 B   d&8 #J& 5Z999"4I(    *}llJ%&?-    rHalwayssamerevsneverfulladd>rhrfrirgc||jvrttd|zt|rttdt |ddrttdt |ddrttd|j}|j}|j} ||jkrd|_d|_n3||j krd|_d|_n||j krd|_d|_|p| |_| ||||||||_||_| |_dS#||_||_| |_wxYw) a]Copy this revlog to another, possibly with format changes. The destination revlog will contain the same revisions and nodes. However, it may not be bit-for-bit identical due to e.g. delta encoding differences. The ``deltareuse`` argument control how deltas from the existing revlog are preserved in the destination revlog. The argument can have the following values: DELTAREUSEALWAYS Deltas will always be reused (if possible), even if the destination revlog would not select the same revisions for the delta. This is the fastest mode of operation. DELTAREUSESAMEREVS Deltas will be reused if the destination revlog would pick the same revisions for the delta. This mode strikes a balance between speed and optimization. DELTAREUSENEVER Deltas will never be reused. This is the slowest mode of execution. This mode can be used to recompute deltas (e.g. if the diff/delta algorithm changes). DELTAREUSEFULLADD Revision will be re-added as if their were new content. This is slower than DELTAREUSEALWAYS but allow more mechanism to kicks in. eg: large file detection and handling. Delta computation can be slow, so the choice of delta reuse policy can significantly affect run time. The default policy (``DELTAREUSESAMEREVS``) strikes a balance between two extremes. Deltas will be reused if they are appropriate. But if the delta could choose a better revision, it will do so. This means if you are converting a non-generaldelta revlog to a generaldelta revlog, deltas will be recomputed if the delta's parent isn't a parent of the revision. In addition to the delta policy, the ``forcedeltabothparents`` argument controls whether to force compute deltas against both parents for merges. By default, the current default is used. See `revlogutil.sidedata.get_sidedata_helpers` for the doc on `sidedata_helpers`. s value for deltareuse invalid: %ssdestination revlog is not emptyr@Ns$source revlog has filtered revisionss)destination revlog has filtered revisionsTF) DELTAREUSEALLrr rr rrrDELTAREUSEALWAYSDELTAREUSESAMEREVSDELTAREUSENEVER_clone) rr destrevlogr3 deltareuseforcedeltabothparentsr` oldlazydeltaoldlazydeltabaseoldamds rEclonez revlog.clonep sj T/ / /566C  z?? DQABBCC C 4 . . IQFGGHH H :~t 4 4 NQKLLMM M", %4- 2T222,0 )(, %%t666,1 )(, %%t333,1 )(- %+@+JFJ ( KK%    %1J !(8J %+1J ( ( (%1J !(8J %+1J ( 1 1 1 1s A0E E"cRd}|jr|j}tj||}|j} |D]} | | } | ddz} | d} | | dd}| | dd}| d}d}d}||jkr||| }|| }|/tj |||| \}}| |d|d zz} | ||| ||||| || n |j rD| | }|tkr$|t|| f}d}|s*|| }|| }||| }|/tj |||| \}}| |d|d zz} ||5||||| ||| ||| dddn #1swxYwY|r ||| |dS) zBperform the core duty of `revlog.clone` after parameter processingNrrrrrrrr)rrSrbrr:r)rr rvrrqDELTAREUSEFULLADDrr:rrun_sidedata_helpersrrrrrrrrr)rrrpr3rqrrr`rrrqrErrbrrbrcrSrrrDr: new_flagsdps rEroz revlog._clone s   %*K!/ #    G /G /C#JE!Hv%EAhGuQx#BuQx#B8DJGT333))#..==--#/,8,M.#--)Xy"IaLIaL=$@@E&&)"/%'    (C))#..BW}}&(% C0@0@*A*A%B !2"0055G#}}S11H##}}S11H#/,8,M.#--)Xy"IaLIaL=$@@E((,,  ++"&3!),                   / dC...OG /G /s H  H H rHc|jtkr)tjt d|jz|jt krt j||||dSt j||||dS)Ns%cannot censor with version %d revlogs) rrr+rr rr9 v1_censor v2_censor)rr censornode tombstones rEcensorrevisionzrevlog.censorrevision. s  8 + +#:;;&'  !X - -  dB I > > > > >  dB I > > > > >rHc #K|\}}|r"ttd|zV|r"ttd|zV|j}||dkr0ttd|j||dfzVt |d<t |d<|D]}||} |d d }|r|||z}t||||| |}t| |} || kr%ttd | |fz| V#tj$rG|d r;ttd| V|d|Yt $rj} ttdt#|t%j| fz| V|d|Yd} ~ d} ~ wwxYwdS)zVerifies the integrity of the revlog. Yields ``revlogproblem`` instances describing problems that are found. sdata length off by %d bytes)r+sindex contains %d extra bytessexpectedversions0warning: '%s' uses revlog format %d; expected %d)rjrNs safe_renameds skipflagsrs unpacked size is %d, %d expected)r+rSserroroncensoredscensored file datasunpacking %s: %sN)rMrir rrrrSrrbrTr|rrzr+rrO Exceptionrr<r) rrRrIrKversionrErSrQl1l2rqs rEverifyintegrityzrevlog.verifyintegrity9 s !!B  Na(F&G&G"&LMMM M M M  Pa(H&I&IB&NOOO O O O& e./ / /MNN?GU3E-FGH    !UUk!$oO -O -C99S>>Dd -!IIlA66 1C0I y%>>>\\#&&d++,,88' CDDBxO! * 1 1 1+,1' 566T+&**4000 - - -#/00T{{J$;A$>$>?@ k"&&t,,,,,,,,  -SO -O -s!"B$FAI I%AI  Ici}|r@jjfg|d<js'|djjf|rg|d<|rt |d<|r2t tjt|d<|r0t fd D|d<|S)Nsexclusivefiless sharedfilessrevisionscounts trackedsizec3VK|]#}j|jV$dSrl)rstatr)rpathrs rErz%revlog.storageinfo.. sG##37   &&.######rHs storedsize) rrrrrrrr8r|rJrU)rexclusivefiles sharedfilesrevisionscount trackedsize storedsizer s` rE storageinfozrevlog.storageinfo s   K%)[$/$B#CA < K#$++T[$.,IJJJ  # "An   -#&t99A  C #C d4jj$A$A B BAn   "####;?::<<###  Am rHc$|jsdS|jrJ|ds |dsdSg}||5|j\}}}||jjtj| } t||dzD]} |j | } tj ||i| \} } tj| }t}|r|jr~t }||\}}|dkrY|ddkrMt%|t%|kr-|rJ|d|jjkr t(}|}n t}|}| ddks | ddkrd }t+j|| d| d| dzz}| t%|||f}|| tj||||| t%|z } | |j_|||j jzt5|D]\}}||z} |j j| g|R|j | }| dkr5|j.|j|jz}|j |}||z}|| ddddS#1swxYwYdS) Nrr)storer`r:rErrrrmrns0rewriting existing sidedata is not supported yet) rrrrr/rrr0r2rrKrqrryrrrrrr#rr+Abortrrrfrreplace_sidedata_inforrrr)rr]helpersrrh new_entriesrrrcurrent_offsetrEr new_sidedatarbr rr!r"rnew_offset_flags entry_updaterrqpackedrs rErewrite_sidedatazrevlog.rewrite_sidedata s  F<qz '!*  F ]]; ' 'G "G "!1NCd HHT\. < < <!YY[[NXvz226 86 8 3&2&G%, '''# e'3&E ''#-=)&@4+;@0?-'+}}5H'I'I$A}T )!,55 ..5H1I1III#$ )!,#|FGG9J52?//8H52?/8q==E!HMMNC+c***$)8eAh%(.B#B "+,,$-    ."+666 .///""<000#&9":"::,0IIKK )) HHX 55 6 6 6!+.. " "1l0 09q99990055!88 4!/$2FFF!Z33F;;F#f_F &!!!! "G "G "G "G "G "G "G "G "G "G "G "G "G "G "G "G "G "G "sJ;LL  L ) NFFFNFNFTrl)r()rN)rF)NN)F)rr@)NNN)FNN)rH)FFFFF)~r[r\r]__doc__r+r_flagserrorclassrrrrr1 propertycacherrrr!r&r+rrr: contextlibcontextmanagerr<r@rBrFrHrLrRrUrXr^rbrErOrrrbrurxr|rrrrrrrSrrrrrrrrrrrrrrr rr!r)r#r/r-r2r)r>rOrQr_rdrlrrrrrrrrPr:rrrrzrrrrrrrr!rrrr$rrrr:r,r1rArDrMrUr2CG_DELTAMODE_STDrcrlrmrnrxrkrvrorrrrrArHrEr>r>s++Z(#_=_=_=_=BP=P=P=d2Z!Z!Z!Z!x      === 777    6666###((($$$&&&GGGG   HHH>>>* J J J$---"+++"""""" '''$   """ & & &&222***'''>''''RNNNN*FFF>:>:>:>:@MMMM ++++0CCCC4^*^*^*^*@????666 : : :00004   111 ((( I I I          D>>>@ K K K15151515fBBB F F F FD)))),BBBBH%%%@111 F F F2222 # # # #****X)%)%)%)%V$$$L<<<<:::>\ \ \ |??? ? ? ? B(((  "L L L L n>   0+0+0+xCCCCJ ) ) )?@?@?@L qqqqf333III    000d&&&P&"'-% % % % N!$O"BBBM %"a2a2a2a2FY/Y/Y/v ? ? ? ?g-g-g-V >R"R"R"R"R"rH)mrrrrrFr0r-rrSrrrrrr i18nr r.r revlogutils.constantsr r rrrrrrrrrrrrrrrrrrr revlogutils.flagutilr!r"r#r$r%r&r' thirdpartyr(r)r*r+r,r-r/r0r1 interfacesr2 interfaceutilr3rvr4rr5r6rr7r8r9r:rutilsr;r< importmodr= importrustrr r~r$rrrFrJrLrrTrHAS_FAST_PERSISTENT_NODEMAP implementerirevisiondeltarJrXiverifyproblemrirsrwryr|rrrrIr>rArHrErs  .                                             & 9 % % v ,, F g & & V x ( ( /  )48H8H 99 :455d % % % % % % %65 %:455t!!!!!!!65!    4G899" "/// Q; & b0"b0"b0"b0"b0"b0"b0"b0"b0"b0"rH