This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9846

cext: add support for revlogv2
ClosedPublic

Authored by Alphare on Jan 20 2021, 3:45 PM.

Details

Reviewers
indygreg
marmoute
Group Reviewers
hg-reviewers
Commits
rHG358737abeeef: cext: add support for revlogv2
Summary

This enables the C code to retrieve/create entries in the revlog v2 format.
This is mainly a matter of taking into account the additional slots for
sidedata, etc.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

Alphare created this revision.Jan 20 2021, 3:45 PM
baymax updated this revision to Diff 25606.Feb 12 2021, 7:46 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 25618.Feb 12 2021, 6:59 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 25667.Feb 19 2021, 6:13 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 25967.Feb 25 2021, 11:45 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 26003.Mar 1 2021, 12:11 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute requested changes to this revision.Mar 2 2021, 11:35 AM
marmoute added a subscriber: marmoute.

Can you elaborate a bit more about the change in the commit message. From what I gather from the diff, this is mostly about dealing with different entry size. However it would be nice to a a clearer statement to make sure reviewer have all the pieces.

This revision now requires changes to proceed.Mar 2 2021, 11:35 AM
Alphare edited the summary of this revision. (Show Details)Mar 4 2021, 3:32 AM
Alphare updated this revision to Diff 26048.
marmoute accepted this revision.Mar 9 2021, 11:08 AM
baymax updated this revision to Diff 26219.Mar 10 2021, 2:10 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute accepted this revision.Mar 11 2021, 1:05 PM
Alphare added a commit: rHG358737abeeef: cext: add support for revlogv2.Mar 15 2021, 2:30 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG358737abeeef: cext: add support for revlogv2 (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/parsers.c (5 lines)
Mmercurial/cext/revlog.c (133 lines)
Mmercurial/revlog.py (1 line)

Diff 25618

mercurial/cext/parsers.c

return NULL; return NULL;
} }
static char parsers_doc[] = "Efficient content parsing."; static char parsers_doc[] = "Efficient content parsing.";
PyObject *encodedir(PyObject *self, PyObject *args); PyObject *encodedir(PyObject *self, PyObject *args);
PyObject *pathencode(PyObject *self, PyObject *args); PyObject *pathencode(PyObject *self, PyObject *args);
PyObject *lowerencode(PyObject *self, PyObject *args); PyObject *lowerencode(PyObject *self, PyObject *args);
PyObject *parse_index2(PyObject *self, PyObject *args); PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs);
static PyMethodDef methods[] = { static PyMethodDef methods[] = {
{"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"}, {"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"},
{"nonnormalotherparententries", nonnormalotherparententries, METH_VARARGS, {"nonnormalotherparententries", nonnormalotherparententries, METH_VARARGS,
"create a set containing non-normal and other parent entries of given " "create a set containing non-normal and other parent entries of given "
"dirstate\n"}, "dirstate\n"},
{"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"}, {"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"},
{"parse_index2", parse_index2, METH_VARARGS, "parse a revlog index\n"}, {"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS,
"parse a revlog index\n"},
{"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"}, {"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"},
{"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"}, {"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"},
{"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"}, {"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"},
{"dict_new_presized", dict_new_presized, METH_VARARGS, {"dict_new_presized", dict_new_presized, METH_VARARGS,
"construct a dict with an expected size\n"}, "construct a dict with an expected size\n"},
{"make_file_foldmap", make_file_foldmap, METH_VARARGS, {"make_file_foldmap", make_file_foldmap, METH_VARARGS,
"make file foldmap\n"}, "make file foldmap\n"},
{"jsonescapeu8fast", jsonescapeu8fast, METH_VARARGS, {"jsonescapeu8fast", jsonescapeu8fast, METH_VARARGS,

mercurial/cext/revlog.c

PyObject *headrevs; /* cache, invalidated on changes */ PyObject *headrevs; /* cache, invalidated on changes */
PyObject *filteredrevs; /* filtered revs set */ PyObject *filteredrevs; /* filtered revs set */
nodetree nt; /* base-16 trie */ nodetree nt; /* base-16 trie */
int ntinitialized; /* 0 or 1 */ int ntinitialized; /* 0 or 1 */
int ntrev; /* last rev scanned */ int ntrev; /* last rev scanned */
int ntlookups; /* # lookups */ int ntlookups; /* # lookups */
int ntmisses; /* # lookups that miss the cache */ int ntmisses; /* # lookups that miss the cache */
int inlined; int inlined;
long hdrsize; /* size of index headers. Differs in v1 v.s. v2 format */
}; };
static Py_ssize_t index_length(const indexObject *self) static Py_ssize_t index_length(const indexObject *self)
{ {
return self->length + self->new_length; return self->length + self->new_length;
} }
static const char nullid[32] = {0}; static const char nullid[32] = {0};
static const Py_ssize_t nullrev = -1; static const Py_ssize_t nullrev = -1;
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
static int index_find_node(indexObject *self, const char *node); static int index_find_node(indexObject *self, const char *node);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#"); static const char *const v1_tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");
static const char *const v2_tuple_format =
PY23("Kiiiiiis#KiKi", "Kiiiiiiy#KiKi");
#else #else
static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#"); static const char *const v1_tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");
static const char *const v2_tuple_format =
PY23("kiiiiiis#kiki", "kiiiiiiy#kiki");
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
static const long v1_hdrsize = 64; static const long v1_hdrsize = 64;
/* A Revlogv2 index entry is 96 bytes long. */
static const long v2_hdrsize = 96;
static void raise_revlog_error(void) static void raise_revlog_error(void)
{ {
PyObject *mod = NULL, *dict = NULL, *errclass = NULL; PyObject *mod = NULL, *dict = NULL, *errclass = NULL;
mod = PyImport_ImportModule("mercurial.error"); mod = PyImport_ImportModule("mercurial.error");
if (mod == NULL) { if (mod == NULL) {
goto cleanup; goto cleanup;
} }
} }
/* /*
* Return a pointer to the beginning of a RevlogNG record. * Return a pointer to the beginning of a RevlogNG record.
*/ */
static const char *index_deref(indexObject *self, Py_ssize_t pos) static const char *index_deref(indexObject *self, Py_ssize_t pos)
{ {
if (pos >= self->length) if (pos >= self->length)
return self->added + (pos - self->length) * v1_hdrsize; return self->added + (pos - self->length) * self->hdrsize;
if (self->inlined && pos > 0) { if (self->inlined && pos > 0) {
if (self->offsets == NULL) { if (self->offsets == NULL) {
Py_ssize_t ret; Py_ssize_t ret;
self->offsets = self->offsets =
PyMem_Malloc(self->length * sizeof(*self->offsets)); PyMem_Malloc(self->length * sizeof(*self->offsets));
if (self->offsets == NULL) if (self->offsets == NULL)
return (const char *)PyErr_NoMemory(); return (const char *)PyErr_NoMemory();
ret = inline_scan(self, self->offsets); ret = inline_scan(self, self->offsets);
if (ret == -1) { if (ret == -1) {
return NULL; return NULL;
}; };
} }
return self->offsets[pos]; return self->offsets[pos];
} }
return (const char *)(self->buf.buf) + pos * v1_hdrsize; return (const char *)(self->buf.buf) + pos * self->hdrsize;
} }
/* /*
* Get parents of the given rev. * Get parents of the given rev.
* *
* The specified rev must be valid and must not be nullrev. A returned * The specified rev must be valid and must not be nullrev. A returned
* parent revision may be nullrev, but is guaranteed to be in valid range. * parent revision may be nullrev, but is guaranteed to be in valid range.
*/ */
* 4 bytes: base revision * 4 bytes: base revision
* 4 bytes: link revision * 4 bytes: link revision
* 4 bytes: parent 1 revision * 4 bytes: parent 1 revision
* 4 bytes: parent 2 revision * 4 bytes: parent 2 revision
* 32 bytes: nodeid (only 20 bytes used with SHA-1) * 32 bytes: nodeid (only 20 bytes used with SHA-1)
*/ */
static PyObject *index_get(indexObject *self, Py_ssize_t pos) static PyObject *index_get(indexObject *self, Py_ssize_t pos)
{ {
uint64_t offset_flags; uint64_t offset_flags, sidedata_offset, unified_revlog_id;
int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2,
sidedata_comp_len, rank;
const char *c_node_id; const char *c_node_id;
const char *data; const char *data;
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
if (pos == nullrev) { if (pos == nullrev) {
Py_INCREF(self->nullentry); Py_INCREF(self->nullentry);
return self->nullentry; return self->nullentry;
} }
comp_len = getbe32(data + 8); comp_len = getbe32(data + 8);
uncomp_len = getbe32(data + 12); uncomp_len = getbe32(data + 12);
base_rev = getbe32(data + 16); base_rev = getbe32(data + 16);
link_rev = getbe32(data + 20); link_rev = getbe32(data + 20);
parent_1 = getbe32(data + 24); parent_1 = getbe32(data + 24);
parent_2 = getbe32(data + 28); parent_2 = getbe32(data + 28);
c_node_id = data + 32; c_node_id = data + 32;
return Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len, if (self->hdrsize == v1_hdrsize) {
base_rev, link_rev, parent_1, parent_2, c_node_id, return Py_BuildValue(v1_tuple_format, offset_flags, comp_len,
self->nodelen); uncomp_len, base_rev, link_rev, parent_1,
parent_2, c_node_id, self->nodelen);
} else {
unified_revlog_id = getbe64(data + 64);
rank = getbe32(data + 72);
sidedata_offset = getbe64(data + 76);
sidedata_comp_len = getbe32(data + 84);
return Py_BuildValue(v2_tuple_format, offset_flags, comp_len,
uncomp_len, base_rev, link_rev, parent_1,
parent_2, c_node_id, self->nodelen,
unified_revlog_id, rank, sidedata_offset,
sidedata_comp_len);
}
} }
/* /*
* Return the hash of node corresponding to the given rev. * Return the hash of node corresponding to the given rev.
*/ */
static const char *index_node(indexObject *self, Py_ssize_t pos) static const char *index_node(indexObject *self, Py_ssize_t pos)
{ {
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
return 0; return 0;
PyErr_Format(PyExc_ValueError, "node len %zd != expected node len %zd", PyErr_Format(PyExc_ValueError, "node len %zd != expected node len %zd",
thisnodelen, nodelen); thisnodelen, nodelen);
return -1; return -1;
} }
static PyObject *index_append(indexObject *self, PyObject *obj) static PyObject *index_append(indexObject *self, PyObject *obj)
{ {
uint64_t offset_flags; uint64_t offset_flags, unified_revlog_id, sidedata_offset;
int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;
Py_ssize_t c_node_id_len; Py_ssize_t c_node_id_len, rank, sidedata_comp_len;
const char *c_node_id; const char *c_node_id;
char *data; char *data;
if (!PyArg_ParseTuple(obj, tuple_format, &offset_flags, &comp_len, if (self->hdrsize == v1_hdrsize) {
&uncomp_len, &base_rev, &link_rev, &parent_1, if (!PyArg_ParseTuple(obj, v1_tuple_format, &offset_flags,
&parent_2, &c_node_id, &c_node_id_len)) { &comp_len, &uncomp_len, &base_rev,
&link_rev, &parent_1, &parent_2,
&c_node_id, &c_node_id_len)) {
PyErr_SetString(PyExc_TypeError, "8-tuple required"); PyErr_SetString(PyExc_TypeError, "8-tuple required");
return NULL; return NULL;
} }
} else {
if (!PyArg_ParseTuple(
obj, v2_tuple_format, &offset_flags, &comp_len,
&uncomp_len, &base_rev, &link_rev, &parent_1, &parent_2,
&c_node_id, &c_node_id_len, &unified_revlog_id, &rank,
&sidedata_offset, &sidedata_comp_len)) {
PyErr_SetString(PyExc_TypeError, "12-tuple required");
return NULL;
}
}
if (c_node_id_len != self->nodelen) { if (c_node_id_len != self->nodelen) {
PyErr_SetString(PyExc_TypeError, "invalid node"); PyErr_SetString(PyExc_TypeError, "invalid node");
return NULL; return NULL;
} }
if (self->new_length == self->added_length) { if (self->new_length == self->added_length) {
size_t new_added_length = size_t new_added_length =
self->added_length ? self->added_length * 2 : 4096; self->added_length ? self->added_length * 2 : 4096;
void *new_added = void *new_added = PyMem_Realloc(self->added, new_added_length *
PyMem_Realloc(self->added, new_added_length * v1_hdrsize); self->hdrsize);
if (!new_added) if (!new_added)
return PyErr_NoMemory(); return PyErr_NoMemory();
self->added = new_added; self->added = new_added;
self->added_length = new_added_length; self->added_length = new_added_length;
} }
rev = self->length + self->new_length; rev = self->length + self->new_length;
data = self->added + v1_hdrsize * self->new_length++; data = self->added + self->hdrsize * self->new_length++;
putbe32(offset_flags >> 32, data); putbe32(offset_flags >> 32, data);
putbe32(offset_flags & 0xffffffffU, data + 4); putbe32(offset_flags & 0xffffffffU, data + 4);
putbe32(comp_len, data + 8); putbe32(comp_len, data + 8);
putbe32(uncomp_len, data + 12); putbe32(uncomp_len, data + 12);
putbe32(base_rev, data + 16); putbe32(base_rev, data + 16);
putbe32(link_rev, data + 20); putbe32(link_rev, data + 20);
putbe32(parent_1, data + 24); putbe32(parent_1, data + 24);
putbe32(parent_2, data + 28); putbe32(parent_2, data + 28);
memcpy(data + 32, c_node_id, c_node_id_len); memcpy(data + 32, c_node_id, c_node_id_len);
/* Padding since SHA-1 is only 20 bytes for now */
memset(data + 32 + c_node_id_len, 0, 32 - c_node_id_len); memset(data + 32 + c_node_id_len, 0, 32 - c_node_id_len);
if (self->hdrsize != v1_hdrsize) {
putbe64(unified_revlog_id, data + 64);
putbe32(rank, data + 72);
putbe64(sidedata_offset, data + 76);
putbe32(sidedata_comp_len, data + 84);
/* Padding for 96 bytes alignment */
memset(data + 88, 0, self->hdrsize - 88);
}
if (self->ntinitialized) if (self->ntinitialized)
nt_insert(&self->nt, c_node_id, rev); nt_insert(&self->nt, c_node_id, rev);
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
* Find all RevlogNG entries in an index that has inline data. Update * Find all RevlogNG entries in an index that has inline data. Update
* the optional "offsets" table with those entries. * the optional "offsets" table with those entries.
*/ */
static Py_ssize_t inline_scan(indexObject *self, const char **offsets) static Py_ssize_t inline_scan(indexObject *self, const char **offsets)
{ {
const char *data = (const char *)self->buf.buf; const char *data = (const char *)self->buf.buf;
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
Py_ssize_t end = self->buf.len; Py_ssize_t end = self->buf.len;
long incr = v1_hdrsize; long incr = self->hdrsize;
Py_ssize_t len = 0; Py_ssize_t len = 0;
while (pos + v1_hdrsize <= end && pos >= 0) { while (pos + self->hdrsize <= end && pos >= 0) {
uint32_t comp_len; uint32_t comp_len, sidedata_comp_len = 0;
/* 3rd element of header is length of compressed inline data */ /* 3rd element of header is length of compressed inline data */
comp_len = getbe32(data + pos + 8); comp_len = getbe32(data + pos + 8);
incr = v1_hdrsize + comp_len; if (self->hdrsize == v2_hdrsize) {
sidedata_comp_len = getbe32(data + pos + 84);
}
incr = self->hdrsize + comp_len + sidedata_comp_len;
if (offsets) if (offsets)
offsets[len] = data + pos; offsets[len] = data + pos;
len++; len++;
pos += incr; pos += incr;
} }
if (pos != end) { if (pos != end) {
if (!PyErr_Occurred()) if (!PyErr_Occurred())
PyErr_SetString(PyExc_ValueError, "corrupt index file"); PyErr_SetString(PyExc_ValueError, "corrupt index file");
return -1; return -1;
} }
return len; return len;
} }
static int index_init(indexObject *self, PyObject *args) static int index_init(indexObject *self, PyObject *args, PyObject *kwargs)
{ {
PyObject *data_obj, *inlined_obj; PyObject *data_obj, *inlined_obj, *revlogv2;
Py_ssize_t size; Py_ssize_t size;
static char *kwlist[] = {"data", "inlined", "revlogv2", NULL};
/* Initialize before argument-checking to avoid index_dealloc() crash. /* Initialize before argument-checking to avoid index_dealloc() crash.
*/ */
self->added = NULL; self->added = NULL;
self->new_length = 0; self->new_length = 0;
self->added_length = 0; self->added_length = 0;
self->data = NULL; self->data = NULL;
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
self->headrevs = NULL; self->headrevs = NULL;
self->filteredrevs = Py_None; self->filteredrevs = Py_None;
Py_INCREF(Py_None); Py_INCREF(Py_None);
self->ntinitialized = 0; self->ntinitialized = 0;
self->offsets = NULL; self->offsets = NULL;
self->nodelen = 20; self->nodelen = 20;
self->nullentry = NULL; self->nullentry = NULL;
if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj)) revlogv2 = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", kwlist,
&data_obj, &inlined_obj, &revlogv2))
return -1; return -1;
if (!PyObject_CheckBuffer(data_obj)) { if (!PyObject_CheckBuffer(data_obj)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"data does not support buffer interface"); "data does not support buffer interface");
return -1; return -1;
} }
if (self->nodelen < 20 || self->nodelen > (Py_ssize_t)sizeof(nullid)) { if (self->nodelen < 20 || self->nodelen > (Py_ssize_t)sizeof(nullid)) {
PyErr_SetString(PyExc_RuntimeError, "unsupported node size"); PyErr_SetString(PyExc_RuntimeError, "unsupported node size");
return -1; return -1;
} }
self->nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, if (revlogv2 && PyObject_IsTrue(revlogv2)) {
-1, -1, -1, -1, nullid, self->nodelen); self->hdrsize = v2_hdrsize;
} else {
self->hdrsize = v1_hdrsize;
}
if (self->hdrsize == v1_hdrsize) {
self->nullentry =
Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1,
-1, -1, -1, nullid, self->nodelen);
} else {
self->nullentry = Py_BuildValue(
PY23("iiiiiiis#iiii", "iiiiiiiy#iiii"), 0, 0, 0, -1, -1, -1,
-1, nullid, self->nodelen, 0, 0, 0, 0);
}
if (!self->nullentry) if (!self->nullentry)
return -1; return -1;
PyObject_GC_UnTrack(self->nullentry); PyObject_GC_UnTrack(self->nullentry);
if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1) if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1)
return -1; return -1;
size = self->buf.len; size = self->buf.len;
self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj); self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj);
self->data = data_obj; self->data = data_obj;
self->ntlookups = self->ntmisses = 0; self->ntlookups = self->ntmisses = 0;
self->ntrev = -1; self->ntrev = -1;
Py_INCREF(self->data); Py_INCREF(self->data);
if (self->inlined) { if (self->inlined) {
Py_ssize_t len = inline_scan(self, NULL); Py_ssize_t len = inline_scan(self, NULL);
if (len == -1) if (len == -1)
goto bail; goto bail;
self->length = len; self->length = len;
} else { } else {
if (size % v1_hdrsize) { if (size % self->hdrsize) {
PyErr_SetString(PyExc_ValueError, "corrupt index file"); PyErr_SetString(PyExc_ValueError, "corrupt index file");
goto bail; goto bail;
} }
self->length = size / v1_hdrsize; self->length = size / self->hdrsize;
} }
return 0; return 0;
bail: bail:
return -1; return -1;
} }
static PyObject *index_nodemap(indexObject *self) static PyObject *index_nodemap(indexObject *self)
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)index_init, /* tp_init */ (initproc)index_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
}; };
/* /*
* returns a tuple of the form (index, index, cache) with elements as * returns a tuple of the form (index, cache) with elements as
* follows: * follows:
* *
* index: an index object that lazily parses RevlogNG records * index: an index object that lazily parses Revlog (v1 or v2) records
* cache: if data is inlined, a tuple (0, index_file_content), else None * cache: if data is inlined, a tuple (0, index_file_content), else None
* index_file_content could be a string, or a buffer * index_file_content could be a string, or a buffer
* *
* added complications are for backwards compatibility * added complications are for backwards compatibility
*/ */
PyObject *parse_index2(PyObject *self, PyObject *args) PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs)
{ {
PyObject *cache = NULL; PyObject *cache = NULL;
indexObject *idx; indexObject *idx;
int ret; int ret;
idx = PyObject_New(indexObject, &HgRevlogIndex_Type); idx = PyObject_New(indexObject, &HgRevlogIndex_Type);
if (idx == NULL) if (idx == NULL)
goto bail; goto bail;
ret = index_init(idx, args); ret = index_init(idx, args, kwargs);
if (ret == -1) if (ret == -1)
goto bail; goto bail;
if (idx->inlined) { if (idx->inlined) {
cache = Py_BuildValue("iO", 0, idx->data); cache = Py_BuildValue("iO", 0, idx->data);
if (cache == NULL) if (cache == NULL)
goto bail; goto bail;
} else { } else {

mercurial/revlog.py

dagop, dagop,
error, error,
mdiff, mdiff,
policy, policy,
pycompat, pycompat,
templatefilters, templatefilters,
util, util,
) )
from .pure import parsers as pureparsers
from .interfaces import ( from .interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from .revlogutils import ( from .revlogutils import (
deltas as deltautil, deltas as deltautil,
flagutil, flagutil,
nodemap as nodemaputil, nodemap as nodemaputil,