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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 (127 lines)

Diff 26374

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#Ki", "Kiiiiiiy#Ki");
#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#ki", "kiiiiiiy#ki");
#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;
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;
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 {
sidedata_offset = getbe64(data + 64);
sidedata_comp_len = getbe32(data + 72);
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,
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, 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, 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, &sidedata_offset, &sidedata_comp_len)) {
PyErr_SetString(PyExc_TypeError, "10-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(sidedata_offset, data + 64);
putbe32(sidedata_comp_len, data + 72);
/* Padding for 96 bytes alignment */
memset(data + 76, 0, self->hdrsize - 76);
}
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 + 72);
}
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#ii", "iiiiiiiy#ii"), 0, 0, 0, -1, -1, -1,
-1, nullid, self->nodelen, 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 {