( )⚙ D12229 cext: use PyLong symbols

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12229

cext: use PyLong symbols
ClosedPublic

Authored by indygreg on Mar 1 2022, 7:22 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG13d705c98914: cext: use PyLong symbols
Summary

We no longer support Python 2. So we can unconditionally use the Python 3
symbol names.

Diff Detail

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

Event Timeline

indygreg created this revision.Mar 1 2022, 7:22 PM
Alphare accepted this revision.Mar 2 2022, 5:18 AM
This revision is now accepted and ready to land.Mar 2 2022, 5:18 AM
indygreg added a commit: rHG13d705c98914: cext: use PyLong symbols.Mar 2 2022, 7:42 AM
Closed by commit rHG13d705c98914: cext: use PyLong symbols (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

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

Diff 32304

mercurial/cext/revlog.c

#include <structmember.h> #include <structmember.h>
#include "bitmanipulation.h" #include "bitmanipulation.h"
#include "charencode.h" #include "charencode.h"
#include "compat.h" #include "compat.h"
#include "revlog.h" #include "revlog.h"
#include "util.h" #include "util.h"
#ifdef IS_PY3K
/* 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
* supported and proper types are used in the extensions themselves. */
#define PyInt_Check PyLong_Check
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AsLong PyLong_AsLong
#endif
typedef struct indexObjectStruct indexObject; typedef struct indexObjectStruct indexObject;
typedef struct { typedef struct {
int children[16]; int children[16];
} nodetreenode; } nodetreenode;
typedef struct { typedef struct {
int abi_version; int abi_version;
PyObject *t = NULL; PyObject *t = NULL;
if (obj == NULL) if (obj == NULL)
return NULL; return NULL;
#define istat(__n, __d) \ #define istat(__n, __d) \
do { \ do { \
s = PyBytes_FromString(__d); \ s = PyBytes_FromString(__d); \
t = PyInt_FromSsize_t(self->__n); \ t = PyLong_FromSsize_t(self->__n); \
if (!s || !t) \ if (!s || !t) \
goto bail; \ goto bail; \
if (PyDict_SetItem(obj, s, t) == -1) \ if (PyDict_SetItem(obj, s, t) == -1) \
goto bail; \ goto bail; \
Py_CLEAR(s); \ Py_CLEAR(s); \
Py_CLEAR(t); \ Py_CLEAR(t); \
} while (0) } while (0)
revstates = (char *)calloc(len + 1, 1); revstates = (char *)calloc(len + 1, 1);
if (revstates == NULL) { if (revstates == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
l = PyList_GET_SIZE(roots); l = PyList_GET_SIZE(roots);
for (i = 0; i < l; i++) { for (i = 0; i < l; i++) {
revnum = PyInt_AsLong(PyList_GET_ITEM(roots, i)); revnum = PyLong_AsLong(PyList_GET_ITEM(roots, i));
if (revnum == -1 && PyErr_Occurred()) if (revnum == -1 && PyErr_Occurred())
goto bail; goto bail;
/* If root is out of range, e.g. wdir(), it must be unreachable /* If root is out of range, e.g. wdir(), it must be unreachable
* from heads. So we can just ignore it. */ * from heads. So we can just ignore it. */
if (revnum + 1 < 0 || revnum + 1 >= len + 1) if (revnum + 1 < 0 || revnum + 1 >= len + 1)
continue; continue;
revstates[revnum + 1] |= RS_ROOT; revstates[revnum + 1] |= RS_ROOT;
} }
/* Populate tovisit with all the heads */ /* Populate tovisit with all the heads */
l = PyList_GET_SIZE(heads); l = PyList_GET_SIZE(heads);
for (i = 0; i < l; i++) { for (i = 0; i < l; i++) {
revnum = PyInt_AsLong(PyList_GET_ITEM(heads, i)); revnum = PyLong_AsLong(PyList_GET_ITEM(heads, i));
if (revnum == -1 && PyErr_Occurred()) if (revnum == -1 && PyErr_Occurred())
goto bail; goto bail;
if (revnum + 1 < 0 || revnum + 1 >= len + 1) { if (revnum + 1 < 0 || revnum + 1 >= len + 1) {
PyErr_SetString(PyExc_IndexError, "head out of range"); PyErr_SetString(PyExc_IndexError, "head out of range");
goto bail; goto bail;
} }
if (!(revstates[revnum + 1] & RS_SEEN)) { if (!(revstates[revnum + 1] & RS_SEEN)) {
tovisit[lentovisit++] = (int)revnum; tovisit[lentovisit++] = (int)revnum;
revstates[revnum + 1] |= RS_SEEN; revstates[revnum + 1] |= RS_SEEN;
} }
} }
/* Visit the tovisit list and find the reachable roots */ /* Visit the tovisit list and find the reachable roots */
k = 0; k = 0;
while (k < lentovisit) { while (k < lentovisit) {
/* Add the node to reachable if it is a root*/ /* Add the node to reachable if it is a root*/
revnum = tovisit[k++]; revnum = tovisit[k++];
if (revstates[revnum + 1] & RS_ROOT) { if (revstates[revnum + 1] & RS_ROOT) {
revstates[revnum + 1] |= RS_REACHABLE; revstates[revnum + 1] |= RS_REACHABLE;
val = PyInt_FromLong(revnum); val = PyLong_FromLong(revnum);
if (val == NULL) if (val == NULL)
goto bail; goto bail;
r = PyList_Append(reachable, val); r = PyList_Append(reachable, val);
Py_DECREF(val); Py_DECREF(val);
if (r < 0) if (r < 0)
goto bail; goto bail;
if (includepath == 0) if (includepath == 0)
continue; continue;
* index_get_parents */ * index_get_parents */
if (r < 0) if (r < 0)
goto bail; goto bail;
if (((revstates[parents[0] + 1] | if (((revstates[parents[0] + 1] |
revstates[parents[1] + 1]) & revstates[parents[1] + 1]) &
RS_REACHABLE) && RS_REACHABLE) &&
!(revstates[i + 1] & RS_REACHABLE)) { !(revstates[i + 1] & RS_REACHABLE)) {
revstates[i + 1] |= RS_REACHABLE; revstates[i + 1] |= RS_REACHABLE;
val = PyInt_FromSsize_t(i); val = PyLong_FromSsize_t(i);
if (val == NULL) if (val == NULL)
goto bail; goto bail;
r = PyList_Append(reachable, val); r = PyList_Append(reachable, val);
Py_DECREF(val); Py_DECREF(val);
if (r < 0) if (r < 0)
goto bail; goto bail;
} }
} }
phases = calloc(len, 1); phases = calloc(len, 1);
if (phases == NULL) { if (phases == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
return NULL; return NULL;
} }
for (i = 0; i < numphases; ++i) { for (i = 0; i < numphases; ++i) {
PyObject *pyphase = PyInt_FromLong(trackedphases[i]); PyObject *pyphase = PyLong_FromLong(trackedphases[i]);
PyObject *phaseroots = NULL; PyObject *phaseroots = NULL;
if (pyphase == NULL) if (pyphase == NULL)
goto release; goto release;
phaseroots = PyDict_GetItem(roots, pyphase); phaseroots = PyDict_GetItem(roots, pyphase);
Py_DECREF(pyphase); Py_DECREF(pyphase);
if (phaseroots == NULL) if (phaseroots == NULL)
continue; continue;
rev = add_roots_get_min(self, phaseroots, phases, rev = add_roots_get_min(self, phaseroots, phases,
break; break;
default: default:
/* this should never happen since the phase number is /* this should never happen since the phase number is
* specified by this function. */ * specified by this function. */
PyErr_SetString(PyExc_SystemError, PyErr_SetString(PyExc_SystemError,
"bad phase number in internal list"); "bad phase number in internal list");
goto release; goto release;
} }
pyrev = PyInt_FromLong(rev); pyrev = PyLong_FromLong(rev);
if (pyrev == NULL) if (pyrev == NULL)
goto release; goto release;
if (PySet_Add(pyphase, pyrev) == -1) { if (PySet_Add(pyphase, pyrev) == -1) {
Py_DECREF(pyrev); Py_DECREF(pyrev);
goto release; goto release;
} }
Py_DECREF(pyrev); Py_DECREF(pyrev);
} }
phasesetsdict = _dict_new_presized(numphases); phasesetsdict = _dict_new_presized(numphases);
if (phasesetsdict == NULL) if (phasesetsdict == NULL)
goto release; goto release;
for (i = 0; i < numphases; ++i) { for (i = 0; i < numphases; ++i) {
PyObject *pyphase = PyInt_FromLong(trackedphases[i]); PyObject *pyphase = PyLong_FromLong(trackedphases[i]);
if (pyphase == NULL) if (pyphase == NULL)
goto release; goto release;
if (PyDict_SetItem(phasesetsdict, pyphase, phasesets[i]) == if (PyDict_SetItem(phasesetsdict, pyphase, phasesets[i]) ==
-1) { -1) {
Py_DECREF(pyphase); Py_DECREF(pyphase);
goto release; goto release;
} }
Py_DECREF(phasesets[i]); Py_DECREF(phasesets[i]);
} }
} }
len = index_length(self); len = index_length(self);
heads = PyList_New(0); heads = PyList_New(0);
if (heads == NULL) if (heads == NULL)
goto bail; goto bail;
if (len == 0) { if (len == 0) {
PyObject *nullid = PyInt_FromLong(-1); PyObject *nullid = PyLong_FromLong(-1);
if (nullid == NULL || PyList_Append(heads, nullid) == -1) { if (nullid == NULL || PyList_Append(heads, nullid) == -1) {
Py_XDECREF(nullid); Py_XDECREF(nullid);
goto bail; goto bail;
} }
goto done; goto done;
} }
nothead = calloc(len, 1); nothead = calloc(len, 1);
} }
} }
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
PyObject *head; PyObject *head;
if (nothead[i]) if (nothead[i])
continue; continue;
head = PyInt_FromSsize_t(i); head = PyLong_FromSsize_t(i);
if (head == NULL || PyList_Append(heads, head) == -1) { if (head == NULL || PyList_Append(heads, head) == -1) {
Py_XDECREF(head); Py_XDECREF(head);
goto bail; goto bail;
} }
} }
done: done:
self->headrevs = heads; self->headrevs = heads;
base = (Py_ssize_t)index_baserev(self, rev); base = (Py_ssize_t)index_baserev(self, rev);
if (base == rev) { if (base == rev) {
base = -1; base = -1;
} }
if (base == -2) { if (base == -2) {
assert(PyErr_Occurred()); assert(PyErr_Occurred());
goto bail; goto bail;
} }
key = PyInt_FromSsize_t(base); key = PyLong_FromSsize_t(base);
allvalues = PyDict_GetItem(cache, key); allvalues = PyDict_GetItem(cache, key);
if (allvalues == NULL && PyErr_Occurred()) { if (allvalues == NULL && PyErr_Occurred()) {
goto bail; goto bail;
} }
if (allvalues == NULL) { if (allvalues == NULL) {
int r; int r;
allvalues = PyList_New(0); allvalues = PyList_New(0);
if (!allvalues) { if (!allvalues) {
goto bail; goto bail;
} }
r = PyDict_SetItem(cache, key, allvalues); r = PyDict_SetItem(cache, key, allvalues);
Py_DECREF(allvalues); Py_DECREF(allvalues);
if (r < 0) { if (r < 0) {
goto bail; goto bail;
} }
} }
value = PyInt_FromSsize_t(rev); value = PyLong_FromSsize_t(rev);
if (PyList_Append(allvalues, value)) { if (PyList_Append(allvalues, value)) {
goto bail; goto bail;
} }
Py_CLEAR(key); Py_CLEAR(key);
Py_CLEAR(value); Py_CLEAR(value);
} }
Py_RETURN_NONE; Py_RETURN_NONE;
bail: bail:
int stopped; int stopped;
PyObject *chain = NULL, *result = NULL; PyObject *chain = NULL, *result = NULL;
const Py_ssize_t length = index_length(self); const Py_ssize_t length = index_length(self);
if (!PyArg_ParseTuple(args, "iOi", &rev, &stoparg, &generaldelta)) { if (!PyArg_ParseTuple(args, "iOi", &rev, &stoparg, &generaldelta)) {
return NULL; return NULL;
} }
if (PyInt_Check(stoparg)) { if (PyLong_Check(stoparg)) {
stoprev = (int)PyInt_AsLong(stoparg); stoprev = (int)PyLong_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");
/* Error should be set by index_deref() */ /* Error should be set by index_deref() */
assert(PyErr_Occurred()); assert(PyErr_Occurred());
goto bail; goto bail;
} }
iterrev = rev; iterrev = rev;
while (iterrev != baserev && iterrev != stoprev) { while (iterrev != baserev && iterrev != stoprev) {
PyObject *value = PyInt_FromLong(iterrev); PyObject *value = PyLong_FromLong(iterrev);
if (value == NULL) { if (value == NULL) {
goto bail; goto bail;
} }
if (PyList_Append(chain, value)) { if (PyList_Append(chain, value)) {
Py_DECREF(value); Py_DECREF(value);
goto bail; goto bail;
} }
Py_DECREF(value); Py_DECREF(value);
assert(PyErr_Occurred()); assert(PyErr_Occurred());
goto bail; goto bail;
} }
} }
if (iterrev == stoprev) { if (iterrev == stoprev) {
stopped = 1; stopped = 1;
} else { } else {
PyObject *value = PyInt_FromLong(iterrev); PyObject *value = PyLong_FromLong(iterrev);
if (value == NULL) { if (value == NULL) {
goto bail; goto bail;
} }
if (PyList_Append(chain, value)) { if (PyList_Append(chain, value)) {
Py_DECREF(value); Py_DECREF(value);
goto bail; goto bail;
} }
Py_DECREF(value); Py_DECREF(value);
/* Turn the python list into a native integer array (for efficiency) */ /* Turn the python list into a native integer array (for efficiency) */
revs = (Py_ssize_t *)calloc(num_revs, sizeof(Py_ssize_t)); revs = (Py_ssize_t *)calloc(num_revs, sizeof(Py_ssize_t));
if (revs == NULL) { if (revs == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
for (i = 0; i < num_revs; i++) { for (i = 0; i < num_revs; i++) {
Py_ssize_t revnum = PyInt_AsLong(PyList_GET_ITEM(list_revs, i)); Py_ssize_t revnum =
PyLong_AsLong(PyList_GET_ITEM(list_revs, i));
if (revnum == -1 && PyErr_Occurred()) { if (revnum == -1 && PyErr_Occurred()) {
goto bail; goto bail;
} }
if (revnum < nullrev || revnum >= idxlen) { if (revnum < nullrev || revnum >= idxlen) {
PyErr_Format(PyExc_IndexError, PyErr_Format(PyExc_IndexError,
"index out of range: %zd", revnum); "index out of range: %zd", revnum);
goto bail; goto bail;
} }
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 NULL; return NULL;
} }
return PyInt_FromLong(length); return PyLong_FromLong(length);
} }
static void nt_dealloc(nodetree *self) static void nt_dealloc(nodetree *self)
{ {
free(self->nodes); free(self->nodes);
self->nodes = NULL; self->nodes = NULL;
} }
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 (PyLong_Check(value)) {
long idx; long idx;
if (!pylong_to_long(value, &idx)) { if (!pylong_to_long(value, &idx)) {
return NULL; return NULL;
} }
return index_get(self, idx); return index_get(self, idx);
} }
if (node_check(self->nodelen, value, &node) == -1) if (node_check(self->nodelen, value, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node); rev = index_find_node(self, node);
if (rev >= -1) if (rev >= -1)
return PyInt_FromLong(rev); return PyLong_FromLong(rev);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
/* /*
* Fully populate the radix tree. * Fully populate the radix tree.
*/ */
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 NULL; return NULL;
} }
return PyInt_FromLong(length); return PyLong_FromLong(length);
} }
static PyObject *index_m_get(indexObject *self, PyObject *args) static PyObject *index_m_get(indexObject *self, PyObject *args)
{ {
PyObject *val; PyObject *val;
char *node; char *node;
int rev; int rev;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(self->nodelen, val, &node) == -1) if (node_check(self->nodelen, val, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node); rev = index_find_node(self, node);
if (rev == -3) if (rev == -3)
return NULL; return NULL;
if (rev == -2) if (rev == -2)
Py_RETURN_NONE; Py_RETURN_NONE;
return PyInt_FromLong(rev); return PyLong_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 (PyLong_Check(value)) {
long rev; long rev;
if (!pylong_to_long(value, &rev)) { if (!pylong_to_long(value, &rev)) {
return -1; return -1;
} }
return rev >= -1 && rev < index_length(self); return rev >= -1 && rev < index_length(self);
} }
if (node_check(self->nodelen, value, &node) == -1) if (node_check(self->nodelen, value, &node) == -1)
{ {
char *node; char *node;
int rev; int rev;
if (node_check(self->nodelen, val, &node) == -1) if (node_check(self->nodelen, val, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node); rev = index_find_node(self, node);
if (rev >= -1) if (rev >= -1)
return PyInt_FromLong(rev); return PyLong_FromLong(rev);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
typedef uint64_t bitmask; typedef uint64_t bitmask;
/* /*
int parents[2]; int parents[2];
if (!sv) if (!sv)
continue; continue;
if (sv < poison) { if (sv < poison) {
interesting -= 1; interesting -= 1;
if (sv == allseen) { if (sv == allseen) {
PyObject *obj = PyInt_FromLong(v); PyObject *obj = PyLong_FromLong(v);
if (obj == NULL) if (obj == NULL)
goto bail; goto bail;
if (PyList_Append(gca, obj) == -1) { if (PyList_Append(gca, obj) == -1) {
Py_DECREF(obj); Py_DECREF(obj);
goto bail; goto bail;
} }
sv |= poison; sv |= poison;
for (i = 0; i < revcount; i++) { for (i = 0; i < revcount; i++) {
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)PyLong_AsLong(PyList_GET_ITEM(revs, i));
if (n > maxrev) if (n > maxrev)
maxrev = n; maxrev = n;
} }
depth = calloc(sizeof(*depth), maxrev + 1); depth = calloc(sizeof(*depth), maxrev + 1);
if (depth == NULL) if (depth == NULL)
return PyErr_NoMemory(); return PyErr_NoMemory();
seen = calloc(sizeof(*seen), maxrev + 1); seen = calloc(sizeof(*seen), maxrev + 1);
if (seen == NULL) { if (seen == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
interesting = calloc(sizeof(*interesting), ((size_t)1) << revcount); interesting = calloc(sizeof(*interesting), ((size_t)1) << revcount);
if (interesting == NULL) { if (interesting == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
if (PyList_Sort(revs) == -1) if (PyList_Sort(revs) == -1)
goto bail; goto bail;
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)PyLong_AsLong(PyList_GET_ITEM(revs, i));
long b = 1l << i; long b = 1l << i;
depth[n] = 1; depth[n] = 1;
seen[n] = b; seen[n] = b;
interesting[b] = 1; interesting[b] = 1;
} }
/* invariant: ninteresting is the number of non-zero entries in /* invariant: ninteresting is the number of non-zero entries in
* interesting. */ * interesting. */
len = index_length(self); len = index_length(self);
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 (!PyLong_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 = PyLong_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;
} }
if (val < 0 || val >= len) { if (val < 0 || val >= len) {
PyErr_SetString(PyExc_IndexError, "index out of range"); PyErr_SetString(PyExc_IndexError, "index out of range");
goto bail; goto bail;
ret = PyList_New(0); ret = PyList_New(0);
goto done; goto done;
} }
if (revcount == 1) { if (revcount == 1) {
PyObject *obj; PyObject *obj;
ret = PyList_New(1); ret = PyList_New(1);
if (ret == NULL) if (ret == NULL)
goto bail; goto bail;
obj = PyInt_FromLong(revs[0]); obj = PyLong_FromLong(revs[0]);
if (obj == NULL) if (obj == NULL)
goto bail; goto bail;
PyList_SET_ITEM(ret, 0, obj); PyList_SET_ITEM(ret, 0, obj);
goto done; goto done;
} }
ret = find_gca_candidates(self, revs, revcount); ret = find_gca_candidates(self, revs, revcount);
if (ret == NULL) if (ret == NULL)
return index_slice_del(self, item); return index_slice_del(self, item);
if (node_check(self->nodelen, item, &node) == -1) if (node_check(self->nodelen, 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 = PyLong_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)
return -1; return -1;