( )⚙ D4114 index: split up nt_init() in two

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4114

index: split up nt_init() in two
ClosedPublic

Authored by martinvonz on Aug 5 2018, 3:58 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGc0b6a7c78a21: index: split up nt_init() in two
Summary

I'd like to make nt_init() take a pointer to a nodetree to initialize,
but it currently also allocates the nodetree. This patch prepares for
that change by making nt_init() be about initializing an existing node
tree and by creating a new index_init_nt() that creates the nodetree.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Aug 5 2018, 3:58 AM
martinvonz updated this revision to Diff 9979.Aug 6 2018, 9:24 AM
martinvonz updated this revision to Diff 10038.Aug 7 2018, 2:27 AM
Closed by commit rHGc0b6a7c78a21: index: split up nt_init() in two (authored by martinvonz). · Explain WhyAug 7 2018, 9:12 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/revlog.c (49 lines)

Diff 9979

mercurial/cext/revlog.c

} }
static int nt_delete_node(nodetree *self, const char *node) static int nt_delete_node(nodetree *self, const char *node)
{ {
/* rev==-2 happens to get encoded as 0, which is interpreted as not set */ /* rev==-2 happens to get encoded as 0, which is interpreted as not set */
return nt_insert(self, node, -2); return nt_insert(self, node, -2);
} }
static int nt_init(indexObject *self) static int nt_init(nodetree *self, indexObject *index, unsigned capacity)
{
self->index = index;
self->capacity = capacity;
self->depth = 0;
self->splits = 0;
self->nodes = calloc(self->capacity, sizeof(nodetreenode));
if (self->nodes == NULL) {
PyErr_NoMemory();
return -1;
}
self->length = 1;
if (nt_insert(self, nullid, -1) == -1) {
free(self->nodes);
return -1;
}
return 0;
}
static int index_init_nt(indexObject *self)
{ {
if (self->nt == NULL) { if (self->nt == NULL) {
self->nt = PyMem_Malloc(sizeof(nodetree)); self->nt = PyMem_Malloc(sizeof(nodetree));
if (self->nt == NULL) { if (self->nt == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
return -1; return -1;
} }
if ((size_t)self->raw_length > INT_MAX / sizeof(nodetreenode)) { if ((size_t)self->raw_length > INT_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_ValueError, "overflow in nt_init"); PyErr_SetString(PyExc_ValueError, "overflow in index_init_nt");
return -1; return -1;
} }
self->nt->capacity = self->raw_length < 4 unsigned capacity = (self->raw_length < 4 ? 4 : (int)self->raw_length / 2);
? 4 : (int)self->raw_length / 2; if (nt_init(self->nt, self, capacity) == -1) {
self->nt->nodes = calloc(self->nt->capacity, sizeof(nodetreenode));
if (self->nt->nodes == NULL) {
free(self->nt); free(self->nt);
self->nt = NULL; self->nt = NULL;
PyErr_NoMemory();
return -1; return -1;
} }
self->ntrev = (int)index_length(self); self->ntrev = (int)index_length(self);
self->ntlookups = 1; self->ntlookups = 1;
self->ntmisses = 0; self->ntmisses = 0;
self->nt->depth = 0;
self->nt->splits = 0;
self->nt->length = 1;
self->nt->index = self;
if (nt_insert(self->nt, nullid, -1) == -1) {
free(self->nt->nodes);
free(self->nt);
self->nt = NULL;
return -1;
}
} }
return 0; return 0;
} }
/* /*
* Return values: * Return values:
* *
* -3: error (exception set) * -3: error (exception set)
* -2: not found (no exception set) * -2: not found (no exception set)
* rest: valid rev * rest: valid rev
*/ */
static int index_find_node(indexObject *self, static int index_find_node(indexObject *self,
const char *node, Py_ssize_t nodelen) const char *node, Py_ssize_t nodelen)
{ {
int rev; int rev;
if (nt_init(self) == -1) if (index_init_nt(self) == -1)
return -3; return -3;
self->ntlookups++; self->ntlookups++;
rev = nt_find(self->nt, node, nodelen, 0); rev = nt_find(self->nt, node, nodelen, 0);
if (rev >= -1) if (rev >= -1)
return rev; return rev;
/* /*
for (i = 0; i < nodelen; i++) for (i = 0; i < nodelen; i++)
hexdigit(node, i); hexdigit(node, i);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
/* input contains non-hex characters */ /* input contains non-hex characters */
PyErr_Clear(); PyErr_Clear();
Py_RETURN_NONE; Py_RETURN_NONE;
} }
if (nt_init(self) == -1) if (index_init_nt(self) == -1)
return NULL; return NULL;
if (nt_populate(self) == -1) if (nt_populate(self) == -1)
return NULL; return NULL;
rev = nt_partialmatch(self->nt, node, nodelen); rev = nt_partialmatch(self->nt, node, nodelen);
switch (rev) { switch (rev) {
case -4: case -4:
raise_revlog_error(); raise_revlog_error();
int length; int length;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(val, &node) == -1) if (node_check(val, &node) == -1)
return NULL; return NULL;
self->ntlookups++; self->ntlookups++;
if (nt_init(self) == -1) if (index_init_nt(self) == -1)
return NULL; return NULL;
if (nt_populate(self) == -1) if (nt_populate(self) == -1)
return NULL; return NULL;
length = nt_shortest(self->nt, node); length = nt_shortest(self->nt, node);
if (length == -3) if (length == -3)
return NULL; return NULL;
if (length == -2) { if (length == -2) {
raise_revlog_error(); raise_revlog_error();
return self->nt ? nt_delete_node(self->nt, node) : 0; return self->nt ? nt_delete_node(self->nt, node) : 0;
rev = PyInt_AsLong(value); rev = PyInt_AsLong(value);
if (rev > INT_MAX || rev < 0) { if (rev > INT_MAX || rev < 0) {
if (!PyErr_Occurred()) if (!PyErr_Occurred())
PyErr_SetString(PyExc_ValueError, "rev out of range"); PyErr_SetString(PyExc_ValueError, "rev out of range");
return -1; return -1;
} }
if (nt_init(self) == -1) if (index_init_nt(self) == -1)
return -1; return -1;
return nt_insert(self->nt, node, (int)rev); return nt_insert(self->nt, node, (int)rev);
} }
/* /*
* 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.
*/ */