comparison mercurial/revlog.py @ 43076:2372284d9457

formatting: blacken the codebase

This is using my patch to black
(https://github.com/psf/black/pull/826) so we don't un-wrap collection
literals.

Done with:

  hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S

# skip-blame mass-reformatting only

# no-check-commit reformats foo_bar functions

Differential Revision: https://phab.mercurial-scm.org/D6971

43075:57875cf423c9

    REVIDX_FLAGS_ORDER,
    REVIDX_ISCENSORED,
    REVIDX_RAWTEXT_CHANGING_FLAGS,
    REVIDX_SIDEDATA,
)
from .thirdparty import (
    attr,
)
from . import (
    ancestor,
    dagop,
    error,
    mdiff,

# Flag processors for REVIDX_ELLIPSIS.
def ellipsisreadprocessor(rl, text):
    return text, False, {}

def ellipsiswriteprocessor(rl, text, sidedata):
    return text, False

def ellipsisrawprocessor(rl, text):
    return False

ellipsisprocessor = (
    ellipsisreadprocessor,
    ellipsiswriteprocessor,
    ellipsisrawprocessor,
)

def getoffset(q):
    return int(q >> 16)

def gettype(q):
    return int(q & 0xFFFF)

def offset_type(offset, type):
    if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
        raise ValueError('unknown revlog index flags')
    return int(int(offset) << 16 | type)

@attr.s(slots=True, frozen=True)
class _revisioninfo(object):
    """Information about a revision that allows building its fulltext
    node:       expected hash of the revision

    cachedelta: (baserev, uncompressed_delta) or None
    flags:      flags associated to the revision storage

    One of btext[0] or cachedelta must be set.
    """
    node = attr.ib()
    p1 = attr.ib()
    p2 = attr.ib()
    btext = attr.ib()
    textlen = attr.ib()
    cachedelta = attr.ib()
    flags = attr.ib()

@interfaceutil.implementer(repository.irevisiondelta)
@attr.s(slots=True)
class revlogrevisiondelta(object):
    node = attr.ib()

    baserevisionsize = attr.ib()
    revision = attr.ib()
    delta = attr.ib()
    linknode = attr.ib(default=None)

@interfaceutil.implementer(repository.iverifyproblem)
@attr.s(frozen=True)
class revlogproblem(object):
    warning = attr.ib(default=None)
    error = attr.ib(default=None)
    node = attr.ib(default=None)

# index v0:
#  4 bytes: offset
#  4 bytes: compressed length
#  4 bytes: base rev

# 20 bytes: nodeid
indexformatv0 = struct.Struct(">4l20s20s20s")
indexformatv0_pack = indexformatv0.pack
indexformatv0_unpack = indexformatv0.unpack

class revlogoldindex(list):
    def __getitem__(self, i):
        if i == -1:
            return (0, 0, 0, -1, -1, -1, -1, nullid)
        return list.__getitem__(self, i)

class revlogoldio(object):
    def __init__(self):
        self.size = indexformatv0.size

        index = []
        nodemap = {nullid: nullrev}
        n = off = 0
        l = len(data)
        while off + s <= l:
            cur = data[off:off + s]
            off += s
            e = indexformatv0_unpack(cur)
            # transform to revlogv1 format
            e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
                  nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])
            index.append(e2)
            nodemap[e[6]] = n
            n += 1

        return revlogoldindex(index), nodemap, None

    def packentry(self, entry, node, version, rev):
        if gettype(entry[0]):
            raise error.RevlogError(_('index entry flags need revlog '
                                      'version 1'))
        e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
              node(entry[5]), node(entry[6]), entry[7])
        return indexformatv0_pack(*e2)

# index ng:
#  6 bytes: offset
#  2 bytes: flags
#  4 bytes: compressed length

versionformat_pack = versionformat.pack
versionformat_unpack = versionformat.unpack

# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
# signed integer)
_maxentrysize = 0x7fffffff

class revlogio(object):
    def __init__(self):
        self.size = indexformatng.size

    def packentry(self, entry, node, version, rev):
        p = indexformatng_pack(*entry)
        if rev == 0:
            p = versionformat_pack(version) + p[4:]
        return p

class revlog(object):
    """
    the underlying revision storage object

    compression for the data content.
    """

    _flagserrorclass = error.RevlogError

    def __init__(self, opener, indexfile, datafile=None, checkambig=False,
                 mmaplargeindex=False, censorable=False,
                 upperboundcomp=None):
        """
        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.

        # revlog v0 doesn't have flag processors
        for flag, processor in opts.get(b'flagprocessors', {}).iteritems():
            flagutil.insertflagprocessor(flag, processor, self._flagprocessors)

        if self._chunkcachesize <= 0:
            raise error.RevlogError(_('revlog chunk cache size %r is not '
                                      'greater than 0') % self._chunkcachesize)
        elif self._chunkcachesize & (self._chunkcachesize - 1):
            raise error.RevlogError(_('revlog chunk cache size %r is not a '
                                      'power of 2') % self._chunkcachesize)

        indexdata = ''
        self._initempty = True
        try:
            with self._indexfp() as f:
                if (mmapindexthreshold is not None and
                    self.opener.fstat(f).st_size >= mmapindexthreshold):
                    # TODO: should .close() to release resources without
                    # relying on Python GC
                    indexdata = util.buffer(util.mmapread(f))
                else:
                    indexdata = f.read()

        flags = versionflags & ~0xFFFF
        fmt = versionflags & 0xFFFF

        if fmt == REVLOGV0:
            if flags:
                raise error.RevlogError(_('unknown flags (%#04x) in version %d '
                                          'revlog %s') %
                                        (flags >> 16, fmt, self.indexfile))

            self._inline = False
            self._generaldelta = False

        elif fmt == REVLOGV1:
            if flags & ~REVLOGV1_FLAGS:
                raise error.RevlogError(_('unknown flags (%#04x) in version %d '
                                          'revlog %s') %
                                        (flags >> 16, fmt, self.indexfile))

            self._inline = versionflags & FLAG_INLINE_DATA
            self._generaldelta = versionflags & FLAG_GENERALDELTA

        elif fmt == REVLOGV2:
            if flags & ~REVLOGV2_FLAGS:
                raise error.RevlogError(_('unknown flags (%#04x) in version %d '
                                          'revlog %s') %
                                        (flags >> 16, fmt, self.indexfile))

            self._inline = versionflags & FLAG_INLINE_DATA
            # generaldelta implied by version 2 revlogs.
            self._generaldelta = True

        else:
            raise error.RevlogError(_('unknown version (%d) in revlog %s') %
                                    (fmt, self.indexfile))
        # sparse-revlog can't be on without general-delta (issue6056)
        if not self._generaldelta:
            self._sparserevlog = False

        self._storedeltachains = True

        if self.version == REVLOGV0:
            self._io = revlogoldio()
        try:
            d = self._io.parseindex(indexdata, self._inline)
        except (ValueError, IndexError):
            raise error.RevlogError(_("index %s is corrupted") %
                                    self.indexfile)
        self.index, nodemap, self._chunkcache = d
        if nodemap is not None:
            self.nodemap = self._nodecache = nodemap
        if not self._chunkcache:
            self._chunkclear()

            with func() as fp:
                yield fp

    def tip(self):
        return self.node(len(self.index) - 1)
    def __contains__(self, rev):
        return 0 <= rev < len(self)
    def __len__(self):
        return len(self.index)
    def __iter__(self):
        return iter(pycompat.xrange(len(self)))
    def revs(self, start=0, stop=None):
        """iterate over all rev in this revlog (from start to stop)"""
        return storageutil.iterrevs(len(self), start=start, stop=stop)

    @util.propertycache

        # Disable delta if either rev requires a content-changing flag
        # processor (ex. LFS). This is because such flag processor can alter
        # the rawtext content that the delta will be based on, and two clients
        # could have a same revlog node with different flags (i.e. different
        # rawtext contents) and the delta could be incompatible.
        if ((self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS)
            or (self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS)):
            return False
        return True

    def clearcaches(self):
        self._revisioncache = None

        return self.start(rev) + self.length(rev)

    def parents(self, node):
        i = self.index
        d = i[self.rev(node)]
        return i[d[5]][7], i[d[6]][7] # map revisions to nodes inline

    def chainlen(self, rev):
        return self._chaininfo(rev)[0]

    def _chaininfo(self, rev):

            roots = list(roots)
            if not roots:
                return nonodes
            lowestrev = min([self.rev(n) for n in roots])
        else:
            roots = [nullid] # Everybody's a descendant of nullid
            lowestrev = nullrev
        if (lowestrev == nullrev) and (heads is None):
            # We want _all_ the nodes!
            return ([self.node(r) for r in self], [nullid], list(self.heads()))
        if heads is None:

                r = self.rev(n)
                if r >= lowestrev:
                    if n not in ancestors:
                        # If we are possibly a descendant of one of the roots
                        # and we haven't already been marked as an ancestor
                        ancestors.add(n) # Mark as ancestor
                        # Add non-nullid parents to list of nodes to tag.
                        nodestotag.update([p for p in self.parents(n) if
                                           p != nullid])
                    elif n in heads: # We've seen it before, is it a fake head?
                        # So it is, real heads should not be the ancestors of
                        # any other heads.
                        heads.pop(n)
            if not ancestors:
                return nonodes

        else:
            start = self.rev(start)

        stoprevs = set(self.rev(n) for n in stop or [])

        revs = dagop.headrevssubset(self.revs, self.parentrevs, startrev=start,
                                    stoprevs=stoprevs)

        return [self.node(rev) for rev in revs]

    def children(self, node):
        """find the children of a given node"""

    def _commonancestorsheads(self, *revs):
        """calculate all the heads of the common ancestors of revs"""
        try:
            ancs = self.index.commonancestorsheads(*revs)
        except (AttributeError, OverflowError): # C implementation failed
            ancs = ancestor.commonancestorsheads(self.parentrevs, *revs)
        return ancs

    def isancestor(self, a, b):
        """return True if node a is an ancestor of node b

    def reachableroots(self, minroot, heads, roots, includepath=False):
        """return (heads(::<roots> and <roots>::<heads>))

        If includepath is True, return (<roots>::<heads>)."""
        try:
            return self.index.reachableroots2(minroot, heads, roots,
                                              includepath)
        except AttributeError:
            return dagop._reachablerootspure(self.parentrevs,
                                             minroot, roots, heads, includepath)

    def ancestor(self, a, b):
        """calculate the "best" common ancestor of nodes a and b"""

        a, b = self.rev(a), self.rev(b)

        if len(id) == 20:
            # possibly a binary node
            # odds of a binary node being all hex in ASCII are 1 in 10**25
            try:
                node = id
                self.rev(node) # quick search the index
                return node
            except error.LookupError:
                pass # may be partial hex id
        try:
            # str(rev)
            rev = int(id)
            if "%d" % rev != id:
                raise ValueError

        except error.RevlogError:
            # parsers.c radix tree lookup gave multiple matches
            # fast path: for unfiltered changelog, radix tree is accurate
            if not getattr(self, 'filteredrevs', None):
                raise error.AmbiguousPrefixLookupError(
                    id, self.indexfile, _('ambiguous identifier'))
            # fall through to slow path that filters hidden revisions
        except (AttributeError, ValueError):
            # we are pure python, or key was too short to search radix tree
            pass

        if len(id) <= 40:
            try:
                # hex(node)[:...]
                l = len(id) // 2  # grab an even number of digits
                prefix = bin(id[:l * 2])
                nl = [e[7] for e in self.index if e[7].startswith(prefix)]
                nl = [n for n in nl if hex(n).startswith(id) and
                      self.hasnode(n)]
                if nullhex.startswith(id):
                    nl.append(nullid)
                if len(nl) > 0:
                    if len(nl) == 1 and not maybewdir:
                        self._pcache[id] = nl[0]
                        return nl[0]
                    raise error.AmbiguousPrefixLookupError(
                        id, self.indexfile, _('ambiguous identifier'))
                if maybewdir:
                    raise error.WdirUnsupported
                return None
            except TypeError:
                pass

        raise error.LookupError(id, self.indexfile, _('no match found'))

    def shortest(self, node, minlength=1):
        """Find the shortest unambiguous prefix that matches node."""
        def isvalid(prefix):
            try:
                matchednode = self._partialmatch(prefix)
            except error.AmbiguousPrefixLookupError:
                return False

        # Cache data both forward and backward around the requested
        # data, in a fixed size window. This helps speed up operations
        # involving reading the revlog backwards.
        cachesize = self._chunkcachesize
        realoffset = offset & ~(cachesize - 1)
        reallength = (((offset + length + cachesize) & ~(cachesize - 1))
                      - realoffset)
        with self._datareadfp(df) as df:
            df.seek(realoffset)
            d = df.read(reallength)

        self._cachesegment(realoffset, d)
        if offset != realoffset or reallength != length:
            startoffset = offset - realoffset
            if len(d) - startoffset < length:
                raise error.RevlogError(
                    _('partial read of revlog %s; expected %d bytes from '
                      'offset %d, got %d') %
                    (self.indexfile if self._inline else self.datafile,
                     length, realoffset, len(d) - startoffset))

            return util.buffer(d, startoffset, length)

        if len(d) < length:
            raise error.RevlogError(
                _('partial read of revlog %s; expected %d bytes from offset '
                  '%d, got %d') %
                (self.indexfile if self._inline else self.datafile,
                 length, offset, len(d)))

        return d

    def _getsegment(self, offset, length, df=None):
        """Obtain a segment of raw data from the revlog.

        # is it in the cache?
        cachestart = offset - o
        cacheend = cachestart + length
        if cachestart >= 0 and cacheend <= l:
            if cachestart == 0 and cacheend == l:
                return d # avoid a copy
            return util.buffer(d, cachestart, cacheend - cachestart)

        return self._readsegment(offset, length, df=df)

    def _getsegmentforrevs(self, startrev, endrev, df=None):

        ladd = l.append

        if not self._withsparseread:
            slicedchunks = (revs,)
        else:
            slicedchunks = deltautil.slicechunk(self, revs,
                                                targetsize=targetsize)

        for revschunk in slicedchunks:
            firstrev = revschunk[0]
            # Skip trailing revisions with empty diff
            for lastrev in revschunk[::-1]:

        revlog data directly. So this function needs raw revision data.
        """
        if rev1 != nullrev and self.deltaparent(rev2) == rev1:
            return bytes(self._chunk(rev2))

        return mdiff.textdiff(self.rawdata(rev1),
                              self.rawdata(rev2))

    def _processflags(self, text, flags, operation, raw=False):
        """deprecated entry point to access flag processors"""
        msg = ('_processflag(...) use the specialized variant')
        util.nouideprecwarn(msg, '5.2', stacklevel=2)
        if raw:
            return text, flagutil.processflagsraw(self, text, flags)
        elif operation == 'read':
            return flagutil.processflagsread(self, text, flags)
        else: # write operation
            return flagutil.processflagswrite(self, text, flags)

    def revision(self, nodeorrev, _df=None, raw=False):
        """return an uncompressed revision of a given node or revision
        number.

        raw - an optional argument specifying if the revision data is to be
        treated as raw data when applying flag transforms. 'raw' should be set
        to True when generating changegroups or in debug commands.
        """
        if raw:
            msg = ('revlog.revision(..., raw=True) is deprecated, '
                   'use revlog.rawdata(...)')
            util.nouideprecwarn(msg, '5.2', stacklevel=2)
        return self._revisiondata(nodeorrev, _df, raw=raw)[0]

    def sidedata(self, nodeorrev, _df=None):
        """a map of extra data related to the changeset but not part of the hash

        else:
            try:
                r = flagutil.processflagsread(self, rawtext, flags)
            except error.SidedataHashError as exc:
                msg = _("integrity check failed on %s:%s sidedata key %d")
                msg %= (self.indexfile, pycompat.bytestr(rev),
                        exc.sidedatakey)
                raise error.RevlogError(msg)
            text, validatehash, sidedata = r
        if validatehash:
            self.checkhash(text, node, rev=rev)
        if not validated:

        if basetext is None:
            basetext = bytes(bins[0])
            bins = bins[1:]

        rawtext = mdiff.patches(basetext, bins)
        del basetext # let us have a chance to free memory early
        return (rev, rawtext, False)

    def rawdata(self, nodeorrev, _df=None):
        """return an uncompressed raw data of a given node or revision number.

                    self._revisioncache = None

                revornode = rev
                if revornode is None:
                    revornode = templatefilters.short(hex(node))
                raise error.RevlogError(_("integrity check failed on %s:%s")
                    % (self.indexfile, pycompat.bytestr(revornode)))
        except error.RevlogError:
            if self._censorable and storageutil.iscensoredtext(text):
                raise error.CensoredNodeError(self.indexfile, node, text)
            raise

        This should be called after revisions are added to the revlog. If the
        revlog has grown too large to be an inline revlog, it will convert it
        to use multiple index and data files.
        """
        tiprev = len(self) - 1
        if (not self._inline or
            (self.start(tiprev) + self.length(tiprev)) < _maxinline):
            return

        trinfo = tr.find(self.indexfile)
        if trinfo is None:
            raise error.RevlogError(_("%s not found in the transaction")
                                    % self.indexfile)

        trindex = trinfo[2]
        if trindex is not None:
            dataoff = self.start(trindex)
        else:

    def _nodeduplicatecallback(self, transaction, node):
        """called when trying to add a node already stored.
        """

    def addrevision(self, text, transaction, link, p1, p2, cachedelta=None,
                    node=None, flags=REVIDX_DEFAULT_FLAGS, deltacomputer=None,
                    sidedata=None):
        """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

        flags - the known flags to set on the revision
        deltacomputer - an optional deltacomputer instance shared between
            multiple calls
        """
        if link == nullrev:
            raise error.RevlogError(_("attempted to add linkrev -1 to %s")
                                    % self.indexfile)

        if sidedata is None:
            sidedata = {}
            flags = flags & ~REVIDX_SIDEDATA
        elif not self.hassidedata:
            raise error.ProgrammingError(
                _("trying to add sidedata to a revlog who don't support them")
                )
        else:
            flags |= REVIDX_SIDEDATA

        if flags:
            node = node or self.hash(text, p1, p2)

        rawtext, validatehash = flagutil.processflagswrite(self, text, flags,
                                                           sidedata=sidedata)

        # If the flag processor modifies the revision data, ignore any provided
        # cachedelta.
        if rawtext != text:
            cachedelta = None

        if len(rawtext) > _maxentrysize:
            raise error.RevlogError(
                _("%s: size of %d bytes exceeds maximum revlog storage of 2GiB")
                % (self.indexfile, len(rawtext)))

        node = node or self.hash(rawtext, p1, p2)
        if node in self.nodemap:
            return node

        if validatehash:
            self.checkhash(rawtext, node, p1=p1, p2=p2)

        return self.addrawrevision(rawtext, transaction, link, p1, p2, node,
                                   flags, cachedelta=cachedelta,
                                   deltacomputer=deltacomputer)

    def addrawrevision(self, rawtext, transaction, link, p1, p2, node, flags,
                       cachedelta=None, deltacomputer=None):
        """add 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).
        """
        dfh = None
        if not self._inline:
            dfh = self._datafp("a+")
        ifh = self._indexfp("a+")
        try:
            return self._addrevision(node, rawtext, transaction, link, p1, p2,
                                     flags, cachedelta, ifh, dfh,
                                     deltacomputer=deltacomputer)
        finally:
            if dfh:
                dfh.close()
            ifh.close()

        if t == 'x':
            try:
                return _zlibdecompress(data)
            except zlib.error as e:
                raise error.RevlogError(_('revlog decompress error: %s') %
                                        stringutil.forcebytestr(e))
        # '\0' is more common than 'u' so it goes first.
        elif t == '\0':
            return data
        elif t == 'u':
            return util.buffer(data, 1)

            except KeyError:
                raise error.RevlogError(_('unknown compression type %r') % t)

        return compressor.decompress(data)

    def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
                     cachedelta, ifh, dfh, alwayscache=False,
                     deltacomputer=None):
        """internal function to add revisions to the log

        see addrevision for argument descriptions.

        note: "addrevision" takes non-raw text, "_addrevision" takes raw text.

        invariants:
        - rawtext is optional (can be None); if not set, cachedelta must be set.
          if both are set, they must correspond to each other.
        """
        if node == nullid:
            raise error.RevlogError(_("%s: attempt to add null revision") %
                                    self.indexfile)
        if node == wdirid or node in wdirfilenodeids:
            raise error.RevlogError(_("%s: attempt to add wdir revision") %
                                    self.indexfile)

        if self._inline:
            fh = ifh
        else:
            fh = dfh

        # become comparable to the uncompressed text
        if rawtext is None:
            # need rawtext size, before changed by flag processors, which is
            # the non-raw size. use revlog explicitly to avoid filelog's extra
            # logic that might remove metadata size.
            textlen = mdiff.patchedsize(revlog.size(self, cachedelta[0]),
                                        cachedelta[1])
        else:
            textlen = len(rawtext)

        if deltacomputer is None:
            deltacomputer = deltautil.deltacomputer(self)

        revinfo = _revisioninfo(node, p1, p2, btext, textlen, cachedelta, flags)

        deltainfo = deltacomputer.finddeltainfo(revinfo, fh)

        e = (offset_type(offset, flags), deltainfo.deltalen, textlen,
             deltainfo.base, link, p1r, p2r, node)
        self.index.append(e)
        self.nodemap[node] = curr

        # Reset the pure node cache start lookup offset to account for new
        # revision.
        if self._nodepos is not None:
            self._nodepos = curr

        entry = self._io.packentry(e, self.node, self.version, curr)
        self._writeentry(transaction, ifh, dfh, entry, deltainfo.data,
                         link, offset)

        rawtext = btext[0]

        if alwayscache and rawtext is None:
            rawtext = deltacomputer.buildtext(revinfo, fh)

        if type(rawtext) == bytes: # only accept immutable objects
            self._revisioncache = (node, curr, rawtext)
        self._chainbasecache[curr] = deltainfo.chainbase
        return node

    def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset):

            dfh = None
        else:
            transaction.add(self.indexfile, isize, r)
            transaction.add(self.datafile, end)
            dfh = self._datafp("a+")
        def flush():
            if dfh:
                dfh.flush()
            ifh.flush()

                    # this can happen if two branches make the same change
                    continue

                for p in (p1, p2):
                    if p not in self.nodemap:
                        raise error.LookupError(p, self.indexfile,
                                                _('unknown parent'))

                if deltabase not in self.nodemap:
                    raise error.LookupError(deltabase, self.indexfile,
                                            _('unknown delta base'))

                baserev = self.rev(deltabase)

                if baserev != nullrev and self.iscensored(baserev):
                    # if base is censored, delta must be full replacement in a
                    # single patch operation
                    hlen = struct.calcsize(">lll")
                    oldlen = self.rawsize(baserev)
                    newlen = len(delta) - hlen
                    if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
                        raise error.CensoredBaseError(self.indexfile,
                                                      self.node(baserev))

                if not flags and self._peek_iscensored(baserev, delta, flush):
                    flags |= REVIDX_ISCENSORED

                # We assume consumers of addrevisioncb will want to retrieve

                # revision(). revision() will fast path if there is a cache
                # hit. So, we tell _addrevision() to always cache in this case.
                # We're only using addgroup() in the context of changegroup
                # generation so the revision data can always be handled as raw
                # by the flagprocessor.
                self._addrevision(node, None, transaction, link,
                                  p1, p2, flags, (baserev, delta),
                                  ifh, dfh,
                                  alwayscache=bool(addrevisioncb),
                                  deltacomputer=deltacomputer)

                if addrevisioncb:
                    addrevisioncb(self, node)

                if not dfh and not self._inline:

        """find the minimum rev that must be stripped to strip the linkrev

        Returns a tuple containing the minimum rev and a set of all revs that
        have linkrevs that will be broken by this strip.
        """
        return storageutil.resolvestripinfo(minlink, len(self) - 1,
                                            self.headrevs(),
                                            self.linkrev, self.parentrevs)

    def strip(self, minlink, transaction):
        """truncate the revlog on the first revision with a linkrev >= minlink

        This function is called when we're stripping revision minlink and

        res = [self.indexfile]
        if not self._inline:
            res.append(self.datafile)
        return res

    def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
                      assumehaveparentrevisions=False,
                      deltamode=repository.CG_DELTAMODE_STD):
        if nodesorder not in ('nodes', 'storage', 'linear', None):
            raise error.ProgrammingError('unhandled value for nodesorder: %s' %
                                         nodesorder)

        if nodesorder is None and not self._generaldelta:
            nodesorder = 'storage'

        if (not self._storedeltachains and
                deltamode != repository.CG_DELTAMODE_PREV):
            deltamode = repository.CG_DELTAMODE_FULL

        return storageutil.emitrevisions(
            self, nodes, nodesorder, revlogrevisiondelta,
            deltaparentfn=self.deltaparent,
            candeltafn=self.candelta,
            rawsizefn=self.rawsize,
            revdifffn=self.revdiff,
            flagsfn=self.flags,
            deltamode=deltamode,
            revisiondata=revisiondata,
            assumehaveparentrevisions=assumehaveparentrevisions)

    DELTAREUSEALWAYS = 'always'
    DELTAREUSESAMEREVS = 'samerevs'
    DELTAREUSENEVER = 'never'

    DELTAREUSEFULLADD = 'fulladd'

    DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'}

    def clone(self, tr, destrevlog, addrevisioncb=None,
            deltareuse=DELTAREUSESAMEREVS, forcedeltabothparents=None):
        """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.

                destrevlog._lazydeltabase = False
                destrevlog._lazydelta = False

            destrevlog._deltabothparents = forcedeltabothparents or oldamd

            self._clone(tr, destrevlog, addrevisioncb, deltareuse,
                        forcedeltabothparents)

        finally:
            destrevlog._lazydelta = oldlazydelta
            destrevlog._lazydeltabase = oldlazydeltabase
            destrevlog._deltabothparents = oldamd

    def _clone(self, tr, destrevlog, addrevisioncb, deltareuse,
               forcedeltabothparents):
        """perform the core duty of `revlog.clone` after parameter processing"""
        deltacomputer = deltautil.deltacomputer(destrevlog)
        index = self.index
        for rev in self:
            entry = index[rev]

            # Some classes override linkrev to take filtered revs into
            # account. Use raw entry from index.
            flags = entry[0] & 0xffff
            linkrev = entry[4]
            p1 = index[entry[5]][7]
            p2 = index[entry[6]][7]
            node = entry[7]

            # the revlog chunk is a delta.
            cachedelta = None
            rawtext = None
            if deltareuse == self.DELTAREUSEFULLADD:
                text = self.revision(rev)
                destrevlog.addrevision(text, tr, linkrev, p1, p2,
                                       cachedelta=cachedelta,
                                       node=node, flags=flags,
                                       deltacomputer=deltacomputer)
            else:
                if destrevlog._lazydelta:
                    dp = self.deltaparent(rev)
                    if dp != nullrev:
                        cachedelta = (dp, bytes(self._chunk(rev)))

                if not cachedelta:
                    rawtext = self.rawdata(rev)

                ifh = destrevlog.opener(destrevlog.indexfile, 'a+',
                                        checkambig=False)
                dfh = None
                if not destrevlog._inline:
                    dfh = destrevlog.opener(destrevlog.datafile, 'a+')
                try:
                    destrevlog._addrevision(node, rawtext, tr, linkrev, p1,
                                            p2, flags, cachedelta, ifh, dfh,
                                            deltacomputer=deltacomputer)
                finally:
                    if dfh:
                        dfh.close()
                    ifh.close()

            if addrevisioncb:
                addrevisioncb(self, rev, node)

    def censorrevision(self, tr, censornode, tombstone=b''):
        if (self.version & 0xFFFF) == REVLOGV0:
            raise error.RevlogError(_('cannot censor with version %d revlogs') %
                                    self.version)

        censorrev = self.rev(censornode)
        tombstone = storageutil.packmeta({b'censored': tombstone}, b'')

        if len(tombstone) > self.rawsize(censorrev):
            raise error.Abort(_('censor tombstone must be no longer than '
                                'censored data'))

        # Rewriting the revlog in place is hard. Our strategy for censoring is
        # to create a new revlog, copy all revisions to it, then replace the
        # revlogs on transaction close.

        newindexfile = self.indexfile + b'.tmpcensored'
        newdatafile = self.datafile + b'.tmpcensored'

        # This is a bit dangerous. We could easily have a mismatch of state.
        newrl = revlog(self.opener, newindexfile, newdatafile,
                       censorable=True)
        newrl.version = self.version
        newrl._generaldelta = self._generaldelta
        newrl._io = self._io

        for rev in self.revs():
            node = self.node(rev)
            p1, p2 = self.parents(node)

            if rev == censorrev:
                newrl.addrawrevision(tombstone, tr, self.linkrev(censorrev),
                                     p1, p2, censornode, REVIDX_ISCENSORED)

                if newrl.deltaparent(rev) != nullrev:
                    raise error.Abort(_('censored revision stored as delta; '
                                        'cannot censor'),
                                      hint=_('censoring of revlogs is not '
                                             'fully implemented; please report '
                                             'this bug'))
                continue

            if self.iscensored(rev):
                if self.deltaparent(rev) != nullrev:
                    raise error.Abort(_('cannot censor due to censored '
                                        'revision having delta stored'))
                rawtext = self._chunk(rev)
            else:
                rawtext = self.rawdata(rev)

            newrl.addrawrevision(rawtext, tr, self.linkrev(rev), p1, p2, node,
                                 self.flags(rev))

        tr.addbackup(self.indexfile, location='store')
        if not self._inline:
            tr.addbackup(self.datafile, location='store')

        version = self.version & 0xFFFF

        # The verifier tells us what version revlog we should be.
        if version != state['expectedversion']:
            yield revlogproblem(
                warning=_("warning: '%s' uses revlog format %d; expected %d") %
                        (self.indexfile, version, state['expectedversion']))

        state['skipread'] = set()

        for rev in self:
            node = self.node(rev)

                l2 = len(self.rawdata(node))

                if l1 != l2:
                    yield revlogproblem(
                        error=_('unpacked size is %d, %d expected') % (l2, l1),
                        node=node)

            except error.CensoredNodeError:
                if state['erroroncensored']:
                    yield revlogproblem(error=_('censored file data'),
                                        node=node)
                    state['skipread'].add(node)
            except Exception as e:
                yield revlogproblem(
                    error=_('unpacking %s: %s') % (short(node),
                                                   stringutil.forcebytestr(e)),
                    node=node)
                state['skipread'].add(node)

    def storageinfo(self, exclusivefiles=False, sharedfiles=False,
                    revisionscount=False, trackedsize=False,
                    storedsize=False):
        d = {}

        if exclusivefiles:
            d['exclusivefiles'] = [(self.opener, self.indexfile)]
            if not self._inline:

        if trackedsize:
            d['trackedsize'] = sum(map(self.rawsize, iter(self)))

        if storedsize:
            d['storedsize'] = sum(self.opener.stat(path).st_size
                                  for path in self.files())

        return d

43076:2372284d9457

    REVIDX_FLAGS_ORDER,
    REVIDX_ISCENSORED,
    REVIDX_RAWTEXT_CHANGING_FLAGS,
    REVIDX_SIDEDATA,
)
from .thirdparty import attr
from . import (
    ancestor,
    dagop,
    error,
    mdiff,

# Flag processors for REVIDX_ELLIPSIS.
def ellipsisreadprocessor(rl, text):
    return text, False, {}


def ellipsiswriteprocessor(rl, text, sidedata):
    return text, False


def ellipsisrawprocessor(rl, text):
    return False


ellipsisprocessor = (
    ellipsisreadprocessor,
    ellipsiswriteprocessor,
    ellipsisrawprocessor,
)


def getoffset(q):
    return int(q >> 16)


def gettype(q):
    return int(q & 0xFFFF)


def offset_type(offset, type):
    if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
        raise ValueError('unknown revlog index flags')
    return int(int(offset) << 16 | type)


@attr.s(slots=True, frozen=True)
class _revisioninfo(object):
    """Information about a revision that allows building its fulltext
    node:       expected hash of the revision

    cachedelta: (baserev, uncompressed_delta) or None
    flags:      flags associated to the revision storage

    One of btext[0] or cachedelta must be set.
    """

    node = attr.ib()
    p1 = attr.ib()
    p2 = attr.ib()
    btext = attr.ib()
    textlen = attr.ib()
    cachedelta = attr.ib()
    flags = attr.ib()


@interfaceutil.implementer(repository.irevisiondelta)
@attr.s(slots=True)
class revlogrevisiondelta(object):
    node = attr.ib()

    baserevisionsize = attr.ib()
    revision = attr.ib()
    delta = attr.ib()
    linknode = attr.ib(default=None)


@interfaceutil.implementer(repository.iverifyproblem)
@attr.s(frozen=True)
class revlogproblem(object):
    warning = attr.ib(default=None)
    error = attr.ib(default=None)
    node = attr.ib(default=None)


# index v0:
#  4 bytes: offset
#  4 bytes: compressed length
#  4 bytes: base rev

# 20 bytes: nodeid
indexformatv0 = struct.Struct(">4l20s20s20s")
indexformatv0_pack = indexformatv0.pack
indexformatv0_unpack = indexformatv0.unpack


class revlogoldindex(list):
    def __getitem__(self, i):
        if i == -1:
            return (0, 0, 0, -1, -1, -1, -1, nullid)
        return list.__getitem__(self, i)


class revlogoldio(object):
    def __init__(self):
        self.size = indexformatv0.size

        index = []
        nodemap = {nullid: nullrev}
        n = off = 0
        l = len(data)
        while off + s <= l:
            cur = data[off : off + s]
            off += s
            e = indexformatv0_unpack(cur)
            # transform to revlogv1 format
            e2 = (
                offset_type(e[0], 0),
                e[1],
                -1,
                e[2],
                e[3],
                nodemap.get(e[4], nullrev),
                nodemap.get(e[5], nullrev),
                e[6],
            )
            index.append(e2)
            nodemap[e[6]] = n
            n += 1

        return revlogoldindex(index), nodemap, None

    def packentry(self, entry, node, version, rev):
        if gettype(entry[0]):
            raise error.RevlogError(
                _('index entry flags need revlog ' 'version 1')
            )
        e2 = (
            getoffset(entry[0]),
            entry[1],
            entry[3],
            entry[4],
            node(entry[5]),
            node(entry[6]),
            entry[7],
        )
        return indexformatv0_pack(*e2)


# index ng:
#  6 bytes: offset
#  2 bytes: flags
#  4 bytes: compressed length

versionformat_pack = versionformat.pack
versionformat_unpack = versionformat.unpack

# corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
# signed integer)
_maxentrysize = 0x7FFFFFFF


class revlogio(object):
    def __init__(self):
        self.size = indexformatng.size

    def packentry(self, entry, node, version, rev):
        p = indexformatng_pack(*entry)
        if rev == 0:
            p = versionformat_pack(version) + p[4:]
        return p


class revlog(object):
    """
    the underlying revision storage object

    compression for the data content.
    """

    _flagserrorclass = error.RevlogError

    def __init__(
        self,
        opener,
        indexfile,
        datafile=None,
        checkambig=False,
        mmaplargeindex=False,
        censorable=False,
        upperboundcomp=None,
    ):
        """
        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.

        # revlog v0 doesn't have flag processors
        for flag, processor in opts.get(b'flagprocessors', {}).iteritems():
            flagutil.insertflagprocessor(flag, processor, self._flagprocessors)

        if self._chunkcachesize <= 0:
            raise error.RevlogError(
                _('revlog chunk cache size %r is not ' 'greater than 0')
                % self._chunkcachesize
            )
        elif self._chunkcachesize & (self._chunkcachesize - 1):
            raise error.RevlogError(
                _('revlog chunk cache size %r is not a ' 'power of 2')
                % self._chunkcachesize
            )

        indexdata = ''
        self._initempty = True
        try:
            with self._indexfp() as f:
                if (
                    mmapindexthreshold is not None
                    and self.opener.fstat(f).st_size >= mmapindexthreshold
                ):
                    # TODO: should .close() to release resources without
                    # relying on Python GC
                    indexdata = util.buffer(util.mmapread(f))
                else:
                    indexdata = f.read()

        flags = versionflags & ~0xFFFF
        fmt = versionflags & 0xFFFF

        if fmt == REVLOGV0:
            if flags:
                raise error.RevlogError(
                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
                    % (flags >> 16, fmt, self.indexfile)
                )

            self._inline = False
            self._generaldelta = False

        elif fmt == REVLOGV1:
            if flags & ~REVLOGV1_FLAGS:
                raise error.RevlogError(
                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
                    % (flags >> 16, fmt, self.indexfile)
                )

            self._inline = versionflags & FLAG_INLINE_DATA
            self._generaldelta = versionflags & FLAG_GENERALDELTA

        elif fmt == REVLOGV2:
            if flags & ~REVLOGV2_FLAGS:
                raise error.RevlogError(
                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
                    % (flags >> 16, fmt, self.indexfile)
                )

            self._inline = versionflags & FLAG_INLINE_DATA
            # generaldelta implied by version 2 revlogs.
            self._generaldelta = True

        else:
            raise error.RevlogError(
                _('unknown version (%d) in revlog %s') % (fmt, self.indexfile)
            )
        # sparse-revlog can't be on without general-delta (issue6056)
        if not self._generaldelta:
            self._sparserevlog = False

        self._storedeltachains = True

        if self.version == REVLOGV0:
            self._io = revlogoldio()
        try:
            d = self._io.parseindex(indexdata, self._inline)
        except (ValueError, IndexError):
            raise error.RevlogError(_("index %s is corrupted") % self.indexfile)
        self.index, nodemap, self._chunkcache = d
        if nodemap is not None:
            self.nodemap = self._nodecache = nodemap
        if not self._chunkcache:
            self._chunkclear()

            with func() as fp:
                yield fp

    def tip(self):
        return self.node(len(self.index) - 1)

    def __contains__(self, rev):
        return 0 <= rev < len(self)

    def __len__(self):
        return len(self.index)

    def __iter__(self):
        return iter(pycompat.xrange(len(self)))

    def revs(self, start=0, stop=None):
        """iterate over all rev in this revlog (from start to stop)"""
        return storageutil.iterrevs(len(self), start=start, stop=stop)

    @util.propertycache

        # Disable delta if either rev requires a content-changing flag
        # processor (ex. LFS). This is because such flag processor can alter
        # the rawtext content that the delta will be based on, and two clients
        # could have a same revlog node with different flags (i.e. different
        # rawtext contents) and the delta could be incompatible.
        if (self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) or (
            self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS
        ):
            return False
        return True

    def clearcaches(self):
        self._revisioncache = None

        return self.start(rev) + self.length(rev)

    def parents(self, node):
        i = self.index
        d = i[self.rev(node)]
        return i[d[5]][7], i[d[6]][7]  # map revisions to nodes inline

    def chainlen(self, rev):
        return self._chaininfo(rev)[0]

    def _chaininfo(self, rev):

            roots = list(roots)
            if not roots:
                return nonodes
            lowestrev = min([self.rev(n) for n in roots])
        else:
            roots = [nullid]  # Everybody's a descendant of nullid
            lowestrev = nullrev
        if (lowestrev == nullrev) and (heads is None):
            # We want _all_ the nodes!
            return ([self.node(r) for r in self], [nullid], list(self.heads()))
        if heads is None:

                r = self.rev(n)
                if r >= lowestrev:
                    if n not in ancestors:
                        # If we are possibly a descendant of one of the roots
                        # and we haven't already been marked as an ancestor
                        ancestors.add(n)  # Mark as ancestor
                        # Add non-nullid parents to list of nodes to tag.
                        nodestotag.update(
                            [p for p in self.parents(n) if p != nullid]
                        )
                    elif n in heads:  # We've seen it before, is it a fake head?
                        # So it is, real heads should not be the ancestors of
                        # any other heads.
                        heads.pop(n)
            if not ancestors:
                return nonodes

        else:
            start = self.rev(start)

        stoprevs = set(self.rev(n) for n in stop or [])

        revs = dagop.headrevssubset(
            self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
        )

        return [self.node(rev) for rev in revs]

    def children(self, node):
        """find the children of a given node"""

    def _commonancestorsheads(self, *revs):
        """calculate all the heads of the common ancestors of revs"""
        try:
            ancs = self.index.commonancestorsheads(*revs)
        except (AttributeError, OverflowError):  # C implementation failed
            ancs = ancestor.commonancestorsheads(self.parentrevs, *revs)
        return ancs

    def isancestor(self, a, b):
        """return True if node a is an ancestor of node b

    def reachableroots(self, minroot, heads, roots, includepath=False):
        """return (heads(::<roots> and <roots>::<heads>))

        If includepath is True, return (<roots>::<heads>)."""
        try:
            return self.index.reachableroots2(
                minroot, heads, roots, includepath
            )
        except AttributeError:
            return dagop._reachablerootspure(
                self.parentrevs, minroot, roots, heads, includepath
            )

    def ancestor(self, a, b):
        """calculate the "best" common ancestor of nodes a and b"""

        a, b = self.rev(a), self.rev(b)

        if len(id) == 20:
            # possibly a binary node
            # odds of a binary node being all hex in ASCII are 1 in 10**25
            try:
                node = id
                self.rev(node)  # quick search the index
                return node
            except error.LookupError:
                pass  # may be partial hex id
        try:
            # str(rev)
            rev = int(id)
            if "%d" % rev != id:
                raise ValueError

        except error.RevlogError:
            # parsers.c radix tree lookup gave multiple matches
            # fast path: for unfiltered changelog, radix tree is accurate
            if not getattr(self, 'filteredrevs', None):
                raise error.AmbiguousPrefixLookupError(
                    id, self.indexfile, _('ambiguous identifier')
                )
            # fall through to slow path that filters hidden revisions
        except (AttributeError, ValueError):
            # we are pure python, or key was too short to search radix tree
            pass

        if len(id) <= 40:
            try:
                # hex(node)[:...]
                l = len(id) // 2  # grab an even number of digits
                prefix = bin(id[: l * 2])
                nl = [e[7] for e in self.index if e[7].startswith(prefix)]
                nl = [
                    n for n in nl if hex(n).startswith(id) and self.hasnode(n)
                ]
                if nullhex.startswith(id):
                    nl.append(nullid)
                if len(nl) > 0:
                    if len(nl) == 1 and not maybewdir:
                        self._pcache[id] = nl[0]
                        return nl[0]
                    raise error.AmbiguousPrefixLookupError(
                        id, self.indexfile, _('ambiguous identifier')
                    )
                if maybewdir:
                    raise error.WdirUnsupported
                return None
            except TypeError:
                pass

        raise error.LookupError(id, self.indexfile, _('no match found'))

    def shortest(self, node, minlength=1):
        """Find the shortest unambiguous prefix that matches node."""

        def isvalid(prefix):
            try:
                matchednode = self._partialmatch(prefix)
            except error.AmbiguousPrefixLookupError:
                return False

        # Cache data both forward and backward around the requested
        # data, in a fixed size window. This helps speed up operations
        # involving reading the revlog backwards.
        cachesize = self._chunkcachesize
        realoffset = offset & ~(cachesize - 1)
        reallength = (
            (offset + length + cachesize) & ~(cachesize - 1)
        ) - realoffset
        with self._datareadfp(df) as df:
            df.seek(realoffset)
            d = df.read(reallength)

        self._cachesegment(realoffset, d)
        if offset != realoffset or reallength != length:
            startoffset = offset - realoffset
            if len(d) - startoffset < length:
                raise error.RevlogError(
                    _(
                        'partial read of revlog %s; expected %d bytes from '
                        'offset %d, got %d'
                    )
                    % (
                        self.indexfile if self._inline else self.datafile,
                        length,
                        realoffset,
                        len(d) - startoffset,
                    )
                )

            return util.buffer(d, startoffset, length)

        if len(d) < length:
            raise error.RevlogError(
                _(
                    'partial read of revlog %s; expected %d bytes from offset '
                    '%d, got %d'
                )
                % (
                    self.indexfile if self._inline else self.datafile,
                    length,
                    offset,
                    len(d),
                )
            )

        return d

    def _getsegment(self, offset, length, df=None):
        """Obtain a segment of raw data from the revlog.

        # is it in the cache?
        cachestart = offset - o
        cacheend = cachestart + length
        if cachestart >= 0 and cacheend <= l:
            if cachestart == 0 and cacheend == l:
                return d  # avoid a copy
            return util.buffer(d, cachestart, cacheend - cachestart)

        return self._readsegment(offset, length, df=df)

    def _getsegmentforrevs(self, startrev, endrev, df=None):

        ladd = l.append

        if not self._withsparseread:
            slicedchunks = (revs,)
        else:
            slicedchunks = deltautil.slicechunk(
                self, revs, targetsize=targetsize
            )

        for revschunk in slicedchunks:
            firstrev = revschunk[0]
            # Skip trailing revisions with empty diff
            for lastrev in revschunk[::-1]:

        revlog data directly. So this function needs raw revision data.
        """
        if rev1 != nullrev and self.deltaparent(rev2) == rev1:
            return bytes(self._chunk(rev2))

        return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))

    def _processflags(self, text, flags, operation, raw=False):
        """deprecated entry point to access flag processors"""
        msg = '_processflag(...) use the specialized variant'
        util.nouideprecwarn(msg, '5.2', stacklevel=2)
        if raw:
            return text, flagutil.processflagsraw(self, text, flags)
        elif operation == 'read':
            return flagutil.processflagsread(self, text, flags)
        else:  # write operation
            return flagutil.processflagswrite(self, text, flags)

    def revision(self, nodeorrev, _df=None, raw=False):
        """return an uncompressed revision of a given node or revision
        number.

        raw - an optional argument specifying if the revision data is to be
        treated as raw data when applying flag transforms. 'raw' should be set
        to True when generating changegroups or in debug commands.
        """
        if raw:
            msg = (
                'revlog.revision(..., raw=True) is deprecated, '
                'use revlog.rawdata(...)'
            )
            util.nouideprecwarn(msg, '5.2', stacklevel=2)
        return self._revisiondata(nodeorrev, _df, raw=raw)[0]

    def sidedata(self, nodeorrev, _df=None):
        """a map of extra data related to the changeset but not part of the hash

        else:
            try:
                r = flagutil.processflagsread(self, rawtext, flags)
            except error.SidedataHashError as exc:
                msg = _("integrity check failed on %s:%s sidedata key %d")
                msg %= (self.indexfile, pycompat.bytestr(rev), exc.sidedatakey)
                raise error.RevlogError(msg)
            text, validatehash, sidedata = r
        if validatehash:
            self.checkhash(text, node, rev=rev)
        if not validated:

        if basetext is None:
            basetext = bytes(bins[0])
            bins = bins[1:]

        rawtext = mdiff.patches(basetext, bins)
        del basetext  # let us have a chance to free memory early
        return (rev, rawtext, False)

    def rawdata(self, nodeorrev, _df=None):
        """return an uncompressed raw data of a given node or revision number.

                    self._revisioncache = None

                revornode = rev
                if revornode is None:
                    revornode = templatefilters.short(hex(node))
                raise error.RevlogError(
                    _("integrity check failed on %s:%s")
                    % (self.indexfile, pycompat.bytestr(revornode))
                )
        except error.RevlogError:
            if self._censorable and storageutil.iscensoredtext(text):
                raise error.CensoredNodeError(self.indexfile, node, text)
            raise

        This should be called after revisions are added to the revlog. If the
        revlog has grown too large to be an inline revlog, it will convert it
        to use multiple index and data files.
        """
        tiprev = len(self) - 1
        if (
            not self._inline
            or (self.start(tiprev) + self.length(tiprev)) < _maxinline
        ):
            return

        trinfo = tr.find(self.indexfile)
        if trinfo is None:
            raise error.RevlogError(
                _("%s not found in the transaction") % self.indexfile
            )

        trindex = trinfo[2]
        if trindex is not None:
            dataoff = self.start(trindex)
        else:

    def _nodeduplicatecallback(self, transaction, node):
        """called when trying to add a node already stored.
        """

    def addrevision(
        self,
        text,
        transaction,
        link,
        p1,
        p2,
        cachedelta=None,
        node=None,
        flags=REVIDX_DEFAULT_FLAGS,
        deltacomputer=None,
        sidedata=None,
    ):
        """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

        flags - the known flags to set on the revision
        deltacomputer - an optional deltacomputer instance shared between
            multiple calls
        """
        if link == nullrev:
            raise error.RevlogError(
                _("attempted to add linkrev -1 to %s") % self.indexfile
            )

        if sidedata is None:
            sidedata = {}
            flags = flags & ~REVIDX_SIDEDATA
        elif not self.hassidedata:
            raise error.ProgrammingError(
                _("trying to add sidedata to a revlog who don't support them")
            )
        else:
            flags |= REVIDX_SIDEDATA

        if flags:
            node = node or self.hash(text, p1, p2)

        rawtext, validatehash = flagutil.processflagswrite(
            self, text, flags, sidedata=sidedata
        )

        # If the flag processor modifies the revision data, ignore any provided
        # cachedelta.
        if rawtext != text:
            cachedelta = None

        if len(rawtext) > _maxentrysize:
            raise error.RevlogError(
                _("%s: size of %d bytes exceeds maximum revlog storage of 2GiB")
                % (self.indexfile, len(rawtext))
            )

        node = node or self.hash(rawtext, p1, p2)
        if node in self.nodemap:
            return node

        if validatehash:
            self.checkhash(rawtext, node, p1=p1, p2=p2)

        return self.addrawrevision(
            rawtext,
            transaction,
            link,
            p1,
            p2,
            node,
            flags,
            cachedelta=cachedelta,
            deltacomputer=deltacomputer,
        )

    def addrawrevision(
        self,
        rawtext,
        transaction,
        link,
        p1,
        p2,
        node,
        flags,
        cachedelta=None,
        deltacomputer=None,
    ):
        """add 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).
        """
        dfh = None
        if not self._inline:
            dfh = self._datafp("a+")
        ifh = self._indexfp("a+")
        try:
            return self._addrevision(
                node,
                rawtext,
                transaction,
                link,
                p1,
                p2,
                flags,
                cachedelta,
                ifh,
                dfh,
                deltacomputer=deltacomputer,
            )
        finally:
            if dfh:
                dfh.close()
            ifh.close()

        if t == 'x':
            try:
                return _zlibdecompress(data)
            except zlib.error as e:
                raise error.RevlogError(
                    _('revlog decompress error: %s')
                    % stringutil.forcebytestr(e)
                )
        # '\0' is more common than 'u' so it goes first.
        elif t == '\0':
            return data
        elif t == 'u':
            return util.buffer(data, 1)

            except KeyError:
                raise error.RevlogError(_('unknown compression type %r') % t)

        return compressor.decompress(data)

    def _addrevision(
        self,
        node,
        rawtext,
        transaction,
        link,
        p1,
        p2,
        flags,
        cachedelta,
        ifh,
        dfh,
        alwayscache=False,
        deltacomputer=None,
    ):
        """internal function to add revisions to the log

        see addrevision for argument descriptions.

        note: "addrevision" takes non-raw text, "_addrevision" takes raw text.

        invariants:
        - rawtext is optional (can be None); if not set, cachedelta must be set.
          if both are set, they must correspond to each other.
        """
        if node == nullid:
            raise error.RevlogError(
                _("%s: attempt to add null revision") % self.indexfile
            )
        if node == wdirid or node in wdirfilenodeids:
            raise error.RevlogError(
                _("%s: attempt to add wdir revision") % self.indexfile
            )

        if self._inline:
            fh = ifh
        else:
            fh = dfh

        # become comparable to the uncompressed text
        if rawtext is None:
            # need rawtext size, before changed by flag processors, which is
            # the non-raw size. use revlog explicitly to avoid filelog's extra
            # logic that might remove metadata size.
            textlen = mdiff.patchedsize(
                revlog.size(self, cachedelta[0]), cachedelta[1]
            )
        else:
            textlen = len(rawtext)

        if deltacomputer is None:
            deltacomputer = deltautil.deltacomputer(self)

        revinfo = _revisioninfo(node, p1, p2, btext, textlen, cachedelta, flags)

        deltainfo = deltacomputer.finddeltainfo(revinfo, fh)

        e = (
            offset_type(offset, flags),
            deltainfo.deltalen,
            textlen,
            deltainfo.base,
            link,
            p1r,
            p2r,
            node,
        )
        self.index.append(e)
        self.nodemap[node] = curr

        # Reset the pure node cache start lookup offset to account for new
        # revision.
        if self._nodepos is not None:
            self._nodepos = curr

        entry = self._io.packentry(e, self.node, self.version, curr)
        self._writeentry(
            transaction, ifh, dfh, entry, deltainfo.data, link, offset
        )

        rawtext = btext[0]

        if alwayscache and rawtext is None:
            rawtext = deltacomputer.buildtext(revinfo, fh)

        if type(rawtext) == bytes:  # only accept immutable objects
            self._revisioncache = (node, curr, rawtext)
        self._chainbasecache[curr] = deltainfo.chainbase
        return node

    def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset):

            dfh = None
        else:
            transaction.add(self.indexfile, isize, r)
            transaction.add(self.datafile, end)
            dfh = self._datafp("a+")

        def flush():
            if dfh:
                dfh.flush()
            ifh.flush()

                    # this can happen if two branches make the same change
                    continue

                for p in (p1, p2):
                    if p not in self.nodemap:
                        raise error.LookupError(
                            p, self.indexfile, _('unknown parent')
                        )

                if deltabase not in self.nodemap:
                    raise error.LookupError(
                        deltabase, self.indexfile, _('unknown delta base')
                    )

                baserev = self.rev(deltabase)

                if baserev != nullrev and self.iscensored(baserev):
                    # if base is censored, delta must be full replacement in a
                    # single patch operation
                    hlen = struct.calcsize(">lll")
                    oldlen = self.rawsize(baserev)
                    newlen = len(delta) - hlen
                    if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
                        raise error.CensoredBaseError(
                            self.indexfile, self.node(baserev)
                        )

                if not flags and self._peek_iscensored(baserev, delta, flush):
                    flags |= REVIDX_ISCENSORED

                # We assume consumers of addrevisioncb will want to retrieve

                # revision(). revision() will fast path if there is a cache
                # hit. So, we tell _addrevision() to always cache in this case.
                # We're only using addgroup() in the context of changegroup
                # generation so the revision data can always be handled as raw
                # by the flagprocessor.
                self._addrevision(
                    node,
                    None,
                    transaction,
                    link,
                    p1,
                    p2,
                    flags,
                    (baserev, delta),
                    ifh,
                    dfh,
                    alwayscache=bool(addrevisioncb),
                    deltacomputer=deltacomputer,
                )

                if addrevisioncb:
                    addrevisioncb(self, node)

                if not dfh and not self._inline:

        """find the minimum rev that must be stripped to strip the linkrev

        Returns a tuple containing the minimum rev and a set of all revs that
        have linkrevs that will be broken by this strip.
        """
        return storageutil.resolvestripinfo(
            minlink,
            len(self) - 1,
            self.headrevs(),
            self.linkrev,
            self.parentrevs,
        )

    def strip(self, minlink, transaction):
        """truncate the revlog on the first revision with a linkrev >= minlink

        This function is called when we're stripping revision minlink and

        res = [self.indexfile]
        if not self._inline:
            res.append(self.datafile)
        return res

    def emitrevisions(
        self,
        nodes,
        nodesorder=None,
        revisiondata=False,
        assumehaveparentrevisions=False,
        deltamode=repository.CG_DELTAMODE_STD,
    ):
        if nodesorder not in ('nodes', 'storage', 'linear', None):
            raise error.ProgrammingError(
                'unhandled value for nodesorder: %s' % nodesorder
            )

        if nodesorder is None and not self._generaldelta:
            nodesorder = 'storage'

        if (
            not self._storedeltachains
            and deltamode != repository.CG_DELTAMODE_PREV
        ):
            deltamode = repository.CG_DELTAMODE_FULL

        return storageutil.emitrevisions(
            self,
            nodes,
            nodesorder,
            revlogrevisiondelta,
            deltaparentfn=self.deltaparent,
            candeltafn=self.candelta,
            rawsizefn=self.rawsize,
            revdifffn=self.revdiff,
            flagsfn=self.flags,
            deltamode=deltamode,
            revisiondata=revisiondata,
            assumehaveparentrevisions=assumehaveparentrevisions,
        )

    DELTAREUSEALWAYS = 'always'
    DELTAREUSESAMEREVS = 'samerevs'
    DELTAREUSENEVER = 'never'

    DELTAREUSEFULLADD = 'fulladd'

    DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'}

    def clone(
        self,
        tr,
        destrevlog,
        addrevisioncb=None,
        deltareuse=DELTAREUSESAMEREVS,
        forcedeltabothparents=None,
    ):
        """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.

                destrevlog._lazydeltabase = False
                destrevlog._lazydelta = False

            destrevlog._deltabothparents = forcedeltabothparents or oldamd

            self._clone(
                tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
            )

        finally:
            destrevlog._lazydelta = oldlazydelta
            destrevlog._lazydeltabase = oldlazydeltabase
            destrevlog._deltabothparents = oldamd

    def _clone(
        self, tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
    ):
        """perform the core duty of `revlog.clone` after parameter processing"""
        deltacomputer = deltautil.deltacomputer(destrevlog)
        index = self.index
        for rev in self:
            entry = index[rev]

            # Some classes override linkrev to take filtered revs into
            # account. Use raw entry from index.
            flags = entry[0] & 0xFFFF
            linkrev = entry[4]
            p1 = index[entry[5]][7]
            p2 = index[entry[6]][7]
            node = entry[7]

            # the revlog chunk is a delta.
            cachedelta = None
            rawtext = None
            if deltareuse == self.DELTAREUSEFULLADD:
                text = self.revision(rev)
                destrevlog.addrevision(
                    text,
                    tr,
                    linkrev,
                    p1,
                    p2,
                    cachedelta=cachedelta,
                    node=node,
                    flags=flags,
                    deltacomputer=deltacomputer,
                )
            else:
                if destrevlog._lazydelta:
                    dp = self.deltaparent(rev)
                    if dp != nullrev:
                        cachedelta = (dp, bytes(self._chunk(rev)))

                if not cachedelta:
                    rawtext = self.rawdata(rev)

                ifh = destrevlog.opener(
                    destrevlog.indexfile, 'a+', checkambig=False
                )
                dfh = None
                if not destrevlog._inline:
                    dfh = destrevlog.opener(destrevlog.datafile, 'a+')
                try:
                    destrevlog._addrevision(
                        node,
                        rawtext,
                        tr,
                        linkrev,
                        p1,
                        p2,
                        flags,
                        cachedelta,
                        ifh,
                        dfh,
                        deltacomputer=deltacomputer,
                    )
                finally:
                    if dfh:
                        dfh.close()
                    ifh.close()

            if addrevisioncb:
                addrevisioncb(self, rev, node)

    def censorrevision(self, tr, censornode, tombstone=b''):
        if (self.version & 0xFFFF) == REVLOGV0:
            raise error.RevlogError(
                _('cannot censor with version %d revlogs') % self.version
            )

        censorrev = self.rev(censornode)
        tombstone = storageutil.packmeta({b'censored': tombstone}, b'')

        if len(tombstone) > self.rawsize(censorrev):
            raise error.Abort(
                _('censor tombstone must be no longer than ' 'censored data')
            )

        # Rewriting the revlog in place is hard. Our strategy for censoring is
        # to create a new revlog, copy all revisions to it, then replace the
        # revlogs on transaction close.

        newindexfile = self.indexfile + b'.tmpcensored'
        newdatafile = self.datafile + b'.tmpcensored'

        # This is a bit dangerous. We could easily have a mismatch of state.
        newrl = revlog(self.opener, newindexfile, newdatafile, censorable=True)
        newrl.version = self.version
        newrl._generaldelta = self._generaldelta
        newrl._io = self._io

        for rev in self.revs():
            node = self.node(rev)
            p1, p2 = self.parents(node)

            if rev == censorrev:
                newrl.addrawrevision(
                    tombstone,
                    tr,
                    self.linkrev(censorrev),
                    p1,
                    p2,
                    censornode,
                    REVIDX_ISCENSORED,
                )

                if newrl.deltaparent(rev) != nullrev:
                    raise error.Abort(
                        _(
                            'censored revision stored as delta; '
                            'cannot censor'
                        ),
                        hint=_(
                            'censoring of revlogs is not '
                            'fully implemented; please report '
                            'this bug'
                        ),
                    )
                continue

            if self.iscensored(rev):
                if self.deltaparent(rev) != nullrev:
                    raise error.Abort(
                        _(
                            'cannot censor due to censored '
                            'revision having delta stored'
                        )
                    )
                rawtext = self._chunk(rev)
            else:
                rawtext = self.rawdata(rev)

            newrl.addrawrevision(
                rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev)
            )

        tr.addbackup(self.indexfile, location='store')
        if not self._inline:
            tr.addbackup(self.datafile, location='store')

        version = self.version & 0xFFFF

        # The verifier tells us what version revlog we should be.
        if version != state['expectedversion']:
            yield revlogproblem(
                warning=_("warning: '%s' uses revlog format %d; expected %d")
                % (self.indexfile, version, state['expectedversion'])
            )

        state['skipread'] = set()

        for rev in self:
            node = self.node(rev)

                l2 = len(self.rawdata(node))

                if l1 != l2:
                    yield revlogproblem(
                        error=_('unpacked size is %d, %d expected') % (l2, l1),
                        node=node,
                    )

            except error.CensoredNodeError:
                if state['erroroncensored']:
                    yield revlogproblem(
                        error=_('censored file data'), node=node
                    )
                    state['skipread'].add(node)
            except Exception as e:
                yield revlogproblem(
                    error=_('unpacking %s: %s')
                    % (short(node), stringutil.forcebytestr(e)),
                    node=node,
                )
                state['skipread'].add(node)

    def storageinfo(
        self,
        exclusivefiles=False,
        sharedfiles=False,
        revisionscount=False,
        trackedsize=False,
        storedsize=False,
    ):
        d = {}

        if exclusivefiles:
            d['exclusivefiles'] = [(self.opener, self.indexfile)]
            if not self._inline:

        if trackedsize:
            d['trackedsize'] = sum(map(self.rawsize, iter(self)))

        if storedsize:
            d['storedsize'] = sum(
                self.opener.stat(path).st_size for path in self.files()
            )

        return d