revlog: report node and file when lookup fails

hgext/imerge.py

@@ -1,406 +1,407 b''
 # Copyright (C) 2007 Brendan Cully <[e-mail]>
 # Published under the GNU GPL
 
 '''
 imerge - interactive merge
 '''
 
 from mercurial.i18n import _
 from mercurial.node import hex, short
 from mercurial import commands, cmdutil, dispatch, fancyopts
 from mercurial import hg, filemerge, util, revlog
 import os, tarfile
 
 class InvalidStateFileException(Exception): pass
 
 class ImergeStateFile(object):
     def __init__(self, im):
         self.im = im
 
     def save(self, dest):
         tf = tarfile.open(dest, 'w:gz')
 
         st = os.path.join(self.im.path, 'status')
         tf.add(st, os.path.join('.hg', 'imerge', 'status'))
 
         for f in self.im.resolved:
             (fd, fo) = self.im.conflicts[f]
             abssrc = self.im.repo.wjoin(fd)
             tf.add(abssrc, fd)
 
         tf.close()
 
     def load(self, source):
         wlock = self.im.repo.wlock()
         lock = self.im.repo.lock()
 
         tf = tarfile.open(source, 'r')
         contents = tf.getnames()
         # tarfile normalizes path separators to '/'
         statusfile = '.hg/imerge/status'
         if statusfile not in contents:
             raise InvalidStateFileException('no status file')
 
         tf.extract(statusfile, self.im.repo.root)
         p1, p2 = self.im.load()
         if self.im.repo.dirstate.parents()[0] != p1.node():
             hg.clean(self.im.repo, p1.node())
         self.im.start(p2.node())
         for tarinfo in tf:
             tf.extract(tarinfo, self.im.repo.root)
         self.im.load()
 
 class Imerge(object):
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
         self.path = repo.join('imerge')
         self.opener = util.opener(self.path)
 
         self.wctx = self.repo.workingctx()
         self.conflicts = {}
         self.resolved = []
 
     def merging(self):
         return len(self.wctx.parents()) > 1
 
     def load(self):
         # status format. \0-delimited file, fields are
         # p1, p2, conflict count, conflict filenames, resolved filenames
         # conflict filenames are tuples of localname, remoteorig, remotenew
 
         statusfile = self.opener('status')
 
         status = statusfile.read().split('\0')
         if len(status) < 3:
             raise util.Abort('invalid imerge status file')
 
         try:
             parents = [self.repo.changectx(n) for n in status[:2]]
         except revlog.LookupError, e:
-            raise util.Abort('merge parent %s not in repository' % e.name)
+            raise util.Abort(_('merge parent %s not in repository') %
+                             short(e.name))
 
         status = status[2:]
         conflicts = int(status.pop(0)) * 3
         self.resolved = status[conflicts:]
         for i in xrange(0, conflicts, 3):
             self.conflicts[status[i]] = (status[i+1], status[i+2])
 
         return parents
 
     def save(self):
         lock = self.repo.lock()
 
         if not os.path.isdir(self.path):
             os.mkdir(self.path)
         statusfile = self.opener('status', 'wb')
 
         out = [hex(n.node()) for n in self.wctx.parents()]
         out.append(str(len(self.conflicts)))
         conflicts = self.conflicts.items()
         conflicts.sort()
         for fw, fd_fo in conflicts:
             out.append(fw)
             out.extend(fd_fo)
         out.extend(self.resolved)
 
         statusfile.write('\0'.join(out))
 
     def remaining(self):
         return [f for f in self.conflicts if f not in self.resolved]
 
     def filemerge(self, fn, interactive=True):
         wlock = self.repo.wlock()
 
         (fd, fo) = self.conflicts[fn]
         p1, p2 = self.wctx.parents()
 
         # this could be greatly improved
         realmerge = os.environ.get('HGMERGE')
         if not interactive:
             os.environ['HGMERGE'] = 'merge'
 
         # The filemerge ancestor algorithm does not work if self.wctx
         # already has two parents (in normal merge it doesn't yet). But
         # this is very dirty.
         self.wctx._parents.pop()
         try:
             # TODO: we should probably revert the file if merge fails
             return filemerge.filemerge(self.repo, fn, fd, fo, self.wctx, p2)
         finally:
             self.wctx._parents.append(p2)
             if realmerge:
                 os.environ['HGMERGE'] = realmerge
             elif not interactive:
                 del os.environ['HGMERGE']
 
     def start(self, rev=None):
         _filemerge = filemerge.filemerge
         def filemerge_(repo, fw, fd, fo, wctx, mctx):
             self.conflicts[fw] = (fd, fo)
 
         filemerge.filemerge = filemerge_
         commands.merge(self.ui, self.repo, rev=rev)
         filemerge.filemerge = _filemerge
 
         self.wctx = self.repo.workingctx()
         self.save()
 
     def resume(self):
         self.load()
 
         dp = self.repo.dirstate.parents()
         p1, p2 = self.wctx.parents()
         if p1.node() != dp[0] or p2.node() != dp[1]:
             raise util.Abort('imerge state does not match working directory')
 
     def next(self):
         remaining = self.remaining()
         return remaining and remaining[0]
 
     def resolve(self, files):
         resolved = dict.fromkeys(self.resolved)
         for fn in files:
             if fn not in self.conflicts:
                 raise util.Abort('%s is not in the merge set' % fn)
             resolved[fn] = True
         self.resolved = resolved.keys()
         self.resolved.sort()
         self.save()
         return 0
 
     def unresolve(self, files):
         resolved = dict.fromkeys(self.resolved)
         for fn in files:
             if fn not in resolved:
                 raise util.Abort('%s is not resolved' % fn)
             del resolved[fn]
         self.resolved = resolved.keys()
         self.resolved.sort()
         self.save()
         return 0
 
     def pickle(self, dest):
         '''write current merge state to file to be resumed elsewhere'''
         state = ImergeStateFile(self)
         return state.save(dest)
 
     def unpickle(self, source):
         '''read merge state from file'''
         state = ImergeStateFile(self)
         return state.load(source)
 
 def load(im, source):
     if im.merging():
         raise util.Abort('there is already a merge in progress '
                          '(update -C <rev> to abort it)' )
     m, a, r, d =  im.repo.status()[:4]
     if m or a or r or d:
         raise util.Abort('working directory has uncommitted changes')
 
     rc = im.unpickle(source)
     if not rc:
         status(im)
     return rc
 
 def merge_(im, filename=None, auto=False):
     success = True
     if auto and not filename:
         for fn in im.remaining():
             rc = im.filemerge(fn, interactive=False)
             if rc:
                 success = False
             else:
                 im.resolve([fn])
         if success:
             im.ui.write('all conflicts resolved\n')
         else:
             status(im)
         return 0
 
     if not filename:
         filename = im.next()
         if not filename:
             im.ui.write('all conflicts resolved\n')
             return 0
 
     rc = im.filemerge(filename, interactive=not auto)
     if not rc:
         im.resolve([filename])
         if not im.next():
             im.ui.write('all conflicts resolved\n')
     return rc
 
 def next(im):
     n = im.next()
     if n:
         im.ui.write('%s\n' % n)
     else:
         im.ui.write('all conflicts resolved\n')
     return 0
 
 def resolve(im, *files):
     if not files:
         raise util.Abort('resolve requires at least one filename')
     return im.resolve(files)
 
 def save(im, dest):
     return im.pickle(dest)
 
 def status(im, **opts):
     if not opts.get('resolved') and not opts.get('unresolved'):
         opts['resolved'] = True
         opts['unresolved'] = True
 
     if im.ui.verbose:
         p1, p2 = [short(p.node()) for p in im.wctx.parents()]
         im.ui.note(_('merging %s and %s\n') % (p1, p2))
 
     conflicts = im.conflicts.keys()
     conflicts.sort()
     remaining = dict.fromkeys(im.remaining())
     st = []
     for fn in conflicts:
         if opts.get('no_status'):
             mode = ''
         elif fn in remaining:
             mode = 'U '
         else:
             mode = 'R '
         if ((opts.get('resolved') and fn not in remaining)
             or (opts.get('unresolved') and fn in remaining)):
             st.append((mode, fn))
     st.sort()
     for (mode, fn) in st:
         if im.ui.verbose:
             fo, fd = im.conflicts[fn]
             if fd != fn:
                 fn = '%s (%s)' % (fn, fd)
         im.ui.write('%s%s\n' % (mode, fn))
     if opts.get('unresolved') and not remaining:
         im.ui.write(_('all conflicts resolved\n'))
 
     return 0
 
 def unresolve(im, *files):
     if not files:
         raise util.Abort('unresolve requires at least one filename')
     return im.unresolve(files)
 
 subcmdtable = {
     'load': (load, []),
     'merge':
         (merge_,
          [('a', 'auto', None, _('automatically resolve if possible'))]),
     'next': (next, []),
     'resolve': (resolve, []),
     'save': (save, []),
     'status':
         (status,
          [('n', 'no-status', None, _('hide status prefix')),
           ('', 'resolved', None, _('only show resolved conflicts')),
           ('', 'unresolved', None, _('only show unresolved conflicts'))]),
     'unresolve': (unresolve, [])
 }
 
 def dispatch_(im, args, opts):
     def complete(s, choices):
         candidates = []
         for choice in choices:
             if choice.startswith(s):
                 candidates.append(choice)
         return candidates
 
     c, args = args[0], list(args[1:])
     cmd = complete(c, subcmdtable.keys())
     if not cmd:
         raise cmdutil.UnknownCommand('imerge ' + c)
     if len(cmd) > 1:
         cmd.sort()
         raise cmdutil.AmbiguousCommand('imerge ' + c, cmd)
     cmd = cmd[0]
 
     func, optlist = subcmdtable[cmd]
     opts = {}
     try:
         args = fancyopts.fancyopts(args, optlist, opts)
         return func(im, *args, **opts)
     except fancyopts.getopt.GetoptError, inst:
         raise dispatch.ParseError('imerge', '%s: %s' % (cmd, inst))
     except TypeError:
         raise dispatch.ParseError('imerge', _('%s: invalid arguments') % cmd)
 
 def imerge(ui, repo, *args, **opts):
     '''interactive merge
 
     imerge lets you split a merge into pieces. When you start a merge
     with imerge, the names of all files with conflicts are recorded.
     You can then merge any of these files, and if the merge is
     successful, they will be marked as resolved. When all files are
     resolved, the merge is complete.
 
     If no merge is in progress, hg imerge [rev] will merge the working
     directory with rev (defaulting to the other head if the repository
     only has two heads). You may also resume a saved merge with
     hg imerge load <file>.
 
     If a merge is in progress, hg imerge will default to merging the
     next unresolved file.
 
     The following subcommands are available:
 
     status:
       show the current state of the merge
       options:
         -n --no-status:  do not print the status prefix
            --resolved:   only print resolved conflicts
            --unresolved: only print unresolved conflicts
     next:
       show the next unresolved file merge
     merge [<file>]:
       merge <file>. If the file merge is successful, the file will be
       recorded as resolved. If no file is given, the next unresolved
       file will be merged.
     resolve <file>...:
       mark files as successfully merged
     unresolve <file>...:
       mark files as requiring merging.
     save <file>:
       save the state of the merge to a file to be resumed elsewhere
     load <file>:
       load the state of the merge from a file created by save
     '''
 
     im = Imerge(ui, repo)
 
     if im.merging():
         im.resume()
     else:
         rev = opts.get('rev')
         if rev and args:
             raise util.Abort('please specify just one revision')
 
         if len(args) == 2 and args[0] == 'load':
             pass
         else:
             if args:
                 rev = args[0]
             im.start(rev=rev)
             if opts.get('auto'):
                 args = ['merge', '--auto']
             else:
                 args = ['status']
 
     if not args:
         args = ['merge']
 
     return dispatch_(im, args, opts)
 
 cmdtable = {
     '^imerge':
     (imerge,
      [('r', 'rev', '', _('revision to merge')),
       ('a', 'auto', None, _('automatically merge where possible'))],
       'hg imerge [command]')
 }

mercurial/bundlerepo.py

@@ -1,282 +1,283 b''
 """
 bundlerepo.py - repository class for viewing uncompressed bundles
 
 This provides a read-only repository interface to bundles as if
 they were part of the actual repository.
 
 Copyright 2006, 2007 Benoit Boissinot <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 """
 
 from node import hex, nullid, short
 from i18n import _
 import changegroup, util, os, struct, bz2, tempfile, mdiff
 import localrepo, changelog, manifest, filelog, revlog
 
 class bundlerevlog(revlog.revlog):
     def __init__(self, opener, indexfile, bundlefile,
                  linkmapper=None):
         # How it works:
         # to retrieve a revision, we need to know the offset of
         # the revision in the bundlefile (an opened file).
         #
         # We store this offset in the index (start), to differentiate a
         # rev in the bundle and from a rev in the revlog, we check
         # len(index[r]). If the tuple is bigger than 7, it is a bundle
         # (it is bigger since we store the node to which the delta is)
         #
         revlog.revlog.__init__(self, opener, indexfile)
         self.bundlefile = bundlefile
         self.basemap = {}
         def chunkpositer():
             for chunk in changegroup.chunkiter(bundlefile):
                 pos = bundlefile.tell()
                 yield chunk, pos - len(chunk)
         n = self.count()
         prev = None
         for chunk, start in chunkpositer():
             size = len(chunk)
             if size < 80:
                 raise util.Abort("invalid changegroup")
             start += 80
             size -= 80
             node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80])
             if node in self.nodemap:
                 prev = node
                 continue
             for p in (p1, p2):
                 if not p in self.nodemap:
-                    raise revlog.LookupError(hex(p1), _("unknown parent %s") % short(p1))
+                    raise revlog.LookupError(p1, self.indexfile,
+                                             _("unknown parent"))
             if linkmapper is None:
                 link = n
             else:
                 link = linkmapper(cs)
 
             if not prev:
                 prev = p1
             # start, size, full unc. size, base (unused), link, p1, p2, node
             e = (revlog.offset_type(start, 0), size, -1, -1, link,
                  self.rev(p1), self.rev(p2), node)
             self.basemap[n] = prev
             self.index.insert(-1, e)
             self.nodemap[node] = n
             prev = node
             n += 1
 
     def bundle(self, rev):
         """is rev from the bundle"""
         if rev < 0:
             return False
         return rev in self.basemap
     def bundlebase(self, rev): return self.basemap[rev]
     def chunk(self, rev, df=None, cachelen=4096):
         # Warning: in case of bundle, the diff is against bundlebase,
         # not against rev - 1
         # XXX: could use some caching
         if not self.bundle(rev):
             return revlog.revlog.chunk(self, rev, df)
         self.bundlefile.seek(self.start(rev))
         return self.bundlefile.read(self.length(rev))
 
     def revdiff(self, rev1, rev2):
         """return or calculate a delta between two revisions"""
         if self.bundle(rev1) and self.bundle(rev2):
             # hot path for bundle
             revb = self.rev(self.bundlebase(rev2))
             if revb == rev1:
                 return self.chunk(rev2)
         elif not self.bundle(rev1) and not self.bundle(rev2):
             return revlog.revlog.revdiff(self, rev1, rev2)
 
         return mdiff.textdiff(self.revision(self.node(rev1)),
                          self.revision(self.node(rev2)))
 
     def revision(self, node):
         """return an uncompressed revision of a given"""
         if node == nullid: return ""
 
         text = None
         chain = []
         iter_node = node
         rev = self.rev(iter_node)
         # reconstruct the revision if it is from a changegroup
         while self.bundle(rev):
             if self._cache and self._cache[0] == iter_node:
                 text = self._cache[2]
                 break
             chain.append(rev)
             iter_node = self.bundlebase(rev)
             rev = self.rev(iter_node)
         if text is None:
             text = revlog.revlog.revision(self, iter_node)
 
         while chain:
             delta = self.chunk(chain.pop())
             text = mdiff.patches(text, [delta])
 
         p1, p2 = self.parents(node)
         if node != revlog.hash(text, p1, p2):
             raise revlog.RevlogError(_("integrity check failed on %s:%d")
                                      % (self.datafile, self.rev(node)))
 
         self._cache = (node, self.rev(node), text)
         return text
 
     def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
         raise NotImplementedError
     def addgroup(self, revs, linkmapper, transaction, unique=0):
         raise NotImplementedError
     def strip(self, rev, minlink):
         raise NotImplementedError
     def checksize(self):
         raise NotImplementedError
 
 class bundlechangelog(bundlerevlog, changelog.changelog):
     def __init__(self, opener, bundlefile):
         changelog.changelog.__init__(self, opener)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile)
 
 class bundlemanifest(bundlerevlog, manifest.manifest):
     def __init__(self, opener, bundlefile, linkmapper):
         manifest.manifest.__init__(self, opener)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile,
                               linkmapper)
 
 class bundlefilelog(bundlerevlog, filelog.filelog):
     def __init__(self, opener, path, bundlefile, linkmapper):
         filelog.filelog.__init__(self, opener, path)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile,
                               linkmapper)
 
 class bundlerepository(localrepo.localrepository):
     def __init__(self, ui, path, bundlename):
         localrepo.localrepository.__init__(self, ui, path)
 
         if path:
             self._url = 'bundle:' + path + '+' + bundlename
         else:
             self._url = 'bundle:' + bundlename
 
         self.tempfile = None
         self.bundlefile = open(bundlename, "rb")
         header = self.bundlefile.read(6)
         if not header.startswith("HG"):
             raise util.Abort(_("%s: not a Mercurial bundle file") % bundlename)
         elif not header.startswith("HG10"):
             raise util.Abort(_("%s: unknown bundle version") % bundlename)
         elif header == "HG10BZ":
             fdtemp, temp = tempfile.mkstemp(prefix="hg-bundle-",
                                             suffix=".hg10un", dir=self.path)
             self.tempfile = temp
             fptemp = os.fdopen(fdtemp, 'wb')
             def generator(f):
                 zd = bz2.BZ2Decompressor()
                 zd.decompress("BZ")
                 for chunk in f:
                     yield zd.decompress(chunk)
             gen = generator(util.filechunkiter(self.bundlefile, 4096))
 
             try:
                 fptemp.write("HG10UN")
                 for chunk in gen:
                     fptemp.write(chunk)
             finally:
                 fptemp.close()
                 self.bundlefile.close()
 
             self.bundlefile = open(self.tempfile, "rb")
             # seek right after the header
             self.bundlefile.seek(6)
         elif header == "HG10UN":
             # nothing to do
             pass
         else:
             raise util.Abort(_("%s: unknown bundle compression type")
                              % bundlename)
         # dict with the mapping 'filename' -> position in the bundle
         self.bundlefilespos = {}
 
     def __getattr__(self, name):
         if name == 'changelog':
             self.changelog = bundlechangelog(self.sopener, self.bundlefile)
             self.manstart = self.bundlefile.tell()
             return self.changelog
         if name == 'manifest':
             self.bundlefile.seek(self.manstart)
             self.manifest = bundlemanifest(self.sopener, self.bundlefile,
                                            self.changelog.rev)
             self.filestart = self.bundlefile.tell()
             return self.manifest
         if name == 'manstart':
             self.changelog
             return self.manstart
         if name == 'filestart':
             self.manifest
             return self.filestart
         return localrepo.localrepository.__getattr__(self, name)
 
     def url(self):
         return self._url
 
     def dev(self):
         return -1
 
     def file(self, f):
         if not self.bundlefilespos:
             self.bundlefile.seek(self.filestart)
             while 1:
                 chunk = changegroup.getchunk(self.bundlefile)
                 if not chunk:
                     break
                 self.bundlefilespos[chunk] = self.bundlefile.tell()
                 for c in changegroup.chunkiter(self.bundlefile):
                     pass
 
         if f[0] == '/':
             f = f[1:]
         if f in self.bundlefilespos:
             self.bundlefile.seek(self.bundlefilespos[f])
             return bundlefilelog(self.sopener, f, self.bundlefile,
                                  self.changelog.rev)
         else:
             return filelog.filelog(self.sopener, f)
 
     def close(self):
         """Close assigned bundle file immediately."""
         self.bundlefile.close()
 
     def __del__(self):
         bundlefile = getattr(self, 'bundlefile', None)
         if bundlefile and not bundlefile.closed:
             bundlefile.close()
         tempfile = getattr(self, 'tempfile', None)
         if tempfile is not None:
             os.unlink(tempfile)
 
 def instance(ui, path, create):
     if create:
         raise util.Abort(_('cannot create new bundle repository'))
     parentpath = ui.config("bundle", "mainreporoot", "")
     if parentpath:
         # Try to make the full path relative so we get a nice, short URL.
         # In particular, we don't want temp dir names in test outputs.
         cwd = os.getcwd()
         if parentpath == cwd:
             parentpath = ''
         else:
             cwd = os.path.join(cwd,'')
             if parentpath.startswith(cwd):
                 parentpath = parentpath[len(cwd):]
     path = util.drop_scheme('file', path)
     if path.startswith('bundle:'):
         path = util.drop_scheme('bundle', path)
         s = path.split("+", 1)
         if len(s) == 1:
             repopath, bundlename = parentpath, s[0]
         else:
             repopath, bundlename = s
     else:
         repopath, bundlename = parentpath, path
     return bundlerepository(ui, repopath, bundlename)

mercurial/context.py

@@ -1,620 +1,622 b''
 # context.py - changeset and file context objects for mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import nullid, nullrev, short
 from i18n import _
 import ancestor, bdiff, revlog, util, os, errno
 
 class changectx(object):
     """A changecontext object makes access to data related to a particular
     changeset convenient."""
     def __init__(self, repo, changeid=None):
         """changeid is a revision number, node, or tag"""
         self._repo = repo
 
         if not changeid and changeid != 0:
             p1, p2 = self._repo.dirstate.parents()
             self._rev = self._repo.changelog.rev(p1)
             if self._rev == -1:
                 changeid = 'tip'
             else:
                 self._node = p1
                 return
 
         self._node = self._repo.lookup(changeid)
         self._rev = self._repo.changelog.rev(self._node)
 
     def __str__(self):
         return short(self.node())
 
     def __repr__(self):
         return "<changectx %s>" % str(self)
 
     def __eq__(self, other):
         try:
             return self._rev == other._rev
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def __nonzero__(self):
         return self._rev != nullrev
 
     def __getattr__(self, name):
         if name == '_changeset':
             self._changeset = self._repo.changelog.read(self.node())
             return self._changeset
         elif name == '_manifest':
             self._manifest = self._repo.manifest.read(self._changeset[0])
             return self._manifest
         elif name == '_manifestdelta':
             md = self._repo.manifest.readdelta(self._changeset[0])
             self._manifestdelta = md
             return self._manifestdelta
         else:
             raise AttributeError, name
 
     def __contains__(self, key):
         return key in self._manifest
 
     def __getitem__(self, key):
         return self.filectx(key)
 
     def __iter__(self):
         a = self._manifest.keys()
         a.sort()
         for f in a:
             yield f
 
     def changeset(self): return self._changeset
     def manifest(self): return self._manifest
 
     def rev(self): return self._rev
     def node(self): return self._node
     def user(self): return self._changeset[1]
     def date(self): return self._changeset[2]
     def files(self): return self._changeset[3]
     def description(self): return self._changeset[4]
     def branch(self): return self._changeset[5].get("branch")
     def extra(self): return self._changeset[5]
     def tags(self): return self._repo.nodetags(self._node)
 
     def parents(self):
         """return contexts for each parent changeset"""
         p = self._repo.changelog.parents(self._node)
         return [changectx(self._repo, x) for x in p]
 
     def children(self):
         """return contexts for each child changeset"""
         c = self._repo.changelog.children(self._node)
         return [changectx(self._repo, x) for x in c]
 
     def _fileinfo(self, path):
         if '_manifest' in self.__dict__:
             try:
                 return self._manifest[path], self._manifest.flags(path)
             except KeyError:
-                raise revlog.LookupError(path, _("'%s' not found in manifest") % path)
+                raise revlog.LookupError(self._node, path,
+                                         _('not found in manifest'))
         if '_manifestdelta' in self.__dict__ or path in self.files():
             if path in self._manifestdelta:
                 return self._manifestdelta[path], self._manifestdelta.flags(path)
         node, flag = self._repo.manifest.find(self._changeset[0], path)
         if not node:
-            raise revlog.LookupError(path, _("'%s' not found in manifest") % path)
+            raise revlog.LookupError(self._node, path,
+                                     _('not found in manifest'))
 
         return node, flag
 
     def filenode(self, path):
         return self._fileinfo(path)[0]
 
     def fileflags(self, path):
         try:
             return self._fileinfo(path)[1]
         except revlog.LookupError:
             return ''
 
     def filectx(self, path, fileid=None, filelog=None):
         """get a file context from this changeset"""
         if fileid is None:
             fileid = self.filenode(path)
         return filectx(self._repo, path, fileid=fileid,
                        changectx=self, filelog=filelog)
 
     def filectxs(self):
         """generate a file context for each file in this changeset's
            manifest"""
         mf = self.manifest()
         m = mf.keys()
         m.sort()
         for f in m:
             yield self.filectx(f, fileid=mf[f])
 
     def ancestor(self, c2):
         """
         return the ancestor context of self and c2
         """
         n = self._repo.changelog.ancestor(self._node, c2._node)
         return changectx(self._repo, n)
 
 class filectx(object):
     """A filecontext object makes access to data related to a particular
        filerevision convenient."""
     def __init__(self, repo, path, changeid=None, fileid=None,
                  filelog=None, changectx=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         self._repo = repo
         self._path = path
 
         assert (changeid is not None
                 or fileid is not None
                 or changectx is not None)
 
         if filelog:
             self._filelog = filelog
 
         if changeid is not None:
             self._changeid = changeid
         if changectx is not None:
             self._changectx = changectx
         if fileid is not None:
             self._fileid = fileid
 
     def __getattr__(self, name):
         if name == '_changectx':
             self._changectx = changectx(self._repo, self._changeid)
             return self._changectx
         elif name == '_filelog':
             self._filelog = self._repo.file(self._path)
             return self._filelog
         elif name == '_changeid':
             if '_changectx' in self.__dict__:
                 self._changeid = self._changectx.rev()
             else:
                 self._changeid = self._filelog.linkrev(self._filenode)
             return self._changeid
         elif name == '_filenode':
             if '_fileid' in self.__dict__:
                 self._filenode = self._filelog.lookup(self._fileid)
             else:
                 self._filenode = self._changectx.filenode(self._path)
             return self._filenode
         elif name == '_filerev':
             self._filerev = self._filelog.rev(self._filenode)
             return self._filerev
         else:
             raise AttributeError, name
 
     def __nonzero__(self):
         try:
             n = self._filenode
             return True
         except revlog.LookupError:
             # file is missing
             return False
 
     def __str__(self):
         return "%s@%s" % (self.path(), short(self.node()))
 
     def __repr__(self):
         return "<filectx %s>" % str(self)
 
     def __eq__(self, other):
         try:
             return (self._path == other._path
                     and self._fileid == other._fileid)
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def filectx(self, fileid):
         '''opens an arbitrary revision of the file without
         opening a new filelog'''
         return filectx(self._repo, self._path, fileid=fileid,
                        filelog=self._filelog)
 
     def filerev(self): return self._filerev
     def filenode(self): return self._filenode
     def fileflags(self): return self._changectx.fileflags(self._path)
     def isexec(self): return 'x' in self.fileflags()
     def islink(self): return 'l' in self.fileflags()
     def filelog(self): return self._filelog
 
     def rev(self):
         if '_changectx' in self.__dict__:
             return self._changectx.rev()
         if '_changeid' in self.__dict__:
             return self._changectx.rev()
         return self._filelog.linkrev(self._filenode)
 
     def linkrev(self): return self._filelog.linkrev(self._filenode)
     def node(self): return self._changectx.node()
     def user(self): return self._changectx.user()
     def date(self): return self._changectx.date()
     def files(self): return self._changectx.files()
     def description(self): return self._changectx.description()
     def branch(self): return self._changectx.branch()
     def manifest(self): return self._changectx.manifest()
     def changectx(self): return self._changectx
 
     def data(self): return self._filelog.read(self._filenode)
     def path(self): return self._path
     def size(self): return self._filelog.size(self._filerev)
 
     def cmp(self, text): return self._filelog.cmp(self._filenode, text)
 
     def renamed(self):
         """check if file was actually renamed in this changeset revision
 
         If rename logged in file revision, we report copy for changeset only
         if file revisions linkrev points back to the changeset in question
         or both changeset parents contain different file revisions.
         """
 
         renamed = self._filelog.renamed(self._filenode)
         if not renamed:
             return renamed
 
         if self.rev() == self.linkrev():
             return renamed
 
         name = self.path()
         fnode = self._filenode
         for p in self._changectx.parents():
             try:
                 if fnode == p.filenode(name):
                     return None
             except revlog.LookupError:
                 pass
         return renamed
 
     def parents(self):
         p = self._path
         fl = self._filelog
         pl = [(p, n, fl) for n in self._filelog.parents(self._filenode)]
 
         r = self._filelog.renamed(self._filenode)
         if r:
             pl[0] = (r[0], r[1], None)
 
         return [filectx(self._repo, p, fileid=n, filelog=l)
                 for p,n,l in pl if n != nullid]
 
     def children(self):
         # hard for renames
         c = self._filelog.children(self._filenode)
         return [filectx(self._repo, self._path, fileid=x,
                         filelog=self._filelog) for x in c]
 
     def annotate(self, follow=False, linenumber=None):
         '''returns a list of tuples of (ctx, line) for each line
         in the file, where ctx is the filectx of the node where
         that line was last changed.
         This returns tuples of ((ctx, linenumber), line) for each line,
         if "linenumber" parameter is NOT "None".
         In such tuples, linenumber means one at the first appearance
         in the managed file.
         To reduce annotation cost,
         this returns fixed value(False is used) as linenumber,
         if "linenumber" parameter is "False".'''
 
         def decorate_compat(text, rev):
             return ([rev] * len(text.splitlines()), text)
 
         def without_linenumber(text, rev):
             return ([(rev, False)] * len(text.splitlines()), text)
 
         def with_linenumber(text, rev):
             size = len(text.splitlines())
             return ([(rev, i) for i in xrange(1, size + 1)], text)
 
         decorate = (((linenumber is None) and decorate_compat) or
                     (linenumber and with_linenumber) or
                     without_linenumber)
 
         def pair(parent, child):
             for a1, a2, b1, b2 in bdiff.blocks(parent[1], child[1]):
                 child[0][b1:b2] = parent[0][a1:a2]
             return child
 
         getlog = util.cachefunc(lambda x: self._repo.file(x))
         def getctx(path, fileid):
             log = path == self._path and self._filelog or getlog(path)
             return filectx(self._repo, path, fileid=fileid, filelog=log)
         getctx = util.cachefunc(getctx)
 
         def parents(f):
             # we want to reuse filectx objects as much as possible
             p = f._path
             if f._filerev is None: # working dir
                 pl = [(n.path(), n.filerev()) for n in f.parents()]
             else:
                 pl = [(p, n) for n in f._filelog.parentrevs(f._filerev)]
 
             if follow:
                 r = f.renamed()
                 if r:
                     pl[0] = (r[0], getlog(r[0]).rev(r[1]))
 
             return [getctx(p, n) for p, n in pl if n != nullrev]
 
         # use linkrev to find the first changeset where self appeared
         if self.rev() != self.linkrev():
             base = self.filectx(self.filerev())
         else:
             base = self
 
         # find all ancestors
         needed = {base: 1}
         visit = [base]
         files = [base._path]
         while visit:
             f = visit.pop(0)
             for p in parents(f):
                 if p not in needed:
                     needed[p] = 1
                     visit.append(p)
                     if p._path not in files:
                         files.append(p._path)
                 else:
                     # count how many times we'll use this
                     needed[p] += 1
 
         # sort by revision (per file) which is a topological order
         visit = []
         for f in files:
             fn = [(n.rev(), n) for n in needed.keys() if n._path == f]
             visit.extend(fn)
         visit.sort()
         hist = {}
 
         for r, f in visit:
             curr = decorate(f.data(), f)
             for p in parents(f):
                 if p != nullid:
                     curr = pair(hist[p], curr)
                     # trim the history of unneeded revs
                     needed[p] -= 1
                     if not needed[p]:
                         del hist[p]
             hist[f] = curr
 
         return zip(hist[f][0], hist[f][1].splitlines(1))
 
     def ancestor(self, fc2):
         """
         find the common ancestor file context, if any, of self, and fc2
         """
 
         acache = {}
 
         # prime the ancestor cache for the working directory
         for c in (self, fc2):
             if c._filerev == None:
                 pl = [(n.path(), n.filenode()) for n in c.parents()]
                 acache[(c._path, None)] = pl
 
         flcache = {self._path:self._filelog, fc2._path:fc2._filelog}
         def parents(vertex):
             if vertex in acache:
                 return acache[vertex]
             f, n = vertex
             if f not in flcache:
                 flcache[f] = self._repo.file(f)
             fl = flcache[f]
             pl = [(f, p) for p in fl.parents(n) if p != nullid]
             re = fl.renamed(n)
             if re:
                 pl.append(re)
             acache[vertex] = pl
             return pl
 
         a, b = (self._path, self._filenode), (fc2._path, fc2._filenode)
         v = ancestor.ancestor(a, b, parents)
         if v:
             f, n = v
             return filectx(self._repo, f, fileid=n, filelog=flcache[f])
 
         return None
 
 class workingctx(changectx):
     """A workingctx object makes access to data related to
     the current working directory convenient."""
     def __init__(self, repo):
         self._repo = repo
         self._rev = None
         self._node = None
 
     def __str__(self):
         return str(self._parents[0]) + "+"
 
     def __nonzero__(self):
         return True
 
     def __getattr__(self, name):
         if name == '_parents':
             self._parents = self._repo.parents()
             return self._parents
         if name == '_status':
             self._status = self._repo.status()
             return self._status
         if name == '_manifest':
             self._buildmanifest()
             return self._manifest
         else:
             raise AttributeError, name
 
     def _buildmanifest(self):
         """generate a manifest corresponding to the working directory"""
 
         man = self._parents[0].manifest().copy()
         copied = self._repo.dirstate.copies()
         is_exec = util.execfunc(self._repo.root,
                                 lambda p: man.execf(copied.get(p,p)))
         is_link = util.linkfunc(self._repo.root,
                                 lambda p: man.linkf(copied.get(p,p)))
         modified, added, removed, deleted, unknown = self._status[:5]
         for i, l in (("a", added), ("m", modified), ("u", unknown)):
             for f in l:
                 man[f] = man.get(copied.get(f, f), nullid) + i
                 try:
                     man.set(f, is_exec(f), is_link(f))
                 except OSError:
                     pass
 
         for f in deleted + removed:
             if f in man:
                 del man[f]
 
         self._manifest = man
 
     def manifest(self): return self._manifest
 
     def user(self): return self._repo.ui.username()
     def date(self): return util.makedate()
     def description(self): return ""
     def files(self):
         f = self.modified() + self.added() + self.removed()
         f.sort()
         return f
 
     def modified(self): return self._status[0]
     def added(self): return self._status[1]
     def removed(self): return self._status[2]
     def deleted(self): return self._status[3]
     def unknown(self): return self._status[4]
     def clean(self): return self._status[5]
     def branch(self): return self._repo.dirstate.branch()
 
     def tags(self):
         t = []
         [t.extend(p.tags()) for p in self.parents()]
         return t
 
     def parents(self):
         """return contexts for each parent changeset"""
         return self._parents
 
     def children(self):
         return []
 
     def fileflags(self, path):
         if '_manifest' in self.__dict__:
             try:
                 return self._manifest.flags(path)
             except KeyError:
                 return ''
 
         pnode = self._parents[0].changeset()[0]
         orig = self._repo.dirstate.copies().get(path, path)
         node, flag = self._repo.manifest.find(pnode, orig)
         is_link = util.linkfunc(self._repo.root, lambda p: 'l' in flag)
         is_exec = util.execfunc(self._repo.root, lambda p: 'x' in flag)
         try:
             return (is_link(path) and 'l' or '') + (is_exec(path) and 'e' or '')
         except OSError:
             pass
 
         if not node or path in self.deleted() or path in self.removed():
             return ''
         return flag
 
     def filectx(self, path, filelog=None):
         """get a file context from the working directory"""
         return workingfilectx(self._repo, path, workingctx=self,
                               filelog=filelog)
 
     def ancestor(self, c2):
         """return the ancestor context of self and c2"""
         return self._parents[0].ancestor(c2) # punt on two parents for now
 
 class workingfilectx(filectx):
     """A workingfilectx object makes access to data related to a particular
        file in the working directory convenient."""
     def __init__(self, repo, path, filelog=None, workingctx=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         self._repo = repo
         self._path = path
         self._changeid = None
         self._filerev = self._filenode = None
 
         if filelog:
             self._filelog = filelog
         if workingctx:
             self._changectx = workingctx
 
     def __getattr__(self, name):
         if name == '_changectx':
             self._changectx = workingctx(self._repo)
             return self._changectx
         elif name == '_repopath':
             self._repopath = (self._repo.dirstate.copied(self._path)
                               or self._path)
             return self._repopath
         elif name == '_filelog':
             self._filelog = self._repo.file(self._repopath)
             return self._filelog
         else:
             raise AttributeError, name
 
     def __nonzero__(self):
         return True
 
     def __str__(self):
         return "%s@%s" % (self.path(), self._changectx)
 
     def filectx(self, fileid):
         '''opens an arbitrary revision of the file without
         opening a new filelog'''
         return filectx(self._repo, self._repopath, fileid=fileid,
                        filelog=self._filelog)
 
     def rev(self):
         if '_changectx' in self.__dict__:
             return self._changectx.rev()
         return self._filelog.linkrev(self._filenode)
 
     def data(self): return self._repo.wread(self._path)
     def renamed(self):
         rp = self._repopath
         if rp == self._path:
             return None
         return rp, self._changectx._parents[0]._manifest.get(rp, nullid)
 
     def parents(self):
         '''return parent filectxs, following copies if necessary'''
         p = self._path
         rp = self._repopath
         pcl = self._changectx._parents
         fl = self._filelog
         pl = [(rp, pcl[0]._manifest.get(rp, nullid), fl)]
         if len(pcl) > 1:
             if rp != p:
                 fl = None
             pl.append((p, pcl[1]._manifest.get(p, nullid), fl))
 
         return [filectx(self._repo, p, fileid=n, filelog=l)
                 for p,n,l in pl if n != nullid]
 
     def children(self):
         return []
 
     def size(self): return os.stat(self._repo.wjoin(self._path)).st_size
     def date(self):
         t, tz = self._changectx.date()
         try:
             return (int(os.lstat(self._repo.wjoin(self._path)).st_mtime), tz)
         except OSError, err:
             if err.errno != errno.ENOENT: raise
             return (t, tz)
 
     def cmp(self, text): return self._repo.wread(self._path) == text

mercurial/revlog.py

@@ -1,1319 +1,1319 b''
 """
 revlog.py - storage back-end for mercurial
 
 This provides efficient delta storage with O(1) retrieve and append
 and O(changes) merge between branches
 
 Copyright 2005-2007 Matt Mackall <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 """
 
 from node import bin, hex, nullid, nullrev, short
 from i18n import _
 import changegroup, errno, ancestor, mdiff
 import sha, struct, util, zlib
 
 _pack = struct.pack
 _unpack = struct.unpack
 _compress = zlib.compress
 _decompress = zlib.decompress
 _sha = sha.new
 
 # revlog flags
 REVLOGV0 = 0
 REVLOGNG = 1
 REVLOGNGINLINEDATA = (1 << 16)
 REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA
 REVLOG_DEFAULT_FORMAT = REVLOGNG
 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS
 
 class RevlogError(Exception):
     pass
 
 class LookupError(RevlogError):
-    def __init__(self, name, message=None):
-        if message is None:
-            message = _('not found: %s') % name
-        RevlogError.__init__(self, message)
+    def __init__(self, name, index, message):
         self.name = name
+        if isinstance(name, str) and len(name) == 20:
+            name = short(name)
+        RevlogError.__init__(self, _('%s@%s: %s') % (index, name, message))
 
 def getoffset(q):
     return int(q >> 16)
 
 def gettype(q):
     return int(q & 0xFFFF)
 
 def offset_type(offset, type):
     return long(long(offset) << 16 | type)
 
 def hash(text, p1, p2):
     """generate a hash from the given text and its parent hashes
 
     This hash combines both the current file contents and its history
     in a manner that makes it easy to distinguish nodes with the same
     content in the revision graph.
     """
     l = [p1, p2]
     l.sort()
     s = _sha(l[0])
     s.update(l[1])
     s.update(text)
     return s.digest()
 
 def compress(text):
     """ generate a possibly-compressed representation of text """
     if not text:
         return ("", text)
     l = len(text)
     bin = None
     if l < 44:
         pass
     elif l > 1000000:
         # zlib makes an internal copy, thus doubling memory usage for
         # large files, so lets do this in pieces
         z = zlib.compressobj()
         p = []
         pos = 0
         while pos < l:
             pos2 = pos + 2**20
             p.append(z.compress(text[pos:pos2]))
             pos = pos2
         p.append(z.flush())
         if sum(map(len, p)) < l:
             bin = "".join(p)
     else:
         bin = _compress(text)
     if bin is None or len(bin) > l:
         if text[0] == '\0':
             return ("", text)
         return ('u', text)
     return ("", bin)
 
 def decompress(bin):
     """ decompress the given input """
     if not bin:
         return bin
     t = bin[0]
     if t == '\0':
         return bin
     if t == 'x':
         return _decompress(bin)
     if t == 'u':
         return bin[1:]
     raise RevlogError(_("unknown compression type %r") % t)
 
 class lazyparser(object):
     """
     this class avoids the need to parse the entirety of large indices
     """
 
     # lazyparser is not safe to use on windows if win32 extensions not
     # available. it keeps file handle open, which make it not possible
     # to break hardlinks on local cloned repos.
 
     def __init__(self, dataf, size):
         self.dataf = dataf
         self.s = struct.calcsize(indexformatng)
         self.datasize = size
         self.l = size/self.s
         self.index = [None] * self.l
         self.map = {nullid: nullrev}
         self.allmap = 0
         self.all = 0
         self.mapfind_count = 0
 
     def loadmap(self):
         """
         during a commit, we need to make sure the rev being added is
         not a duplicate.  This requires loading the entire index,
         which is fairly slow.  loadmap can load up just the node map,
         which takes much less time.
         """
         if self.allmap:
             return
         end = self.datasize
         self.allmap = 1
         cur = 0
         count = 0
         blocksize = self.s * 256
         self.dataf.seek(0)
         while cur < end:
             data = self.dataf.read(blocksize)
             off = 0
             for x in xrange(256):
                 n = data[off + ngshaoffset:off + ngshaoffset + 20]
                 self.map[n] = count
                 count += 1
                 if count >= self.l:
                     break
                 off += self.s
             cur += blocksize
 
     def loadblock(self, blockstart, blocksize, data=None):
         if self.all:
             return
         if data is None:
             self.dataf.seek(blockstart)
             if blockstart + blocksize > self.datasize:
                 # the revlog may have grown since we've started running,
                 # but we don't have space in self.index for more entries.
                 # limit blocksize so that we don't get too much data.
                 blocksize = max(self.datasize - blockstart, 0)
             data = self.dataf.read(blocksize)
         lend = len(data) / self.s
         i = blockstart / self.s
         off = 0
         # lazyindex supports __delitem__
         if lend > len(self.index) - i:
             lend = len(self.index) - i
         for x in xrange(lend):
             if self.index[i + x] == None:
                 b = data[off : off + self.s]
                 self.index[i + x] = b
                 n = b[ngshaoffset:ngshaoffset + 20]
                 self.map[n] = i + x
             off += self.s
 
     def findnode(self, node):
         """search backwards through the index file for a specific node"""
         if self.allmap:
             return None
 
         # hg log will cause many many searches for the manifest
         # nodes.  After we get called a few times, just load the whole
         # thing.
         if self.mapfind_count > 8:
             self.loadmap()
             if node in self.map:
                 return node
             return None
         self.mapfind_count += 1
         last = self.l - 1
         while self.index[last] != None:
             if last == 0:
                 self.all = 1
                 self.allmap = 1
                 return None
             last -= 1
         end = (last + 1) * self.s
         blocksize = self.s * 256
         while end >= 0:
             start = max(end - blocksize, 0)
             self.dataf.seek(start)
             data = self.dataf.read(end - start)
             findend = end - start
             while True:
                 # we're searching backwards, so we have to make sure
                 # we don't find a changeset where this node is a parent
                 off = data.find(node, 0, findend)
                 findend = off
                 if off >= 0:
                     i = off / self.s
                     off = i * self.s
                     n = data[off + ngshaoffset:off + ngshaoffset + 20]
                     if n == node:
                         self.map[n] = i + start / self.s
                         return node
                 else:
                     break
             end -= blocksize
         return None
 
     def loadindex(self, i=None, end=None):
         if self.all:
             return
         all = False
         if i == None:
             blockstart = 0
             blocksize = (65536 / self.s) * self.s
             end = self.datasize
             all = True
         else:
             if end:
                 blockstart = i * self.s
                 end = end * self.s
                 blocksize = end - blockstart
             else:
                 blockstart = (i & ~1023) * self.s
                 blocksize = self.s * 1024
                 end = blockstart + blocksize
         while blockstart < end:
             self.loadblock(blockstart, blocksize)
             blockstart += blocksize
         if all:
             self.all = True
 
 class lazyindex(object):
     """a lazy version of the index array"""
     def __init__(self, parser):
         self.p = parser
     def __len__(self):
         return len(self.p.index)
     def load(self, pos):
         if pos < 0:
             pos += len(self.p.index)
         self.p.loadindex(pos)
         return self.p.index[pos]
     def __getitem__(self, pos):
         return _unpack(indexformatng, self.p.index[pos] or self.load(pos))
     def __setitem__(self, pos, item):
         self.p.index[pos] = _pack(indexformatng, *item)
     def __delitem__(self, pos):
         del self.p.index[pos]
     def insert(self, pos, e):
         self.p.index.insert(pos, _pack(indexformatng, *e))
     def append(self, e):
         self.p.index.append(_pack(indexformatng, *e))
 
 class lazymap(object):
     """a lazy version of the node map"""
     def __init__(self, parser):
         self.p = parser
     def load(self, key):
         n = self.p.findnode(key)
         if n == None:
             raise KeyError(key)
     def __contains__(self, key):
         if key in self.p.map:
             return True
         self.p.loadmap()
         return key in self.p.map
     def __iter__(self):
         yield nullid
         for i in xrange(self.p.l):
             ret = self.p.index[i]
             if not ret:
                 self.p.loadindex(i)
                 ret = self.p.index[i]
             if isinstance(ret, str):
                 ret = _unpack(indexformatng, ret)
             yield ret[7]
     def __getitem__(self, key):
         try:
             return self.p.map[key]
         except KeyError:
             try:
                 self.load(key)
                 return self.p.map[key]
             except KeyError:
                 raise KeyError("node " + hex(key))
     def __setitem__(self, key, val):
         self.p.map[key] = val
     def __delitem__(self, key):
         del self.p.map[key]
 
 indexformatv0 = ">4l20s20s20s"
 v0shaoffset = 56
 
 class revlogoldio(object):
     def __init__(self):
         self.size = struct.calcsize(indexformatv0)
 
     def parseindex(self, fp, inline):
         s = self.size
         index = []
         nodemap =  {nullid: nullrev}
         n = off = 0
         data = fp.read()
         l = len(data)
         while off + s <= l:
             cur = data[off:off + s]
             off += s
             e = _unpack(indexformatv0, 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 index, nodemap, None
 
     def packentry(self, entry, node, version, rev):
         e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
               node(entry[5]), node(entry[6]), entry[7])
         return _pack(indexformatv0, *e2)
 
 # index ng:
 # 6 bytes offset
 # 2 bytes flags
 # 4 bytes compressed length
 # 4 bytes uncompressed length
 # 4 bytes: base rev
 # 4 bytes link rev
 # 4 bytes parent 1 rev
 # 4 bytes parent 2 rev
 # 32 bytes: nodeid
 indexformatng = ">Qiiiiii20s12x"
 ngshaoffset = 32
 versionformat = ">I"
 
 class revlogio(object):
     def __init__(self):
         self.size = struct.calcsize(indexformatng)
 
     def parseindex(self, fp, inline):
         try:
             size = util.fstat(fp).st_size
         except AttributeError:
             size = 0
 
         if util.openhardlinks() and not inline and size > 1000000:
             # big index, let's parse it on demand
             parser = lazyparser(fp, size)
             index = lazyindex(parser)
             nodemap = lazymap(parser)
             e = list(index[0])
             type = gettype(e[0])
             e[0] = offset_type(0, type)
             index[0] = e
             return index, nodemap, None
 
         s = self.size
         cache = None
         index = []
         nodemap =  {nullid: nullrev}
         n = off = 0
         # if we're not using lazymap, always read the whole index
         data = fp.read()
         l = len(data) - s
         append = index.append
         if inline:
             cache = (0, data)
             while off <= l:
                 e = _unpack(indexformatng, data[off:off + s])
                 nodemap[e[7]] = n
                 append(e)
                 n += 1
                 if e[1] < 0:
                     break
                 off += e[1] + s
         else:
             while off <= l:
                 e = _unpack(indexformatng, data[off:off + s])
                 nodemap[e[7]] = n
                 append(e)
                 n += 1
                 off += s
 
         e = list(index[0])
         type = gettype(e[0])
         e[0] = offset_type(0, type)
         index[0] = e
 
         return index, nodemap, cache
 
     def packentry(self, entry, node, version, rev):
         p = _pack(indexformatng, *entry)
         if rev == 0:
             p = _pack(versionformat, version) + p[4:]
         return p
 
 class revlog(object):
     """
     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, includings 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.
     """
     def __init__(self, opener, indexfile):
         """
         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.
         """
         self.indexfile = indexfile
         self.datafile = indexfile[:-2] + ".d"
         self.opener = opener
         self._cache = None
         self._chunkcache = None
         self.nodemap = {nullid: nullrev}
         self.index = []
 
         v = REVLOG_DEFAULT_VERSION
         if hasattr(opener, "defversion"):
             v = opener.defversion
             if v & REVLOGNG:
                 v |= REVLOGNGINLINEDATA
 
         i = ""
         try:
             f = self.opener(self.indexfile)
             i = f.read(4)
             f.seek(0)
             if len(i) > 0:
                 v = struct.unpack(versionformat, i)[0]
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
 
         self.version = v
         self._inline = v & REVLOGNGINLINEDATA
         flags = v & ~0xFFFF
         fmt = v & 0xFFFF
         if fmt == REVLOGV0 and flags:
             raise RevlogError(_("index %s unknown flags %#04x for format v0")
                               % (self.indexfile, flags >> 16))
         elif fmt == REVLOGNG and flags & ~REVLOGNGINLINEDATA:
             raise RevlogError(_("index %s unknown flags %#04x for revlogng")
                               % (self.indexfile, flags >> 16))
         elif fmt > REVLOGNG:
             raise RevlogError(_("index %s unknown format %d")
                               % (self.indexfile, fmt))
 
         self._io = revlogio()
         if self.version == REVLOGV0:
             self._io = revlogoldio()
         if i:
             d = self._io.parseindex(f, self._inline)
             self.index, self.nodemap, self._chunkcache = d
 
         # add the magic null revision at -1
         self.index.append((0, 0, 0, -1, -1, -1, -1, nullid))
 
     def _loadindex(self, start, end):
         """load a block of indexes all at once from the lazy parser"""
         if isinstance(self.index, lazyindex):
             self.index.p.loadindex(start, end)
 
     def _loadindexmap(self):
         """loads both the map and the index from the lazy parser"""
         if isinstance(self.index, lazyindex):
             p = self.index.p
             p.loadindex()
             self.nodemap = p.map
 
     def _loadmap(self):
         """loads the map from the lazy parser"""
         if isinstance(self.nodemap, lazymap):
             self.nodemap.p.loadmap()
             self.nodemap = self.nodemap.p.map
 
     def tip(self):
         return self.node(len(self.index) - 2)
     def count(self):
         return len(self.index) - 1
 
     def rev(self, node):
         try:
             return self.nodemap[node]
         except KeyError:
-            raise LookupError(hex(node), _('%s: no node %s') % (self.indexfile, hex(node)))
+            raise LookupError(node, self.indexfile, _('no node'))
     def node(self, rev):
         return self.index[rev][7]
     def linkrev(self, node):
         return self.index[self.rev(node)][4]
     def parents(self, node):
         d = self.index[self.rev(node)][5:7]
         return (self.node(d[0]), self.node(d[1]))
     def parentrevs(self, rev):
         return self.index[rev][5:7]
     def start(self, rev):
         return int(self.index[rev][0] >> 16)
     def end(self, rev):
         return self.start(rev) + self.length(rev)
     def length(self, rev):
         return self.index[rev][1]
     def base(self, rev):
         return self.index[rev][3]
 
     def size(self, rev):
         """return the length of the uncompressed text for a given revision"""
         l = self.index[rev][2]
         if l >= 0:
             return l
 
         t = self.revision(self.node(rev))
         return len(t)
 
         # alternate implementation, The advantage to this code is it
         # will be faster for a single revision.  But, the results are not
         # cached, so finding the size of every revision will be slower.
         """
         if self.cache and self.cache[1] == rev:
             return len(self.cache[2])
 
         base = self.base(rev)
         if self.cache and self.cache[1] >= base and self.cache[1] < rev:
             base = self.cache[1]
             text = self.cache[2]
         else:
             text = self.revision(self.node(base))
 
         l = len(text)
         for x in xrange(base + 1, rev + 1):
             l = mdiff.patchedsize(l, self.chunk(x))
         return l
         """
 
     def reachable(self, node, stop=None):
         """return a hash of all nodes ancestral to a given node, including
          the node itself, stopping when stop is matched"""
         reachable = {}
         visit = [node]
         reachable[node] = 1
         if stop:
             stopn = self.rev(stop)
         else:
             stopn = 0
         while visit:
             n = visit.pop(0)
             if n == stop:
                 continue
             if n == nullid:
                 continue
             for p in self.parents(n):
                 if self.rev(p) < stopn:
                     continue
                 if p not in reachable:
                     reachable[p] = 1
                     visit.append(p)
         return reachable
 
     def nodesbetween(self, roots=None, heads=None):
         """Return a tuple containing three elements. Elements 1 and 2 contain
         a final list bases and heads after all the unreachable ones have been
         pruned.  Element 0 contains a topologically sorted list of all
 
         nodes that satisfy these constraints:
         1. All nodes must be descended from a node in roots (the nodes on
            roots are considered descended from themselves).
         2. All nodes must also be ancestors of a node in heads (the nodes in
            heads are considered to be their own ancestors).
 
         If roots is unspecified, nullid is assumed as the only root.
         If heads is unspecified, it is taken to be the output of the
         heads method (i.e. a list of all nodes in the repository that
         have no children)."""
         nonodes = ([], [], [])
         if roots is not None:
             roots = list(roots)
             if not roots:
                 return nonodes
             lowestrev = min([self.rev(n) for n in roots])
         else:
             roots = [nullid] # Everybody's a descendent of nullid
             lowestrev = nullrev
         if (lowestrev == nullrev) and (heads is None):
             # We want _all_ the nodes!
             return ([self.node(r) for r in xrange(0, self.count())],
                     [nullid], list(self.heads()))
         if heads is None:
             # All nodes are ancestors, so the latest ancestor is the last
             # node.
             highestrev = self.count() - 1
             # Set ancestors to None to signal that every node is an ancestor.
             ancestors = None
             # Set heads to an empty dictionary for later discovery of heads
             heads = {}
         else:
             heads = list(heads)
             if not heads:
                 return nonodes
             ancestors = {}
             # Turn heads into a dictionary so we can remove 'fake' heads.
             # Also, later we will be using it to filter out the heads we can't
             # find from roots.
             heads = dict.fromkeys(heads, 0)
             # Start at the top and keep marking parents until we're done.
             nodestotag = heads.keys()
             # Remember where the top was so we can use it as a limit later.
             highestrev = max([self.rev(n) for n in nodestotag])
             while nodestotag:
                 # grab a node to tag
                 n = nodestotag.pop()
                 # Never tag nullid
                 if n == nullid:
                     continue
                 # A node's revision number represents its place in a
                 # topologically sorted list of nodes.
                 r = self.rev(n)
                 if r >= lowestrev:
                     if n not in ancestors:
                         # If we are possibly a descendent of one of the roots
                         # and we haven't already been marked as an ancestor
                         ancestors[n] = 1 # Mark as ancestor
                         # Add non-nullid parents to list of nodes to tag.
                         nodestotag.extend([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
             # Now that we have our set of ancestors, we want to remove any
             # roots that are not ancestors.
 
             # If one of the roots was nullid, everything is included anyway.
             if lowestrev > nullrev:
                 # But, since we weren't, let's recompute the lowest rev to not
                 # include roots that aren't ancestors.
 
                 # Filter out roots that aren't ancestors of heads
                 roots = [n for n in roots if n in ancestors]
                 # Recompute the lowest revision
                 if roots:
                     lowestrev = min([self.rev(n) for n in roots])
                 else:
                     # No more roots?  Return empty list
                     return nonodes
             else:
                 # We are descending from nullid, and don't need to care about
                 # any other roots.
                 lowestrev = nullrev
                 roots = [nullid]
         # Transform our roots list into a 'set' (i.e. a dictionary where the
         # values don't matter.
         descendents = dict.fromkeys(roots, 1)
         # Also, keep the original roots so we can filter out roots that aren't
         # 'real' roots (i.e. are descended from other roots).
         roots = descendents.copy()
         # Our topologically sorted list of output nodes.
         orderedout = []
         # Don't start at nullid since we don't want nullid in our output list,
         # and if nullid shows up in descedents, empty parents will look like
         # they're descendents.
         for r in xrange(max(lowestrev, 0), highestrev + 1):
             n = self.node(r)
             isdescendent = False
             if lowestrev == nullrev:  # Everybody is a descendent of nullid
                 isdescendent = True
             elif n in descendents:
                 # n is already a descendent
                 isdescendent = True
                 # This check only needs to be done here because all the roots
                 # will start being marked is descendents before the loop.
                 if n in roots:
                     # If n was a root, check if it's a 'real' root.
                     p = tuple(self.parents(n))
                     # If any of its parents are descendents, it's not a root.
                     if (p[0] in descendents) or (p[1] in descendents):
                         roots.pop(n)
             else:
                 p = tuple(self.parents(n))
                 # A node is a descendent if either of its parents are
                 # descendents.  (We seeded the dependents list with the roots
                 # up there, remember?)
                 if (p[0] in descendents) or (p[1] in descendents):
                     descendents[n] = 1
                     isdescendent = True
             if isdescendent and ((ancestors is None) or (n in ancestors)):
                 # Only include nodes that are both descendents and ancestors.
                 orderedout.append(n)
                 if (ancestors is not None) and (n in heads):
                     # We're trying to figure out which heads are reachable
                     # from roots.
                     # Mark this head as having been reached
                     heads[n] = 1
                 elif ancestors is None:
                     # Otherwise, we're trying to discover the heads.
                     # Assume this is a head because if it isn't, the next step
                     # will eventually remove it.
                     heads[n] = 1
                     # But, obviously its parents aren't.
                     for p in self.parents(n):
                         heads.pop(p, None)
         heads = [n for n in heads.iterkeys() if heads[n] != 0]
         roots = roots.keys()
         assert orderedout
         assert roots
         assert heads
         return (orderedout, roots, heads)
 
     def heads(self, start=None, stop=None):
         """return the list of all nodes that have no children
 
         if start is specified, only heads that are descendants of
         start will be returned
         if stop is specified, it will consider all the revs from stop
         as if they had no children
         """
         if start is None and stop is None:
             count = self.count()
             if not count:
                 return [nullid]
             ishead = [1] * (count + 1)
             index = self.index
             for r in xrange(count):
                 e = index[r]
                 ishead[e[5]] = ishead[e[6]] = 0
             return [self.node(r) for r in xrange(count) if ishead[r]]
 
         if start is None:
             start = nullid
         if stop is None:
             stop = []
         stoprevs = dict.fromkeys([self.rev(n) for n in stop])
         startrev = self.rev(start)
         reachable = {startrev: 1}
         heads = {startrev: 1}
 
         parentrevs = self.parentrevs
         for r in xrange(startrev + 1, self.count()):
             for p in parentrevs(r):
                 if p in reachable:
                     if r not in stoprevs:
                         reachable[r] = 1
                     heads[r] = 1
                 if p in heads and p not in stoprevs:
                     del heads[p]
 
         return [self.node(r) for r in heads]
 
     def children(self, node):
         """find the children of a given node"""
         c = []
         p = self.rev(node)
         for r in range(p + 1, self.count()):
             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
             if prevs:
                 for pr in prevs:
                     if pr == p:
                         c.append(self.node(r))
             elif p == nullrev:
                 c.append(self.node(r))
         return c
 
     def _match(self, id):
         if isinstance(id, (long, int)):
             # rev
             return self.node(id)
         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
                 r = self.rev(node) # quick search the index
                 return node
             except LookupError:
                 pass # may be partial hex id
         try:
             # str(rev)
             rev = int(id)
             if str(rev) != id:
                 raise ValueError
             if rev < 0:
                 rev = self.count() + rev
             if rev < 0 or rev >= self.count():
                 raise ValueError
             return self.node(rev)
         except (ValueError, OverflowError):
             pass
         if len(id) == 40:
             try:
                 # a full hex nodeid?
                 node = bin(id)
                 r = self.rev(node)
                 return node
             except TypeError:
                 pass
 
     def _partialmatch(self, id):
         if len(id) < 40:
             try:
                 # hex(node)[:...]
                 bin_id = bin(id[:len(id) & ~1]) # grab an even number of digits
                 node = None
                 for n in self.nodemap:
                     if n.startswith(bin_id) and hex(n).startswith(id):
                         if node is not None:
-                            raise LookupError(hex(node),
-                                              _("Ambiguous identifier"))
+                            raise LookupError(id, self.indexfile,
+                                              _('ambiguous identifier'))
                         node = n
                 if node is not None:
                     return node
             except TypeError:
                 pass
 
     def lookup(self, id):
         """locate a node based on:
             - revision number or str(revision number)
             - nodeid or subset of hex nodeid
         """
         n = self._match(id)
         if n is not None:
             return n
         n = self._partialmatch(id)
         if n:
             return n
 
-        raise LookupError(id, _("No match found"))
+        raise LookupError(id, self.indexfile, _('no match found'))
 
     def cmp(self, node, text):
         """compare text with a given file revision"""
         p1, p2 = self.parents(node)
         return hash(text, p1, p2) != node
 
     def chunk(self, rev, df=None):
         def loadcache(df):
             if not df:
                 if self._inline:
                     df = self.opener(self.indexfile)
                 else:
                     df = self.opener(self.datafile)
             df.seek(start)
             self._chunkcache = (start, df.read(cache_length))
 
         start, length = self.start(rev), self.length(rev)
         if self._inline:
             start += (rev + 1) * self._io.size
         end = start + length
 
         offset = 0
         if not self._chunkcache:
             cache_length = max(65536, length)
             loadcache(df)
         else:
             cache_start = self._chunkcache[0]
             cache_length = len(self._chunkcache[1])
             cache_end = cache_start + cache_length
             if start >= cache_start and end <= cache_end:
                 # it is cached
                 offset = start - cache_start
             else:
                 cache_length = max(65536, length)
                 loadcache(df)
 
         # avoid copying large chunks
         c = self._chunkcache[1]
         if cache_length != length:
             c = c[offset:offset + length]
 
         return decompress(c)
 
     def delta(self, node):
         """return or calculate a delta between a node and its predecessor"""
         r = self.rev(node)
         return self.revdiff(r - 1, r)
 
     def revdiff(self, rev1, rev2):
         """return or calculate a delta between two revisions"""
         if rev1 + 1 == rev2 and self.base(rev1) == self.base(rev2):
             return self.chunk(rev2)
 
         return mdiff.textdiff(self.revision(self.node(rev1)),
                               self.revision(self.node(rev2)))
 
     def revision(self, node):
         """return an uncompressed revision of a given"""
         if node == nullid:
             return ""
         if self._cache and self._cache[0] == node:
             return str(self._cache[2])
 
         # look up what we need to read
         text = None
         rev = self.rev(node)
         base = self.base(rev)
 
         # check rev flags
         if self.index[rev][0] & 0xFFFF:
             raise RevlogError(_('incompatible revision flag %x') %
                               (self.index[rev][0] & 0xFFFF))
 
         df = None
 
         # do we have useful data cached?
         if self._cache and self._cache[1] >= base and self._cache[1] < rev:
             base = self._cache[1]
             text = str(self._cache[2])
             self._loadindex(base, rev + 1)
             if not self._inline and rev > base + 1:
                 df = self.opener(self.datafile)
         else:
             self._loadindex(base, rev + 1)
             if not self._inline and rev > base:
                 df = self.opener(self.datafile)
             text = self.chunk(base, df=df)
 
         bins = [self.chunk(r, df) for r in xrange(base + 1, rev + 1)]
         text = mdiff.patches(text, bins)
         p1, p2 = self.parents(node)
         if node != hash(text, p1, p2):
             raise RevlogError(_("integrity check failed on %s:%d")
                               % (self.datafile, rev))
 
         self._cache = (node, rev, text)
         return text
 
     def checkinlinesize(self, tr, fp=None):
         if not self._inline:
             return
         if not fp:
             fp = self.opener(self.indexfile, 'r')
             fp.seek(0, 2)
         size = fp.tell()
         if size < 131072:
             return
         trinfo = tr.find(self.indexfile)
         if trinfo == None:
             raise RevlogError(_("%s not found in the transaction")
                               % self.indexfile)
 
         trindex = trinfo[2]
         dataoff = self.start(trindex)
 
         tr.add(self.datafile, dataoff)
         df = self.opener(self.datafile, 'w')
         calc = self._io.size
         for r in xrange(self.count()):
             start = self.start(r) + (r + 1) * calc
             length = self.length(r)
             fp.seek(start)
             d = fp.read(length)
             df.write(d)
         fp.close()
         df.close()
         fp = self.opener(self.indexfile, 'w', atomictemp=True)
         self.version &= ~(REVLOGNGINLINEDATA)
         self._inline = False
         for i in xrange(self.count()):
             e = self._io.packentry(self.index[i], self.node, self.version, i)
             fp.write(e)
 
         # if we don't call rename, the temp file will never replace the
         # real index
         fp.rename()
 
         tr.replace(self.indexfile, trindex * calc)
         self._chunkcache = None
 
     def addrevision(self, text, transaction, link, p1, p2, d=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
         p1, p2 - the parent nodeids of the revision
         d - an optional precomputed delta
         """
         dfh = None
         if not self._inline:
             dfh = self.opener(self.datafile, "a")
         ifh = self.opener(self.indexfile, "a+")
         return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)
 
     def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
         node = hash(text, p1, p2)
         if node in self.nodemap:
             return node
 
         curr = self.count()
         prev = curr - 1
         base = self.base(prev)
         offset = self.end(prev)
 
         if curr:
             if not d:
                 ptext = self.revision(self.node(prev))
                 d = mdiff.textdiff(ptext, text)
             data = compress(d)
             l = len(data[1]) + len(data[0])
             dist = l + offset - self.start(base)
 
         # full versions are inserted when the needed deltas
         # become comparable to the uncompressed text
         if not curr or dist > len(text) * 2:
             data = compress(text)
             l = len(data[1]) + len(data[0])
             base = curr
 
         e = (offset_type(offset, 0), l, len(text),
              base, link, self.rev(p1), self.rev(p2), node)
         self.index.insert(-1, e)
         self.nodemap[node] = curr
 
         entry = self._io.packentry(e, self.node, self.version, curr)
         if not self._inline:
             transaction.add(self.datafile, offset)
             transaction.add(self.indexfile, curr * len(entry))
             if data[0]:
                 dfh.write(data[0])
             dfh.write(data[1])
             dfh.flush()
             ifh.write(entry)
         else:
             offset += curr * self._io.size
             transaction.add(self.indexfile, offset, curr)
             ifh.write(entry)
             ifh.write(data[0])
             ifh.write(data[1])
             self.checkinlinesize(transaction, ifh)
 
         self._cache = (node, curr, text)
         return node
 
     def ancestor(self, a, b):
         """calculate the least common ancestor of nodes a and b"""
 
         def parents(rev):
             return [p for p in self.parentrevs(rev) if p != nullrev]
 
         c = ancestor.ancestor(self.rev(a), self.rev(b), parents)
         if c is None:
             return nullid
 
         return self.node(c)
 
     def group(self, nodelist, lookup, infocollect=None):
         """calculate a delta group
 
         Given a list of changeset revs, return a set of deltas and
         metadata corresponding to nodes. the first delta is
         parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
         have this parent as it has all history before these
         changesets. parent is parent[0]
         """
         revs = [self.rev(n) for n in nodelist]
 
         # if we don't have any revisions touched by these changesets, bail
         if not revs:
             yield changegroup.closechunk()
             return
 
         # add the parent of the first rev
         p = self.parents(self.node(revs[0]))[0]
         revs.insert(0, self.rev(p))
 
         # build deltas
         for d in xrange(0, len(revs) - 1):
             a, b = revs[d], revs[d + 1]
             nb = self.node(b)
 
             if infocollect is not None:
                 infocollect(nb)
 
             p = self.parents(nb)
             meta = nb + p[0] + p[1] + lookup(nb)
             if a == -1:
                 d = self.revision(nb)
                 meta += mdiff.trivialdiffheader(len(d))
             else:
                 d = self.revdiff(a, b)
             yield changegroup.chunkheader(len(meta) + len(d))
             yield meta
             if len(d) > 2**20:
                 pos = 0
                 while pos < len(d):
                     pos2 = pos + 2 ** 18
                     yield d[pos:pos2]
                     pos = pos2
             else:
                 yield d
 
         yield changegroup.closechunk()
 
     def addgroup(self, revs, linkmapper, transaction, unique=0):
         """
         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.
         """
 
         #track the base of the current delta log
         r = self.count()
         t = r - 1
         node = None
 
         base = prev = nullrev
         start = end = textlen = 0
         if r:
             end = self.end(t)
 
         ifh = self.opener(self.indexfile, "a+")
         isize = r * self._io.size
         if self._inline:
             transaction.add(self.indexfile, end + isize, r)
             dfh = None
         else:
             transaction.add(self.indexfile, isize, r)
             transaction.add(self.datafile, end)
             dfh = self.opener(self.datafile, "a")
 
         # loop through our set of deltas
         chain = None
         for chunk in revs:
             node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80])
             link = linkmapper(cs)
             if node in self.nodemap:
                 # this can happen if two branches make the same change
                 # if unique:
                 #    raise RevlogError(_("already have %s") % hex(node[:4]))
                 chain = node
                 continue
             delta = buffer(chunk, 80)
             del chunk
 
             for p in (p1, p2):
                 if not p in self.nodemap:
-                    raise LookupError(hex(p), _("unknown parent %s") % short(p))
+                    raise LookupError(p, self.indexfile, _('unknown parent'))
 
             if not chain:
                 # retrieve the parent revision of the delta chain
                 chain = p1
                 if not chain in self.nodemap:
-                    raise LookupError(hex(chain), _("unknown base %s") % short(chain[:4]))
+                    raise LookupError(chain, self.indexfile, _('unknown base'))
 
             # full versions are inserted when the needed deltas become
             # comparable to the uncompressed text or when the previous
             # version is not the one we have a delta against. We use
             # the size of the previous full rev as a proxy for the
             # current size.
 
             if chain == prev:
                 cdelta = compress(delta)
                 cdeltalen = len(cdelta[0]) + len(cdelta[1])
                 textlen = mdiff.patchedsize(textlen, delta)
 
             if chain != prev or (end - start + cdeltalen) > textlen * 2:
                 # flush our writes here so we can read it in revision
                 if dfh:
                     dfh.flush()
                 ifh.flush()
                 text = self.revision(chain)
                 if len(text) == 0:
                     # skip over trivial delta header
                     text = buffer(delta, 12)
                 else:
                     text = mdiff.patches(text, [delta])
                 del delta
                 chk = self._addrevision(text, transaction, link, p1, p2, None,
                                         ifh, dfh)
                 if not dfh and not self._inline:
                     # addrevision switched from inline to conventional
                     # reopen the index
                     dfh = self.opener(self.datafile, "a")
                     ifh = self.opener(self.indexfile, "a")
                 if chk != node:
                     raise RevlogError(_("consistency error adding group"))
                 textlen = len(text)
             else:
                 e = (offset_type(end, 0), cdeltalen, textlen, base,
                      link, self.rev(p1), self.rev(p2), node)
                 self.index.insert(-1, e)
                 self.nodemap[node] = r
                 entry = self._io.packentry(e, self.node, self.version, r)
                 if self._inline:
                     ifh.write(entry)
                     ifh.write(cdelta[0])
                     ifh.write(cdelta[1])
                     self.checkinlinesize(transaction, ifh)
                     if not self._inline:
                         dfh = self.opener(self.datafile, "a")
                         ifh = self.opener(self.indexfile, "a")
                 else:
                     dfh.write(cdelta[0])
                     dfh.write(cdelta[1])
                     ifh.write(entry)
 
             t, r, chain, prev = r, r + 1, node, node
             base = self.base(t)
             start = self.start(base)
             end = self.end(t)
 
         return node
 
     def strip(self, minlink):
         """truncate the revlog on the first revision with a linkrev >= minlink
 
         This function is called when we're stripping revision minlink and
         its descendants from the repository.
 
         We have to remove all revisions with linkrev >= minlink, because
         the equivalent changelog revisions will be renumbered after the
         strip.
 
         So we truncate the revlog on the first of these revisions, and
         trust that the caller has saved the revisions that shouldn't be
         removed and that it'll readd them after this truncation.
         """
         if self.count() == 0:
             return
 
         if isinstance(self.index, lazyindex):
             self._loadindexmap()
 
         for rev in xrange(0, self.count()):
             if self.index[rev][4] >= minlink:
                 break
         else:
             return
 
         # first truncate the files on disk
         end = self.start(rev)
         if not self._inline:
             df = self.opener(self.datafile, "a")
             df.truncate(end)
             end = rev * self._io.size
         else:
             end += rev * self._io.size
 
         indexf = self.opener(self.indexfile, "a")
         indexf.truncate(end)
 
         # then reset internal state in memory to forget those revisions
         self._cache = None
         self._chunkcache = None
         for x in xrange(rev, self.count()):
             del self.nodemap[self.node(x)]
 
         del self.index[rev:-1]
 
     def checksize(self):
         expected = 0
         if self.count():
             expected = max(0, self.end(self.count() - 1))
 
         try:
             f = self.opener(self.datafile)
             f.seek(0, 2)
             actual = f.tell()
             dd = actual - expected
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
             dd = 0
 
         try:
             f = self.opener(self.indexfile)
             f.seek(0, 2)
             actual = f.tell()
             s = self._io.size
             i = max(0, actual / s)
             di = actual - (i * s)
             if self._inline:
                 databytes = 0
                 for r in xrange(self.count()):
                     databytes += max(0, self.length(r))
                 dd = 0
                 di = actual - self.count() * s - databytes
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
             di = 0
 
         return (dd, di)

tests/test-bundle-r.out

@@ -1,232 +1,232 b''
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 2 files removed, 0 files unresolved
    rev    offset  length   base linkrev nodeid       p1           p2
      0         0       3      0       0 362fef284ce2 000000000000 000000000000
      1         3       5      1       1 125144f7e028 362fef284ce2 000000000000
      2         8       7      2       2 4c982badb186 125144f7e028 000000000000
      3        15       9      3       3 19b1fc555737 4c982badb186 000000000000
    rev    offset  length   base linkrev nodeid       p1           p2
      0         0      75      0       7 905359268f77 000000000000 000000000000
    rev    offset  length   base linkrev nodeid       p1           p2
      0         0      75      0       8 905359268f77 000000000000 000000000000
    rev    offset  length   base linkrev nodeid       p1           p2
      0         0       8      0       6 12ab3bcc5ea4 000000000000 000000000000
    rev    offset  length   base linkrev nodeid       p1           p2
      0         0      48      0       0 43eadb1d2d06 000000000000 000000000000
      1        48      48      1       1 8b89697eba2c 43eadb1d2d06 000000000000
      2        96      48      2       2 626a32663c2f 8b89697eba2c 000000000000
      3       144      48      3       3 f54c32f13478 626a32663c2f 000000000000
      4       192      58      3       6 de68e904d169 626a32663c2f 000000000000
      5       250      68      3       7 3b45cc2ab868 de68e904d169 000000000000
      6       318      54      6       8 24d86153a002 f54c32f13478 000000000000
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 4 files, 9 changesets, 7 total revisions
 searching for changes
 1 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 1 changesets, 1 total revisions
 0:5649c9d34dd8
 searching for changes
 2 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 2 changesets, 2 total revisions
 1:10b2180f755b
 searching for changes
 3 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 3 changesets with 3 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 3 changesets, 3 total revisions
 2:d62976ca1e50
 searching for changes
 4 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 4 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 4 changesets, 4 total revisions
 3:ac69c658229d
 searching for changes
 2 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 2 changesets, 2 total revisions
 1:5f4f3ceb285e
 searching for changes
 3 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 3 changesets with 3 changes to 1 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 1 files, 3 changesets, 3 total revisions
 2:024e4e7df376
 searching for changes
 4 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 5 changes to 2 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 2 files, 4 changesets, 5 total revisions
 3:1e3f6b843bd6
 searching for changes
 5 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 5 changesets with 6 changes to 3 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 3 files, 5 changesets, 6 total revisions
 4:80fe151401c2
 searching for changes
 5 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 5 changesets with 5 changes to 2 files
 (run 'hg update' to get a working copy)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 2 files, 5 changesets, 5 total revisions
 4:836ac62537ab
 pulling from ../test-7
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 2 changes to 3 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 4 files, 9 changesets, 7 total revisions
 rolling back last transaction
 % should fail
 abort: --base is incompatible with specifiying a destination
 abort: repository default-push not found!
 2 changesets found
 4 changesets found
 6 changesets found
 1 changesets found
 1 changesets found
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 % 2
 2:d62976ca1e50
 adding changesets
 transaction abort!
 rollback completed
-abort: unknown parent ac69c658229d!
+abort: 00changelog.i@ac69c658229d: unknown parent!
 % 2
 2:d62976ca1e50
 adding changesets
 adding manifests
 adding file changes
 added 6 changesets with 4 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 % 8
 8:836ac62537ab
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 4 files, 9 changesets, 7 total revisions
 rolling back last transaction
 % 2
 2:d62976ca1e50
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 2 files
 (run 'hg update' to get a working copy)
 % 4
 4:836ac62537ab
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 2 files, 5 changesets, 5 total revisions
 rolling back last transaction
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 3 changes to 3 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 % 6
 6:80fe151401c2
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 3 files, 7 changesets, 6 total revisions
 warning: detected divergent renames of afile to:
  anotherfile
  adifferentfile
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 7 changesets found
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding changesets
 adding manifests
 adding file changes
 added 7 changesets with 4 changes to 4 files
 (run 'hg update' to get a working copy)
 % 9
 9:607fe5912aad
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 4 files, 10 changesets, 7 total revisions

tests/test-diffdir.out

@@ -1,22 +1,22 b''
 diff -r acd8075edac9 b
 --- /dev/null
 +++ b/b
 @@ -0,0 +1,1 @@
 +123
 diff -r acd8075edac9 b
 --- /dev/null
 +++ b/b
 @@ -0,0 +1,1 @@
 +123
 diff -r acd8075edac9 a
 --- a/a
 +++ b/a
 @@ -0,0 +1,1 @@
 +foo
 diff -r acd8075edac9 b
 --- /dev/null
 +++ b/b
 @@ -0,0 +1,1 @@
 +123
-abort: Ambiguous identifier!
-abort: Ambiguous identifier!
+abort: 00changelog.i@: ambiguous identifier!
+abort: 00changelog.i@: ambiguous identifier!

tests/test-imerge.out

@@ -1,50 +1,50 b''
 adding bar
 adding foo
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 % start imerge
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 U foo
 foo
 bar
 bar
 bar
 % status -v
 merging e6da46716401 and 30d266f502e7
 U foo (foo2)
 % next
 foo
 % merge next
 merging foo and foo2
 all conflicts resolved
 % unresolve
 % merge foo
 merging foo and foo2
 all conflicts resolved
 % save
 % load
 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 R foo
 all conflicts resolved
 foo
 changeset:   3:fa9a6defdcaf
 tag:         tip
 parent:      2:e6da46716401
 parent:      1:30d266f502e7
 user:        test
 date:        Thu Jan 01 00:00:03 1970 +0000
 files:       foo foo2
 description:
 merged
 
 
 % nothing to merge -- tip
 abort: there is nothing to merge
 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 % nothing to merge
 abort: there is nothing to merge - use "hg update" instead
 % load unknown parent
-abort: merge parent e6da4671640124fe5d3d70d2f54441d6cd76ae35 not in repository
+abort: merge parent e6da46716401 not in repository

tests/test-log.out

@@ -1,223 +1,223 b''
 adding a
 changeset:   0:8580ff50825a
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     a
 
 % -f, directory
 abort: can only follow copies/renames for explicit file names
 % -f, but no args
 changeset:   4:b30c444c7c84
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:05 1970 +0000
 summary:     e
 
 changeset:   3:16b60bf3f99a
 user:        test
 date:        Thu Jan 01 00:00:04 1970 +0000
 summary:     d
 
 changeset:   2:21fba396af4c
 user:        test
 date:        Thu Jan 01 00:00:03 1970 +0000
 summary:     c
 
 changeset:   1:c0296dabce9b
 user:        test
 date:        Thu Jan 01 00:00:02 1970 +0000
 summary:     b
 
 changeset:   0:8580ff50825a
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     a
 
 % one rename
 changeset:   0:8580ff50825a
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 files:       a
 description:
 a
 
 
 % many renames
 changeset:   4:b30c444c7c84
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:05 1970 +0000
 files:       dir/b e
 description:
 e
 
 
 changeset:   2:21fba396af4c
 user:        test
 date:        Thu Jan 01 00:00:03 1970 +0000
 files:       b dir/b
 description:
 c
 
 
 changeset:   1:c0296dabce9b
 user:        test
 date:        Thu Jan 01 00:00:02 1970 +0000
 files:       b
 description:
 b
 
 
 changeset:   0:8580ff50825a
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 files:       a
 description:
 a
 
 
 % log copies
 4 e (dir/b)
 3 b (a)
 2 dir/b (b)
 1 b (a)
 0 
 % log copies, non-linear manifest
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding foo
 5 e (dir/b)
 % log copies, execute bit set
 6 
 % log -p d
 changeset:   3:16b60bf3f99a
 user:        test
 date:        Thu Jan 01 00:00:04 1970 +0000
 files:       a b d
 description:
 d
 
 
 diff -r 21fba396af4c -r 16b60bf3f99a d
 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
 +++ b/d	Thu Jan 01 00:00:04 1970 +0000
 @@ -0,0 +1,1 @@
 +a
 
 adding base
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding b1
 % log -f
 changeset:   3:e62f78d544b4
 tag:         tip
 parent:      1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1
 
 changeset:   1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     r1
 
 changeset:   0:67e992f2c4f3
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     base
 
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding b2
 % log -f -r 1:tip
 changeset:   1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     r1
 
 changeset:   2:60c670bf5b30
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     r2
 
 changeset:   3:e62f78d544b4
 parent:      1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1
 
 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 % log -r . with two parents
 warning: working directory has two parents, tag '.' uses the first
 changeset:   3:e62f78d544b4
 parent:      1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1
 
 % log -r . with one parent
 changeset:   5:302e9dd6890d
 tag:         tip
 parent:      3:e62f78d544b4
 parent:      4:ddb82e70d1a1
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     m12
 
 % log --follow-first
 changeset:   6:2404bbcab562
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1.1
 
 changeset:   5:302e9dd6890d
 parent:      3:e62f78d544b4
 parent:      4:ddb82e70d1a1
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     m12
 
 changeset:   3:e62f78d544b4
 parent:      1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1
 
 changeset:   1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     r1
 
 changeset:   0:67e992f2c4f3
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     base
 
 % log -P 2
 changeset:   6:2404bbcab562
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1.1
 
 changeset:   5:302e9dd6890d
 parent:      3:e62f78d544b4
 parent:      4:ddb82e70d1a1
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     m12
 
 changeset:   4:ddb82e70d1a1
 parent:      0:67e992f2c4f3
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b2
 
 changeset:   3:e62f78d544b4
 parent:      1:3d5bf5654eda
 user:        test
 date:        Thu Jan 01 00:00:01 1970 +0000
 summary:     b1
 
 % log -r ""
-abort: Ambiguous identifier!
+abort: 00changelog.i@: ambiguous identifier!