Mercurial > public > mercurial-scm > hg

comparison mercurial/revlog.py @ 4918:e017d3a82e1d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
revlog: raise offset/type helpers to global scope
author Matt Mackall <mpm@selenic.com>
date Sat, 21 Jul 2007 16:18:21 -0500
parents 62c56d8f368b
children c0df0cce64a4
comparison
equal deleted inserted replaced
4917:126f527b3ba3 4918:e017d3a82e1d
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.
331 v = self.defversion 342 v = self.defversion
332 try: 343 try:
333 f = self.opener(self.indexfile) 344 f = self.opener(self.indexfile)
334 i = f.read(4) 345 i = f.read(4)
335 f.seek(0) 346 f.seek(0)
347 if len(i) > 0:
348 v = struct.unpack(versionformat, i)[0]
336 except IOError, inst: 349 except IOError, inst:
337 if inst.errno != errno.ENOENT: 350 if inst.errno != errno.ENOENT:
338 raise 351 raise
339 i = "" 352 i = ""
340 else: 353 else:
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))