Show More
@@ -292,9 +292,10 b' def offset_type(offset, type):' | |||||
292 | class revlogoldio(object): |
|
292 | class revlogoldio(object): | |
293 | def __init__(self): |
|
293 | def __init__(self): | |
294 | self.chunkcache = None |
|
294 | self.chunkcache = None | |
|
295 | self.size = struct.calcsize(indexformatv0) | |||
295 |
|
296 | |||
296 | def parseindex(self, fp, st, inline): |
|
297 | def parseindex(self, fp, st, inline): | |
297 | s = struct.calcsize(indexformatv0) |
|
298 | s = self.size | |
298 | index = [] |
|
299 | index = [] | |
299 | nodemap = {nullid: nullrev} |
|
300 | nodemap = {nullid: nullrev} | |
300 | n = off = 0 |
|
301 | n = off = 0 | |
@@ -304,8 +305,11 b' class revlogoldio(object):' | |||||
304 | cur = data[off:off + s] |
|
305 | cur = data[off:off + s] | |
305 | off += s |
|
306 | off += s | |
306 | e = struct.unpack(indexformatv0, cur) |
|
307 | e = struct.unpack(indexformatv0, cur) | |
307 | index.append(e) |
|
308 | # transform to revlogv1 format | |
308 | nodemap[e[-1]] = n |
|
309 | e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3], | |
|
310 | nodemap[e[4]], nodemap[e[5]], e[6]) | |||
|
311 | index.append(e2) | |||
|
312 | nodemap[e[6]] = n | |||
309 | n += 1 |
|
313 | n += 1 | |
310 |
|
314 | |||
311 | return index, nodemap |
|
315 | return index, nodemap | |
@@ -313,6 +317,7 b' class revlogoldio(object):' | |||||
313 | class revlogio(object): |
|
317 | class revlogio(object): | |
314 | def __init__(self): |
|
318 | def __init__(self): | |
315 | self.chunkcache = None |
|
319 | self.chunkcache = None | |
|
320 | self.size = struct.calcsize(indexformatng) | |||
316 |
|
321 | |||
317 | def parseindex(self, fp, st, inline): |
|
322 | def parseindex(self, fp, st, inline): | |
318 | if (lazyparser.safe_to_use and not inline and |
|
323 | if (lazyparser.safe_to_use and not inline and | |
@@ -327,7 +332,7 b' class revlogio(object):' | |||||
327 | index[0] = e |
|
332 | index[0] = e | |
328 | return index, nodemap |
|
333 | return index, nodemap | |
329 |
|
334 | |||
330 | s = struct.calcsize(indexformatng) |
|
335 | s = self.size | |
331 | index = [] |
|
336 | index = [] | |
332 | nodemap = {nullid: nullrev} |
|
337 | nodemap = {nullid: nullrev} | |
333 | n = off = 0 |
|
338 | n = off = 0 | |
@@ -442,10 +447,8 b' class revlog(object):' | |||||
442 | self.nodemap = {nullid: nullrev} |
|
447 | self.nodemap = {nullid: nullrev} | |
443 | self.index = [] |
|
448 | self.index = [] | |
444 | self._io = revlogio() |
|
449 | self._io = revlogio() | |
445 | self.indexformat = indexformatng |
|
|||
446 | if self.version == REVLOGV0: |
|
450 | if self.version == REVLOGV0: | |
447 | self._io = revlogoldio() |
|
451 | self._io = revlogoldio() | |
448 | self.indexformat = indexformatv0 |
|
|||
449 | if i: |
|
452 | if i: | |
450 | self.index, self.nodemap = self._io.parseindex(f, st, self._inline()) |
|
453 | self.index, self.nodemap = self._io.parseindex(f, st, self._inline()) | |
451 |
|
454 | |||
@@ -484,22 +487,16 b' class revlog(object):' | |||||
484 | if node == nullid: return (nullid, nullid) |
|
487 | if node == nullid: return (nullid, nullid) | |
485 | r = self.rev(node) |
|
488 | r = self.rev(node) | |
486 | d = self.index[r][-3:-1] |
|
489 | d = self.index[r][-3:-1] | |
487 | if self.version == REVLOGV0: |
|
|||
488 | return d |
|
|||
489 | return (self.node(d[0]), self.node(d[1])) |
|
490 | return (self.node(d[0]), self.node(d[1])) | |
490 | def parentrevs(self, rev): |
|
491 | def parentrevs(self, rev): | |
491 | if rev == nullrev: |
|
492 | if rev == nullrev: | |
492 | return (nullrev, nullrev) |
|
493 | return (nullrev, nullrev) | |
493 | d = self.index[rev][-3:-1] |
|
494 | d = self.index[rev][-3:-1] | |
494 | if self.version == REVLOGV0: |
|
|||
495 | return (self.rev(d[0]), self.rev(d[1])) |
|
|||
496 | return d |
|
495 | return d | |
497 | def start(self, rev): |
|
496 | def start(self, rev): | |
498 | if rev == nullrev: |
|
497 | if rev == nullrev: | |
499 | return 0 |
|
498 | return 0 | |
500 | if self.version != REVLOGV0: |
|
499 | return getoffset(self.index[rev][0]) | |
501 | return getoffset(self.index[rev][0]) |
|
|||
502 | return self.index[rev][0] |
|
|||
503 |
|
500 | |||
504 | def end(self, rev): return self.start(rev) + self.length(rev) |
|
501 | def end(self, rev): return self.start(rev) + self.length(rev) | |
505 |
|
502 | |||
@@ -507,9 +504,7 b' class revlog(object):' | |||||
507 | """return the length of the uncompressed text for a given revision""" |
|
504 | """return the length of the uncompressed text for a given revision""" | |
508 | if rev == nullrev: |
|
505 | if rev == nullrev: | |
509 | return 0 |
|
506 | return 0 | |
510 | l = -1 |
|
507 | l = self.index[rev][2] | |
511 | if self.version != REVLOGV0: |
|
|||
512 | l = self.index[rev][2] |
|
|||
513 | if l >= 0: |
|
508 | if l >= 0: | |
514 | return l |
|
509 | return l | |
515 |
|
510 | |||
@@ -844,7 +839,7 b' class revlog(object):' | |||||
844 | start, length = self.start(rev), self.length(rev) |
|
839 | start, length = self.start(rev), self.length(rev) | |
845 | inline = self._inline() |
|
840 | inline = self._inline() | |
846 | if inline: |
|
841 | if inline: | |
847 |
start += (rev + 1) * |
|
842 | start += (rev + 1) * self._io.size | |
848 | end = start + length |
|
843 | end = start + length | |
849 | def loadcache(df): |
|
844 | def loadcache(df): | |
850 | cache_length = max(cachelen, length) # 4k |
|
845 | cache_length = max(cachelen, length) # 4k | |
@@ -948,7 +943,7 b' class revlog(object):' | |||||
948 |
|
943 | |||
949 | tr.add(self.datafile, dataoff) |
|
944 | tr.add(self.datafile, dataoff) | |
950 | df = self.opener(self.datafile, 'w') |
|
945 | df = self.opener(self.datafile, 'w') | |
951 | calc = struct.calcsize(self.indexformat) |
|
946 | calc = self._io.size | |
952 | for r in xrange(self.count()): |
|
947 | for r in xrange(self.count()): | |
953 | start = self.start(r) + (r + 1) * calc |
|
948 | start = self.start(r) + (r + 1) * calc | |
954 | length = self.length(r) |
|
949 | length = self.length(r) | |
@@ -961,14 +956,14 b' class revlog(object):' | |||||
961 | self.version &= ~(REVLOGNGINLINEDATA) |
|
956 | self.version &= ~(REVLOGNGINLINEDATA) | |
962 | if self.count(): |
|
957 | if self.count(): | |
963 | x = self.index[0] |
|
958 | x = self.index[0] | |
964 |
e = struct.pack( |
|
959 | e = struct.pack(indexformatng, *x)[4:] | |
965 | l = struct.pack(versionformat, self.version) |
|
960 | l = struct.pack(versionformat, self.version) | |
966 | fp.write(l) |
|
961 | fp.write(l) | |
967 | fp.write(e) |
|
962 | fp.write(e) | |
968 |
|
963 | |||
969 | for i in xrange(1, self.count()): |
|
964 | for i in xrange(1, self.count()): | |
970 | x = self.index[i] |
|
965 | x = self.index[i] | |
971 |
e = struct.pack( |
|
966 | e = struct.pack(indexformatng, *x) | |
972 | fp.write(e) |
|
967 | fp.write(e) | |
973 |
|
968 | |||
974 | # if we don't call rename, the temp file will never replace the |
|
969 | # if we don't call rename, the temp file will never replace the | |
@@ -1031,15 +1026,17 b' class revlog(object):' | |||||
1031 | if t >= 0: |
|
1026 | if t >= 0: | |
1032 | offset = self.end(t) |
|
1027 | offset = self.end(t) | |
1033 |
|
1028 | |||
1034 | if self.version == REVLOGV0: |
|
1029 | e = (offset_type(offset, 0), l, len(text), | |
1035 |
|
|
1030 | base, link, self.rev(p1), self.rev(p2), node) | |
1036 | else: |
|
|||
1037 | e = (offset_type(offset, 0), l, len(text), |
|
|||
1038 | base, link, self.rev(p1), self.rev(p2), node) |
|
|||
1039 |
|
1031 | |||
1040 | self.index.append(e) |
|
1032 | self.index.append(e) | |
1041 | self.nodemap[node] = n |
|
1033 | self.nodemap[node] = n | |
1042 | entry = struct.pack(self.indexformat, *e) |
|
1034 | ||
|
1035 | if self.version == REVLOGV0: | |||
|
1036 | e = (offset, l, base, link, p1, p2, node) | |||
|
1037 | entry = struct.pack(indexformatv0, *e) | |||
|
1038 | else: | |||
|
1039 | entry = struct.pack(indexformatng, *e) | |||
1043 |
|
1040 | |||
1044 | if not self._inline(): |
|
1041 | if not self._inline(): | |
1045 | transaction.add(self.datafile, offset) |
|
1042 | transaction.add(self.datafile, offset) | |
@@ -1194,23 +1191,25 b' class revlog(object):' | |||||
1194 | raise RevlogError(_("consistency error adding group")) |
|
1191 | raise RevlogError(_("consistency error adding group")) | |
1195 | textlen = len(text) |
|
1192 | textlen = len(text) | |
1196 | else: |
|
1193 | else: | |
1197 | if self.version == REVLOGV0: |
|
1194 | e = (offset_type(end, 0), len(cdelta), textlen, base, | |
1198 |
|
|
1195 | link, self.rev(p1), self.rev(p2), node) | |
1199 | else: |
|
|||
1200 | e = (offset_type(end, 0), len(cdelta), textlen, base, |
|
|||
1201 | link, self.rev(p1), self.rev(p2), node) |
|
|||
1202 | self.index.append(e) |
|
1196 | self.index.append(e) | |
1203 | self.nodemap[node] = r |
|
1197 | self.nodemap[node] = r | |
1204 | if self._inline(): |
|
1198 | if self._inline(): | |
1205 |
ifh.write(struct.pack( |
|
1199 | ifh.write(struct.pack(indexformatng, *e)) | |
1206 | ifh.write(cdelta) |
|
1200 | ifh.write(cdelta) | |
1207 | self.checkinlinesize(transaction, ifh) |
|
1201 | self.checkinlinesize(transaction, ifh) | |
1208 | if not self._inline(): |
|
1202 | if not self._inline(): | |
1209 | dfh = self.opener(self.datafile, "a") |
|
1203 | dfh = self.opener(self.datafile, "a") | |
1210 | ifh = self.opener(self.indexfile, "a") |
|
1204 | ifh = self.opener(self.indexfile, "a") | |
1211 | else: |
|
1205 | else: | |
|
1206 | if self.version == REVLOGV0: | |||
|
1207 | e = (end, len(cdelta), base, link, p1, p2, node) | |||
|
1208 | entry = struct.pack(indexformatv0, *e) | |||
|
1209 | else: | |||
|
1210 | entry = struct.pack(indexformatng, *e) | |||
1212 | dfh.write(cdelta) |
|
1211 | dfh.write(cdelta) | |
1213 |
ifh.write( |
|
1212 | ifh.write(entry) | |
1214 |
|
1213 | |||
1215 | t, r, chain, prev = r, r + 1, node, node |
|
1214 | t, r, chain, prev = r, r + 1, node, node | |
1216 | base = self.base(t) |
|
1215 | base = self.base(t) | |
@@ -1240,9 +1239,9 b' class revlog(object):' | |||||
1240 | if not self._inline(): |
|
1239 | if not self._inline(): | |
1241 | df = self.opener(self.datafile, "a") |
|
1240 | df = self.opener(self.datafile, "a") | |
1242 | df.truncate(end) |
|
1241 | df.truncate(end) | |
1243 |
end = rev * |
|
1242 | end = rev * self._io.size | |
1244 | else: |
|
1243 | else: | |
1245 |
end += rev * |
|
1244 | end += rev * self._io.size | |
1246 |
|
1245 | |||
1247 | indexf = self.opener(self.indexfile, "a") |
|
1246 | indexf = self.opener(self.indexfile, "a") | |
1248 | indexf.truncate(end) |
|
1247 | indexf.truncate(end) | |
@@ -1274,7 +1273,7 b' class revlog(object):' | |||||
1274 | f = self.opener(self.indexfile) |
|
1273 | f = self.opener(self.indexfile) | |
1275 | f.seek(0, 2) |
|
1274 | f.seek(0, 2) | |
1276 | actual = f.tell() |
|
1275 | actual = f.tell() | |
1277 | s = struct.calcsize(self.indexformat) |
|
1276 | s = self._io.size | |
1278 | i = actual / s |
|
1277 | i = actual / s | |
1279 | di = actual - (i * s) |
|
1278 | di = actual - (i * s) | |
1280 | if self._inline(): |
|
1279 | if self._inline(): |
General Comments 0
You need to be logged in to leave comments.
Login now