( )⚙ D5235 revlog: replace PyInt_AS_LONG with a more portable helper function

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5235

revlog: replace PyInt_AS_LONG with a more portable helper function
ClosedPublic

Authored by durin42 on Nov 6 2018, 11:44 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGfa33196088c4: revlog: replace PyInt_AS_LONG with a more portable helper function
Summary

PyInt_AS_LONG disappears on Python, and our previous #define was
producing some problems on Python 3. Let's give up and make an inline
helper function that makes this more sane.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Nov 6 2018, 11:44 AM
yuja added a subscriber: yuja.Nov 7 2018, 7:35 AM

+/* Convert a PyInt or PyLong to a long. Returns false if there is an
+ error, in which case an exception will already have been set. */
+static inline bool pylong_to_long(PyObject *pylong, long *out)

Nit: I prefer 0/-1 return value instead of bool since that's the convention
of CPython API.

+ *out = PyLong_AsLong(pylong);
+ return PyErr_Occurred() == NULL;

Perhaps, checking *out != -1 can be a fast path, though I don't know how
much we care about the performance here.

static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev)
{

  • if (!(PyInt_Check(rev))) {

+ long lrev;
+ if (!pylong_to_long(rev, &lrev)) {

		return 0;

Needs PyErr_Clear() since non_int in self` isn't an error.

durin42 updated this revision to Diff 12469.Nov 7 2018, 1:42 PM
durin42 added a comment.Nov 7 2018, 1:44 PM
In D5235#78172, @yuja wrote:

+/* Convert a PyInt or PyLong to a long. Returns false if there is an
+ error, in which case an exception will already have been set. */
+static inline bool pylong_to_long(PyObject *pylong, long *out)

Nit: I prefer 0/-1 return value instead of bool since that's the convention
of CPython API.

I got lazy, but we can change it if we like.

+ *out = PyLong_AsLong(pylong);
+ return PyErr_Occurred() == NULL;

Perhaps, checking *out != -1 can be a fast path, though I don't know how
much we care about the performance here.

I don't either, but it was easy to add the if statement.

static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev)
{

  • if (!(PyInt_Check(rev))) {

+ long lrev;
+ if (!pylong_to_long(rev, &lrev)) {

		return 0;

Needs PyErr_Clear() since non_int in self` isn't an error.

Good catch, fixed.

yuja added a comment.Nov 8 2018, 6:27 AM

@@ -464,7 +470,9 @@

		if (iter == NULL)
			return -2;
		while ((iter_item = PyIter_Next(iter))) {
  • iter_item_long = PyInt_AS_LONG(iter_item);

+ if (!pylong_to_long(iter_item, &iter_item_long)) {
+ return -1;

Py_DECREF(iter_item) and return -2.

I didn't notice it last time, sorry.

+ }

			Py_DECREF(iter_item);
			if (iter_item_long < min_idx)
				min_idx = iter_item_long;
durin42 updated this revision to Diff 12502.Nov 12 2018, 11:46 AM
Closed by commit rHGfa33196088c4: revlog: replace PyInt_AS_LONG with a more portable helper function (authored by durin42). · Explain WhyNov 13 2018, 6:42 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/revlog.c (103 lines)
Mmercurial/cext/util.h (13 lines)

Diff 12502

mercurial/cext/revlog.c

#ifdef IS_PY3K #ifdef IS_PY3K
/* The mapping of Python types is meant to be temporary to get Python /* The mapping of Python types is meant to be temporary to get Python
* 3 to compile. We should remove this once Python 3 support is fully * 3 to compile. We should remove this once Python 3 support is fully
* supported and proper types are used in the extensions themselves. */ * supported and proper types are used in the extensions themselves. */
#define PyInt_Check PyLong_Check #define PyInt_Check PyLong_Check
#define PyInt_FromLong PyLong_FromLong #define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AS_LONG PyLong_AS_LONG
#define PyInt_AsLong PyLong_AsLong #define PyInt_AsLong PyLong_AsLong
#endif #endif
typedef struct indexObjectStruct indexObject; typedef struct indexObjectStruct indexObject;
typedef struct { typedef struct {
int children[16]; int children[16];
} nodetreenode; } nodetreenode;
if (dict == NULL) { if (dict == NULL) {
goto cleanup; goto cleanup;
} }
Py_INCREF(dict); Py_INCREF(dict);
errclass = PyDict_GetItemString(dict, "RevlogError"); errclass = PyDict_GetItemString(dict, "RevlogError");
if (errclass == NULL) { if (errclass == NULL) {
PyErr_SetString(PyExc_SystemError, PyErr_SetString(PyExc_SystemError,
"could not find RevlogError"); "could not find RevlogError");
goto cleanup; goto cleanup;
} }
/* value of exception is ignored by callers */ /* value of exception is ignored by callers */
PyErr_SetString(errclass, "RevlogError"); PyErr_SetString(errclass, "RevlogError");
cleanup: cleanup:
Py_XDECREF(dict); Py_XDECREF(dict);
Py_XDECREF(mod); Py_XDECREF(mod);
} }
/* /*
* 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 (self->inlined && pos > 0) { if (self->inlined && pos > 0) {
if (self->offsets == NULL) { if (self->offsets == NULL) {
self->offsets = PyMem_Malloc(self->raw_length * self->offsets = PyMem_Malloc(self->raw_length *
sizeof(*self->offsets)); sizeof(*self->offsets));
if (self->offsets == NULL) if (self->offsets == NULL)
return (const char *)PyErr_NoMemory(); return (const char *)PyErr_NoMemory();
inline_scan(self, self->offsets); inline_scan(self, self->offsets);
} }
return self->offsets[pos]; return self->offsets[pos];
} }
return (const char *)(self->buf.buf) + pos * v1_hdrsize; return (const char *)(self->buf.buf) + pos * v1_hdrsize;
} }
static inline int index_get_parents(indexObject *self, Py_ssize_t rev, int *ps, static inline int index_get_parents(indexObject *self, Py_ssize_t rev, int *ps,
int maxrev) int maxrev)
{ {
if (rev >= self->length) { if (rev >= self->length) {
long tmp;
PyObject *tuple = PyObject *tuple =
PyList_GET_ITEM(self->added, rev - self->length); PyList_GET_ITEM(self->added, rev - self->length);
ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5)); if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 5), &tmp)) {
ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6)); return -1;
}
ps[0] = (int)tmp;
if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 6), &tmp)) {
return -1;
}
ps[1] = (int)tmp;
} else { } else {
const char *data = index_deref(self, rev); const char *data = index_deref(self, rev);
ps[0] = getbe32(data + 24); ps[0] = getbe32(data + 24);
ps[1] = getbe32(data + 28); ps[1] = getbe32(data + 28);
} }
/* If index file is corrupted, ps[] may point to invalid revisions. So /* If index file is corrupted, ps[] may point to invalid revisions. So
* there is a risk of buffer overflow to trust them unconditionally. */ * there is a risk of buffer overflow to trust them unconditionally. */
if (ps[0] > maxrev || ps[1] > maxrev) { if (ps[0] > maxrev || ps[1] > maxrev) {
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;
entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len, entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,
base_rev, link_rev, parent_1, parent_2, c_node_id, base_rev, link_rev, parent_1, parent_2, c_node_id,
20); 20);
if (entry) { if (entry) {
PyObject_GC_UnTrack(entry); PyObject_GC_UnTrack(entry);
Py_INCREF(entry); Py_INCREF(entry);
} }
self->cache[pos] = entry; self->cache[pos] = entry;
* Return the 20-byte SHA of the node corresponding to the given rev. The * Return the 20-byte SHA of the node corresponding to the given rev. The
* rev is assumed to be existing. If not, an exception is set. * rev is assumed to be existing. If not, an exception is set.
*/ */
static const char *index_node_existing(indexObject *self, Py_ssize_t pos) static const char *index_node_existing(indexObject *self, Py_ssize_t pos)
{ {
const char *node = index_node(self, pos); const char *node = index_node(self, pos);
if (node == NULL) { if (node == NULL) {
PyErr_Format(PyExc_IndexError, "could not access rev %d", PyErr_Format(PyExc_IndexError, "could not access rev %d",
(int)pos); (int)pos);
} }
return node; return node;
} }
static int nt_insert(nodetree *self, const char *node, int rev); static int nt_insert(nodetree *self, const char *node, int rev);
static int node_check(PyObject *obj, char **node) static int node_check(PyObject *obj, char **node)
{ {
Py_ssize_t min_idx = index_length(self) + 2; Py_ssize_t min_idx = index_length(self) + 2;
long iter_item_long; long iter_item_long;
if (PyList_GET_SIZE(list) != 0) { if (PyList_GET_SIZE(list) != 0) {
iter = PyObject_GetIter(list); iter = PyObject_GetIter(list);
if (iter == NULL) if (iter == NULL)
return -2; return -2;
while ((iter_item = PyIter_Next(iter))) { while ((iter_item = PyIter_Next(iter))) {
iter_item_long = PyInt_AS_LONG(iter_item); if (!pylong_to_long(iter_item, &iter_item_long)) {
Py_DECREF(iter_item);
return -2;
}
Py_DECREF(iter_item); Py_DECREF(iter_item);
if (iter_item_long < min_idx) if (iter_item_long < min_idx)
min_idx = iter_item_long; min_idx = iter_item_long;
phases[iter_item_long] = (char)marker; phases[iter_item_long] = (char)marker;
} }
Py_DECREF(iter); Py_DECREF(iter);
} }
* revstates: array of length len+1 (all revs + nullrev) */ * revstates: array of length len+1 (all revs + nullrev) */
int *tovisit = NULL; int *tovisit = NULL;
long lentovisit = 0; long lentovisit = 0;
enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 }; enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 };
char *revstates = NULL; char *revstates = NULL;
/* Get arguments */ /* Get arguments */
if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads, if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads,
&PyList_Type, &roots, &PyBool_Type, &PyList_Type, &roots, &PyBool_Type,
&includepatharg)) &includepatharg))
goto bail; goto bail;
if (includepatharg == Py_True) if (includepatharg == Py_True)
includepath = 1; includepath = 1;
/* Initialize return set */ /* Initialize return set */
reachable = PyList_New(0); reachable = PyList_New(0);
if (reachable == NULL) if (reachable == NULL)
for (i = 0; i < numphase - 1; i++) { for (i = 0; i < numphase - 1; i++) {
phaseroots = PyList_GET_ITEM(roots, i); phaseroots = PyList_GET_ITEM(roots, i);
phaseset = PySet_New(NULL); phaseset = PySet_New(NULL);
if (phaseset == NULL) if (phaseset == NULL)
goto release; goto release;
PyList_SET_ITEM(phasessetlist, i + 1, phaseset); PyList_SET_ITEM(phasessetlist, i + 1, phaseset);
if (!PyList_Check(phaseroots)) { if (!PyList_Check(phaseroots)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"roots item must be a list"); "roots item must be a list");
goto release; goto release;
} }
minrevphase = minrevphase =
add_roots_get_min(self, phaseroots, i + 1, phases); add_roots_get_min(self, phaseroots, i + 1, phases);
if (minrevphase == -2) /* Error from add_roots_get_min */ if (minrevphase == -2) /* Error from add_roots_get_min */
goto release; goto release;
minrevallphases = MIN(minrevallphases, minrevphase); minrevallphases = MIN(minrevallphases, minrevphase);
} }
/* Propagate the phase information from the roots to the revs */ /* Propagate the phase information from the roots to the revs */
if (minrevallphases != -1) { if (minrevallphases != -1) {
int parents[2]; int parents[2];
for (i = minrevallphases; i < len; i++) { for (i = minrevallphases; i < len; i++) {
if (index_get_parents(self, i, parents, (int)len - 1) < if (index_get_parents(self, i, parents, (int)len - 1) <
0) 0)
goto release; goto release;
set_phase_from_parents(phases, parents[0], parents[1], set_phase_from_parents(phases, parents[0], parents[1],
i); i);
} }
} }
/* Transform phase list to a python list */ /* Transform phase list to a python list */
phasessize = PyInt_FromSsize_t(len); phasessize = PyInt_FromSsize_t(len);
if (phasessize == NULL) if (phasessize == NULL)
goto release; goto release;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
phase = phases[i]; phase = phases[i];
/* If nothead[i] == 1, it means we've seen an unfiltered child /* If nothead[i] == 1, it means we've seen an unfiltered child
* of this node already, and therefore this node is not * of this node already, and therefore this node is not
* filtered. So we can skip the expensive check_filter step. * filtered. So we can skip the expensive check_filter step.
*/ */
if (nothead[i] != 1) { if (nothead[i] != 1) {
isfiltered = check_filter(filter, i); isfiltered = check_filter(filter, i);
if (isfiltered == -1) { if (isfiltered == -1) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"unable to check filter"); "unable to check filter");
goto bail; goto bail;
} }
if (isfiltered) { if (isfiltered) {
nothead[i] = 1; nothead[i] = 1;
continue; continue;
} }
} }
*/ */
static inline int index_baserev(indexObject *self, int rev) static inline int index_baserev(indexObject *self, int rev)
{ {
const char *data; const char *data;
if (rev >= self->length) { if (rev >= self->length) {
PyObject *tuple = PyObject *tuple =
PyList_GET_ITEM(self->added, rev - self->length); PyList_GET_ITEM(self->added, rev - self->length);
return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3)); long ret;
if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 3), &ret)) {
return -2;
}
return (int)ret;
} else { } else {
data = index_deref(self, rev); data = index_deref(self, rev);
if (data == NULL) { if (data == NULL) {
return -2; return -2;
} }
return getbe32(data + 16); return getbe32(data + 16);
} }
stoprev = (int)PyInt_AsLong(stoparg); stoprev = (int)PyInt_AsLong(stoparg);
if (stoprev == -1 && PyErr_Occurred()) { if (stoprev == -1 && PyErr_Occurred()) {
return NULL; return NULL;
} }
} else if (stoparg == Py_None) { } else if (stoparg == Py_None) {
stoprev = -2; stoprev = -2;
} else { } else {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"stoprev must be integer or None"); "stoprev must be integer or None");
return NULL; return NULL;
} }
if (rev < 0 || rev >= length) { if (rev < 0 || rev >= length) {
PyErr_SetString(PyExc_ValueError, "revlog index out of range"); PyErr_SetString(PyExc_ValueError, "revlog index out of range");
return NULL; return NULL;
} }
} }
if (iterrev < 0) { if (iterrev < 0) {
break; break;
} }
if (iterrev >= length) { if (iterrev >= length) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
"revision outside index"); "revision outside index");
return NULL; return NULL;
} }
baserev = index_baserev(self, iterrev); baserev = index_baserev(self, iterrev);
/* This should never happen. */ /* This should never happen. */
if (baserev <= -2) { if (baserev <= -2) {
/* Error should be set by index_deref() */ /* Error should be set by index_deref() */
static int nt_new(nodetree *self) static int nt_new(nodetree *self)
{ {
if (self->length == self->capacity) { if (self->length == self->capacity) {
unsigned newcapacity; unsigned newcapacity;
nodetreenode *newnodes; nodetreenode *newnodes;
newcapacity = self->capacity * 2; newcapacity = self->capacity * 2;
if (newcapacity >= INT_MAX / sizeof(nodetreenode)) { if (newcapacity >= INT_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
"overflow in nt_new"); "overflow in nt_new");
return -1; return -1;
} }
newnodes = newnodes =
realloc(self->nodes, newcapacity * sizeof(nodetreenode)); realloc(self->nodes, newcapacity * sizeof(nodetreenode));
if (newnodes == NULL) { if (newnodes == NULL) {
PyErr_SetString(PyExc_MemoryError, "out of memory"); PyErr_SetString(PyExc_MemoryError, "out of memory");
return -1; return -1;
} }
return -2; return -2;
} }
static PyObject *index_getitem(indexObject *self, PyObject *value) static PyObject *index_getitem(indexObject *self, PyObject *value)
{ {
char *node; char *node;
int rev; int rev;
if (PyInt_Check(value)) if (PyInt_Check(value)) {
return index_get(self, PyInt_AS_LONG(value)); long idx;
if (!pylong_to_long(value, &idx)) {
return NULL;
}
return index_get(self, idx);
}
if (node_check(value, &node) == -1) if (node_check(value, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node, 20); rev = index_find_node(self, node, 20);
if (rev >= -1) if (rev >= -1)
return PyInt_FromLong(rev); return PyInt_FromLong(rev);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return PyInt_FromLong(rev); return PyInt_FromLong(rev);
} }
static int index_contains(indexObject *self, PyObject *value) static int index_contains(indexObject *self, PyObject *value)
{ {
char *node; char *node;
if (PyInt_Check(value)) { if (PyInt_Check(value)) {
long rev = PyInt_AS_LONG(value); long rev;
if (!pylong_to_long(value, &rev)) {
return -1;
}
return rev >= -1 && rev < index_length(self); return rev >= -1 && rev < index_length(self);
} }
if (node_check(value, &node) == -1) if (node_check(value, &node) == -1)
return -1; return -1;
switch (index_find_node(self, node, 20)) { switch (index_find_node(self, node, 20)) {
case -3: case -3:
int i, j, v, ninteresting; int i, j, v, ninteresting;
PyObject *dict = NULL, *keys = NULL; PyObject *dict = NULL, *keys = NULL;
long *seen = NULL; long *seen = NULL;
int maxrev = -1; int maxrev = -1;
long final; long final;
if (revcount > capacity) { if (revcount > capacity) {
PyErr_Format(PyExc_OverflowError, PyErr_Format(PyExc_OverflowError,
"bitset size (%ld) > capacity (%ld)", "bitset size (%ld) > capacity (%ld)",
(long)revcount, (long)capacity); (long)revcount, (long)capacity);
return NULL; return NULL;
} }
for (i = 0; i < revcount; i++) { for (i = 0; i < revcount; i++) {
int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i)); int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i));
if (n > maxrev) if (n > maxrev)
maxrev = n; maxrev = n;
} }
for (i = 0; i < argcount; i++) { for (i = 0; i < argcount; i++) {
static const int capacity = 24; static const int capacity = 24;
PyObject *obj = PySequence_GetItem(args, i); PyObject *obj = PySequence_GetItem(args, i);
bitmask x; bitmask x;
long val; long val;
if (!PyInt_Check(obj)) { if (!PyInt_Check(obj)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"arguments must all be ints"); "arguments must all be ints");
Py_DECREF(obj); Py_DECREF(obj);
goto bail; goto bail;
} }
val = PyInt_AsLong(obj); val = PyInt_AsLong(obj);
Py_DECREF(obj); Py_DECREF(obj);
if (val == -1) { if (val == -1) {
ret = PyList_New(0); ret = PyList_New(0);
goto done; goto done;
for (k = 0; k < revcount; k++) { for (k = 0; k < revcount; k++) {
if (val == revs[k]) if (val == revs[k])
goto duplicate; goto duplicate;
} }
} else } else
repeat |= x; repeat |= x;
if (revcount >= capacity) { if (revcount >= capacity) {
PyErr_Format(PyExc_OverflowError, PyErr_Format(PyExc_OverflowError,
"bitset size (%d) > capacity (%d)", "bitset size (%d) > capacity (%d)",
revcount, capacity); revcount, capacity);
goto bail; goto bail;
} }
revs[revcount++] = (int)val; revs[revcount++] = (int)val;
duplicate:; duplicate:;
} }
if (revcount == 0) { if (revcount == 0) {
ret = PyList_New(0); ret = PyList_New(0);
{ {
Py_ssize_t start, stop, step, slicelength; Py_ssize_t start, stop, step, slicelength;
Py_ssize_t length = index_length(self) + 1; Py_ssize_t length = index_length(self) + 1;
int ret = 0; int ret = 0;
/* Argument changed from PySliceObject* to PyObject* in Python 3. */ /* Argument changed from PySliceObject* to PyObject* in Python 3. */
#ifdef IS_PY3K #ifdef IS_PY3K
if (PySlice_GetIndicesEx(item, length, &start, &stop, &step, if (PySlice_GetIndicesEx(item, length, &start, &stop, &step,
&slicelength) < 0) &slicelength) < 0)
#else #else
if (PySlice_GetIndicesEx((PySliceObject *)item, length, &start, &stop, if (PySlice_GetIndicesEx((PySliceObject *)item, length, &start, &stop,
&step, &slicelength) < 0) &step, &slicelength) < 0)
#endif #endif
return -1; return -1;
if (slicelength <= 0) if (slicelength <= 0)
return 0; return 0;
if ((step < 0 && start < stop) || (step > 0 && start > stop)) if ((step < 0 && start < stop) || (step > 0 && start > stop))
stop = start; stop = start;
if (step < 0) { if (step < 0) {
stop = start + 1; stop = start + 1;
start = stop + step * (slicelength - 1) - 1; start = stop + step * (slicelength - 1) - 1;
step = -step; step = -step;
} }
if (step != 1) { if (step != 1) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"revlog index delete requires step size of 1"); "revlog index delete requires step size of 1");
return -1; return -1;
} }
if (stop != length - 1) { if (stop != length - 1) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
"revlog index deletion indices are invalid"); "revlog index deletion indices are invalid");
return -1; return -1;
} }
if (start < self->length) { if (start < self->length) {
if (self->ntinitialized) { if (self->ntinitialized) {
Py_ssize_t i; Py_ssize_t i;
for (i = start + 1; i < self->length; i++) { for (i = start + 1; i < self->length; i++) {
if (self->ntinitialized) { if (self->ntinitialized) {
index_invalidate_added(self, start - self->length); index_invalidate_added(self, start - self->length);
if (self->ntrev > start) if (self->ntrev > start)
self->ntrev = (int)start; self->ntrev = (int)start;
} }
if (self->added) if (self->added)
ret = PyList_SetSlice(self->added, start - self->length, ret = PyList_SetSlice(self->added, start - self->length,
PyList_GET_SIZE(self->added), NULL); PyList_GET_SIZE(self->added), NULL);
done: done:
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
return ret; return ret;
} }
/* /*
* Supported ops: * Supported ops:
* *
if (PySlice_Check(item) && value == NULL) if (PySlice_Check(item) && value == NULL)
return index_slice_del(self, item); return index_slice_del(self, item);
if (node_check(item, &node) == -1) if (node_check(item, &node) == -1)
return -1; return -1;
if (value == NULL) if (value == NULL)
return self->ntinitialized ? nt_delete_node(&self->nt, node) return self->ntinitialized ? nt_delete_node(&self->nt, node)
: 0; : 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 (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
Py_INCREF(Py_None); Py_INCREF(Py_None);
self->ntinitialized = 0; self->ntinitialized = 0;
self->offsets = NULL; self->offsets = NULL;
if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj)) if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj))
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 (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);
PyObject *inclusivearg = NULL; PyObject *inclusivearg = NULL;
long stoprev = 0; long stoprev = 0;
long *initrevs = NULL; long *initrevs = NULL;
int inclusive = 0; int inclusive = 0;
Py_ssize_t i; Py_ssize_t i;
indexObject *index; indexObject *index;
if (!PyArg_ParseTuple(args, "O!O!lO!", &indexType, &index, &PyList_Type, if (!PyArg_ParseTuple(args, "O!O!lO!", &indexType, &index, &PyList_Type,
&initrevsarg, &stoprev, &PyBool_Type, &initrevsarg, &stoprev, &PyBool_Type,
&inclusivearg)) &inclusivearg))
return -1; return -1;
Py_INCREF(index); Py_INCREF(index);
self->index = index; self->index = index;
if (inclusivearg == Py_True) if (inclusivearg == Py_True)
inclusive = 1; inclusive = 1;
Py_ssize_t linit = PyList_GET_SIZE(initrevsarg); Py_ssize_t linit = PyList_GET_SIZE(initrevsarg);
initrevs = (long *)calloc(linit, sizeof(long)); initrevs = (long *)calloc(linit, sizeof(long));
if (initrevs == NULL) { if (initrevs == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
for (i = 0; i < linit; i++) { for (i = 0; i < linit; i++) {
initrevs[i] = PyInt_AsLong(PyList_GET_ITEM(initrevsarg, i)); initrevs[i] = PyInt_AsLong(PyList_GET_ITEM(initrevsarg, i));
} }
if (PyErr_Occurred()) if (PyErr_Occurred())
goto bail; goto bail;
self->iter = rustlazyancestors_init(index, index_get_parents, linit, self->iter = rustlazyancestors_init(index, index_get_parents, linit,
initrevs, stoprev, inclusive); initrevs, stoprev, inclusive);
if (self->iter == NULL) { if (self->iter == NULL) {
/* if this is because of GraphError::ParentOutOfRange /* if this is because of GraphError::ParentOutOfRange
* index_get_parents() has already set the proper ValueError */ * index_get_parents() has already set the proper ValueError */
goto bail; goto bail;
} }
free(initrevs); free(initrevs);
return 0; return 0;
*/ */
return NULL; return NULL;
} }
return PyInt_FromLong(res); return PyInt_FromLong(res);
} }
static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev) static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev)
{ {
if (!(PyInt_Check(rev))) { long lrev;
if (!pylong_to_long(rev, &lrev)) {
PyErr_Clear();
return 0; return 0;
} }
return rustlazyancestors_contains(self->iter, PyInt_AS_LONG(rev)); return rustlazyancestors_contains(self->iter, lrev);
} }
static PySequenceMethods rustla_sequence_methods = { static PySequenceMethods rustla_sequence_methods = {
0, /* sq_length */ 0, /* sq_length */
0, /* sq_concat */ 0, /* sq_concat */
0, /* sq_repeat */ 0, /* sq_repeat */
0, /* sq_item */ 0, /* sq_item */
0, /* sq_slice */ 0, /* sq_slice */
nodetreeType.tp_new = PyType_GenericNew; nodetreeType.tp_new = PyType_GenericNew;
if (PyType_Ready(&nodetreeType) < 0) if (PyType_Ready(&nodetreeType) < 0)
return; return;
Py_INCREF(&nodetreeType); Py_INCREF(&nodetreeType);
PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType); PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType);
if (!nullentry) { if (!nullentry) {
nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0,
0, -1, -1, -1, -1, nullid, 20); 0, -1, -1, -1, -1, nullid, 20);
} }
if (nullentry) if (nullentry)
PyObject_GC_UnTrack(nullentry); PyObject_GC_UnTrack(nullentry);
#ifdef WITH_RUST #ifdef WITH_RUST
rustlazyancestorsType.tp_new = PyType_GenericNew; rustlazyancestorsType.tp_new = PyType_GenericNew;
if (PyType_Ready(&rustlazyancestorsType) < 0) if (PyType_Ready(&rustlazyancestorsType) < 0)
return; return;
Py_INCREF(&rustlazyancestorsType); Py_INCREF(&rustlazyancestorsType);
PyModule_AddObject(mod, "rustlazyancestors", PyModule_AddObject(mod, "rustlazyancestors",
(PyObject *)&rustlazyancestorsType); (PyObject *)&rustlazyancestorsType);
#endif #endif
} }

mercurial/cext/util.h

parameter. For example, with the initial minused = 1000, the parameter. For example, with the initial minused = 1000, the
dictionary created has size 1024. Of course in a lot of cases that dictionary created has size 1024. Of course in a lot of cases that
can be greater than the maximum load factor Python's dict object can be greater than the maximum load factor Python's dict object
expects (= 2/3), so as soon as we cross the threshold we'll resize expects (= 2/3), so as soon as we cross the threshold we'll resize
anyway. So create a dictionary that's at least 3/2 the size. */ anyway. So create a dictionary that's at least 3/2 the size. */
return _PyDict_NewPresized(((1 + expected_size) / 2) * 3); return _PyDict_NewPresized(((1 + expected_size) / 2) * 3);
} }
/* Convert a PyInt or PyLong to a long. Returns false if there is an
error, in which case an exception will already have been set. */
static inline bool pylong_to_long(PyObject *pylong, long *out)
{
*out = PyLong_AsLong(pylong);
/* Fast path to avoid hitting PyErr_Occurred if the value was obviously
* not an error. */
if (*out != -1) {
return true;
}
return PyErr_Occurred() == NULL;
}
#endif /* _HG_UTIL_H_ */ #endif /* _HG_UTIL_H_ */