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