mercurial-crew-with-dirclash: comparison mercurial/revlog.py

equal deleted inserted replaced

-:c2febf5420e9
+:3addf4531643
 from node import *
 from i18n import _
 import binascii, changegroup, errno, ancestor, mdiff, os
 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)
 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.new(l[0])
+s = _sha(l[0])
 s.update(l[1])
 s.update(text)
 return s.digest()
 def compress(text):
 return ("", text)
 if len(text) < 44:
 if text[0] == '\0':
 return ("", text)
 return ('u', text)
-bin = zlib.compress(text)
+bin = _compress(text)
 if len(bin) > len(text):
 if text[0] == '\0':
 return ("", text)
 return ('u', text)
 return ("", bin)
 return bin
 t = bin[0]
 if t == '\0':
 return bin
 if t == 'x':
-return zlib.decompress(bin)
+return _decompress(bin)
 if t == 'u':
 return bin[1:]
 raise RevlogError(_("unknown compression type %r") % t)
 class lazyparser(object):
 if pos < 0:
 pos += len(self.p.index)
 self.p.loadindex(pos)
 return self.p.index[pos]
 def __getitem__(self, pos):
-return struct.unpack(indexformatng,
+return _unpack(indexformatng, self.p.index[pos] or self.load(pos))
-self.p.index[pos] or self.load(pos))
 def __setitem__(self, pos, item):
-self.p.index[pos] = struct.pack(indexformatng, *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, struct.pack(indexformatng, *e))
+self.p.index.insert(pos, _pack(indexformatng, *e))
 def append(self, e):
-self.p.index.append(struct.pack(indexformatng, *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
 ret = self.p.index[i]
 if not ret:
 self.p.loadindex(i)
 ret = self.p.index[i]
 if isinstance(ret, str):
-ret = struct.unpack(indexformatng, ret)
+ret = _unpack(indexformatng, ret)
 yield ret[7]
 def __getitem__(self, key):
 try:
 return self.p.map[key]
 except KeyError:
 data = fp.read()
 l = len(data)
 while off + s <= l:
 cur = data[off:off + s]
 off += s
-e = struct.unpack(indexformatv0, cur)
+e = _unpack(indexformatv0, cur)
 # transform to revlogv1 format
 e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
 nodemap[e[4]], nodemap[e[5]], e[6])
 index.append(e2)
 nodemap[e[6]] = n
 return index, nodemap, None
 def packentry(self, entry, node, version):
 e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
 node(entry[5]), node(entry[6]), entry[7])
-return struct.pack(indexformatv0, *e2)
+return _pack(indexformatv0, *e2)
 # index ng:
 # 6 bytes offset
 # 2 bytes flags
 # 4 bytes compressed length
 nodemap =  {nullid: nullrev}
 n = off = 0
 # if we're not using lazymap, always read the whole index
 data = fp.read()
 l = len(data) - s
-unpack = struct.unpack
 append = index.append
 if inline:
 cache = (0, data)
 while off <= l:
-e = unpack(indexformatng, data[off:off + s])
+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])
+e = _unpack(indexformatng, data[off:off + s])
 nodemap[e[7]] = n
 append(e)
 n += 1
 off += s
 index[0] = e
 return index, nodemap, cache
 def packentry(self, entry, node, version):
-p = struct.pack(indexformatng, *entry)
+p = _pack(indexformatng, *entry)
 if not entry[3] and not getoffset(entry[0]) and entry[5] == nullrev:
-p = struct.pack(versionformat, version) + p[4:]
+p = _pack(versionformat, version) + p[4:]
 return p
 class revlog(object):
 """
 the underlying revision storage object

changeset 5008	3addf4531643
parent 5007	c2febf5420e9
child 5320	8409a2e3a78d
child 5322	fb070713ff36