279 del self.p.map[key] |
279 del self.p.map[key] |
280 |
280 |
281 class RevlogError(Exception): pass |
281 class RevlogError(Exception): pass |
282 class LookupError(RevlogError): pass |
282 class LookupError(RevlogError): pass |
283 |
283 |
|
284 def getoffset(q): |
|
285 if q & 0xFFFF: |
|
286 raise RevlogError(_('incompatible revision flag %x') % q) |
|
287 return int(q >> 16) |
|
288 |
|
289 def gettype(q): |
|
290 return int(q & 0xFFFF) |
|
291 |
|
292 def offset_type(offset, type): |
|
293 return long(long(offset) << 16 | type) |
|
294 |
284 class revlog(object): |
295 class revlog(object): |
285 """ |
296 """ |
286 the underlying revision storage object |
297 the underlying revision storage object |
287 |
298 |
288 A revlog consists of two parts, an index and the revision data. |
299 A revlog consists of two parts, an index and the revision data. |
349 and st.st_mtime == oldst.st_mtime |
362 and st.st_mtime == oldst.st_mtime |
350 and st.st_ctime == oldst.st_ctime |
363 and st.st_ctime == oldst.st_ctime |
351 and st.st_size == oldst.st_size): |
364 and st.st_size == oldst.st_size): |
352 return |
365 return |
353 self.indexstat = st |
366 self.indexstat = st |
354 if len(i) > 0: |
|
355 v = struct.unpack(versionformat, i)[0] |
|
356 flags = v & ~0xFFFF |
367 flags = v & ~0xFFFF |
357 fmt = v & 0xFFFF |
368 fmt = v & 0xFFFF |
358 if fmt == REVLOGV0: |
369 if fmt == REVLOGV0: |
359 if flags: |
370 if flags: |
360 raise RevlogError(_("index %s unknown flags %#04x for format v0") |
371 raise RevlogError(_("index %s unknown flags %#04x for format v0") |
383 self.nodemap = lazymap(parser) |
394 self.nodemap = lazymap(parser) |
384 else: |
395 else: |
385 self.parseindex(f, st) |
396 self.parseindex(f, st) |
386 if self.version != REVLOGV0: |
397 if self.version != REVLOGV0: |
387 e = list(self.index[0]) |
398 e = list(self.index[0]) |
388 type = self.ngtype(e[0]) |
399 type = gettype(e[0]) |
389 e[0] = self.offset_type(0, type) |
400 e[0] = offset_type(0, type) |
390 self.index[0] = e |
401 self.index[0] = e |
391 else: |
402 else: |
392 self.nodemap = {nullid: nullrev} |
403 self.nodemap = {nullid: nullrev} |
393 self.index = [] |
404 self.index = [] |
394 |
405 |
436 break |
447 break |
437 if not st: |
448 if not st: |
438 break |
449 break |
439 |
450 |
440 |
451 |
441 def ngoffset(self, q): |
|
442 if q & 0xFFFF: |
|
443 raise RevlogError(_('%s: incompatible revision flag %x') % |
|
444 (self.indexfile, q)) |
|
445 return long(q >> 16) |
|
446 |
|
447 def ngtype(self, q): |
|
448 return int(q & 0xFFFF) |
|
449 |
|
450 def offset_type(self, offset, type): |
|
451 return long(long(offset) << 16 | type) |
|
452 |
|
453 def loadindex(self, start, end): |
452 def loadindex(self, start, end): |
454 """load a block of indexes all at once from the lazy parser""" |
453 """load a block of indexes all at once from the lazy parser""" |
455 if isinstance(self.index, lazyindex): |
454 if isinstance(self.index, lazyindex): |
456 self.index.p.loadindex(start, end) |
455 self.index.p.loadindex(start, end) |
457 |
456 |
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 if self.version != REVLOGV0: |
501 return self.ngoffset(self.index[rev][0]) |
500 return getoffset(self.index[rev][0]) |
502 return self.index[rev][0] |
501 return self.index[rev][0] |
503 |
502 |
504 def end(self, rev): return self.start(rev) + self.length(rev) |
503 def end(self, rev): return self.start(rev) + self.length(rev) |
505 |
504 |
506 def size(self, rev): |
505 def size(self, rev): |
1040 offset = self.end(t) |
1039 offset = self.end(t) |
1041 |
1040 |
1042 if self.version == REVLOGV0: |
1041 if self.version == REVLOGV0: |
1043 e = (offset, l, base, link, p1, p2, node) |
1042 e = (offset, l, base, link, p1, p2, node) |
1044 else: |
1043 else: |
1045 e = (self.offset_type(offset, 0), l, len(text), |
1044 e = (offset_type(offset, 0), l, len(text), |
1046 base, link, self.rev(p1), self.rev(p2), node) |
1045 base, link, self.rev(p1), self.rev(p2), node) |
1047 |
1046 |
1048 self.index.append(e) |
1047 self.index.append(e) |
1049 self.nodemap[node] = n |
1048 self.nodemap[node] = n |
1050 entry = struct.pack(self.indexformat, *e) |
1049 entry = struct.pack(self.indexformat, *e) |
1203 textlen = len(text) |
1202 textlen = len(text) |
1204 else: |
1203 else: |
1205 if self.version == REVLOGV0: |
1204 if self.version == REVLOGV0: |
1206 e = (end, len(cdelta), base, link, p1, p2, node) |
1205 e = (end, len(cdelta), base, link, p1, p2, node) |
1207 else: |
1206 else: |
1208 e = (self.offset_type(end, 0), len(cdelta), textlen, base, |
1207 e = (offset_type(end, 0), len(cdelta), textlen, base, |
1209 link, self.rev(p1), self.rev(p2), node) |
1208 link, self.rev(p1), self.rev(p2), node) |
1210 self.index.append(e) |
1209 self.index.append(e) |
1211 self.nodemap[node] = r |
1210 self.nodemap[node] = r |
1212 if self.inlinedata(): |
1211 if self.inlinedata(): |
1213 ifh.write(struct.pack(self.indexformat, *e)) |
1212 ifh.write(struct.pack(self.indexformat, *e)) |